Metafor

ULiege - Aerospace & Mechanical Engineering

User Tools

Site Tools


doc:user:results:courbes_res



Saving history curves to disk

Introduction

In this section, it will be shown how to write the evolution of given fields to disk, e.g. the contact force as function of time. This is done with what is called “result curves”.

These curves are saved for each time step while archiving files (bfac) are usually saved at a lower sampling frequency. This leads to a very good temporal resolution for these curves.

The respective files are saved in the folder of the test case (workspace/test_name by default). The information of each curve is saved twice, once as a binary file used internally (values.v), and once as a text file (valeurs.ascii), easy to load in Matlab, Excel, …

The class “ValuesManager” manages the interfac, allowing :

  • the definition of a ValueExtractor (extracting results),
  • the retrieval of a vector to view it in real time,

Depending on whether one or several values are extracted, the file on disk will be a vector or a matrix. The number of values saved for each time step depends on the extraction command.




ValuesManager

The ValuesManager manages the extraction of data at each time step. It is a container of ValueExtractors defined in the analysis metafor :

valuesmanager = metafor.getValuesManager()
valuesmanager.add(nbr, extractor, name = "")        # manages extraction, result storage... 
valuesmanager.add(nbr, extractor, v2sOp, name = "") # same + transformation from vector to scalar
valuesmanager.getDataVector(nbr)                    # returns a reference of the vector storing values     
                                                    # (for example to create and view curves)
valuesmanager.setOnFile(False)                      # Keep curves in memory instead of writing 
                                                    # .v and .ascii files
                                                    

where

nbr number of the curve (unique)
extractor reference of a ValueExtractor
v2sOp Operator such as VectorToScalarOperator
name name of the curve (of the file)
can be generated automatically by the extractor (not always meaningful)




FacValuesManager

The FacValuesManager manages the extraction of data at each time a “bfac” file is written. It is exactly the same object as the ValuesManager, but called at different times of the time integration.

To access the FacValuesManager, just get it from metafor. The rest of the syntax is the same.

facValuesManager = metafor.getFacValuesManager()
Be carefull that ThermoDynamics Fields (TdFieldValueExtractor) will give false values, as they accumulate values from each time step !!! Metafor will not prohibit the use of them (it is up to you to NOT define them).

StageValuesManager

The StageValuesManager manages the extraction of data at the end of each stage. It is exactly the same object as the ValuesManager, but called at different times of the time integration.

To access the StageValuesManager, just get it from metafor. The rest of the syntax is the same.

  stageValuesManager = metafor.getStageValuesManager()
Be carefull that ThermoDynamics Fields (TdFieldValueExtractor) will give false values, as they accumulate values from each time step !!! Metafor will not prohibit the use of them (it is up to you to NOT define them).

ValueExtractor

ValueExtractor defines which values are to be archived. It manages:

  • selecting an entity on which the value is extracted (node, point, line, interaction, …),
  • the field to extract (value in data base, extrapolated internal field, averaged internal field, thermodynamic field, …),
  • operations to apply on these fields (average, max, min, … ).

Extracting values at a given node

DbNodalValueExtractor

Extract values stored in the data base, so fields which are indeed stored in nodes (positions, displacements, temperature, forces, velocities, …).

valueExtractor = DbNodalValueExtractor(gObject, dbField)
valueExtractor = DbNodalValueExtractor(gObject, dbField, sOp = None, maxV = -1)

where

gObject Geometric object containing the nodes at which the field is extracted
dbField Field1D describing the scalar to extract
sOp SortingOperator : sort nodes according to a geometric criterion def=None will give the order in which these nodes are generated (not reliable)
maxV Number of values saved after sorting def=-1 ⇒ keep all values

Example:

valuesmanager.add(8, DbNodalValueExtractor( curveset(1), Field1D(TY,GF2)), 
                  SumOperator(), 'totalForce_X')

Extract a result curve numbered 8 defined by the sum of all internal forces along line 1. This curve is named totalForce_X.

IFNodalValueExtractor

