Contents     Functions     Index          PDF

4.3  Sensors

• Sensor GUI, a simple example
• Sensor data structure and init commands
• rel
• general
• trans
• triax,laser
• strain,stress
• resultant
• Topology correlation and observation matrix
• Sens
• SensMatch
• DofLoadSensDof
• Obsolete

Sensors are used for test/analysis correlation and in analysis for models where one wants to post-process partial information. This general objective is supported by the use of SensDof entries. Supported sensor types are

4.3.1  Sensor GUI, a simple example

Using the feplot properties GUI, one can edit and visualize sensors.
Following example loads ubeam model, defines some sensors and opens the sensor GUI.

model=demosdt('demo ubeam-pro');
cf=feplot; model=cf.mdl; 
 
model=fe_case(model,'SensDof append trans','output',...
    [1,0.0,0.5,2.5,0.0,0.0,1.0]); %  add a translation sensor
model=fe_case(model,'SensDof append triax','output',8); % add triax sensor
model=fe_case(model,'SensDof append strain','output',...
    [4,0.0,0.5,2.5,0.0,0.0,1.0]); %  add strain sensor
 
model=fe_case(model,'sensmatch radius1','output'); % match sensor set 'output'
 
fecom(cf,'promodelviewon');
fecom(cf,'curtab Cases','output'); % open sensor GUI

Clicking on Edit Label one can edit the full list of sensor labels.
The whole sensor set can be visualized as arrows in the feplot figure clicking on the eye button on the top of the figure. Once visualization is activated one can activate the cursor on sensors by clicking on CursorSel. Then one can edit sensor properties by clicking on corresponding arrow in the feplot figure.

---

Figure 4.9: GUI for sensor edition

---

4.3.2  Sensor data structure and init commands

SensDof case entries can contain the following fields

A .tdof in the form of a DOF definition vector can be transformed to the 5 column format using fe_sens('tdof',DOF).

SensId gives an identifier for each sensor. It should thus be unique and there may be conflicts if it is not.

NodeId specifies a node identifier for the spatial localization of the sensor. If not needed (resultant sensors for example), NodeId can be set for zero. A negative NodeId is used to look for the node position in sens.Node rather than model.Node. Most initalization calls accept the specification of a physical x y z position, a .vert0 field is then defined.

nx ny nz specifies a measurement direction for sensors that need one.

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 modifier -dof in order to measure along the defined DOF directions (needed of the two nodes are coincident). As many sensors as DOF are then added. For a relative force sensor, on can use the command modifier -coeff to define the associated spring stiffness (sensor value is the product of the relative displacement and the stiffness of the spring).

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 can be specified by giving

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

When defining the sensor with only a DOF, or with [DOF, BasID] (BasID is the ID of the basis defined in the .bas field of the model), SensID should not be given. Translation is then the value of this DOF displacement. Otherwise, translation is measured at x y z or at the node NodeID, and along direction nx ny nz (this vector need not be normalized, sensor value is the scalar product of the direction vector and the displacement vector).
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> trans', Name, Sensor) command.

Following example defines a translation sensor with each possible way:

model=demosdt('demo ubeam-pro')
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',...
  [10.03]);
cf=feplot;cf.sel(2)='-output';cf.o(1)={'sel2 ty 7','linewidth',2};

Examples on the definition of test sensors are given in section 3.1.1.

Sens.Stack entries for translation can use the following fields

triax,laser

3 translation sensors set can be specified by giving [NodeID].

In fact defining a triax sensor 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. Sensor can also be a vector of NodeID. Then, one can add a set of sensors with a single call to the fe_case(model,'SensDof <append> triax', Name, Sensor) command.
For scanning laser vibrometer tests consider using the fe_sens laser command to define sens.tdof.

strain,stress

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]);

Since stress and strains are discontinuous across element boundaries, placing the sensor arbitrarily can generate some inaccuracy. A -stick can be added to the match command to force placement of the sensor and the center of the matching element. This will typically be a more appropriate location to evaluate stresses or strains.

resultant

Resultant sensors measure the resultant force on a given surface. 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.

4.3.3  Topology correlation and observation matrix

Sens

The response at sensors is related to the response a DOFs by an observation equation

The fe_case SensDof calls detailed above initalize the sensors but not the topology correlation (element matching) needed to build the observation matrix. This is done using any of the commands detailed below.

After the matching phase, one can build the observation matrix with
SensFull=fe_case(model,'sens',SensDofEntryName)
When using a reduced superelement model, you should use
SensRed=fe_case(model,'sensSE',SensDofEntryName).

SensMatch

