SDT-base         Contents     Functions              PDF Index

4.8  Sensors : Data structure and init commands

• SensDof Data structure
• SensDof init commands
• rel
• general
• trans
• dof
• triax,laser
• strain,stress
• resultant

Sensors related to a finite element model are stored in the model structure as a SensDof case entry. This is a reference section on SensDof case entries. A tutorial on the basic configuration with a test wire frame and translation sensors is given in section 2.8 and the high level definition format of sensors is documented in section ??.

4.8.1  SensDof Data structure

SensDof entries describe a sensor configuration and can contain the following fields

Use cases are

• animate test. Are then needed: nodes for sensors position, sensor orientations, possibly wire-frame (elements connecting sensors) to ease viewing.
• predict model outputs :
• observe full FEM or superelement response on sensors (use for correlation)
• estimate states/model view from sensors (expansion)

4.8.2  SensDof init commands

All sensors are generated with the command
fe_case(model,'SensDof <append, combine> Sensor_type',Sensor,data,SensLab)
Sensor is the case entry name to which sensors will be added. data is a structure, a vector, or a matrix, which describes the sensor to be added. The nature of data depends on Sensor_type as detailed below. SensLab is an optional cell array used to define sensor labels. There should be as much elements in SensLab as sensors added. If there is only one string in the cell array SensLab, it is used to generate labels substituting for each sensor $id by its SensId, $type by its type (trans, strain ...), $j1 by its number in the set currently added. If SensLab is not given, default label generation is $type_$id.
In the default mode ('SensDof' command), new sensors replace any existing ones. In the append mode ('SensDof append'), if a sensor is added with an existing SensID, the SensID of new sensor will changed to a free SensID value. In the combine mode ('SensDof combine'), existing sensor with the same SensID will be replaced by the new one.

rel

Relative displacement sensor or relative force sensor (spring load). Data passed to the command is [NodeID1 NodeID2].

This sensor measures the relative displacement between NodeID1 and NodeID2, along the direction defined from NodeID1 to NodeID2. One can use the command option -dof in order to measure along the defined DOF directions (mandatory if the two nodes are coincident). As many sensors as DOF are then added. For a relative force sensor, on can use the command option -coef to define the associated spring stiffness (sensor value is the product of the relative displacement and the stiffness of the spring).

If some DOF are missing, the sensor will be generated with a warning and a partial observation corresponding to the found DOF only.

The following example defines 3 relative displacement sensors (one in the direction of the two nodes, and two others along x and y):

model=demosdt('demo ubeam-pro')
data=[30 372];
model=fe_case(model,'SensDof append rel','output',data);
model=fe_case(model,'SensDof append rel -dof 1 2','output',data);

general

General sensors are defined by a linear observation equation. This is a low level definition that should be used for sensors that can't be described otherwise. Data passed to the command is a structure with field .cta (observation matrix), .DOF DOF associated to the observation matrix, and possibly .lab giving a label for each row of the observation matrix.

The following example defines a general sensor

model=demosdt('demo ubeam-pro');
Sensor=struct('cta',[1 -1;0 1],'DOF',[8.03; 9.03]);
model=fe_case(model,'SensDof append general','output',Sensor);

trans

Translation sensors (see also section 2.8.2) can be specified by giving

[DOF]
[DOF, BasID]
[SensID, NodeID, nx, ny, nz]
[SensID, x, y, z, nx, ny, nz]

This is often used with wire frames, see section 2.8.2. The definition of test sensors is given in section 3.1.1.

The basic case is the measurement of a translation corresponding the main directions of a coordinate system. The DOF format (1.02 for 1y, see section 7.5) can then be simply used, the DOF values are used as is then used as SensID. Note that this form is also acceptable to define sensors for other DOFs (rotation, temperature, ...).

A number of software packages use local coordinate systems rather than a direction to define sensors. SDT provides compatibility as follows.

If model.bas contains local coordinate systems and deformations are given in the global frame (DID in column 3 of model.Node is zero), the directions nx ny nz (sens.tdof columns 3 to 5) must reflect local definitions. A call giving [DOF, BasID] defines the sensor direction in the main directions of basis BasID and the sensor direction is adjusted.