Extract Internal Fields Values at nodes. As these values only exists at integration point level of the elements, the extracted values are the result of the extrapolation of Integration points values to the node (a contribution of each element using the node is taken into account).

valueExtractor = IFNodalValueExtractor(gObject, InternalField, sOp=None, maxV=-1)

where

gObject Geometric object containing the nodes at which the field is extracted
InternalField internal field of the element extrapolated in the node
sOp SortingOperator : sort nodes according to a geometric criterion def=None will give the order in which these nodes are generated (not reliable)
maxV Number of values saved after sorting def=-1 ⇒ keep all values

Extracting values at a given position

A set of extractor can be defined on points that do not correspond to node position.

The value is computed from the interpolation of elementary values from the first element that belong the point. An outer tolerance is defined (OutsideTol) to allow detection of point just outside the mesh.

The point can be Lagrangian (fixed to material : default) or Eulerian (geometrically defined fixed or not) where element and reduced coordinate are computed at each extraction)

DbGeoPointValueExtractor

Extract values stored in the data base, On geometrically defined point (positions, displacements, temperature, forces, velocities, …).

valueExtractor = DbGeoPointValueExtractor (pointList, mesh, field)
valueExtractor.setEulerian(True) 
valueExtractor.setOutsideTol(tol)

where

listPt List of points where the field is extracted
mesh Mesh from which the value is extracted
dbField Field1D describing the scalar to extract
tol Outside tolerance in terms of reduced coordinate (default = 0.2)

Example:

  pt102 = pointset.define(102,0.15*Lx,0.75*Ly,0)     # geo point of extraction (must be in pointset)
  dyPt102 = DbGeoPointValueExtractor([pt102,], geometry.getMesh(), Field1D(TY, RE))
  dyPt102.setEulerian(True)                       # Eulerian point (not moving with elements)
  dyPt102.setOutsideTol(0.5)                      # half an element outside detection tolerance

IFGeoPointValueExtractor

Extract Internal Fields Values on geometrically defined point(s). Value are interpolated from Integration Points Values.

valueExtractor = IFGeoPointValueExtractor (pointList, mesh, InternalField)
valueExtractor.setEulerian(True) 
valueExtractor.setOutsideTol(tol)

where

listPt List of points where the field is extracted
mesh Mesh from which the value is extracted
InternalField internal field of the element extrapolated in the node
tol Outside tolerance in terms of reduced coordinate (default = 0.2)

Example:

  pt102 = pointset.define(102,0.15*Lx,0.75*Ly,0)     # geo point of extraction (must be in pointset)
  eplPt102 = IFGeoPointValueExtractor([pt102,], geometry.getMesh(), IF_EPL) 
  eplPt102.setEulerian(True)                        # Eulerian point (not moving with elements)
  eplPt102.setOutsideTol(0.5)                       # half an element outside detection tolerance 
  

GeoPtValueExtractor

Extract fields at a given position. Interpolates nodal value of the corresponding element. These nodal values are either variables stored in these nodes (positions, displacements, temperature, fores, velocities, …) or an extrapolation and average of variables stored at the integration points.

valueExtractor = GeoPtValueExtractor (listPt, mesh, field)
valueExtractor = GeoPtValueExtractor (listPt, mesh, field, sOp = None)

where

listPt List of points where the field is extracted
mesh Mesh from which the value is extracted
field Field1D describing the scalar to extract or internal field of the element extrapolated and averaged in the node
sOp SortingOperator : sort nodes according to a geometric criterion def=None will give the order in which these nodes are generated (not reliable)

Example:

valuesmanager.add(8, GeoPtValueExtractor ( [point1, point2], Field1D(T0,RE)), 'temperature_P1_P2')

Extract a result curve numbered 8 defined by the temperature in points 1 and 2. This curve is named temperature_P1_P2.

TdFieldValueExtractor

Extract thermodynamic fields :

  valueExtractor = TdFieldValueExtractor(meta, gObject, tdFieldID)
  valueExtractor = TdFieldValueExtractor(meta, nodeSet, tdFieldID)
