next up previous contents index
Next: II.5 The ``ClaLoad'' class Up: II. Composite Reference Manual Previous: II.3 The ``ClaMat'' class   Contents   Index


II.4 The ``ClaLam'' class

The ``ClaLam'' class is used to store lay-ups and calculate laminate mechanical properties and load responses. They are characterized by the lay-up the define.

Table II.4.1 gives the list of methods defined in ``ClaLam'' class.

Table II.4.1: The different methods that have been defined in ``ClaLam'' class.
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
Creation and initialization methods table.ClaLam.methods
ClaLam.newnew II.4.2 IV.5.2
ClaLam.initializeinitialize II.4.2  
ClaLam.cloneclone II.4.13  
Class single methods
ClaLam.setMuxMuysetMuxMuy II.4.1  
ClaLam.getMuxMuygetMuxMuy II.4.1  
Manipulations of the laminate plies
ClaLam.clearPliesclearPlies II.4.4  
ClaLam.addPlyaddPly II.4.4 IV.5.2
ClaLam.setNbrPliessetNbrPlies II.4.4  
ClaLam.setPlysetPly II.4.4  
ClaLam.getNbrPliesgetNbrPlies II.4.4  
ClaLam.getPlyDatagetPlyData II.4.4  
Other laminate data
ClaLam.clearAllowablesclearAllowables II.4.5  
ClaLam.insertAllowablesinsertAllowables II.4.5 IV.5.6
ClaLam.fillAllowablesfillAllowables II.4.5  
ClaLam.getDataAllowablesgetDataAllowables II.4.5  
ClaLam.setRefTsetRefT II.4.5  
ClaLam.getRefTgetRefT II.4.5  
ClaLam.setRefHsetRefH II.4.5  
ClaLam.getRefHgetRefH II.4.5  
ClaLam.setLaminateIlsssetLaminateIlss II.4.5 IV.5.4.3
ClaLam.setAllPliesIlsssetAllPliesIlss II.4.5 IV.5.4.3
Laminate properties
ClaLam.calcLaminatePropertiescalcLaminateProperties II.4.6 IV.5.3
ClaLam.get_thicknessget_thickness II.4.6  
ClaLam.get_surfacicMassget_surfacicMass II.4.6  
ClaLam.get_averageDensityget_averageDensity II.4.6  
ClaLam.get_ABBDget_ABBD II.4.6 IV.5.2
ClaLam.get_Gget_G II.4.6 IV.5.5
ClaLam.get_alfaEh1get_alfaEh1 II.4.6 IV.5.2
ClaLam.get_alfaEh2get_alfaEh2 II.4.6  
ClaLam.get_alfaEh3get_alfaEh3 II.4.6  
ClaLam.get_alfaGh1get_alfaGh1 II.4.6  
ClaLam.get_alfaGh2get_alfaGh2 II.4.6  
ClaLam.get_betaEh1get_betaEh1 II.4.6  
ClaLam.get_betaEh2get_betaEh2 II.4.6  
ClaLam.get_betaEh3get_betaEh3 II.4.6  
ClaLam.get_betaGh1get_betaGh1 II.4.6  
ClaLam.get_betaGh2get_betaGh2 II.4.6  
ClaLam.get_abbd_complMatget_abbd_complMat II.4.6  
ClaLam.get_g_complMatget_g_complMat II.4.6  
ClaLam.get_alfae0get_alfae0 II.4.6  
ClaLam.get_alfae1get_alfae1 II.4.6  
ClaLam.get_alfak0get_alfak0 II.4.6  
ClaLam.get_alfak1get_alfak1 II.4.6  
ClaLam.get_alfas0get_alfas0 II.4.6  
ClaLam.get_alfas1get_alfas1 II.4.6  
ClaLam.get_betae0get_betae0 II.4.6  
ClaLam.get_betae1get_betae1 II.4.6  
ClaLam.get_betak0get_betak0 II.4.6  
ClaLam.get_betak1get_betak1 II.4.6  
ClaLam.get_betas0get_betas0 II.4.6  
ClaLam.get_betas1get_betas1 II.4.6  
ClaLam.get_engineeringget_engineering II.4.6 IV.5.4.1
ClaLam.get_LambdaTget_LambdaT II.4.6 IV.5.3
ClaLam.get_R33Tget_R33T II.4.6 IV.5.3
ClaLam.get_RhoCpHget_RhoCpH II.4.6 IV.5.3
ClaLam.get_LambdaHget_LambdaH II.4.6  
ClaLam.get_R33Hget_R33H II.4.6  
Laminate load response
ClaLam.calcResponsecalcResponse II.4.7.1 IV.5.4.2
ClaLam.isThermalLoadingDefinedisThermalLoadingDefined II.4.7.2  
ClaLam.getDeltaTgetDeltaT II.4.7.2 IV.5.4.1
ClaLam.getT0getT0 II.4.7.2  
ClaLam.getGradTgetGradT II.4.7.2  
ClaLam.isMoistureLoadingDefinedisMoistureLoadingDefined II.4.7.2  
ClaLam.getDeltaHgetDeltaH II.4.7.2  
ClaLam.getH0getH0 II.4.7.2  
ClaLam.getGradHgetGradH II.4.7.2  
ClaLam.isMechanicalLoadingDefinedisMechanicalLoadingDefined II.4.7.2  
ClaLam.getNormalForcesgetNormalForces II.4.7.2 IV.5.4.1
ClaLam.getMomentsgetMoments II.4.7.2 IV.5.4.1
ClaLam.getShearForcesgetShearForces II.4.7.2 IV.5.4.1
ClaLam.getNormalStrainsgetNormalStrains II.4.7.2 IV.5.4.1
ClaLam.getCurvaturesgetCurvatures II.4.7.2 IV.5.4.1
ClaLam.getShearStrainsgetShearStrains II.4.7.2 IV.5.4.1
ClaLam.getAverageInPlaneStressesgetAverageInPlaneStresses II.4.7.2 IV.5.4.1
ClaLam.getFlexuralStressesgetFlexuralStresses II.4.7.2 IV.5.4.1
ClaLam.getAverageShearStressesgetAverageShearStresses II.4.7.2 IV.5.4.1
ClaLam.getAverageInPlaneStrainsgetAverageInPlaneStrains II.4.7.2 IV.5.4.1
ClaLam.getFlexuralStrainsgetFlexuralStrains II.4.7.2 IV.5.4.1
ClaLam.getAverageShearStrainsgetAverageShearStrains II.4.7.2 IV.5.4.1
ClaLam.getPliesStrainsgetPliesStrains II.4.7.3 IV.5.4.1
ClaLam.getPliesStressesgetPliesStresses II.4.7.3 IV.5.4.1
ClaLam.getPliesMechanicalStrainsgetPliesMechanicalStrains II.4.7.3 IV.5.4.1
ClaLam.getPliesStrainsWrtLamAxesgetPliesStrainsWrtLamAxes II.4.7.3  
ClaLam.getPliesStressesWrtLamAxesgetPliesStressesWrtLamAxes II.4.7.3  
ClaLam.getPliesMechanicalStrainsWrtLamAxesgetPliesMechanicalStrainsWrtLamAxes II.4.7.3  
ClaLam.getPliesTgetPliesT II.4.7.4  
ClaLam.getPliesDeltaTgetPliesDeltaT II.4.7.4  
ClaLam.getPliesHgetPliesH II.4.7.4  
ClaLam.getPliesDeltaHgetPliesDeltaH II.4.7.4  
ClaLam.getDerivedgetDerived II.4.7.5 IV.5.4.1
ClaLam.getMaxDerivedgetMaxDerived II.4.7.5  
ClaLam.getMinDerivedgetMinDerived II.4.7.5  
ClaLam.getFailureIndicesgetFailureIndices II.4.7.5 IV.5.4.1
ClaLam.getMaxFailureIndicesgetMaxFailureIndices II.4.7.5  
ClaLam.getMinFailureIndicesgetMinFailureIndices II.4.7.5  
ClaLam.getReserveFactorsgetReserveFactors II.4.7.5 IV.5.4.1
ClaLam.getMaxReserveFactorsgetMaxReserveFactors II.4.7.5  
ClaLam.getMinReserveFactorsgetMinReserveFactors II.4.7.5  
ClaLam.getStrengthRatiosgetStrengthRatios II.4.7.5 IV.5.4.1
ClaLam.getMaxStrengthRatiosgetMaxStrengthRatios II.4.7.5  
ClaLam.getMinStrengthRatiosgetMinStrengthRatios II.4.7.5  
ClaLam.calcFiniteElementResponsecalcFiniteElementResponse II.4.8.1  
ClaLam.reInitAllPliesAccelMatricesreInitAllPliesAccelMatrices II.4.8.2  
ClaLam.calcFiniteElementCriteriacalcFiniteElementCriteria II.4.9 IV.5.6
Management of units methods
ClaLam.getUnitsgetUnits II.4.10  
ClaLam.setUnitssetUnits II.4.10  
ClaLam.changeUnitschangeUnits II.4.10  
ClaLam.each_plyeach_ply II.4.12 IV.5.5
NDF lines
ClaLam.initWithNeutralLinesinitWithNeutralLines II.4.11  
ClaLam.getNeutralLinesgetNeutralLines II.4.11  
ClaLam.IdId II.4.3  