The command model=fe_case(model,'sensmatch',Name) builds the observation matrix associated to each sensor of the entry Name, and stores it as a .cta field, and associated .DOF, in the sensor stack. You may omit to provide the name if there is only one sensor set.

This operation requires finding the elements that contain each sensor and the position within the reference element shape so that shape functions can be used to interpolate the response.

The match is performed in an area defined by a length which can be given as a command argument with identifier radius, for example

model=fe_case(model,'sensmatch radius1.0',Name)

In certain applications the sensor may not be contained by the element (for example sensor slightly on the exterior of a volume element). You can then define an element selection to help in the matching. For example fe_case(model,'sensmatch radius1.0',Name,'selface') selects the external surface of volumes. The matching on surfaces allows for a normal projection towards the surface, sensors outside the model volume can thus be matched properly. Note that this selection does not yet let you selected implicit elements within a superelement.

Matching on elements is not always acceptable (for example when using superelements). One can thus use matches to the closest node. SensMatch-Near uses the motion at the matched node. SensMatch-Rigid uses a rigid body constraints to account for the distance between the matched node and the sensor (but is thus only applicable to cases with rotations defined at the nearby node).

In an automated match, the sensor is not always matched to the correct elements on which the sensor is glued, you may want to ensure that the observation matrices created by these commands only use nodes associated to a subset of elements. You can use a selection to define element subset on which perform the match. If you want to match one or more specific sensors to specific element subset, you can give cell array with SensId of sensor to match in a first column and with element string selector in a second column.
model=fe_case(model,'SensMatch',Name,{SensIdVector,'FindEltString'});

This is illustrated below in forcing the interpolation of test node 1206 to use FEM nodes in the plane where it is glued.

 cf=demosdt('demo gartte cor plot');
 fe_case(cf,'sensmatch -near')
 fecom('curtabCases','sensors');fecom('promodelviewon');
 % use fecom CursorSelOn to see how each sensor is matched.
 cf.CStack{'sensors'}.Stack{18,3}
 % modify link to 1206 to be on proper surface
 cf.mdl=fe_case(cf.mdl,'SensMatch-near',...
     'sensors',{1206.02,'withnode {z>.16}'}); 
 cf.CStack{'sensors'}.Stack{18,3}
 % force link to given node (may need to adjust distance)
 cf.mdl=fe_case(cf.mdl,'SensMatch-rigid radius .5','sensors',{1205.07,21}); 
 cf.CStack{'sensors'}.Stack{19,3}

 fecom('showlinks sensors');fecom('textnode',[1206 1205])

DofLoadSensDof

The generation of loads is less general than that of sensors. As a result it may be convenient to use reciprocity to define a load by generating the collocated sensor. When a sensor is defined, and the topology correlation performed with SensMatch, one can define an actuator from this sensor using
model=fe_case(model,'DofLoad SensDof',Input_Name,'Sens_Name:Sens_Nb') or for model using superelements
model=fe_case(model,'DofLoad SensDofSE',Input_Name,'Sens_Name:Sens_Nb').
Sens_Name is the name of the sensor set entry in the model stack of the translation sensor that defines the actuator, and Sens_Nb is its number in this stack entry. Input_Name is the name of the actuator entry that will be created in the model stack. It will be a DofLoad entry.

Obsolete

SDT 5.3 match strategies are still available. Only the arigid match has not been ported to SDT 6.1. This section thus documents SDT 5.3 match calls.

For topology correlation, the sensor configuration must be stored in the sens.tdof field and active FEM DOFs must be declared in sens.DOF. If you do not have your analysis modeshapes yet, you can use sens.DOF=feutil('getdof',sens.DOF). With these fields and a combined test/FEM model you can estimate test node motion from FEM results. Available interpolations are

• near defines the projection based on a nearest node match.
• rigid defines the projection based on a nearest node match but assumes a rigid body link between the DOFs of the FE model and the test DOFs to obtain the DOF definition vector adof describing DOFs used for FEM results.
• arigid is a variant of the rigid link that estimates rotations based on translations of other nodes. This interpolation is more accurate than rigid for solid elements (since they don't have rotational DOFs) and shells (since the value of drilling rotations is often poorly related to the physical rotation of a small segment).

At each point, you can see which interpolations you are using with
fe_sens('info',sens). Note that when defining test nodes in a local basis, the node selection commands are applied in the global coordinate system.

The interpolations are stored in the sens.cta field. With that information you can predict the response of the FEM model at test nodes. For example

 [model,def]=demosdt('demo gartte cor');
 model=fe_sens('rigid sensors',model); % link sensors to model
 % display sensor wire-frame and animate FEM modes
 cf=feplot; cf.model=model; cf.sel='-sensors';
 cf.def=def;fecom(';undefline;scd.5;ch7')