If FEM results are given in local coordinates, you should not specify a basis for the sensor definition, the directions nx ny nz (sens.tdof columns 3 to 5) should be [1 0 0], ... as obtained with a simple [DOF] argument in the sensor definition call.

When specifying a BasId, it the sensor direction nx ny nz is adjusted and given in global FEM coordinates. Observation should thus be made using FEM deformations in global coordinates (with a DID set to zero). If your FEM results are given in local coordinates, you should not specify a basis for the sensor definition. You can also perform the local to global transformation with

cGL= basis('trans E',model.bas,model.node,def.DOF)
def.def=cGL*def.def

The last two input forms specify location as x y z or NodeID, and direction nx ny nz (this vector need not be normalized, sensor value is the scalar product of the direction vector and the displacement vector).
One can add multiple sensors in a single call fe_case(model,'SensDof <append> trans', Name, Sensor) when rows of sensors contain sensor entries of the same form.

Following example defines a translation sensor using each of the forms

model=demosdt('demo ubeam-pro')
model.bas=basis('rotate',[],'r=30;n=[0 1 1]',100);
model=fe_case(model,'SensDof append trans','output',...
  [1,0.0,0.5,2.5,0.0,0.0,1.0]);
model=fe_case(model,'SensDof append trans','output',...
  [2,8,-1.0,0.0,0.0]);
model=fe_case(model,'SensDof append trans','output',[314.03]);
model=fe_case(model,'SensDof append trans','output',...
  [324.03 100]);
cf=feplot;cf.sel(2)='-output';cf.o(1)={'sel2 ty 7','linewidth',2};

Sens.Stack entries for translation can use the following fields

dof

One can simply define a set of sensors along model DOFs with a direct SensDof call model=fe_case(model,'SensDof','SensDofName',DofList). There is no need in that case to pass through SensMatch step in order to get observation matrix.

model=demosdt('demo ubeam-pro')
model=fe_case(model,'SensDof','output',[1.01;2.03;10.01]);
Sens=fe_case(model,'sens','output')

triax,laser

A triax is the same as defining 3 translation sensors, in each of the 3 translation DOF (0.01, 0.02 and 0.03) of a node. Use fe_case(model,'SensDof append triax', Name, NodeId) with a vector NodeId to add multiple triaxes. A positive NodeId refers to a FEM node, while a negative refers to a wire frame node.
For scanning laser vibrometer tests
fe_sens('laser px py pz',model,SightNodes,'SensDofName')
appends translation sensors based on line of sight direction from the laser scanner position px py pz to the measurement nodes SightNodes. Sighted nodes can be specified as a standard node matrix or using a node selection command such as 'NodeId>1000 & NodeId<1100' or also giving a vector of NodeId. If a test wire frame exists in the SensDofName entry, node selection command or NodeId list are defined in this model. If you want to flip the measurement direction, use a call of the form

cf.CStack{'output'}.tdof(:,3:5)=-cf.CStack{'output'}.tdof(:,3:5)

The following example defines some laser sensors, using a test wire frame:

[model,TEST]=demosdt('demo GartDataCotopo'); % load FEM + TEST wireframe
TEST.tdof=[];%Define test wire frame, but start with no tdof
model=fe_case(model,'SensDof','test',TEST);
% Add triax sensor at wireframe point 1001
model=fe_case(model,'SensDof Append Triax','test',-TEST.Node(1));
% Add laser sensors (measured from point 0 0 6) on TEST wire frame location 
model=fe_sens('laser 0 0 6',model,-TEST.Node(2:end,1),'test');
% Show result
cf=feplot(model);fecom(cf,'ShowFiTestDef'); % Display Wireframe only 
fecom('curtab Cases','output'); fecom('proviewon');

To add a sensor on FEM node you would use model=fe_sens('laser 0 0 6',model,20,'test'); but this is not possible here because SensDof entries do not support mixed definitions on test and FEM nodes.