II.4.1 Two Class Methods

One shows in section II.1.6 that two arbitrary parameters $ \mu_x$ and $ \mu_y$ define the relations between $ x$ and $ y$ partial derivatives of laminate bending moment components and out-of-plane shear forces. The default values of these parameters are $ \mu_x=\mu_y=1$ .

Two Class Methods allow the manipulation of these parameters:

As these methods are Class methods, the modification of $ \mu_x$ or $ \mu_y$ affects all the laminates defined in all the CLA databases.

II.4.2 Creation of an object

The singleton method ``ClaLam.newnew'' is used to create ClaLam objects. This method has no argument. Nor has the ``ClaLam.initializeinitialize'' method an argument.)

II.4.3 Identifying a laminate

Two methods allow the manipulation of the identifier of ClaLam objects (``ClaLam.IdId'' attribute):

II.4.4 Manipulation of plies

The ``ClaLam.clearPliesclearPlies'' method has no argument and erases all the plies defining a ClaLam object. After the method has been called, the number of plies of the laminate is zero.

One way to define the plies of the laminate is to add successively all the plies defined in the laminate starting at the bottom layer. The ``ClaLam.addPlyaddPly'' method allows to insert plies in a ClaLam. This method has four or five arguments.

The sequence of plies in the laminate corresponds to the order of addition of the plies by calls to the ``ClaLam.addPlyaddPly'' method. Of course each call of the method ``ClaLam.addPlyaddPly'' increases the number of plies of the laminate by one.