meta Reference of the analysis Metafor
gObject Geometric object containing the nodes at which the thermodynamic field is extracted
nodeset Reference of Metafor NodeSet (calculation over the entire domain)
tdFieldID TdFieldID : thermodynamic field to extract
THERMODYN_TRAV_FINT : Work of Internal Forces
THERMODYN_EN_CIN : Kinetic Energy
THERMODYN_EN_DIS : Dissipated Energy
THERMODYN_TRAV_FEXT : Work of External Forces
THERMODYN_POT_INT : Internal Potential
THERMODYN_LIN_MOM_X : X Linear Momentum
THERMODYN_LIN_MOM_Y : Y Linear Momentum
THERMODYN_LIN_MOM_Z : Z Linear Momentum
THERMODYN_ANG_MOM_X : X Angular Momentum
THERMODYN_ANG_MOM_Y : Y Angular Momentum
THERMODYN_ANG_MOM_Z : Z Angular Momentum

MomentValueExtractor

momentVE = MomentValueExtractor(target, center, momentNature, targetVariant,sOp=None, maxV=-1)

Extract a component of the moment force vector (internal, external, inertial) with respect to a center of an object containing these nodes (meshed object, group, …).

target Geometric object containing the nodes at which the field is extracted
center Point (GeoObject0D) around which the moment is computed
momentNature Component of the extracted moment vector (TX, TY or TZ)
targetVariant variant defining the type of force whose moment is computed (GF1, GF2 or GF3)
sOp SortingOperator : sort nodes according to a geometric criterion def=None will give the order in which these nodes are generated (not reliable)
maxV Number of values saved after sorting def=-1 ⇒ keep all values
  • the center can be a point or a node, fixed or moving
  • MomentValueExtractor has all its meaning if used with VectorToScalarOperator

Moment2AxeValueExtractor

moment2AxeVE = Moment2AxeValueExtractor(target, axis, targetVariant,sOp=None, maxV=-1)

Extract the moment force (internal, external, inertial) with respect to an axis containing these nodes (meshed object, group, …). It computes the torque of forces around the axis.

target Geometric object containing the nodes at which the field is extracted
axis Reference to a Axes object
targetVariant variant defining the type of force whose moment is computed (GF1, GF2 or GF3)
sOp SortingOperator : sort nodes according to a geometric criterion def=None will give the order in which these nodes are generated (not reliable)
maxV Number of values saved after sorting def=-1 ⇒ keep all values
  • the axis can be fixed or moving
  • Moment2AxeValueExtractor has all its meaning if used with VectorToScalarOperator

Extracting values at integration points

IFGaussPointValueExtractor

Extract values of internal fields at the integration points.

valueExtractor = IFGaussPointValueExtractor (topoCell, ifield)

where

topoCell Topological object supporting the element
2D : Topological face
3D : Topological volume
ifield internal field of the element extrapolated to the node
TX : X coordinate
TY : Y coordinate
TZ : Z coordinate

:!: works, but :!::!::!:

Extracting elementary values

IFElementValueExtractor

Extract a value of internal fields averaged over an element.

valueExtractor = IFElementValueExtractor (topoCell, ifield)

where

topoCell Topological object supporting the element
2D : Topological face
3D : Topological volume
ifield internal field of the element extrapolated to the node

:!: works, but :!::!::!:

Extracting analysis values (MiscValueExtractor)

Extract values associated to the computation (analysis values)