strain,stress

Note that an extended version of this functionality is now discussed in section 4.9. Strain sensors can be specified by giving

[SensID, NodeID]
[SensID, x, y, z]
[SensID, NodeID, n1x, n1y, n1z]
[SensID, x, y, z, n1x, n1y, n1z]
[SensID, NodeID, n1x, n1y, n1z, n2x, n2y, n2z]
[SensID, x, y, z, n1x, n1y, n1z, n2x, n2y, n2z]
when no direction is specified 6 sensors are added for stress/strains in the x, y, z, yz, zx, and xy directions (SensId is incremented by steps of 1). With n1x n1y n1z (this vector need not be normalized) on measures the axial strain in this direction. For shear, one specifies a second direction n2x n2y n2z (this vector need not be normalized) (if not given n₂ is taken equal to n₁). The sensor value is given by {n₂}^T[є]{n₁}.
Sensor can also be a matrix if all rows are of the same type. Then, one can add a set of sensors with a single call to the fe_case(model,'SensDof <append> strain', Name, Sensor) command.

Following example defines a strain sensor with each possible way:

model=demosdt('demo ubeam-pro')
model=fe_case(model,'SensDof append strain','output',...
  [4,0.0,0.5,2.5,0.0,0.0,1.0]);
model=fe_case(model,'SensDof append strain','output',...
  [6,134,0.5,0.5,0.5]);
model=fe_case(model,'SensDof append strain','output',...
  [5,0.0,0.4,1.25,1.0,0.0,0.0,0.0,0.0,1.0]);
model=fe_case(model,'SensDof append strain','output',...
  [7,370,0.0,0.0,1.0,0.0,1.0,0.0]);

Stress sensor.
It is the same as the strain sensor. The sensor value is given by {n₂}^T[σ]{n₁}.
Following example defines a stress sensor with each possible way:

model=demosdt('demo ubeam-pro')
model=fe_case(model,'SensDof append stress','output',...
  [4,0.0,0.5,2.5,0.0,0.0,1.0]);
model=fe_case(model,'SensDof append stress','output',...
  [6,134,0.5,0.5,0.5]);
model=fe_case(model,'SensDof append stress','output',...
  [5,0.0,0.4,1.25,1.0,0.0,0.0,0.0,0.0,1.0]);
model=fe_case(model,'SensDof append stress','output',...
  [7,370,0.0,0.0,1.0,0.0,1.0,0.0]);

Element formulations (see section 6.1) include definitions of fields and their derivatives that are strain/stress in mechanical applications and similar quantities otherwise. The general formula is {є}=[B(r,s,t)]{q}. These (generalized) strain vectors are defined for all points of a volume and the default is to use an exact evaluation at the location of the sensor.

In practice, the generalized strains are more accurately predicted at integration points. Placing the sensor arbitrarily can generate some inaccuracy (for example stress and strains are discontinuous across element boundaries two nearby sensors might give different results). The -stick option can be used to for placement at specific gauss points. -stick by itself forces placement of the sensor and the center of the matching element. This will typically be a more appropriate location to evaluate stresses or strains.

To allow arbitrary positioning some level of reinterpolation is needed. The procedure is then to evaluate strain/stresses at Gauss points and use shape functions for reinterpolation. The process must however involve multiple elements to limit interelement discontinuities. This procedure is currently implemented through the fe_caseg('StressCut') command, as detailed in section 4.9.

resultant

Resultant sensors measure the resultant force on a given surface. Note that the observation of resultant fields is discussed in section 4.9.3. They can be specified by giving a structure with fields

Following example defines a resultant sensor:

model=demosdt('demo ubeam-pro')
Sensor.ID=1;
Sensor.EltSel='WithNode{z==1.25} & WithNode{z>1.25}';
Sensor.SurfSel='z==1.25';
Sensor.dir=[0.0 0.0 1.0];
Sensor.type='resultant';
model=fe_case(model,'SensDof append resultant','output',Sensor);

Resultant sensors are not yet available for superelements model.