Instead of defining the sequence of plies sequentially by successive calls to ``ClaLam.addPlyaddPly'' method, the data of each ply can also be defined in random order by calls to ``ClaLam.setPlysetPly'' method. Its arguments are nearly the same as those of the ``ClaLam.addPlyaddPly'' method:

As the ``PlyId'' second argument is optional, the method has 5 or 6 arguments. The ``ClaLam.setPlysetPly'' method is very handy when one defines a new laminate by modifying a few plies from a previously existing one. Of course, an entirely new laminate can also have its ply data initialized with ``ClaLam.setPlysetPly'' method, but then the number of plies must first be set... ``ClaLam.setNbrPliessetNbrPlies'' method has one argument and sets the number of plies. Note that the ply definition data previously stored in the laminate may have random values after using this method.

Two methods allow to access and examine the plies stored in a ClaLam object:

Obviously, the different data inserted in, or retrieved from the ClaLam object should be consistent with the set of units attributed to the same object. This set of units can be attributed to the object after initialization of the data.

II.4.5 Other data

The reference temperature of a laminate is accessed with the two following methods:

Note that an ILSS criterion is calculated, the allowables are always extracted from the laminate definition. When no ClaDb argument is provided for the calculation of the criterion, the laminate ``ilss'' allowable is used; when a ClaDb argument is provided, the ply ``ilss'' allowables are used. This means that the ``ilss'' allowable provided in ClaMat materials is never used.

Obviously, the different data inserted in, or retrieved from the ClaLam object should be consistent with the set of units attributed to the same object. This set of units can be attributed to the object after initialization of the data.

II.4.6 Laminate properties