valueExtractor = MiscValueExtractor(meta, type)
meta Reference of the analysis Metafor
type defines the value to extract:
EXT_T : time
EXT_DT : time step
EXT_NT : time step number
EXT_ITE : number of mechanical iterations over a time step
EXT_ITE_TOT : total number of mechanical iterations (included failed steps !)
EXT_ITE_TH : number of thermal iterations over a time step
EXT_ITE_TH_TOT : total number of thermal iterations (included failed steps !)
EXT_ITE_AR : number of mechanical iterations with update of tangent stiffness matrix over a time step
EXT_ITE_SR : number of mechanical iterations without update of tangent stiffness matrix over a time step
EXT_ITE_AR_TOT : total number of mechanical iterations with update of tangent stiffness matrix (included failed steps !)
EXT_ITE_SR_TOT : total number of mechanical iterations without update of tangent stiffness matrix (included failed steps !)
EXT_ITE_TH_AR : number of thermal iterations with update of tangent stiffness matrix over a time step
EXT_ITE_TH_SR : number of thermal iterations without update of tangent stiffness matrix over a time step
EXT_ITE_TH_AR_TOT : total number of thermal iterations with update of tangent stiffness matrix (included failed steps !)
EXT_ITE_TH_SR_TOT : total number of thermal iterations without update of tangent stiffness matrix (included failed steps !)
EXT_ITE_LS : number of mechanical line-search iterations over a time step
EXT_ITE_LS_TOT : total number of mechanical line-search iterations (included failed steps !)
EXT_ITE_TH_LS : number of thermal line-search iterations over a time step
EXT_ITE_TH_LS_TOT : total number of thermal line-search iterations (included failed steps !)
EXT_ITE_ALM : number of augmentations over a time step
EXT_ITE_ALM_TOT : total number of augmentations (included failed steps !)
EXT_RCOND : reciprocal condition number of the mechanical tangent stiffness matrix
EXT_VM…. : Extractors of virtual memory (see table below)
EXT_USER_CPU : User CPU
EXT_REAL_CPU : Real CPU
EXT_KERNEL_CPU : Kernel CPU

Extractors of virtual memory in Linux and Windows

ExtractType Linux description Windows description
EXT_VMPEAK VmPeak : Peak Virtual Memory usage PeakWorkingSetSize : The Peak Working Set size
EXT_VMSIZE VmSize : Current Virtual Memory usage WorkingSetSizeCurrent : The current Working Set Size
EXT_VMLCK VMLCK : Current mlocked Memory -
EXT_VMHWM VMHWM : Peak resident set size -
EXT_VMRSS VmRSS : Virtual Memory ResidentSetSize -
EXT_VMDATA VmData : size of “data” segment -
EXT_VMSTK VmSTK : size of stack -
EXT_VMEXE VmExe : size of “test” segment -
EXT_VMLIB VmLib : Shared library usage -
EXT_VMPTE VmPTE : pagetable entries size PeakPagefileUsage : The peak value in bytes of the Commit Charge during te lifetime of this process
EXT_VMSWAP VmSwap : swap space used PagefileUsage : The Commit Charge value in bytes for this process

Example:

valuesmanager.add(1, MiscValueExtractor(metafor, EXT_T),'time')

Extract the time value for each time step, in the vector 1 named time.

Extracting values on an interaction

InteractionValueExtractor

Extract a component of a vector computed by the elements of an interaction.

valueExtractor = InteractionValueExtractor (interaction, natureId, vectorId=GEN_EXT_FORC)

where

interaction Reference of an interaction
natureId Fields at Nodes (TX, TY, TZ or TO) (only scalar)
vectorId VectorID : ID defining the vector computed by the element
GEN_INTER_FORC : Generalized internal forces
GEN_EXT_FORC : Generalized external forces
GEN_INERT_FORC : Generalized inertial forces (consistent mass matrix)
GEN_DIAG_MASS_FORC : Generalized inertial forces (diagonalized mass matrix)
GEN_DIS_FORC : Generalized dissipation forces

InteractionGravityCenterAndMassValueExtractor

Extract the time evolution of the position of the center of gravity and mass of an interaction. At each archiving step the extractor fills a four columns text file, where columns 1-3 contain x, y, and z coordinates of the center of gravity respectively, and column 4 contains the value of the mass.

valueExtractor = InteractionGravityCenterAndMassValueExtractor (interaction)

where

interaction –> Reference of an interaction.

Extracting values on a contact interaction

Series of extractors associated to contact interaction. They give values for contact elements, which is to say in each slave nodes.

The matricial output can be sorted and reduced using SortingOperators and/or can be made scalar (at the ValuesManager level) using a VectorToScalarOperator.