The method ``ClaLam.calcLaminatePropertiescalcLaminateProperties'' calculates the laminate properties of the ClaLam object. This means that the stiffness and compliance matrices, the thermal-expansion vectors are estimated and stored into the laminate object. This method can be called only after all the plies of the laminate have been inserted into the object. The method has one argument: a ClaDb object in which all the materials used in the lay-up definition have to be stored (otherwise, an exception is raised). Note that when a ClaLam object is inserted into a ClaDb, the ``ClaLam.calcLaminatePropertiescalcLaminateProperties'' method is called automatically, with this ClaDb object as argument.

Six methods allow to retrieve the properties of a laminate:

These five methods have one optional Real argument that corresponds to a rotation angle wrt laminate axes. If the argument is omitted, zero value is assumed and the engineering constants are calculated in laminate axes. The angle is specified in $ {}^{o}$ .

Four methods return Real scalar values:

These methods have no arguments.

The different calculated results from the ClaLam object are expressed in the units system associated with the object.

II.4.7 Laminate load response

The calculation of the laminate response to a specified loading is always done in two steps:

  1. The laminate load response is calculated for a specific loading. This calculation is used to estimate laminate in-plane forces, bending moments, average strains, curvature, temperature variations... Also layered results are calculated if required. (See description of method ``ClaLam.calcResponsecalcResponse'' in section II.4.7.1.)

    All these results are stored in the ClaLam object and remembered until the next calculation is performed.

  2. Then, the laminate can be ``interrogated'' to obtain a restitution of stored results, or the calculation of new results from the information stored since the last calculation. (See the methods described in sections II.4.7.2, II.4.7.3 and II.4.7.5.
This way of working allows at the same time much flexibility in the recovery of results at an acceptable computational cost.

The different calculated results retrieved from the ClaLam object are expressed in the units system associated with the object.

II.4.7.1 Calculation of the load response

The method ``ClaLam.calcResponsecalcResponse'' is used to calculate the laminate response to a specified loading. When this method is called, several results are systematically calculated and stored: in-plane forces, bending moments, average strains, curvature and temperature variation. The calculation and storage of ply results is optional and commanded by the Boolean arguments of the method.

The ``ClaLam.calcResponsecalcResponse'' may have from 3 up to 6 arguments:

The three last parameters are optional and default to false (no calculation of the corresponding layered results).

II.4.7.2 Laminate internal loads and strains

Several methods allow to recover results calculated at laminate level. All these results correspond to the laminate results for the last call to method ``ClaLam.calcResponsecalcResponse'':

The optional rotation is specified as an angle expressed in degrees. When the parameter is omitted, a zero value is assumed. When a tensor is returned the three components are given in the following order: XX, YY and XY.

II.4.7.3 Ply stresses and strains

Three methods give access to the ply results stored in ClaLam object:

These three methods: The methods return an Array of which each element corresponds to the stresses/strains at one given location in the thickness of the laminate. More precisely, each element is an Array of 2+6=8 elements containing: To the three methods listed above correspond three other methods that return the ply stresses or strains with components expressed in a coordinate system defined wrt the laminate, and not expressed in ply axes. The three methods are called: The first argument of these three methods are a real value corresponding to the rotation of restitution coordinate system wrt laminate axes. The following arguments are the same as those of the three first methods defined above.

II.4.7.4 Temperatures and moistures at ply level

Four methods give access to the temperature and moisture ply results stored in ClaLam object:

The arguments are the same as those of the method described in section II.4.7.3: they correspond to the identifiers of layers at which ply results are recovered. The methods return an Array of which each element corresponds to a layered Result. More precisely, each element is an Array of 3 elements containing:

II.4.7.5 Other ply results

Several methods of the ClaLam class allow to estimate values from the stored ply stresses and strains. Three such methods return the values calculated for several plies:

``ClaLam.getDerivedgetDerived'' and ``ClaLam.getFailureIndicesgetFailureIndices'' have the same parameters: So for example, ``ClaLam.getFailureIndicesgetFailureIndices'' method may be called as follows:
Note that several criteria can be calculated by a single call.

Methods ``ClaLam.getReserveFactorsgetReserveFactors'' and ``ClaLam.getStrengthRatiosgetStrengthRatios'' have one additional parameter: the factor of safety. This parameters is a Real value provided after the list of criteria and before the optional layer identifiers. For example

Each of the four methods described above returns an Array containing two elements:
  1. The first element is an Array of Strings containing the list of criteria that have been calculated. Indeed, the criteria are calculated only if the criterion is available. This Array has X elements.
  2. The second element contains the new layered results. Each element of this Array contains 2+X elements:
The four methods ``ClaLam.getDerivedgetDerived'', ``ClaLam.getFailureIndicesgetFailureIndices'', ``ClaLam.getReserveFactorsgetReserveFactors'' and ``ClaLam.getStrengthRatiosgetStrengthRatios'' have ``Min'' and ``Max'' variants. This makes six additional methods: ``ClaLam.getMinDerivedgetMinDerived'', ``ClaLam.getMinFailureIndicesgetMinFailureIndices'', ``ClaLam.getMinReserveFactorsgetMinReserveFactors'', ``ClaLam.getMinStrengthRatiosgetMinStrengthRatios'', ``ClaLam.getMaxDerivedgetMaxDerived'', ``ClaLam.getMaxFailureIndicesgetMaxFailureIndices'', ``ClaLam.getMaxReserveFactorsgetMaxReserveFactors'' and ``ClaLam.getMaxStrengthRatiosgetMaxStrengthRatios''. These methods have the same parameters as their basic corresponding methods and are used to return values associated to the most critical ply. (The ply leading to maximum or minimum calculated criterion.) The returned Array, however, is different. The returned value is an Array of which each element is an Array of four elements:
  1. The calculated criterion (String).
  2. Two elements identifying the critical layer (an integer and string value).
  3. A Real object corresponding to the critical value.
The criteria presently available are summarized in Table II.1.2.

II.4.8 Laminate finite element load response

II.4.8.1 Calculation of laminate loads, stresses and strains

The ``ClaLam.calcFiniteElementResponsecalcFiniteElementResponse'' method allows the calculation of finite element load response. More precisely the method calculates several Result objects containing finite laminate finite element results, from loading of which some components are finite element results. The method has up to nine arguments:

  1. The first argument is a ``ClaDb'' object in which the materials used in the laminate definition are stored.
  2. The second argument, ``theta'', is a real value corresponding to the angle in degrees of loading wrt laminate axes. In most cases, this angle will be zero. Note that the same angle is used to calculate laminate load response for all elements and nodes on which it is required.
  3. The third argument is a ClaLoad object in which the loading is defined. This ClaLoad object must have some components defined as finite element results.
  4. The fourth argument is an Array of three logical values. Each logical value corresponds to the request of results at bottom, mid and top location respectively, in each ply. (The components are similar to three of the arguments of ``ClaLam.calcResponsecalcResponse'' method described in section II.4.7.1.)
  5. The fifth parameter is an Array of Strings specifying the non-layered laminate results that will be returned by the method.
  6. The sixth parameter is an Array of Strings specifying the layered laminate results that will be returned by the method. (Results at ply level.)
  7. The seventh parameter is a Real object corresponding to the safety factor. This parameter is used by the method only for the calculation of reserve factors, or strength ratios. (See the following argument.)
  8. The eighth parameter is an Array of Arrays describing the failure indices, reserve factors or equivalent scalar derived values requirements. Each element of the first Array is an Array of up to five elements:
    1. A String corresponding to the key by which the corresponding result shall be referred in the Hash returned by ``DataBase.calcFiniteElementResponsecalcFiniteElementResponse'' method.
    2. A String corresponding to the name of the criterion. This name must one of the names defined in Table II.1.2.
    3. A string defining the type of Result that shall be defined. Values can be ``FI'', ``RF'', ``SR'' or ``EQ''. They correspond to the calculation of Failure Indices, Reserve Factors, Strength Ratios or Scalar Derived values respectively. If a Reserve Factor or Strength Ratio is required, the factor of safety parameter is used for the calculation.
    4. A logical value specifying whether the laminate allowables are used for the calculation of Result values. If this value is false, then the ply material allowables are used in the calculations.
    5. A logical value specifying if Result values are required for all the plies. If the argument is ``false'', the critical layer value only is inserted in the returned Result.
    The Logical parameters are optional. If not defined, ``false'' values are assumed.
  9. An Array containing the list of plies on which stresses, strains or scalar failure indices are to be calculated. (For example, an Array of integers corresponding to ply idfiers.)
The method returns a Hash object containing pairs of Strings and Results. One can make a few remarks that should help to understand Results returned by the method: The requirements for laminate non-layered and layered Results are summarized in Table II.4.2 and Table II.4.3 respectively.

II.4.8.2 Acceleration

One explains in section II.1.9.2 how the plies stresses and strains calculation can be significantly accelerated by calculating once and for all intermediate acceleration matrices for each ply. These matrices must be recalculated each time the laminate or one of its materials is modified.

Method ``ClaLam.reInitAllPliesAccelMatricesreInitAllPliesAccelMatrices'' has been added to the ``ClaLam'' class to re-initialize the laminate plies acceleration matrices. This ensures that the matrices will be re-calculated next time they are required.

II.4.8.3 Units

Note that the same method with exactly the same arguments has been defined in the DataBase class. (See section I.1.5.)

An example of use of the method follows:

    criteria = []
    criteria << ["TS FI","TsaiHill2D","FI",true,true]
    criteria << ["TW FI","TsaiWu2D","FI",true,true]
    criteria << ["TW FI Critical","TsaiWu2D","FI",true,false]
    criteria << ["ILSS FI Critical","Ilss","FI",true,false]
        ["Shell Forces","Shell Moments", "Shell Curvatures",
         "Average Strain Tensor"],
        ["Stress Tensor","Strain Tensor","Mechanical Strain Tensor",
         "Ply Temperature Variation"],

Table II.4.2: Laminate non-layered Results requirements.
Requirement Finite Element Result
``Shell Forces'' ``Shell Forces''
``Shell Moments'' ``Shell Moments''
``Shell Curvatures'' ``Shell Curvatures''
``Average Strain Tensor'' ``Average Strain Tensor''

Table II.4.3: Laminate non-layered Results requirements.
Requirement Finite Element Result
``Stress Tensor'' ``Stress Tensor''
``Strain Tensor'' ``Strain Tensor''
``Mechanical Strain Tensor'' ``Mechanical Strain Tensor''
``Ply Temperature'' ``Ply Temperature''
``Ply Temperature Variation'' ``Ply Temperature Variation''
``Ply Moisture'' ``Ply Moisture''
``Ply Moisture Variation'' ``Ply Moisture Variation''

The different calculated results from the ClaLam object are expressed in the units system associated with the object.

II.4.9 Calculation of criteria from FE stresses or strains

The ``DataBase.calcFiniteElementCriteriacalcFiniteElementCriteria'' method allows the calculation of ply failure criteria, reserve factors or equivalent stress or strain from layered Results. The method has four arguments:

The method returns a Hash object containing pairs of Strings and Results. In this case, only scalar Result objects are returned.

The different calculated results from the ClaLam object are expressed in the units system associated with the object.

II.4.10 Management of Units

The ``ClaLam'' class defines three methods for the management of units:

The `ash arguments or return values mentioned above have String keys and values as explained in section II.1.13. The difference between the ``ClaLam.setUnitssetUnits'' and ``ClaLam.changeUnitschangeUnits'' methods is also explained in the same section.

II.4.11 Saving or initializing with NDF lines

Two methods allow to save or read ClaLam objects from an Array of Strings in neutral format. These two methods are ``ClaLam.initWithNeutralLinesinitWithNeutralLines'' and ``ClaLam.getNeutralLinesgetNeutralLines'' that work in a similar way as the corresponding methods in ``ClaDb'' class (section II.2.6).

However, the lines transmitted to ``ClaLam.initWithNeutralLinesinitWithNeutralLines'' or returned by ``ClaLam.getNeutralLinesgetNeutralLines'' correspond to a single ClaLam object definition.

II.4.12 One iterator

The ClaLam class provides the iterator ``ClaLam.each_plyeach_ply'' that iterates on the plies. This iterator returns pairs of elements corresponding to the ply index, and the ply definition. The ply definition is an Array of 5 elements identical to the one returned by ``ClaLam.getPlyDatagetPlyData'' method.

II.4.13 Other methods

``ClaLam.cloneclone'' method has no argument and returns a copy of the ClaLam object.

next up previous contents index
Next: II.5 The ``ClaLoad'' class Up: II. Composite Reference Manual Previous: II.3 The ``ClaMat'' class   Contents   Index
FeResPost 2017-05-28