Extracted values have a filter allowing to archive the extractor name and a subset of slave nodes of the contact interaction.

valueExtractor = ContactStatusValueExtractor(contInt, sOp=None, maxV=-1)
valueExtractor.setGeoFilter(gObject)
gObject = meshed geometric object, included in the object on which the contact interaction is defined. 

By default, all contact elements associated to the interaction are considered (for defo-defo contact in two stages, both master and slave nodes are considered).

Operations are done in the following order:

- Filter operation - Sorting operation - “resize” operation, so reducing the number of stored values after filtering and sorting.

ContactStatusValueExtractor

Extract the status of normal contact in each slave node:

valueExtractor = ContactStatusValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

Outputs:

Status Extracted value
Inactive contact 0.0
Active contact 1.0

The number of nodes in contact is easily deduced:

valuesmanager.add(no, ContactStatusValueExtractor(ci), SumOperator(), 'NodesInContact') 
SlidingStatusValueExtractor

Extract the status of tangential contact in each slave node:

valueExtractor = SlidingStatusValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

Outputs :

Status Extracted value
Inactive contact 0.0
Sticking contact 0.0
Sliding contact 1.0
NormalGapValueExtractor

Extract the normal gap in each slave node:

valueExtractor = NormalGapValueExtractor(contInt, sOp=None, maxV=-1 , _nonContactGapsSetToZero=True)

Inputs :

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
_nonContactGapsSetToZero Set the normal gap of inactive slave node to zero (def = True)

Outputs :

Status Extracted value
Inactive contact 0.0
Active contact normal gap (signed value, positive if overlap???)

The maximal normal gap is easily deduced:

valuesmanager.add(no, NormalGapValueExtractor(ci), AbsMaxOperator(), 'GapMax') 
TangentGapValueExtractor

Extract the norm of tangential gap in each slave node:

valueExtractor = TangentGapValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

The value corresponds to the total gap (sticking gap + sliding gap) with respect to the sticking point of the previous balanced configuration when the slave node is sliding/or sticking. But, when the slave node is sliding, this gap is considered as zero in this extractor and thus only the slave node in sticking contact receives a non-zero value.

It is possible to archive the sliding and the sticking gaps :

valueExtractor.setNonStickingGapsSetToZero(False)

TangentGap1ValueExtractor

Extract the component 1 of tangential gap in each slave node:

valueExtractor = TangentGap1ValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of tangential gap are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)

The value corresponds to the total gap (sticking gap + sliding gap) with respect to the sticking point of the previous balanced configuration when the slave node is sliding/or sticking. But, when the slave node is sliding, this gap is considered as zero in this extractor and thus only the slave node in sticking contact receives a non-zero value.

It is possible to archive the sliding and the sticking gaps :

valueExtractor.setNonStickingGapsSetToZero(False)

TangentGap2ValueExtractor

Extract the component 2 of tangential gap in each slave node:

valueExtractor = TangentGap2ValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of tangential gap are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)

The value corresponds to the total gap (sticking gap + sliding gap) with respect to the sticking point of the previous balanced configuration when the slave node is sliding/or sticking. But, when the slave node is sliding, this gap is considered as zero in this extractor and thus only the slave node in sticking contact receives a non-zero value.

It is possible to archive the sliding and the sticking gaps :

valueExtractor.setNonStickingGapsSetToZero(False)

NormalForceValueExtractor

Extract the nodal normal force in each slave node:

valueExtractor = NormalForceValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
PressureContactValueExtractor

Extract the contact pressure (negative or positive, if bodies are pushed against each other ???) in each slave node:

valueExtractor = PressureContactValueExtractor(contInt, sOp=None, maxV=-1)
When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the normal force.

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
NormalAugmentedLagrangianValueExtractor

Extract the normal augmented lagrangian in each slave node:

valueExtractor = NormalAugmentedLagrangianValueExtractor(contInt, sOp=None, maxV=-1)
When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the normal augmented lagrangian force.

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
TangentForceValueExtractor

Extract the norm of tangential force in each slave node:

valueExtractor = TangentForceValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
Tangent1ForceValueExtractor

Extract the component 1 of tangential force in each slave node:

valueExtractor = Tangent1ForceValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of tangential force are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)
Tangent2ForceValueExtractor

Extract the component 2 of tangential force in each slave node:

valueExtractor = Tangent2ForceValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of tangential force are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)
ShearContactValueExtractor

Extract the norm of shear stress in each slave node:

When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the tangent force.
valueExtractor = ShearContactValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
Shear1ContactValueExtractor

Extract the component 1 of shear stress in each slave node:

When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the tangent force 1.
valueExtractor = Shear1ContactValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of shear stress are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)
Shear2ContactValueExtractor

Extract the component 2 of shear stress in each slave node:

When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the tangent force 2.
valueExtractor = Shear2ContactValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of shear stress are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)
TangentAugmentedLagrangianValueExtractor

Extract the norm of tangential augmented lagrangian in each slave node:

When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the tangent force.
valueExtractor = TangentAugmentedLagrangianValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values
TangentAugmentedLagrangian1ValueExtractor

Extract the component 1 of tangential augmented lagrangien in each slave node:

When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the tangential augmented lagrangian force 1.
valueExtractor = TangentAugmentedLagrangian1ValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of tangential augmented lagrangian are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)
TangentAugmentedLagrangian2ValueExtractor

Extract the component 2 of tangential augmented lagrangien in each slave node:

When AREAINCONTACT = AIC_NO the contact area related to each contact node is equal to 1. Therefore the extracted value in this case corresponds to the tangential augmented lagrangian force 2.
valueExtractor = TangentAugmentedLagrangian2ValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

By default, the components of tangential augmented lagrangian are related to the local tangent system defined by the sliding direction (The tangent 1 is aligned with this direction and the tangent 2 is obtained with the right hand rule.). It is possible to use another local tangent system related to the tool tangents (Pay attention when using with a defo-defo contact interaction !) :

valueExtractor.setUseToolLocalSystemAxes(True)
 
AreaInContactValueExtractor

Extract the slave node contact area in each slave node:

areaInContactValues=AreaInContactValueExtractor(contInt, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
sOp SortingOperator
defaut=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

Then, the area potentially in contact can be deduced:

valuesmanager.add(no, areaInContactValues, SumOperator(), 'AreaInContact')

Nodal contact area of slave nodes in contact (and master nodes in two stages defo-defo):

activeAreaInContactValues=AreaInContactValueExtractor(contInt, sOp=None, maxV=-1)
activeAreaInContactValues.setOnlyInContactStatus()

Then, the active contact area (area which is truly in contact)

valuesmanager.add(no, activeAreaInContactValues, SumOperator(), 'ActiveAreaInContact')

ContactForceValueExtractor

Extract contact resultant forces along TX, TY or TZ of a contact interaction

contactForceValueExtractor=ContactForceValueExtractor(contInt,  natureId, contactForceType=TOTAL_FORCE, sOp=None, maxV=-1)

Inputs:

contInt contact interaction
natureId Fields at Nodes (TX, TY, TZ) (only scalar)
contactForceType Type of contact force
NORMAL_FORCE : Contact normal force
TANGENTIAL_FORCE : Contact tangential force
TOTAL_FORCE=default : Contact normal force + Contact tangential force
sOp SortingOperator
default=None
maxV Number of values saved after sorting def=-1 ⇒ keep all values

The contact force on a slave entity of a contact interaction is only taken into consideration in the extractor

Extracting values on a "TransferRegion"

Extract values associated to transfert during remeshing of an interaction (ALE or complete remeshing).

TransferValueExtractor

Extract the value of the field integral before or after transfer, the value of the difference between both or the value of the transfer error.

valueExtractor = TransferValueExtractor(transferRegion, field, type)

Inputs:

transferRegion “TransferRegion” created on the studied interaction
field ScalarNatureID or Field1D
type BEFORE, AFTER, DIFF or TRANSFER_ERROR

Value of the integral before transfer → type = BEFORE
Value of the integral after transfer → type = AFTER
Value of the difference between the integral before and after transfer → type = DIFF
value of the transfer error → type = TRANSFER_ERROR

The transfer error is defined as:

$$\frac{\int f^{old}-f^{new}}{\int f^{new} }$$

Extracting the number of active/passive elements associated to an interaction

Number of active elements:

valueExtractor = NumberOfActiveElementsExtractor(interaction)

Number of inactive elements:

valueExtractor = NumberOfInactiveElementsExtractor(interaction)

where

interaction reference to the interaction

Example to generate a file brokenelements.ascii which contains the number of elements broken for interaction 1:

  valuesmanager.add(1, NumberOfInactiveElementsExtractor(interactionset(1)),'brokenelements')

Advanced functions

Sorting functions

When a curve is defined by the ValuesManager, a ''SortingOperator'' and the number of points to keep after sorting can be added. For example (see also apps/qs/cont2.py):

valuesManager = metafor.getValuesManager()  
valuesManager .add(8, DbNodalValueExtractor(curveset(1), Field1D(TY,GF2), SortByDist0(0.5,0.0,0.0), 2), 'totalForce_X')
valuesManager .add(9, IFNodalValueExtractor(curveset(1), IF_J2, SortByKsi0(curset(3), 8),'j2OnBaseLine')

The first curve displays the force field as a function of time, on the two nodes closest to (0.5, 0). This can be viewed in Matlab using :

  load totalForce_X;
  mesh(totalForce_X);

The second curve displays the equivalent stress field as a function of time, on the 8 first nodes of line 1, sorted by their curvilinear abscissa when projected on curve 3.

Available sorting operators :

SortByX0 sort along increasing X0 of the nodes
SortByY0 sort along increasing Y0 of the nodes
SortByZ0 sort along increasing Z0 of the nodes
SortByDX0 sort along decreasing X0 of the nodes
SortByDY0 sort along decreasing Y0 of the nodes
SortByDZ0 sort along decreasing Z0 of the nodes
SortByKsi0 sort along curvilinear abscissa of the projection on a given curve
SortByDist0 sort along the initial distance of the nodes from a given point
SortByPos0 sort along the position and a Lock - TX, TY or TZ
SortByNo(num) sort along the user number of the points (or the distance of the number of the points to a given number num)

VectorToScalarOperator

In the previous example, note the parameter None in the command defining values to extract. This parameter can be replaced by a mathematical operator which transforms the list of extracted value at a given time into a scalar.

Several operators exist :

  • None: no operator (all component,s by default)
  • MaxOperator: maximal value
  • MinOperator: minimal value
  • AbsMaxOperator: compute the value whose absolute value is maximal (but keeps its sign)
  • AbsMinOperator: compute the value whose absolute value is minimal (but keeps its sign)
  • MaxAbsOperator: compute the maximal value of the vector containing absolute values (always positive)
  • MinAbsOperator: compute the minimal value of the vector containing absolute values (always positive)
  • MaxOfNonZeroOperator: maximal value excluding zero values
  • MinOfNonZeroOperator: minimal value excluding zero values
  • AbsMaxNonZeroOperator: compute the value whose absolute value is maximal (but keeps its sign), excluding zero values
  • AbsMinNonZeroOperator: compute the value whose absolute value is minimal (but keeps its sign), excluding zero values
  • MaxAbsNonZeroOperator: compute the maximal value of the vector containing absolute values (always positive), excluding zero values
  • MinAbsNonZeroOperator: compute the minimal value of the vector containing absolute values (always positive), excluding zero values
  • MeanOperator: compute the average value
  • SumOperator: compute the sum (used toe extract the resultant force exercised on a given geometric entity)

Use:

Extraction of maximal value of plastic deformation on a volume:

curves = metafor.getValuesManager()
ext =  IFNodalValueExtractor(curset(1), IF_EPL)
curves.add(1, ext, MeanOperator(), 'meanEplOnCurve1')
doc/user/results/courbes_res.txt · Last modified: 2020/11/16 12:29 by crutzen