# FeResPost home page

FeResPost
A library under GPL license that allows you to automate the post-processing of Nastran and Samcef  finite element results

FeResPost library

A library that allows you to read Nastran and Samcef finite element models and results, and to automate postprocessing operations.

Purpose of FeResPost

FeResPost is a library that allows the rapid development of small programs to be used to automate the post-processing of structural analysis finite element results.

Structural analysis

The structure analysis of complex structures often leads to repetitive tasks. This is related to :
  1. The nature of the structure that is being analysed. Identical or similar components are often present several times, and sometimes many times, in the same structure (beams, panels, interfaces, connections...). These different parts or components are generally justified exactly the same way, and the corresponding calculation is often automated (with a programming language, excel...).
  2. A structure is rarely sized for a single event, or checked again a single requirement. Generally, for static analysis, numerous load case are defined to ensure that the structure's strength is sufficient to sustain severel events in its life. This means that for each component, or each type of failure mode, the calculations is often done as many times as the number of defined load cases.
  3. During the development of the structure, the design will be updated several times. Sometimes, several versions of a structure may be justified simultaneously, or consecutively. (Think, for example, at the different versions of the B737 Boeing  or A320 Airbus planes that are flying nowadays.) This also contribute to the repititiveness of structural analysis calculations.
This explains why engineers involved in structural analysis are often also programmers. The need for automation leads them to use spreadsheets, use third party programs to accelerate the justification, or write its own post-processing programs. FeResPost can help in the development of these small programs!

How we can help?

The main purpose of the program is to download and manipulate Result entities in order to calculate margins of safety. Possible operations that can be performed on ``Result'' objects are, for example :
So far, these results can be read from Nastran XDB or OP2 files, or from Samcef DES/FAC files. The corresponding finite element models can also be important from Nastran Bulk BDF files, or Samcef Bacon DAT files.

The groups of elements and nodes can be read from Samcef DAT or Patran session files. Manipulation of these Groups, by addition, substraction, intersection, associations are possible.

FeResPost allows the simultaneous manipulation of several models by defining several NastranDb  and SamcefDb objects, and different Nastran and Samcef models can be manipulated simultaneously.

FeResPost also allows the calculation of composite structure by providing severeal classes for the Classical Laminate Analysis (CLA). Among other things, the CLA classes of FeResPost allow to :
The CLA classes can be used separately from the finite element results, but also used together with  finite element results. This allows for example to:

Classes and Modules

The library provides an access to 7 classes and 2 module allowing the manipulation of FE entities and results. The 7 classes are :
The ``Post'' module gives access to several additional functions.

Four classes used to perform Classical Laminate Analysis calculations are also provided:
The CLA classes are interfaced with the rest of FeResPost and allow to post-process very efficiently composite finite element Results.
The program is mainly written in C++, and the ruby extension is build as a wrapping around a C++ library. This solution ensures that the program is easy to manage and that the program remains efficient because costly operations are done at C++ level (compiled language efficiency).

License 

FeResPost is distributed as a GPL resource. This means that it is free, and that you can modify and re-distribute it gratis as long as you comply with ther therms of the GPL license. (These are given in an Appendix of the User Manual. See below.)

System requirements

Solvers

So far, Results of Nastran and Samcef solvers can be post-processed.

Nastran

Finite element models can be read either from a BDF (bulk data file), or an op2 file. Groups can be build by reading Patran sessions files obtained with the utilities of Patran.

Results can be read from OP2 or XDB files. The most commonly used types of elements are supported. For XDB files, it is also possible to extract results by random access (XDB attachment).

Samcef

Finite element models can be read from a dat file obtained by a ".sauve banque" Bacon command.

Results can be read or accessed randomly from DES/FAC files.

Operating systems and programming languages

The library is distributed as a ruby extension (LINUX and Windows), as a COM component (Windows only) and as a .NET assembly (Windows only).  In order to use FeResPost you need to install first one of the corresponding programming languages :
  • Ruby if you wish to use the ruby extension. (Binaries are distributed for Linux and Windows operating systems, but a recompilation of the sources allow the installation of FeResPost on other OSs.)
  • The COM component can be used with many languages, but on Windows OS only. Testst have been done with Ruby, Python, C++, VBA (in excel). Other languages like C, Java should also be capable of using the COM component.
  • All the .NET languages should be able to use the .NET assembly. This includes VB.NET, IronRuby, Java.NET, C#. Tests have been done with C# language only. (See the examples.)
The programming language in which all those operations are programmed is object oriented and allows the development of very sophisticated and large post-processing programs, or very small tools, according to the wishes of the programmer.

Other resources

Besides the installation of the programming language you wish to use, a few other programs may help you to develop scripts using FeResPost. The examples distributed on this web site and discussed in the User Manual sometimes assume that thos programs have been installed on your computer. For example:

Downloads

Latest version is version 4.2.5!

Manuals

An online HTML manual is available, but we advise to download the PDF version :
The manual presents the different classes defined in FeResPost library, with the associated properties and methods. It also illustrates the use of different FeResPost objects with examples. (See below.)

Examples

One distributes two archives containing the examples. (The content of these two files are the same.)

The examples contain a small satellite Nastran finite element model, and numerous post-processing examples :

Some of these examples are very small and illustrate simple extraction of results from XDB or OP2 files, with a very limited number of manipulations. But one also proposes examples corresponding to entire post-processing projects that could be used readily in a real project. (These examples are provided as Ruby programs, or in excel workbooks.)

One suggest however, that the user reads the examples in the order in which they are defined, starting with the ruby examples, as this is the only way to really understand the use of FeResPost objects.

Sources

As FeResPost is distributed under the GPL license, the sources are also distributed for re-compilation or modification and re-distribution :

Binaries and older versions

Binaries are distributed for several versions of FeResPost and include ruby extensions for Linux and Windows, COM component for Windows, and a .NET assembly. The FeResPost C++ library is also distributed for latest versions, but one recommends to use static linking for your own programs and to recompile yourself the FeResPost classes.
Sources of FeResPost are distributed for the different published versions of the library. These include the C/C++ sources, the examples, and possibly the PDF manual.

Third party contributions

One also distributes a third-party contribution, but without any support :

Mailing lists

You can visit or subscribe to FeResPost Google group :

Subscribe to FeResPost Group

E-mail :

Visit this group

If you have a question to ask, a bug to report, we would appreciate that you do it via FeResPost google group, so that others can benefit of your remarks as well.

You can also subscribe to the freshmeat FeResPost mailing list if you want to be automatically warned about new major revisions of FeResPost. Similar mailing lists are also available on other websites as Softpedia (for Linux or Windows).





FeResPost allows to automate the following operations :



Nastran results random access (XDB file), Nastran results import into DataBase, Nastran results read, Nastran XDB results, Nastran XDB attachment, Nastran OP2 results,

Patran results random access (XDB file), Patran results import into DataBase, Patran results read, Patran XDB results, Patran XDB attachment, Patran OP2 results,

Samcef results random access (DES/FAC files), Samcef results import, Samcef results read, Samcef DES/FAC results, Samcef DES/FAC attachment, Samcef U18,

Satellite, Structure, Structural Analysis, Finite Elements, Aircraft, Airplane, Loads, Load case, SOL101, SOL103, SOL106, SOL600, SOL108, SOL111, Optimization, Stability, Strength, Stress, Strain, Beam, Shell, Composite, Laminate, Sandwich, Honeycomb, CFRP, GFRP, Astrium, Thales, Alcatel, Boeing, Alenia, Embraer, Dassault, Bombardier, Sonaca, Sabca, Samtech, MSC, Siemens, EADS, Spirit, Lockheed, Grumman, Latécoère, Rocket, Tsai-Hill, Tsai-Wu, Yamada-Sun, Von Mises, CATIA, Pro-Engineer, Sonia, Image, Isami, Python, Ruby, Java, Perl, VBA, C++, C#, ELFINI, mesh, properties, coordinate system, node, GRID, Bird impact, fatigue, dynamic response, shock, sinus, shaker, Marc, Abaqus, ansys, NX Nastran, MSC Nastran, Ariane, ISS, Hypermesh, hyperview, Ansys, Femap, Siemens PLM Software, NX Nastran, Nei Nastran, Algor, Von Mises, Cauchy, Tensor, Vector, real, complex, magnitude, phase, cylindrical, spherical, Cartesian, eigen-vector, principal values, eigen-value, frequency, virtual, simulation, McNeal Schwendler, Software, PLM, virtual, computation, simulation, calculation Lockeed, Martin, Pilatus, 310, 320, 330, 340, 350, 380, F7X, Falcon, Bruhn, Roark, 737, 747, 787 Learjet, knownledge based engineering, KBE, kbo, excel, spreadsheet, workbook, Microsoft word, Soyuz, corrosion, ETS, automatic, crash, pilot, test, AIT, quasi-static, gravity, thermo-elastic, thermal, temperature, failure, ply, Young modulus, shear modulus, Poisson ratio, 135, 145, 170, 190, electro-magnetic, power, engine, fuel, kerozen, battery, windgust, return flight loads, open office, calc, Latecoere, mig, yak, proton, jettison, separation, burst, landgear, flap, slat, wing, fuselage, module, service, support, cockpit, tail, tailplane, door, window, stringer, doubler, skin, core, rivet, bolt, fastener, washer, bearing, allowable, kbekbo, solidworks, fempad, dynamic load response, noise, acoustic, thermel, thermo-elastic, Hashin, Puck, hoffman, ILSS, maximum strain, maximum stress, inter-laminar shear stress, delamination, Software, program, solver, implicit, explicit, transient, result, results tresca principal stress, Puck, Hashin Yamada-Sun, Hoffman, ILSS

FeResPost allows to export/import results and groups into/from BLOB objects (Binary Large OBjects) for insertion in in an SQL database. Several of the examples presented use the SQLite database, but the capability should also work with other SQL database systems as MySQL, PostgresSQL,...

FeResPost User Manual

$\textstyle \parbox{1in}{ }$







FeResPost Home Page













FeResPost User Manual




Version 4.2.0




2013/08/04




Renaud Sizaire















renaud.sizaire@ferespost.be




















THIS PAGE IS INTENTIONALLY LEFT BLANK

Introduction

In this document, one presents the manual of FeResPost.

FeResPost

When sizing a structure with FE software, the engineer is often lead to use or develop tools that automate the computation of margins of safety, reserve factors or other results from outputs obtained with a FE solver. Then the engineer is facing several problems:

All these problems induce difficulties in the management of the automated post-processing. These must be as simple and cleanly written as possible to allow an easy understanding by everyone. Also their architecture must be flexible to make the modifications easy to implement and reduce the risk of errors.

The problems mentioned above are very similar to the kind of problems a programmer is facing when writing a large program. To help the programmer in this task, the object-orientation has emerged as a new programming language concept. Object-oriented languages allow the development of more flexible programs with a better architecture and allow the re-usability of code. Many object-oriented languages are now available. They can be compiled languages (C++, Fortran 90,...) or interpreted ones (Ruby, Python, Visual Basic,...).

FeResPost is an extension of ruby devoted to the programming of automated post-processing of finite element results. It provides the definition of several classes and one module. It uses object orientation at two levels:

  1. Ruby being object-oriented, it allows to write interpreted and object-oriented automated post-processing. An example of such an object-oriented post-processing program is given in Chapter IV.3. Ruby has been chosen because the language is clean, nice and very, and can easily be extended with compiled classes and modules.
  2. The FeResPost library is mainly written in C++, which is also an object-oriented language. Then a Ruby wrapping is provided around the C++ code.
During the development of FeResPost, the developer has been trying to maintain as much as possible the simplicity and clarity of the language in which post-processing programs are written. He hopes that this will make the task of the structural analysis engineers using the program, as much as possible an enjoyable task, and not one job that makes him want to throw his computer by the window, to kick his boss or to hang himself.

How to learn FeResPost?

One gives here some advice to people starting to use FeResPost. The order in which the knowledge is acquired matters. One of the worst way to try to learn FeResPost is to read the manual while writing bits of code meant to solve the particular problem the user has in mind. Instead, one suggests the following sequence of knowledge acquisition:

  1. FeResPost is an extension of ruby programming language. This means that the examples provided in the document are small ruby programs. Therefore a basic knowledge of ruby is necessary. People trying to learn ruby and FeResPost at the same time will probably fail in both tasks.

    Very good books on ruby language are available in libraries. Internet resources are also a source of information (newsgroups, tutorials with examples...).

    Note that people already familiar with one or several object-oriented programming languages will have no difficulty to acquire a basic knowledge of ruby.

  2. Then, the user may test FeResPost by running the small examples. These are provided in the sub-directories in ``SMALLEX'' directory. Note that the Nastran bdf files should first be run in order to have the op2 result files available. It may be a good idea to try first to understand the structure of the bdf files and of the organization of the finite element model.

    The small examples are meant to be increasingly difficult. So, the user should first run the examples in ``EX01'' directory, then in ``EX02''... For each example, every statement should be understood, and the corresponding pages of the user manual should be carefully read.

  3. When all the small examples have been run and understood, the user will probably have acquired a reasonable understanding of the various capabilities of FeResPost. Then it may be a good idea to start to read the user manual. For example, to read a few pages each day in such a way that the information can be digested efficiently.

  4. The two examples ``PROJECTa'' and ``PROJECTb'' illustrate the programming of more complex post-processing of Results involving loops on load-cases, on several types of post-processing calculations... These two projects should be studied at the very end.

    ``PROJECTa'' is meant to be studied before ``PROJECTb''. Indeed, ``PROJECTa'' is easier to understand than ``PROJECTb'', because it is less object-oriented. but it is also less complete and less nice from a programming point of view.

The reason why the advices above is given is that many users send mails of questions or complaints because they fail to understand something about FeResPost which is clearly illustrated in the examples. Sometimes, the problems faced by the users are simply related to a lack of understanding of the ruby programming language.

Structure of the document

This document is organized as follows:

A list of the different classes defined in FeResPost with pointers to Tables listing the methods defined by these classes is given in Table 1.


Table 1: Classes defined by FeResPost, and links to the corresponding lists of methods.
Class Chapter Table Page
``Common'' Classes
userManual.DataBase.methods.tabDataBase I.1 I.1.1 [*]
userManual.CoordSys.methods.tabCoordSys I.2 I.2.1 [*]
userManual.Group.methods.tabGroup I.3 I.3.1 [*]
userManual.Result.methods.tabResult I.4 I.4.1 [*]
userManual.ResKeyList.methods.tabResKeyList I.5 I.5.1 [*]
userManual.Post.methods.tabPost (module) I.6 I.6.1 [*]
Classical Laminate Analysis
CLA.ClaDb.methods.tabClaDb II.2 II.2.1 [*]
CLA.ClaMat.methods.tabClaMat II.3 II.3.1 [*]
CLA.ClaLam.methods.tabClaLam II.4 II.4.1 [*]
CLA.ClaLoad.methods.tabClaLoad II.5 II.5.1 [*]
Solver Preferences
userManual.Nastran.DB.methods.tabNastranDb III.1 III.1.1 [*]
userManual.Samcef.DB.methods.tabSamcefDb III.2 III.2.1 [*]

Future developments

FeResPost is still at the very beginning of its development and much work is still necessary to cover a wider range of applications. One gives below a few examples of possible improvements, more or less sorted by order of emergency or facility:

  1. Correction of bugs...
  2. Addition of specialized post-processing modules programmed at C++ level to provide efficiency. For examples:
  3. Extension of FeResPost by providing interfaces towards other FE software like Abaqus,...
  4. Development of extensions for other interpreted languages like python or perl.
  5. Development of a UNO component.
  6. ...
Of course, we are open to constructive remarks and comments about the ruby library in order to improve it.


Contents


Index

.NET
VII. to VII.3.2 | VIII. to VIII.1.4
Abaqus
Future
abbreviations
I.1.4 to I.1.4 | III.2.1.1 | III.2.1.1
asef
III.2.1.4.1
Bacon
III.2.1.1 | III.2.1.1 | VI.4.2.2 | VI.4.2.2
banque
III.2.1.1 to III.2.1.1
big endian
III.1.1.7.8 to III.1.1.7.8 | III.1.1.8.1 to III.1.1.8.1
BLOB
I.3.5 to I.3.5 | I.4.10 to I.4.10 | I.6.8 to I.6.8 | IV.2.6 to IV.2.6.2 | VI.1.8 to VI.1.8 | VI.4.1.3 to VI.4.1.3 | VI.4.2.5 to VI.4.2.5 | VI.4.3.5 to VI.4.3.5 | VI.4.3.6 to VI.4.3.6 | VIII.1.4 to VIII.1.4
bridge
IX.D to IX.D.2.5
C
VI.1.1.5 to VI.1.1.5
C++
I.3.1 | I.4 | I.4.1.1 | VI.1.1.4 to VI.1.1.4
CLA
V.1 to V.1.4 | VII.1 to VII.1.4
ClaDb
II.0 | II.2 to II.2.8 | V.1.1 to V.1.1 | VII.1.1 to VII.1.1
ClaLam
II.0 | II.4 to II.4.13 | V.1.3 to V.1.3 | VII.1.3 to VII.1.3
ClaLoad
II.0 | II.5 to II.5.9 | V.1.4 to V.1.4 | VII.1.4 to VII.1.4
ClaMat
II.0 | II.3 to II.3.7 | V.1.2 to V.1.2 | VII.1.2 to VII.1.2
Classical Laminate Analysis
V.1 to V.1.4 | VII.1 to VII.1.4
code
III.2.2.1 | III.2.2.1 | III.2.2.1 | III.2.2.1 | III.2.2.1 | III.2.2.1 | III.2.2.1 | III.2.2.1 | III.2.2.2 | III.2.2.2 | III.2.2.2 | III.2.2.2 | III.2.2.2 | III.2.2.2
COM
V. to V.3.2 | VI. to VI.4.4.3 | IX.D
Combined strain criterion
to II.1.9.8
Complex, Complex
I.4.8 to I.4.8.5
Component Object Model
V. to V.3.2 | VI. to VI.4.4.3
Composite
I.1.5 to I.1.5 | II. to II.5.9
CoordSys
I.0 | I.2 to I.2.5.3 | III.1.1.4 to III.1.1.4.3 | III.2.1.2 to III.2.1.2.3 | IV.2.4.4
COPYING
IX.E to IX.E
DataBase
I.0 | I.1 to I.1.8 | I.4.5.7 | I.4.5.7 | I.4.5.7 | I.4.5.7 | I.4.5.8
DataBase, flags, readDesFac
III.2.1.4.2
DataBase, flags,@ readDesFac
to III.2.1.4.2
DataBase, key
I.1.3 to I.1.3
des
III.2.1.4 to III.2.1.5.4
disable
III.1.1.6 to III.1.1.6 | III.2.1.4.2 to III.2.1.4.2
dynam
III.2.1.4.1
EDS
III.1.1.6 | III.1.1.6
enable
III.1.1.6 to III.1.1.6 | III.2.1.4.2 to III.2.1.4.2
endiannes
III.1.1.7.8 to III.1.1.7.8 | III.1.1.8.1 to III.1.1.8.1
Equivalent Strain
II.1.3.2 | II.1.8.1 | II.1.9.6 | II.1.9.7 | II.1.9.8
ESAComp
II.0 | II.2.5
excel
V.0.1.4 | V.0.1.4 | VI.1.7 to VI.1.7 | VI.1.8 to VI.1.8 | VI.2 to VI.2.4.3 | VI.3 to VI.3.8 | VI.4 to VI.4.4.3 | IX.D to IX.D.2.5
fac
III.2.1.4 to III.2.1.5.4
FEM
III.1.1.6
FeResPost
I.0
Fick
II.1.11
finite elements
I.0
Fourrier
II.1.10
General Public License
IX.E to IX.E
Gmsh
I.1.8 to I.1.8 | IV.2.5.4 to IV.2.5.4 | VI.4.1.3 to VI.4.1.3 | VI.4.2 | VI.4.2.1 | VI.4.2.1 | VI.4.2.1 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.5 to VI.4.2.5 | VI.4.3.5 to VI.4.3.5 | VI.4.3.6 to VI.4.3.6
GPL
IX.E to IX.E
Group
I.0 | I.1 | I.1 | I.1.2 to I.1.2.2 | I.3 to I.3.7 | I.4.2.15 | I.4.2.16 | I.6 | III.1.1.5 to III.1.1.5 | III.2.1.3 to III.2.1.3 | IV.2.2.2 to IV.2.2.4
Hashin criteria
II.1.9.18 to II.1.9.18 | II.1.9.19 to II.1.9.19
Hoffman criterion
II.1.9.16 to II.1.9.16
Honeycomb criterion
II.1.9.22 to II.1.9.22 | II.1.9.23 to II.1.9.23 | II.1.9.24 to II.1.9.24
I-DEAS
III.1.1.6
identifier
II.0
IDispatch
V.0.1.5 | VI.1.1.4
Ilss criterion
II.1.9.25 to II.1.9.25
iterator
I.1.6 to I.1.6 | I.3.6 to I.3.6 | I.4.11 to I.4.11 | I.5.5 to I.5.5 | III.1.1.10 to III.1.1.10 | III.2.1.8 to III.2.1.8
iterators
IV.2.3 to IV.2.3
key
see DataBase, key | see Result, key
layer
see Result, layer
little endian
III.1.1.7.8 to III.1.1.7.8 | III.1.1.8.1 to III.1.1.8.1
Makefile
IX.A.1.2
Maximum strain criterion
II.1.9.6 to II.1.9.6 | II.1.9.7 to II.1.9.7 | II.1.9.8
Maximum stress criterion
II.1.9.4 to II.1.9.4 | II.1.9.5 to II.1.9.5
mecano
III.2.1.4.1
Mechanical Strain
II.1.3.2 | II.1.3.2 | II.1.8.1 | II.1.9.6 | II.1.9.7 | II.1.9.8
Microsoft
V.0.1.5 | VI.1.1.4
Mohr
I.4.3.4 | I.4.3.4
Nastran
II.1.10.4.3 | II.1.10.4.3 | III.1 to III.1.3 | IV.0
NET
VII. to VII.3.2 | VIII. to VIII.1.4
op2
III.1.1.6 to III.1.1.6 | III.1.2 to III.1.3
Patran
I.0 | I.0 | I.0 | I.1.2.1 | I.1.2.1 | I.3 | I.3.3 | I.3.3 | I.4.7 | III.1.2.1 | IV.1.3
Post
I.0 | I.4.3 | I.4.4 | I.6 to I.6.8
post-processing
I.0
Puck criteria
II.1.9.17 to II.1.9.17
python
VI.1.1.1 to VI.1.1.1
random access
III.1.1.8 to III.1.1.8.5 | III.2.1.5 to III.2.1.5.4
ResKeyList
I.0 | I.4.1.1 | I.4.2 | I.4.2.4 | I.4.2.10 | I.4.2.11 | I.5 to I.5.7
Resul
I.5
Result
I.0 | I.1 | I.1 | I.1.3 to I.1.3.2 | I.4 | I.4.2.5 to I.4.12.5 | I.6 | I.6.2 | I.6.3 to I.6.8 | III.1.1.7 to III.1.1.7.8 | III.1.1.8 to III.1.1.8.5 | III.1.2 to III.1.3 | III.2.1.5 to III.2.1.5.4 | IV.2.4 to IV.2.4.6.3
Result, Complex
I.4.8 to I.4.8.5
Result, key
I.4.1 | I.4.1.1 to I.4.1.1 | I.4.2 | I.4.2.10 | I.4.2.11 | I.4.5.9 | I.4.9 to I.4.9 | I.4.11 to I.4.11 | I.5 | I.5.6 to I.5.6 | IV.2.4.2
Result, layer
I.4.1.1 | I.4.1.1 to I.4.1.1
Result, value
I.1.3 | I.4.1 | I.4.1.1 | I.4.1.2 to I.4.1.2 | I.4.2.10 | I.4.2.11 | I.4.9 to I.4.9 | I.4.11 to I.4.11
results
I.0 | IX.C to IX.C.2
ruby
FeResPost | I.0 | I.0 | I.4 | VI.1.1.2 to VI.1.1.2
Samcef
I.1.4 | I.1.4 | III.1.2.1 | III.2 | III.2.1.4.1 to III.2.3 | VI.3 | VI.3.8 | VI.4.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2 | VI.4.2.2
scalar
I.4.1.2 | I.4.2.6 | I.4.2.7 | I.4.2.8 | I.4.2.9 | I.4.2.12 | I.4.2.13 | I.4.3.1 | I.4.3.2 | I.4.3.4 | I.4.3.5 | I.4.3.6 | I.4.3.7 | I.4.3.7 | I.4.5.7 | I.4.5.9 | I.4.6.4 | I.4.6.5 | I.4.9
SQL
I.3.5 to I.3.5 | I.4.10 to I.4.10 | I.6.8 to I.6.8 | IV.2.6 to IV.2.6.2 | VI.1.8 to VI.1.8 | VI.4.1.3 to VI.4.1.3 | VI.4.2.5 to VI.4.2.5 | VI.4.3.5 to VI.4.3.5 | VI.4.3.6 to VI.4.3.6 | VIII.1.4 to VIII.1.4
SQLite
IV.2.6 to IV.2.6.2 | VI.1.8 to VI.1.8 | VI.4.1.3 to VI.4.1.3 | VI.4.2.5 to VI.4.2.5 | VI.4.3.5 to VI.4.3.5 | VI.4.3.6 to VI.4.3.6 | VIII.1.4 to VIII.1.4
stabi
III.2.1.4.1
tensorial
I.4.1.2 | I.4.3.4 | I.4.3.5 | I.4.3.5 | I.4.3.5 | I.4.3.6 | I.4.3.6 | I.4.3.7 | I.4.5.7 | I.4.5.9 | I.4.9
Tresca criterion
II.1.9.1 to II.1.9.1
Tsai-Hill criterion
II.1.9.9 to II.1.9.9 | II.1.9.10 to II.1.9.10 | II.1.9.11 to II.1.9.11 | II.1.9.12 to II.1.9.12 | II.1.9.13 to II.1.9.13
Tsai-Wu criterion
II.1.9.14 to II.1.9.14 | II.1.9.15 to II.1.9.15
Unigraphics
III.1.1.6
value
see Result, value
VBA
V.0.1.4 to V.0.1.4 | VI.1.7 to VI.1.7 | VI.1.8 to VI.1.8 | VI.2 to VI.2.4.3 | VI.3 to VI.3.8 | VI.4 to VI.4.4.3 | IX.D to IX.D.2.5
VBA-Ruby bridge
IX.D to IX.D.2.5
VBscript
VI.1.1.3 to VI.1.1.3
vectorial
I.4.1.2 | I.4.3.2 | I.4.3.3 | I.4.3.3 | I.4.3.7 | I.4.5.7 | I.4.5.7 | I.4.5.8 | I.4.5.8 | I.4.5.9 | I.4.9
Von Mises
I.4.3.4
Von Mises criterion
II.1.9.2 to II.1.9.2 | II.1.9.3 to II.1.9.3
xdb
III.1.1.7 to III.1.1.7.8 | III.1.1.8 to III.1.1.8.5 | III.1.2 to III.1.3
Yamada-Sun criterion
II.1.9.20 to II.1.9.20 | II.1.9.21 to II.1.9.21


I. FeResPost Reference Manual

I.0 Introduction

FeResPost is a ruby extension that allows the manipulation of finite element entities and results. Its purpose is to ease the development of post-processing programs. The supported solvers and corresponding program preferences are discussed in Part III of the document.

The various capabilities implemented in the ruby extension are mainly inspired by Patran capabilities. Several types of objects can be manipulated:

Finally, additional functions, not member of any class are defined in a module called ``Post''.

Finally, the loading of FeResPost library also modifies some methods of Float and Array classes, as explained in section I.4.6.


I.1 Generic ``DataBase'' class

Basically, a ``DataBase'' class is a container used to store a finite element model, Groups, Results, and other less important entities. The DataBase class also allow to retrieve, manipulate or modify these objects. The DataBase class is a generic class that cannot be instantiated. The specialized classes that inherit the generic DataBase class are described in Part III. Other solvers might be supported in the future. The class hierarchy is schematically represented in Figure I.1.1.

Figure I.1.1: Finite element DataBase classes hierarchy.
\begin{figure}
\centerline{%
\input{userManual/DataBase/XFIG/DbTree.pstex_t}}
\end{figure}

As three classes are represented in Figure I.1.1, the methods described in this Chapter may belong to the generic DataBase class or to the derived classes. A few basic principles should help the user to ``guess'' in which class some of the methods are defined:

Throughout the Chapter one specifies for the different methods, in which class they are defined. This Chapter is divided in several sections:

A list of the methods defined in ``DataBase'' class is given in Table I.1.1.

Table I.1.1: The different methods that have been defined in ``DataBase'' class. userManual.DataBase.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
(new) I.1.1  
(initialize) I.1.1  
(clone) I.1.1  
getNbrCoordSys I.1.1  
getNbrElements I.1.1  
getNbrNodes I.1.1  
checkCoordSysExists I.1.1  
checkElementExists I.1.1  
checkNodeExists I.1.1  
checkRbeExists I.1.1  
getElementType I.1.1  
getElementTypeName I.1.1  
getElementDim I.1.1  
getElementNbrNodes I.1.1  
getElementNbrCornerNodes I.1.1  
getElementNodes I.1.1  
getElementCornerNodes I.1.1  
Attributes
Name I.1.7 IV.2.2.1
Manipulation of Results
getResultLoadCaseNames I.1.3.1 ``EX09/modifCS3D.rb''
getResultSubCaseNames I.1.3.1 ``EX09/modifCS3D.rb''
getResultTypeNames I.1.3.1 ``EX09/modifCS3D.rb''
checkResultExists I.1.3.1  
getResultSize I.1.3.1  
addResult I.1.3.1  
generateCoordResults I.1.3.1 IV.2.4
generateElemAxesResults I.1.3.1  
buildLoadCasesCombili I.1.3.1 ``PROJECTb/DATA/loadCases.rb''
renameResults I.1.3.1  
copyResults I.1.3.1  
removeResults I.1.3.1 ``PROJECTb/DATA/loadCases.rb''
removeAllResults I.1.3.1  
getResultCopy I.1.3.1 IV.2.4.2
enableLayeredResultsReading I.1.3.2  
disableLayeredResultsReading I.1.3.2 IV.2.4
enableSubLayersReading I.1.3.2  
disableSubLayersReading I.1.3.2 IV.2.4
Manipulation of Groups
readGroupsFromPatranSession I.1.2.1 IV.2.2.2
writeGroupsToPatranSession I.1.2.1 IV.2.2.2
addGroupCopy I.1.2.1 IV.2.2.4
getAllGroupNames I.1.2.1 IV.2.2.2
checkGroupExists I.1.2.1  
getGroupCopy I.1.2.1 IV.2.2.2
eraseGroup I.1.2.1  
eraseAllGroups I.1.2.1  
getNbrGroups I.1.2.1  
getGroupAllElements I.1.2.1  
getGroupAllNodes I.1.2.1  
getGroupAllRbes I.1.2.1  
getGroupAllCoordSys I.1.2.1  
getGroupAllFEM I.1.2.1 IV.2.4.3
Manipulation of abbreviations
clearAbbreviations I.1.4  
addAbbreviation I.1.4  
addAbbreviations I.1.4  
getNbrAbbreviations I.1.4  
getAbbreviation I.1.4  
checkAbbreviationExists I.1.4  
getAbbreviations I.1.4  
CLA methods
getClaDb I.1.5 IV.5.1
calcFiniteElementResponse I.1.5 IV.5.6
calcFiniteElementCriteria I.1.5 IV.5.6
calcFemLamProperties I.1.5  
Iterators
each_abbreviation I.1.6  
each_groupName I.1.6 IV.2.2.2
each_resultKey I.1.6 IV.2.4
each_resultKeyCaseId I.1.6 IV.2.4
each_resultKeySubCaseId I.1.6 IV.2.4
each_resultKeyLcScId I.1.6 IV.2.4
each_resultKeyResId I.1.6 IV.2.4
Write methods
to_s I.1.7  
writeGmsh I.1.8 IV.2.5.4
writeGmshMesh I.1.8 IV.2.5.4
Attributes
Name I.1.7  
     


I.1.1 Methods for FEM definition

No generic ``DataBase'' object can be created because ``DataBase'' class cannot be instantiated. This means that a statement like:

   db=DataBase.new()
leads to an error message. All the methods described in this section are defined in the specialized versions of the DataBase class. So no ``new'', ``initialize'' or ``clone'' method.

One defines three methods that allow to retrieve the number of entities of certain types stored in DataBase FE model:

Each of these methods has no argument and returns an integer. Other methods allow to check the existence of finite element entities: Each of these four methods has one integer argument corresponding to the entity the existence of which is checked.

Several methods allow to retrieve elements information. Each of the following methods has one integer argument corresponding to the element ID:

Normally one class corresponds to each solver supported by FeResPost. The preferences for the different supported solvers are described in Part III.


I.1.2 ``Group'' methods

Groups can be stored in, and retrieved from a DataBase object. One presents here the methods defined in generic class DataBase, or in its derived classes, and that are devoted to the manipulation of Group objects. In the DataBase, the Group objects are stored in a mapping associating their names to the Group. This association allows to retrieve the Group when needed.

One makes the distinction between the simple manipulation of Groups described in section I.1.2.1 and the more complicated operation where new Groups are created by association operations (section I.1.2.2). The methods related to these associative operations are often defined in the specialized versions of the Database class.


I.1.2.1 Simple manipulation of Groups

One describes here methods that allow the manipulation of Groups stored in a generic DataBase object. All the methods described in this section are defined in generic DataBase class. These methods are described below:


I.1.2.2 Construction of Groups by association operations

This section is devoted to methods that allow the construction of a new Group by selecting entities associated to other entities of the finite element model. For all these methods, the association is checked by inspection of the finite element model stored in the DataBase. Therefore, these methods are defined in the specialized version of the ``DataBase'' class. Therefore, these methods are systematically defined in specialized versions of the ``DataBase'' class. For each supported solver, a description of these methods is given. (See Part III.)


I.1.3 ``Result'' methods

As explained in the introduction of this Chapter, the DataBase can be used to store Results. Internally, a mapping between keys and Results allows to associate Result objects to an identifier. Each keyI.11 is characterized by three String objects corresponding respectively to the load case name, to the subcase name and to the Result type name.


I.1.3.1 Manipulation of Results

The class ``Result'' is described in Chapter I.4. In this section, one describes the methods of the generic ``DataBase'' class that deal with ``Result'' objects. The ``Result'' methods are:

Methods devoted to the importation of Results from binary Results files are specific to the peculiar solver that produced the Results. These methods are described in Part III.


I.1.3.2 Enabling composite Results reading operations

Four singleton methods allow to enable or disable partially or totally the reading of composite layered Results from finite element result files. These methods influence the behavior of methods defined in the ``specialized'' versions of the ``DataBase'' class. (See Part III.) The four methods are:

By default the reading of layered composite Results is enabled for all sub-layers. The disabling may help to reduce the size of Results stored in specialized DataBases. Actually, the reading of composite results is no longer mandatory as most composite results can be produced with the appropriate methods of the ``CLA'' classes (Part II).


I.1.4 Manipulation of abbreviations

When a Samcef banque is read into a DataBase, the abbreviations defined in the Samcef model are read as well and stored into the Samcef DataBase in a mapping of string objects. Five methods allow the manipulation of abbreviations stored in the DataBase:

  1. ``clearAbbreviations'' has no argument and clears all the abbreviations stored into the DataBase.
  2. ``addAbbreviation'' adds one abbreviation to the DataBase. The method has two String arguments: the key and the value.
  3. ``addAbbreviations'' adds a list of abbreviations to the DataBase. The method has one argument: A Hash object containing the correspondence between keys and values. Each pair is of course a pair of String objects.
  4. ``getNbrAbbreviations'' has no argument and returns the number of abbreviations stored in the DataBase.
  5. ``getAbbreviation'' returns the String value of one abbreviation. The method has one String argument: the key of the abbreviation.
  6. ``checkAbbreviationExists'' returns ``true'' if the abbreviation exists. The method has one String argument: the key of the abbreviation.
  7. ``getAbbreviations'' returns a Hash object containing all the abbreviations stored in the DataBase. This method has no argument.
Note that, even though no abbreviation is defined in other solver models, the abbreviation methods defined in DataBase class can also be used when one works with all models. This is why the methods listed above are defined in generic ``DataBase'' class and not in ``SamcefDb'' class described in Chapter III.2.


I.1.5 Composite methods

The DataBase Class provides one method that returns a ClaDb object corresponding to the materials, plies and Laminates stored in the DataBase. This method is called ``getClaDb'' and has no argument. The units associated to this ClaDb object are the default units as defined in Table II.1.3. If the finite element model is defined in another unit system, it is the responsibility of the user to define correctly the units of the ClaDb database and of all its entities using the method ``setUnitsAllEntities'' of ClaDb class. (See section II.2.4.)

Another method corresponding to the calculation of Results related to laminate load response has been added. This method called ``calcFiniteElementResponse'' has the same arguments as the corresponding method defined in the ``ClaLam'' class. The method and the meaning of its arguments are described in section II.4.8. The method defined in ``DataBase'' class differs from the one defined in ``ClaLam'' class by the fact that the algorithm tries to retrieve the Laminate corresponding to the element to which Result values are attached. The information is found in the DataBase object. More precisely, The algorithm performs as follows:

Similarly, one defined the method ``calcFiniteElementCriteria'' which has exactly the same arguments and outputs as the corresponding method of ``ClaLam'' class described in section II.4.8. The difference between the two methods resides in the fact that the method in DataBase class retrieves the ClaLaminate corresponding to the element to which the tensorial values are attached.

Finally, a third method allows to retrieve laminate engineering properties in the format of Result objects. The method ``calcFemLamProperties'' has three arguments:

  1. A ClaDb object which is used for the calculations of the different laminate properties.
  2. A ResKeyList object that corresponds to the finite element entities for which values shall be inserted in Result object. Note that the produced Result object are non layered. (Only the ElemId and NodeId of the ResKeyList keys matter.)
  3. A Hash with String keys and values corresponding to the requests. The key corresponds to the name by which the returned Result shall be referred. The value corresponds to the laminate engineering property that is requested. Presently, possible values of this parameter are: ``E_f_xx'', ``E_f_yy'', ``E_k0_xx'', ``E_k0_yy'', ``E_xx'', ``E_yy'', ``G_f_xy'', ``G_k0_xy'', ``G_xy'', ``nu_f_xy'', ``nu_f_yx'', ``nu_k0_xy'', ``nu_k0_yx'', ``nu_xy'', ``nu_yx'', ``thickness'', ``surfacicMass'', ``averageDensity''.
The method returns a Hash with String keys and Result values.

An example of use of this method follows:

   ...
   compDb=db.getClaDb
   
   res=db.getResultCopy("COORD","coord","coordinates")
   rkl=res.extractRkl
   
   requests={}
   requests["res1"]="thickness"
   requests["res2"]="E_xx"
   requests["res3"]="E_yy"
   
   resList=db.calcFemLamProperties(compDb,rkl,requests)
   
   resList.each do |id,res|
      Util.printRes(STDOUT,id,res)
   end
   ...

For the different ``finite element'' methods listed above, the units considered for the returned ``Result'' objects are the units of the ``ClaDb'' object argument. This characteristic differs from the behavior of the corresponding methods in ``ClaLam'' class.


I.1.6 Iterators

One describes here the iterators of the generic DataBase class only. The iterators of the specialized versions of the class are described in Part III.


I.1.7 General purpose methods

A few more methods with general purpose are defined:

These methods are defined in the generic ``DataBase'' class.


I.1.8 ``Gmsh'' methods

The ``writeGmsh'' method defined in generic ``dataBase'' class is used to create a Gmsh result file in which parts of the model and of the Results are saved for later visualization. The purpose of the method is to allow the user to visualize parts of the model and Results. An example of use of the method is as follows:

   db.writeGmsh("brol.gmsh",0,[[res,"stress","ElemCenters"],\
                               [displ,"displ","Nodes"]],\
                              [[skelGrp,"mesh slat"]],\
                              [[skelGrp,"skel slat"]])
The method has six parameters:
  1. A string containing the name of the file in which the model and Results will be output.
  2. An integer corresponding to the id of a coordinate system in which the positions are located and in which the components of Result values are expressed. The coordinate system must be defined in the dataBase db and must be a rectangular one.
  3. An Array containing the Results to be stored in Gmsh file. Each element of the Array is An Array of three elements:
  4. An Array containing the Meshes to be stored in Gmsh file. Each element of the Array is An Array of two elements:
  5. An Array containing the parts of the model for which a ``skeleton'' shall be saved in the Gmsh file. (A skeleton is a representation of the mesh with only a few edges.)
  6. A logical parameter specifying whether a binary output is requested. If the parameter is ``true'' a binary output is done, otherwise, the output is an ASCII one. The parameter is optional and binary output is the default. A binary output is significantly faster than an ASCII one.
Parameters 3, 4 and 5 are optional. They can be a void Array or replaced by nil argument. All the last nil parameters may be omitted. Parameter 6 is optional too. If no pair of key-values is found for a Result to be printed. Nothing is output in the gmsh file.

The ``writeGmshMesh'' method defined in generic ``dataBase'' class saves a Gmsh mesh file. The method has up to four arguments (last argument is optional):

  1. A String containing the name of the file in which the mesh is output.
  2. An integer argument corresponding to the coordinate system in which the nodes are expressed.
  3. A Group corresponding to the entities to be saved in the mesh file.
  4. An optional Boolean argument specifying whether the mesh is output in binary format. The default value of the argument is ``true'' and corresponds to a binary output.
An example of use follows:
      db.writeGmshMesh("brol.msh",0,skelGrp,false)


I.2 The ``CoordSys'' class

It may be practical to manipulate coordinate systems at post-processing level. Therefore, a ``CoordSys'' class devoted to the manipulation of coordinate systems is proposed. The methods defined in that class are described in sections I.2.2 and I.2.5. A list of the methods defined in ``CoordSys'' class is given in Table I.2.1.

Table I.2.1: The different methods that have been defined in ``CoordSys'' class. userManual.CoordSys.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
new I.2.2 IV.2.4.4
initialize I.2.5  
clone I.2.5  
Definition
initWith3Points I.2.2.1 IV.2.4.4
initWithOV1V2 I.2.2.2  
initWithOV2V3 I.2.2.2  
initWithOV3V1 I.2.2.2  
initWithOV2V1 I.2.2.2  
initWithOV3V2 I.2.2.2  
initWithOV1V3 I.2.2.2  
updateDefWrt0 I.2.2.2  
Modifying point coordinates
changeCoordsA20 I.2.3.1 IV.2.4.4
changeCoords02B I.2.3.2 IV.2.4.4
changeCoordsA2B I.2.3.3 IV.2.4.4
Modifying vector or tensor components
changeCompsA20 I.2.4.1 IV.2.4.4
changeComps02B I.2.4.2 IV.2.4.4
changeCompsA2B I.2.4.3 IV.2.4.4
Printing
to_s I.2.5  
Attributes
Id I.2.5  
     


I.2.1 The CoordSys object

A CoordSys object corresponds to a coordinate system. CoordSys objects are generally created in a DataBase when a model is imported.

Besides the data corresponding to the definition of the coordinate system, the CoordSys object also contains a definition of the coordinate system wrt the most basic coordinate system ``0''. The corresponding member data are used by functions like the Result methods of modification of reference coordinate systems to perform the transformations of components (sections I.4.5.7 and I.4.5.8). Practically those functions work in two steps:

  1. The components of the Result object are expressed wrt the basic coordinate system ``0''.
  2. Then, the components are expressed wrt the new coordinate system.
The definition of the corresponding member data is done by calling the method ``updateDefWrt0'' (section I.2.2.3).


I.2.2 Construction or manipulation functions

Besides the ``new'' class method that returns a new coordinate system initialized to the ``0'' structural coordinate system, several functions can be used to modify the CoordSys objects.


I.2.2.1 ``initWith3Points''

This function is used to define a coordinate system with the coordinates of three points A, B and C. (See the definition of ``CORD2C'', ``CORD2R'' and ``CORD2S'' in [Sof04b].) This function has 5 arguments:

The three vectors mentioned above are actually Arrays of three real values corresponding to the coordinates of points given in coordinate system identified by the integer argument.

Note that no check is made in a DataBase to ensure that the data are consistent. (For example, checking that the reference coordinate system exists.)


I.2.2.2 Three functions ``initWithOViVj''

The three functions are ``initWithOV1V2'', ``initWithOV2V3'', ``initWithOV3V1'', ``initWithOV2V1'', ``initWithOV3V2'' and ``initWithOV1V3''. They produce CoordSys objects defined by their origin and two direction vectors corresponding to vector $ e$ $ _i$ and to the orientation of vector $ e$ $ _j$ respectively.

The six arguments of these methods are:

Note that the orientation vector $ e$ $ _j$ is not necessarily orthogonal to $ e$ $ _i$ . If the vectors are not orthogonal, then $ i$ is a unit vector parallel to $ e$ $ _i$ , and vector $ j$ is the unit vector perpendicular to $ i$ closest to $ e$ $ _j$ . The last vector $ k$ of the coordinate system is a unit vector perpendicular to both $ i$ and $ j$ .

Here again, no check is made in a DataBase to ensure that the data are consistent. (For example, checking that the reference coordinate system exists.)


I.2.2.3 Function ``updateDefWrt0''

This function updates the definition of a CoordSys object wrt to ``0'' (most basic coordinate system). This function has one argument: the DataBase in which the information needed to build the definition wrt 0 is found.

Note that if one works with several DataBases, the responsibility of managing the correspondence of coordinate systems and DataBases lies on the user.


I.2.3 Transformation of point coordinates

The ``CoordSys'' class defines three methods devoted to the transformation of a point coordinates from one coordinate system to another.


I.2.3.1 Method ``changeCoordsA20''

Method ``changeCoordsA20'' is used to calculate the coordinates of a point wrt basic or ``0'' coordinate system:

The method is called as follows:
   coords0=csA.changeCoordsA20(coordsA)


I.2.3.2 Method ``changeCoords02B''

Method ``changeCoords02B'' is used to calculate the coordinates of a point wrt a given coordinate system ``B'':

The method is called as follows:
   coordsB=csB.changeCoords02B(coords0)


I.2.3.3 Method ``changeCoordsA2B''

Method ``changeCoordsA2B'' is used to calculate the coordinates of a point wrt a given coordinate system ``B''. The initial coordinate system is a given ``A'' coordinate system:

The method is called as follows:
   coordsB=csA.changeCoordsA2B(coordsA,csB)


I.2.4 Transformation of vector and tensor components

The ``CoordSys'' class defines three methods devoted to the transformation of a vector or tensor components from one coordinate system to another. These methods are similar to the methods used to transform point coordinates in section I.2.3 but with the following differences:


I.2.4.1 Method ``changeCompsA20''

Method ``changeCompsA20'' is used to calculate the components of a vector or tensor wrt basic or ``0'' coordinate system:

The method is called as follows:
   vm0=csA.changeCompsA20(coordsA,vmA)


I.2.4.2 Method ``changeComps02B''

Method ``changeComps02B'' is used to calculate the components of a vector or tensor wrt basic or ``B'' coordinate system:

The method is called as follows:
   vmB=csB.changeCoords02B(coords0,vm0)


I.2.4.3 Method ``changeCompsA2B''

Method ``changeCompsA2B'' is used to calculate the components of a vector or tensor wrt basic or ``B'' coordinate system:

The method is called as follows:
   vmB=csA.changeCoordsA2B(coordsA,vmA,csB)


I.2.5 Other functions

One gives here a list of functions that do not fit in any category listed above.

I.2.5.1 ``initialize''

This function initializes or clears a CoordSys object. After initializing, the definition corresponds to the ``0'' structural coordinate system.

I.2.5.2 ``clone''

This function returns a Copy of the CoordSys object to which it is applied.

I.2.5.3 ``to_s''

This function is used for printing the Result object.


I.3 The ``Group'' class

The ``Group'' corresponds to the Patran notion of group. Group objects can be stored in a DataBase object, retrieved from it and manipulated outside the DataBase. One describes here the manipulation methods outside the DataBase class.

A list of the methods defined in ``Group'' class is given in Table I.3.1.

Table I.3.1: The different methods that have been defined in ``Group'' class. userManual.Group.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
new I.3.2 IV.2.5.1
initialize I.3.7  
clone I.3.7  
Identification (attributes)
Name= I.3.7 IV.2.2.3
Name I.3.7  
Manipulation of entities
getEntitiesByType I.3.3 IV.2.2.2
getNbrEntities I.3.3  
getNbrEntitiesByType I.3.3 IV.2.2.2
setEntities I.3.3 IV.2.5.1
setEntitiesByType I.3.3  
addEntities I.3.3  
addEntitiesByType I.3.3  
removeEntities I.3.3  
removeEntitiesByType I.3.3  
clearAllEntitiesByType I.3.3  
matchWithDbEntities I.3.3 IV.2.5.1
importEntitiesByType I.3.3  
Operators
+ I.3.4 IV.2.5.1
- I.3.4  
* I.3.4 IV.2.2.4
/ I.3.4  
BLOBs for SQL
toBlob I.3.5  
fromBlob I.3.5  
Iterators
each_element I.3.6  
each_mpc I.3.6  
each_node I.3.6 IV.2.2.2
each_coordsys I.3.6  
Other methods
to_s I.3.7  
Attributes
Name I.3.7  
NbrElements I.3.7  
NbrNodes I.3.7  
NbrMpcs I.3.7  
NbrCoordsys I.3.7  
     

I.3.1 The concept of ``Group''

A Group is characterized by its name (a String object) and the entities it contains. Four type of entities can be contained in a FeResPost Group: coordinate systems, nodes, elements and MPCs. At C++ level, for each type of entity, the class group manages a set of integers corresponding to the identifiers of the entities.

Part of the operations dealing with Groups are done by methods defined in DataBase class. The methods of DataBase specially devoted to operations mainly related to Groups are described in section I.1.2.


I.3.2 Creation of a Group object

The singleton method ``new'' is used to create Group objects.


I.3.3 Manipulation of entities stored in a Group

The class ``Group'' provides a large choice of methods devoted to the manipulation of the list of entities in its storage. One makes the distinction between operations that modify the content of a Group, and the operations that allow the inspection of this content.

The modification of the Group's content can be done by calls to the following methods:

Presently, only three methods devoted to the manipulation of entities and not modifying the Group have been defined:


I.3.4 Group operators

Eight such operators have been defined. One first explains the meaning and behavior of the four elementary dyadic operations.


I.3.5 ``BLOBs''

Group objects can be saved in SQL database as ``BLOB'' objects.

Two methods are defined in Group class to convert object to and from Blobs:


I.3.6 Iterators of Group class

The class ``Group'' provides four iterators:

These iterators iterate on the corresponding entities stored in the Group object. They produce Integer values that are passed to the block.


I.3.7 Other methods

One gives here a list of methods that do not fit in any category listed above:

The `Name'' and ``Name='' methods correspond to the ``Name'' attribute.


I.4 The ``Result'' class

The ``Result'' class is devoted to the manipulation of finite element Results. Examples of Results are stress tensor on volumic or surfacic elements, displacements, grid point forces,... The ruby class ``Result'' is a wrapping around the C++ class ``Result''.

Results can be read from various solver binary files. See Part III for more information.

The ``Result'' class allows the storage and manipulation of Real as well as Complex values. Note however that several of the methods of Result class do not allow the manipulation of Complex Results. Therefore, indications are inserted here and there in this Chapter to provide information about the ``Complex capabilities'' of the different methods.

An important comment must be done: Even though the results can be imported into a DataBase, this does not mean that the manipulation of the results is correct. Indeed, all manipulation that involve transformation of coordinate systems can be incorrect because geometric non-linearities are not taken into account. Methods that can be affected by this limitation are for example: ``modifyRefCoordSys'', ``modifyPositionRefCoordSys'' and ``calcResultingFM''.

A list of the methods defined in ``Result'' class is given in Table I.4.1.

Table I.4.1: The different methods that have been defined in ``Result'' class. userManual.Result.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
new I.4.12 IV.2.4.5
initialize I.4.12  
clone I.4.12 IV.2.4.5
Manipulation of data
Name= I.4.5.1  
Name I.4.5.1  
clearData I.4.5.1  
getData I.4.9 IV.2.4.2
Size I.4.12 IV.2.4.1
Format= I.4.5.1  
Format I.4.5.1  
TensorOrder= I.4.5.1  
TensorOrder I.4.5.1  
setIntId I.4.5.1  
getIntId I.4.5.1  
setRealId I.4.5.1  
getRealId I.4.5.1  
insert I.4.5.1  
insertRklVals I.4.5.1  
setRefCoordSys I.4.5.2  
renumberLayers I.4.5.3  
renumberSubLayers I.4.5.4  
removeLayers I.4.5.5  
removeSubLayers I.4.5.6  
modifyRefCoordSys I.4.5.7 IV.2.4.4
modifyPositionRefCoordSys I.4.5.8 IV.2.5.2
setToCombili I.4.5.9  
Extraction methods
extractResultOnEntities I.4.2.1  
extractResultOnLayers I.4.2.2  
extractResultOnSubLayers I.4.2.3  
extractResultOnRkl I.4.2.4 IV.2.4.2
extractResultOnResultKeys I.4.2.5  
extractResultOnRange I.4.2.6  
extractResultForNbrVals I.4.2.7  
extractResultMin I.4.2.8  
extractResultMax I.4.2.9 IV.2.4.2
extractRklOnRange I.4.2.10  
extractRklForNbrVals I.4.2.11  
extractRklMin I.4.2.12  
extractRklMax I.4.2.13  
extractRkl I.4.2.14 IV.2.4.2
extractLayers I.4.2.18  
extractSubLayers I.4.2.19  
extractGroup I.4.2.17  
extractGroupOnRange I.4.2.15  
extractGroupForNbrVals I.4.2.16  
Derivation methods
deriveScalToScal I.4.3.1 IV.2.4.2
deriveVectorToOneScal I.4.3.2 IV.2.5.4
deriveVectorToVector I.4.3.3  
deriveTensorToOneScal I.4.3.4  
deriveTensorToTwoScals I.4.3.5  
deriveTensorToThreeScals I.4.3.6  
deriveDyadic I.4.4  
deriveByRemapping I.4.3.7  
Global Force and Moment
calcResultingFM I.4.7 IV.2.5.3
Operators
+ I.4.6.1  
- I.4.6.2  
* I.4.6.3 IV.2.5.2
/ I.4.6.4  
** I.4.6.5  
BLOBs for SQL
toBlob I.4.10 IV.2.6, VIII.1.4, VI.1.8
fromBlob I.4.10  
Iterators
each I.4.11 IV.2.4.3
each_key I.4.11 IV.2.4.4
each_values I.4.11 IV.2.4.4
Complex Results manipulation
set2RI I.4.8.1 IV.2.4.5
set2MP I.4.8.1 IV.2.4.5
conjugate I.4.8.2  
getR I.4.8.4 IV.2.4.5
getM I.4.8.4 IV.2.4.5
getI I.4.8.4 IV.2.4.5
getP I.4.8.4 IV.2.4.5
rotateBy I.4.8.3  
assembleComplex I.4.8.5 IV.2.4.5
Other methods
to_s I.4.12  
Attributes
Name I.4.5.1  
Size I.4.12 (read only)
Format I.4.5.1  
TensorOrder I.4.5.1  
     


I.4.1 The concept of ``Result''

Basically, a Result may be considered as a mapping between ``keys'' and ``values''. These two concepts are discussed in sections I.4.1.1 and I.4.1.2 respectively.

Otherwise several member data of Result objects can be accessed at ruby level. This is the case for Result name, integer and real identifiers. Those are discussed in section I.4.1.3.


I.4.1.1 ``Keys''

The ``keys'' of Results correspond to the entities to which ``values'' are associated. For example, a key may be:

So, at C++ level, each key is characterized by four integers: At ruby level, one can work with either the C++ integer ids, or their string correspondent. The correspondence between string and integers are given in Tables I.4.2, I.4.3, I.4.4 and I.4.5. The data given in these Tables can be completed by additional data peculiar to the different supported solvers. (See Part III for more information.)

In Table I.4.4, the last layers IDs cannot be attributed to Result keys. The elements corresponds to groups of layers and are used to perform extraction operations:


Table I.4.2: Correspondence between element strings and their integer ids.
No element association
"NONE" -1
For Results associated to elements
"elem 1" 1
"elem 2" 2
"elem 3" 3
"elem ..." ...


Table I.4.3: Correspondence between special nodes for element Results and their integer ids.
No node association
"NONE" -999
For Results associated to nodes
"node 1" 1
"node 2" 2
"node 3" 3
"node ..." ...


Table I.4.4: Correspondence between Result layer names and their integer ids.
For unlayered Results
NONE
-999
Undefined layer
UNDEF
-300
For stress recovery in bars and beams
"PointA" -201
"PointB" -202
"PointC" -203
"PointD" -204
"PointE" -205
"PointF" -206
For 2D elements
"Z0" -100
"Z1" -101
"Z2" -102
For Results in laminates (positive layers)
"layer 1" 1
"layer 2" 2
"layer 3" 3
"layer ..." ...
Group of layers for extraction operations
"Beam Points" -2001
"Shell Layers" -2002
"All Plies" -2003
"All Layers" -2004


Table I.4.5: Correspondence between Result sub-layer names and their integer ids. ("All Sub-Layers" is used for extractions only.)
"NONE" 0
"All Sub-Layers" 50
"Bottom" 101
"Mid" 102
"Top" 103

Note that the notion of ``key'' is also closely related to the ``ResKeyList'' ruby class which is simply a list of key objects (see Chapter I.5).


I.4.1.2 ``Values''

The values of Result are characterized by an integer value (32 bits integer) and one or several real values. The integer value corresponds to the coordinate system into which the components are expressed:

Obviously, for several types of coordinate system, the values must be attached to an element to make sense. This is the case for ``elemIJK'', ``plyCS'', ``matCS'', ``elemCS'',...

The real values correspond to the components:

Note that the name of the components given above matter, as they may be used to extract a single component out of a vectorial or tensorial Result. For Complex Result, the numbers of components mentioned above is multiplied by two. They are presented in the following order: The components are stored in single precision real values (float coded on 32 bits). This means that there is no advantage at using double precision real values in your programming as far as the manipulation of results is conscerned.


I.4.1.3 Identification of Result objects

Besides the mapping from key to values, the Result objects contain information that allow their identification. The identification information is:

The methods used to access these member data are described in section I.4.5.1.


I.4.1.4 Other characteristics

A Result object is also characterized by two other integer values:

Methods used to manipulate these data are described in section I.4.5.1. These two integers are attributes of the class.


I.4.2 Extraction methods

The class ``Result'' defines several methods allowing the construction of a new Result object, or of a ``ResKeyList'' object from a previously existing Result by an appropriate selection on the keys. The extraction methods defined in class Result are defined in the following sections.


I.4.2.1 ``extractResultOnEntities'' method

This method is used to extract a sub-set of keys and values from an existing Result object. The method returns the newly created Result object. The method has up to four arguments:

  1. The ``Method'' argument is a String object specifying the algorithm to be used to select the keys and values to be inserted in the new Result object. Possible values of this argument are:
  2. The ``Target'' argument is a Group containing the elements and/or nodes used by some of the algorithms described above to select sub-sets of Results.
  3. The ``LayersList'' argument is an Array containing the list of layers on which the pairs of key and value must be extracted. If the Array is void, then data corresponding to all layers are extracted. If the Array is not void, the elements must be String or integer objects
  4. The ``SubLayersList'' argument is an Array containing the list of sub-layers on which the pairs of key and value must be extracted. If the Array is void, then data corresponding to all sub-layers are extracted. If the Array is not void, the elements must be String or integer objects
The two last arguments are optional. Note that the ``Method'' argument described above is the same as the ``Method'' argument of the DataBase member method ``getResult'' described in section I.1.3.

This method works for Real as well as for Complex Results.


I.4.2.2 ``extractResultOnLayers'' method

This method is used to extract a sub-set of keys and values from an existing Result object. The method returns the newly created Result object. The method has one ``LayersList'' argument: it is an Array containing the list of layers on which the pairs of key and value must be extracted. The elements of the Array argument are integers or String values.

This method works for Real as well as for Complex Results.


I.4.2.3 ``extractResultOnSubLayers'' method

This method is used to extract a sub-set of keys and values from an existing Result object. The method returns the newly created Result object. The method has one ``SubLayersList'' argument: it is an Array containing the list of sub-layers on which the pairs of key and value must be extracted. The elements of the Array argument are integers or String values.

This method works for Real as well as for Complex Results.


I.4.2.4 ``extractResultOnRkl'' method

This method returns a Result object build by extraction of the values corresponding to the keys contained in the ResKeyList ``Target'' argument.

This method works for Real as well as for Complex Results.


I.4.2.5 ``extractResultOnResultKeys'' method

This method returns a Result object build by extraction of the values corresponding to the keys contained in the Result ``Target'' argument. (This method is very similar to ``extractResultOnRkl'' method, except that the target is given by a Result argument.)

This method works for Real as well as for Complex Results.


I.4.2.6 ``extractResultOnRange'' method

This method returns a Result object build by extraction of the values selected by specifying a range. This method can be applied to scalar Result objects only as the range is specified by one or two Real values. The arguments of the method are:

  1. The ``Method'' String argument specifies the extraction algorithm that is used. Four values are possible:
  2. The ``LowerBound'' argument is a real value specifying the lower bound of the range. For some algorithms, this value may be unused and irrelevant.
  3. The ``UpperBound'' argument is a real value specifying the upper bound of the range. For some algorithms, this value may be unused and irrelevant.
This method works for Real Results only.


I.4.2.7 ``extractResultForNbrVals'' method

This method returns a Result object build by extraction of maximum ``NbrVals'' values. This method can be applied to scalar Result objects only and has two arguments:

  1. The ``Method'' String argument specifies the extraction algorithm that is used. Two values are possible:
  2. ``NbrVals'' is an integer argument corresponding to the number of values to be kept.
This method works for Real Results only.


I.4.2.8 ``extractResultMin'' method

This method returns a Result object build by extraction of the minimum value and corresponding key. This method can be applied to scalar Result objects only.

This method works for Real Results only.


I.4.2.9 ``extractResultMax'' method

This method returns a Result object build by extraction of the maximum value and corresponding key. This method can be applied to scalar Result objects only.

This method works for Real Results only.


I.4.2.10 ``extractRklOnRange'' method

This method works exactly as method ``extractResultOnRange'' described in section I.4.2.6 but returns a ResKeyList object instead of a Result object. This means that one returns only a list of keys, but not the associated values.

This method works for Real Results only.


I.4.2.11 ``extractRklForNbrVals'' method

This method works exactly as method ``extractResultForNbrVals'' described in section I.4.2.7 but returns a ResKeyList object instead of a Result object. This means that one returns only a list of keys, but not the associated values.

This method works for Real Results only.


I.4.2.12 ``extractRklMin'' method

This method returns a ResKeyList object build by extraction of the key corresponding to the minimum value. This method can be applied to scalar Result objects only.

This method works for Real Results only.


I.4.2.13 ``extractRklMax'' method

This method returns a ResKeyList object build by extraction of the key corresponding to the maximum value. This method can be applied to scalar Result objects only.

This method works for Real Results only.


I.4.2.14 ``extractRkl'' method

This method returns a ResKeyList object build by extraction of all the keys of the Result object to which the method is applied.

This method works for Real as well as for Complex Results.


I.4.2.15 ``extractGroupOnRange'' method

This method works exactly as method ``extractResultOnRange'' described in section I.4.2.6 but returns a Group object instead of a Result object. The Group contains the element and node entities for which values in the specified range have been found.

This method works for Real Results only.


I.4.2.16 ``extractGroupForNbrVals'' method

This method works exactly as method ``extractResultForNbrVals'' described in section I.4.2.7 but returns a Group object instead of a Result object. The Group contains the element and node entities for which values in the specified range have been found.

This method works for Real Results only.


I.4.2.17 ``extractGroup'' method

This method returns a Group object containing the elements and nodes that are referenced in the Result object. This method has no argument.

This method works for Real as well as for Complex Results.


I.4.2.18 ``extractLayers'' method

This method returns an Array of String and integers corresponding to the layers that are referenced in the Result object. This method has no argument.

This method works for Real as well as for Complex Results.


I.4.2.19 ``extractSubLayers'' method

This method returns an Array of String and integers corresponding to the sub-layers that are referenced in the Result object. This method has no argument.

This method works for Real as well as for Complex Results.


I.4.3 Derivation monadic methods

All the methods presented in this section are devoted to the production of new results by performing operations on the values of the Result object to which they are applied. Each method produces Results with as many pairs ``key-values'' as in the Result object to which it is applied, but the number of components associated to each key may be different than the original number of components. Indeed, the original Result and derived Result have not necessarily a same tensor order.

Most of the methods presented below have only one argument: a Method String object corresponding to the algorithm of derivation. The use of the methods defined below leads sometimes to very heavy notations for simple or very often used operations. Therefore, short-cuts to some methods have been defined in the ``Post'' module (ChapterI.6).


I.4.3.1 ``deriveScalToScal'' method

This method builds a new Result object by performing an operation on all the values of the Result object to which it is applied. Both Result objects correspond to scalar values. The Possible values of the ``Method'' argument are:

The method works for Real Results as well as Complex Results. However, some of the methods are not available for Complex Results: ``asin'', ``acos'', ``atan'' and ``sgn'' can be used with Real Results only.


I.4.3.2 ``deriveVectorToOneScal'' method

This method builds a new Result object by performing an operation on all the values of the Result object to which it is applied. The Result object to which the method is applied must be vectorial. The created Result object is scalar. Possible values of the ``Method'' String argument are:

This method works for Real Results as well as for Complex Results. When applied to a Complex Result object, the method works as follows:


I.4.3.3 ``deriveVectorToVector'' method

This method builds a new Result object by performing an operation on all the values of the Result object to which it is applied. The Result object to which the method is applied must be vectorial. The created Result object is vectorial too. Possible values of the ``Method'' String argument are:

This method works for Real Results as well as for Complex Results.


I.4.3.4 ``deriveTensorToOneScal'' method

This method builds a new Result object by performing an operation on all the values of the Result object to which it is applied. The Result object to which the method is applied must be tensorial. The created Result object is scalar. Possible values of the ``Method'' String argument are:

All the methods listed above work for Real Tensorial Results. For Complex Results, only the methods of Component extractions can be used.


I.4.3.5 ``deriveTensorToTwoScals'' method

This method returns an Array of two Result objects derived from the tensorial Result object on which the method is applied. The returned Results are scalar. Possible values of the ``Method'' String argument are:

This method works for Real Results only.


I.4.3.6 ``deriveTensorToThreeScals'' method

This method returns an Array of three Result objects derived from the tensorial Result object on which the method is applied. The returned Results are scalar. Possible values of the ``Method'' String argument are:

This method works for Real Results only.


I.4.3.7 ``deriveByRemapping'' method

This method returns a Result object obtained by remapping the values of the Result object to which the method is applied. This method takes three parameters:

  1. ``FromTo'': a String object specifying the correspondence between the keys of the old Result object and the keys of the new Result object. Six different values of the ``FromTo'' argument are allowed:
  2. ``Method'': a String object used to specify the way values associated to different keys are merged into a single value (if this happens). An example of situation in which the case may occur is for example when one uses the ``NodesToCenters'' option and that the values of several nodes are merged into the value of a single element. Five values of ``Method'' argument are allowed: Note that when vectorial or tensorial Results are merged (``sum'' or ``average'' options, their respective coordinate systems must be identical. Otherwise an error message is issued.
  3. ``DB'': a DataBase object used by the method to recover the association of node and elements. This association is often needed to perform the remapping.
The ``deriveByRemapping'' method can be used with Real as well as Complex Results. Only, for Complex Results, there are some restriction about the type of ``Method'' argument for merging values: the ``min'' and ``max'' values are not accepted for Complex Results.


I.4.4 Dyadic derivation method

Presently, only one such method is defined: the ``deriveDyadic'' method. This method returns a new Result object corresponding to the dyadic derivation. This method has two arguments:

Possible values for the ``Method'' argument are: Note that several of the methods above for dyadic derivation have corresponding short-cuts in the ``Post'' module.

The different methods listed above are available for Real Results. For Complex Results, only the methods ``vectProduct'', ``sumVectProduct'', ``merge'', ``mergeKeepFirst'' and ``mergeKeepLast'' can be used. Of course, if the ''Second'' argument is a Real object, the ``deriveDyadic'' method cannot be invoked on a Complex Result object.


I.4.5 Methods modifying the object

One presents here methods that modify the Result object to which they are applied.


I.4.5.1 Access to and modification of Result data

Each Result object is also characterized by two integer and two real identifiers. Different methods allow to retrieve or modify the Result data.

For the four last methods listed above, the value of index argument can be 0 or 1. Note that several of the methods listed above correspond to the ``Name'', ``Format'' and ``TensorOrder'' attributes.

All these methods can be used with Real Results as well as with Complex Results.


I.4.5.2 ``setRefCoordSys''

``setRefCoordSys'' is used to attribute a reference coordinate system to the values of a Result. The method has one argument that can have to types:

Note that only the coordinate system ids of the pairs of key and values are modified. The components of the vectorial or tensorial values are left unchanged.

This method can be used with Real Results as well as with Complex Results.


I.4.5.3 ``renumberLayers''

``renumberLayers'' is a method used to renumber the layer integer ids of Result keys. The method has one Hash argument corresponding to the pairs of ``old integers IDs'' and ``new integer IDs''.

This method can be used with Real Results as well as with Complex Results.


I.4.5.4 ``renumberSubLayers''

``renumberSubLayers'' is a method used to renumber the sub-layer integer ids of Result keys. The method has one Hash argument corresponding to the pairs of ``old integers IDs'' and ``new integer IDs''.

This method can be used with Real Results as well as with Complex Results.


I.4.5.5 ``removeLayers''

``removeLayers'' is a method used to remove pairs of key and values selected on the basis of the layer ID of the key. The method has one ``LayersList'' argument: it is an Array containing the list of layers for which the pairs of key and value must be removed. The elements of the Array argument are integer or String values.

This method can be used with Real Results as well as with Complex Results.


I.4.5.6 ``removeSubLayers''

``removeSubLayers'' is a method used to remove pairs of key and values selected on the basis of the layer ID of the key. The method has one ``SubLayersList'' argument: it is an Array containing the list of sub-layers for which the pairs of key and value must be removed. The elements of the Array argument are integer or String values.

This method can be used with Real Results as well as with Complex Results.


I.4.5.7 ``modifyRefCoordSys''

``modifyRefCoordSys'' is used to modify the reference coordinate system wrt which the components of a vectorial or a tensorial Result are applied. If the Result is vectorial it can represent any vectorial quantities except the coordinates. For coordinate vectorial Result, the method ``modifyPositionRefCoordSys'' must be used. This method has no effect on scalar Results.

The methods returns nil (no new Result object is created) and takes two, three or five arguments:

  1. A DataBase object.
  2. An object corresponding to the definition of the coordinate system to which one switches. This object may have different types:
    1. A String object with one of the following values: ``elemCS'', ``nodeCS'', ``matCS'', ``plyCS'', ``elemIJK'', ``lamCS''. All those coordinate systems are local to an element or to a node.

      More information about the peculiarities of ``matCS'', ``plyCS'' and ``lamCS'' coordinate system transformations is given in section IX.B.5.

    2. The argument may by a CoordSys object. Then it must be defined wrt a coordinate system defined in the DataBase argument.
    3. The argument may also be an integer larger than or equal to 0. Then the coordinate system must be defined in the DataBase.
  3. The third argument is the direction vector used to build the projected coordinate system on surfacic elements. The vector is given by an Array of three real objects, and is expressed wrt to the coordinate system given in second argument. If one does not wish to transform into a projected coordinate system, then the third argument must be omitted or nil. (However if arguments 4 and 5 are provided, the third argument cannot be omitted.)
  4. An object corresponding to the definition of the coordinate system from which one switches. This object may have the same values as the second argument.
  5. The last argument is a direction vector used to build the projected coordinate system on surfacic elements. The vector is given by an Array of three real objects, and is expressed wrt to the coordinate system given in second argument. If one does not wish to transform into a projected coordinate system, then the third argument must be nil.
The reason why a DataBase object is given as argument is that for curvilinear coordinate systems, much information about the location of Result value is necessary to perform a correct transformation of the components. Also, all coordinate systems are stored in the DataBase object. Therefore, it is very important that the programmer keeps in mind that all Results are related to a DataBase.

Note that some transformation vectorial or tensorial coordinate systems cannot be reversed. For example, once a Result is expressed in a projected coordinate system. Also, if a conversion has been done in a coordinate system that is not defined in the DataBase, the conversion is impossible. After transformation, the coordinate system referenced in Result values is altered (section I.4.1.2).

If arguments 4 and 5 are provided, the method assumes that the values are expressed in that coordinate system definition. This means that the CsId found in each pair ``key-values'' pair of the Result object is totally disregarded. The use of arguments 4 and 5 may allow the modification of Results expressed in a user or projected coordinate system.

More information on the transformation of coordinate systems is given in section IX.B.4.

This method can be used with Real Results as well as with Complex Results.


I.4.5.8 ``modifyPositionRefCoordSys''

``modifyPositionRefCoordSys'' is used to modify the reference coordinate system wrt which vectorial Results corresponding to coordinates are expressed. The Results must be vectorial.

The method returns nil (no new Result object is created) and takes two arguments:

  1. A DataBase object.
  2. An integer object corresponding to the index of the coordinate system to which one switches. This index must be >0 and defined in the DataBase argument. One can also provide a CoordSys object instead of the integer argument.
For the reason of the presence of the DataBase argument, see section I.4.5.7.

This method can be used with real Results only.


I.4.5.9 ``setToCombili''

The method fills the values of the Result object on which the method is called with the linear combination of the elementary Results given as arguments. The arguments are defined as follows:

  1. An Array of Real values containing the factors of the linear combination.
  2. An Array containing the elementary Results.
The lengths of the two Array arguments must match. Also the type of elementary Results (scalar, vectorial or tensorial) must be identical and the coordinate systems must be the same for a same key.

This method can be used with Real Results as well as with Complex Results. Also, the real factors of the linear combination can be replaced by Complex values. However, all the elements of the Array must be of the same type (Real or Complex).


I.4.6 Operators

Five elementary operators on Result objects have been defined. Also, their corresponding assignment method have been defined. Unless otherwise specified, in the examples given below, $ x$ , $ y$ and $ z$ are Result objects. However the second operand $ y$ of the addition, substraction and multiplication operators can be replaced by:

For the division operation, $ y$ can be replaced by a real argument, but not by a vector or a matrix. For the exponentiation operator, the two Results must be scalar.

One can make a few general remarks:

The support for Complex Result operators depends on the type of dyadic operation. See the sub-sections below for more information.


I.4.6.1 Addition operator

The addition operator can be used as follows:

$\displaystyle z=x+y\ .
$

In the previous expression, the Results $ x$ and $ y$ must have the same tensorial order. Of course, the returned $ z$ object is also of the same tensor order as $ x$ and $ y$ .

This operator works with Complex Result operators as well as with Real Result operators. However, if one operator is a Complex Result, the other operator cannot be a Real Object, or a Vector (Array of Real objects), or a Matrix (Array of Arrays of Real objects).


I.4.6.2 Substraction operator

The substraction operator can be used as follows:

$\displaystyle z=x-y\ .
$

In the previous expression, the Results $ x$ and $ y$ must have the same tensorial order. Of course, the returned $ z$ object is also of the same tensor order as $ x$ and $ y$ .

This operator works with Complex Result operators as well as with Real Result operators. However, if one operator is a Complex Result, the other operator cannot be a Real Object, or a Vector (Array of Real objects), or a Matrix (Array of Arrays of Real objects).


I.4.6.3 Multiplication operator

The multiplication operator can be used as follows:

$\displaystyle z=x*y\ .
$

The meaning of this operation depends on the tensorial orders of $ x$ and $ y$ . The various possibilities are summarized in Table I.4.6 with a short explanation of the meaning of the operation when deemed necessary.


Table I.4.6: Possible arguments of the Result multiplication operator, returned value, and meaning of the operation.
$ z$ $ x$ $ y$ meaning
S S S --
V S V --
M S M --
V V S --
S V V scalar product of two vectors
V V M left multiplication of a matrix by a vector
M M S --
V M V right multiplication of a matrix by a vector

Complex Results are partially supported by the multiplication operator. We list below several characteristics of the operator:


I.4.6.4 Division operator

The division operator can be used as follows:

$\displaystyle z=x/y\ .
$

In the last expression $ x$ can have any tensorial order. The tensorial order of the returned Result $ z$ is identical to the tensorial order of $ x$ . The argument $ y$ can be either a scalar Result object, or a real value.

Complex Results are partially supported by the division operator. The limitations of the operator for complex arguments are the same as for the multiplication operator.


I.4.6.5 Exponent operator

The exponentiation operator can be used as follows:

$\displaystyle z=x**y\ .
$

In the last expression $ x$ must be a scalar Result. The tensorial order of the returned Result $ z$ is identical to the tensorial order of $ x$ . The argument $ y$ can be either a scalar Result object, or a real value. Complex Results cannot be arguments to this operator. The real values of first Result argument must also be positive.

The two following expressions are equivalent:

            z=x**y
            z=Post.pow(x,y)


I.4.7 ``calcResultingFM'' method

This is a class method used to estimate the total force and moment corresponding to a distribution of forces and moments on several points. The method has five arguments:

  1. A DataBase object containing the model used to calculate the total forces and moments.
  2. A first Result object corresponding to the vectorial forces.
  3. A second Result object corresponding to the vectorial moments.
  4. An object corresponding to the coordinate system in which results and position of recovery point are expressed. If the argument is an integer, it must correspond to the index of a CoordSys object defined in the dataBase. The argument can also be a CoordSys object, but its definition must refer a coordinate system defined in the dataBase.
  5. The last argument is a vector (Array of three real values) corresponding to the position of the point wrt which the total force and moment are calculated. The position of the point is defined wrt the coordinate system corresponding to the previous argument. (This may different than what other post-processing tools like Patran do.)
Note that the last argument is optional. If it is omitted, the method assumes that the recovery point is located on the origin of the coordinate system.

If argument Results are in Real format, the method returns an Array containing two vectors (i.e. two Arrays of Real objects). These vectors correspond to the total force and total moment respectively. Note that the method produces no new Result object.

If argument Results are Complex, the method returns an Array containing two Complex vectors (i.e. two Arrays of Complex objects). Note However that the Complex values in the resultants are always given in rectangular format (real and imaginary parts). This is true even when the argument Results are in polar (magnitude-phase) format.


I.4.8 Complex Results

Several methods correspond to operations specific to complex Results. These methods are described below.


I.4.8.1 Rectangular-Polar conversions

Two methods allow to tranform Complex Results expressed in real-imaginary format to magnitude-phase format, and reversely:

For these two methods, no complex conversion is performed if the Result is already in the requested format.


I.4.8.2 Conjugate Complex Result

``conjugate'' produces a Result by initializing its values to conjugate of other values ( $ z\rightarrow\overline{z}$ ). The method has 0 or 1 argument. If the method has one argument, the object on which the method is called is set to the rectangular complex values of its argument. Otherwise, the object on which the methods is called is modified. Note that the method can also be called on a Real Result but has then no effect.


I.4.8.3 Rotation of Complex Result

The method ``rotateBy'' is used to modify the values of a Complex Result by adding an angle specified in degrees to the corresponding phases. However, the method can be used indifferrently with Complex Results in rectangular or in polar formats. The method may have one or two arguments:

Note that the rotation is done by multiplying the Result by a Complex value.


I.4.8.4 Extractions from Complex Results

Four methods produce Real Results from Complex Results by extracting the appropriate components:

These methods must be called on Complex Results. The polar or rectangular format of the Complex Results do not matter: if needed a polar-rectangular conversion of the components is done before the extraction.

The two methods ``getR'' and ``getI'' may have an optional Real argument that correspond to a rotation applied to the Result before extracting the Real or Imaginary component Result. Note that the Result on which the method is called is left unmodified.


I.4.8.5 Assembling Complex from Real Results

The ``assembleComplex'' method is used to assemble a Complex Result object from two Real Results. The method is called on a Result object and has three arguments:

  1. An integer corresponding to the format of the new Complex Result. The accepted values are 2 (real-imaginary or rectangular format) or 3 (polar or magnitude-phase format).
  2. A first Result object that will correspond to the real or magnitude components of the assembled Result.
  3. A second Result object that will correspond to the imaginary of phase components of the assembled Result.
Note that the two Result arguments must satisfy several requirements: An example of valid (but not very useful) call to ``assembleComplex'' follows:
    resR=res2.getR
    resI=res2.getI
    
    resRI=Result.new
    resRI.assembleComplex(2,resR,resI)
(At the end, resRI should be the same as res2.)


I.4.9 ``getData''

The method returns an Array of Arrays containing the data stored in a Result object. The returned Array may actually be considered as a two-dimensional Array with as many lines as there are pairs of key-value in the Result object. Each line of the Array contains five, seven or ten elements:

  1. The first element corresponds to the elemId.
  2. The second element corresponds to the nodeId of the key.
  3. The third element corresponds to the layerId of the key.
  4. The fourth element corresponds to the subLayerId of the key.
  5. The fifth element corresponds to the coordinate system in which the value components are associated. The possible values are summarized in Table I.4.7.
  6. The other elements are real values corresponding to the components (1, 3 or 6 values for a scalar, vectorial or tensorial Result respectively). For the precise meaning of the returned value corresponding to coordinate system, see also section I.4.1.2.
The method may have 5, 4, 3, 2, 1 or no argument. The arguments correspond to the type of the Array elements corresponding to elemId, nodeId, layerId, subLayerId or coordSysId. In the returned Array, these elements may be of String or Integer types. Correspondingly the arguments are Strings the value of which can be "int", "string" or any other String. If any other String is used as argument (for example a void string), the default Integer or String type elements are returned.

For element, node and layer ids, the negative values correspond to ``special'' values. (See Tables I.4.2 to I.4.4.)




Table I.4.7: Correspondence between the integer in C++ ``value'' class and the value returned by Result member method ``getData''.
integer in C++ ``value'' class returned value in ruby
-9999 nil
-2000 "userCS"
-1000 "projCS"
-5 "elemIJK"
-4 "plyCS"
-3 "matCS"
-2 "nodeCS"
-1 "elemCS"
any other integer the same integer


I.4.10 ``BLOBs''

Result objects can be saved in SQL database as ``BLOB'' objects.

Two methods are defined in Result class to convert object to and from Blobs:


I.4.11 Iterators

Three iterators are defined in the class:

For the meaning of the arguments, see more information in section I.4.9. One difference between the ``each'' iterator and the getData method is that the key and values elements are separated into two Arrays in the block. So the iterator is to be used as follows:
    strain.each("int","int","int") do |key,values|
        ...
    end
    ...
    strain.each("int","int","string","string") do |key,values|
        ...
    end
Note that, as the ``each_key'' and ``each_values'' iterators return Arrays, one can indifferently recover an Array argument, or its elements in the arguments of the block that follows the iterator. For example, in the following lines:
    stress.each_key do |stressKey|
        ...
    end
``stressKey'' is an Array of three elements. However in the following lines:
    stress.each_key("int","int","int") do |elemId,nodeId,layerId|
        ...
    end
the arguments correspond to the different identifiers of the Result key.


I.4.12 Other methods

One gives here a list of methods that do not fit in any category listed above.

I.4.12.1 ``new''

This method is used to create a new Result object.

I.4.12.2 ``initialize''

This method initializes or clears a Result object.

I.4.12.3 ``clone''

This method returns a Copy of the Result object to which it is applied.

I.4.12.4 ``Size'' attribute

Returns an integer containing the numbers of pairs ``key-value'' contained in the Results object. This method has no argument. It corresponds to the ``Size'' read-only attribute.

I.4.12.5 ``to_s''

This method is used for printing the Result object.


I.5 The ``ResKeyList'' class

A ResKeyList object is basically a set of Result keys (see Chapter I.4). Actually, a ResKeyList object is a kind of Result with no values associated to the keys.

One shows in section I.4.2 that several methods of class Result allow to build ResKeyList objects from Results, and to extract Results from other Results using ResKeyList objects.

A list of the methods defined in ``ResKeyList'' class is given in Table I.5.1.

Table I.5.1: The different methods that have been defined in ``ResKeyList'' class. userManual.ResKeyList.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization
new I.5.1 IV.2.5.1
initialize I.5.1  
clone I.5.1  
insert I.5.1  
getData I.5.6  
Size I.5.7  
Identification
Name= I.5.7  
Name I.5.7  
Extractions
extractLayers I.5.2  
extractSubLayers I.5.2  
extractGroup I.5.2  
Layers and sub-layers manipulation
renumberLayers I.5.3.1  
renumberSubLayers I.5.3.2  
removeLayers I.5.3.3  
removeSubLayers I.5.3.4  
Operators
+ I.5.4  
- I.5.4  
* I.5.4  
/ I.5.4  
Iterators
each_key I.5.5  
Printing
to_s I.5.7  
Attributes
Name I.5.7  
Size I.5.7 (read only)
     


I.5.1 Creating and filling ResKeyList object

The usual ``new'' and ``initialize'' singleton methods are defined in the ResKeyList class. These methods have no arguments. The class member method ``clone'' has no argument and returns a copy of the object.

The user can fill its one ResKeyList object with the ``insert'' method. This method takes one Array Argument with between 1 and 3 elements corresponding to the element identifier, the node identifier, the layer identifier and the sub-layer identifier. Each element can be a String or an integer.


I.5.2 Extraction functions

Two extraction functions have been defined:

These methods have no arguments.


I.5.3 Methods modifying the object

The two methods described below correspond with the methods with identical names defined in ``Result'' class.


I.5.3.1 ``renumberLayers''

``renumberLayers'' is a method used to renumber the layer integer ids of ResKeyList keys. The method has one Hash argument corresponding to the pairs of ``old integers IDs'' and ``new integer IDs''.


I.5.3.2 ``renumberSubLayers''

``renumberSubLayers'' is a method used to renumber the sub-layer integer ids of ResKeyList keys. The method has one Hash argument corresponding to the pairs of ``old integers IDs'' and ``new integer IDs''.


I.5.3.3 ``removeLayers''

``removeLayers'' is a method used to remove keys selected on the basis of the layer ID of the key. The method has one ``LayersList'' argument: it is an Array containing the list of layers for which the keys must be removed. The elements of the Array argument are integer or String values.


I.5.3.4 ``removeSubLayers''

``removeSubLayers'' is a method used to remove keys selected on the basis of the layer ID of the key. The method has one ``SubLayersList'' argument: it is an Array containing the list of sub-layers for which the keys must be removed. The elements of the Array argument are integer or String values.


I.5.4 Dyadic operators

Eight such operators have been defined. One first explains the meaning and behavior of the four elementary dyadic operations.


I.5.5 Iterators

One ``each_key'' iterator is defined in the class: it iterates on the data and produces Arrays of three elements corresponding to keys. The iterator may have between 0 and 4 arguments argument. The arguments are Strings that specify whether some of the data are to be returned in String or integer format.

Actually, the ``each_key'' iterator of ResKeyList class is identical to the ``each_key'' iterator of Result class.


I.5.6 ``getData''

The method returns an Array of Arrays containing the data stored in a ResKeyList object. The returned Array may actually be considered as a two-dimensional Array with as many lines as there are pairs of keys in the ResKeyList object. Each line of the Array contains four elements:

  1. The first element corresponds to the elemId.
  2. The second element corresponds to the nodeId of the key.
  3. The third element corresponds to the layerId of the key.
  4. The fourth element corresponds to the subLayerId of the key.
The method may have 4, 3, 2, 1 or no argument. The arguments correspond to the type of the Array elements corresponding to elemId, nodeId, layerId or subLayerId. In the returned Array, these elements may be of String or Integer types. Correspondingly the arguments are Strings the value of which can be "int", "string" or any other String. If any other String is used as argument (for example a void string), the default Integer or String type elements are returned.

Actually, this method corresponds to the ``getData'' method of Result class (See section I.4.9). The special key names are the same as those listed in Tables I.4.2 to I.4.4.


I.5.7 Other methods

One gives here a list of methods that do not fit in any category listed above:


I.6 The ``Post'' module

The ``Post'' module contains the definition of methods belonging to no particular class. These methods are all devoted to manipulation of Results or Groups.

A list of the methods defined in ``Post'' module is given in Table I.6.1.

Table I.6.1: The different methods that have been defined in ``Post'' module. userManual.Post.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Manipulation of FeResPost standard output
openMsgOutputFile I.6.1  
closeMsgOutputFile I.6.1  
writeAboutInformation I.6.1  
writeMsgOutputLine I.6.1  
Monadic functions for new Result creation
exp I.6.2  
log I.6.2  
exp10 I.6.2  
log10 I.6.2  
abs I.6.2  
inv I.6.2  
sq I.6.2  
sqrt I.6.2  
sgn I.6.2  
Dyadic functions for new Result creation
min I.6.3  
max I.6.3  
cmp I.6.3  
merge I.6.3  
mergeKeepFirst I.6.3  
mergeKeepLast I.6.3  
pow I.6.3  
vectProduct I.6.3  
sumVectProduct I.6.3  
Groups and Patran session files
readGroupsFromPatranSession I.6.5 I.6.5
writeGroupsToPatranSession I.6.5 I.6.5
Control of verbosity for debugging purposes
setVerbosityLevel I.6.6  
getVerbosityLevel I.6.6  
Conversion of CLA identifiers
convertIdfierToString I.6.7  
convertStringToIdfier I.6.7  
BLOBs for SQL
convertBlob I.6.8  
     


I.6.1 Manipulation of FeResPost standard output

Four methods of ``Post'' Module allow to manipulate the information, warning and error messages issue by FeResPost:

The redirection of standard output is useful when FeResPost is not run in ``console'' mode. Moreover, it is sometimes handy to separate the outputs of FeResPost, and does of the ruby post-processing program.


I.6.2 Monadic functions for new Result creation

In section I.4.3, one defines functions that allow the creation of new Result objects from existing ones. Here, one present short-cuts to some of these functions (for the following functions, x and y are Result objects):


I.6.3 Dyadic functions for new Result creation

In section I.4.3, one defines functions that allow the creation of new Result objects from existing ones. Here, one present short-cuts to some of these functions (for the following functions, x, y and z are Result objects):

Also other functions that have no correspondence in Result class methods can be used to define new Results Most of the dyadic functions insert a pair ``key-value'' in the created Result only if the corresponding key is found in the two Result arguments. ``Post.min'', ``Post.max'' and the `Post.merge'' methods are an exception: if a given key is found in only one of the two argument it is inserted in the new Result.


I.6.4 ``Operator'' methods

Four ``operator'' methods are defined in the ``Post'' module: ``opAdd'', ``opSub'', ``opMul'' and ``opDiv''. These four methods correspond to the four operators ``+'', ``-'', ``*'' and ``/''. These four methods have the following characteristics:

These four methods have been defined to allow the use of FeResPost ruby extension without modifying standard classes like ``Float'' and ``Array''.


I.6.5 Reading and writing of Groups

Method ``readGroupsFromPatranSession'' reads Groups from a Patran session file and returns a Hash containing the list of Groups. The keys are Group names, and the values are the Groups. The method has two arguments:

  1. A String corresponding to the name of the session file.
  2. A DataBase. This argument is optional. If it is provided, the reading method removes from the created Groups all the entities undefined in the DataBase argument.
The session file from which Groups are read is as defined in section I.1.2.1. Examples of use of the method follow:
      ...
      h=Post::readGroupsFromPatranSession("groups.ses")
      ...
      h=Post::readGroupsFromPatranSession("groups.ses",DB)
      ...

Method ``writeGroupsToPatranSession'' is used to save groups in a Patran session file. This method does the inverse of method ``Post::readGroupsFromPatranSession''. The method has two arguments:

  1. The first argument of the method is a String containing the name of the output session file.
  2. The second argument if the list of Groups. This can be a Hash similar to the one produced by method ``Post::readGroupsFromPatranSession'', of an Array of Group objects.

    When the second argument is a Hash, the String keys are used as reference names for the groups. If the second argument is an Array of Groups, their names are used in the session file.

The following statements:
      ...
      h=Post::readGroupsFromPatranSession("groups.ses")
      ...
      Post::writeGroupsToPatranSession("hash.ses",h)
      Post::writeGroupsToPatranSession("values.ses",h.values)
      ...
produce equivalent Patran session files, but the order in which the Groups are defined may differ.


I.6.6 Setting verbosity for debugging purposes

Two methods allow to set the verbosity level of several operations. The level of verbosity is a parameter global for FeResPost and may be used to write several information messages during operations in which the risk of inconsistent data has been deemed high. These information messages may be used to debug FeResPost, or your programs using FeResPost. Actually, the majority of programming errors you will find will be related to your own program, but the printing of FeResPost messages may help you to help find your errors. The two methods defined in ``Post'' Module are:

The verbosity level may presently range from 0 to 2. 0 corresponds to no information messages. The amount of information messages increases with verbosity level.

Presently, the operations influenced by the verbosity level are the operations related to reading finite element models, and accessing Results in disk files.


I.6.7 Conversion of CLA idfiers

Two methods are defined to convert CLA identifiers to Strings, or Strings to CLA identifiers. (See chapter II.0 for the notion of identifier.) The two methods are defined in the ``Post'' Module:

Examples of valid Strings corresponding to CLA identifiers:
		   "testLam",
		   "15",
		   "[15,testLam]",
		   ...


I.6.8 SQL``BLOB'' methods

The methods ``convertBlob'' returns a ``Result'' or ``Group'' object corresponding to a String argument. The String must correspond to a valid FeResPost BLOB object produced by method ``toBlob'' of one of the FeResPost classes.


I.7 Modification of Standard classes

Two standard classes may also be modified in FeResPost: the ``Float'' class and the ``Array'' class; the operators are modified in such a way that the second operand may be a ``Result'' object. If the second operand is not a Result object, the default version of the operator is called. Table I.7.1 summarizes the modifications in these classes.


Table I.7.1: Methods modified in standard classes.
Modification of ``Float'' class
Method name Description Example
+ I.7.1 --
- I.7.1 --
* I.7.1 --
/ I.7.1 --
Modification of ``Array'' class
Method name Description Example
+ I.7.1 --
- I.7.1 --
* I.7.1 --
/ I.7.1 --

Practically, the modification of standard classes is done in ruby file ``modifStdClasses.rb''. Until version 3.2.7 of FeResPost, the modification was done in the compiled library. Now the fact that the modification of standard classes is done with ruby statements allows the user to cancel these modifications, for example by erasing the corresponding lines in the ``FeResPost.rb'' file of the distribution. The file would then look as follows:

   if (RUBY_PLATFORM.include?("win")) then
      require "FeResPost.dll"
   else
      require "FeResPost.so"
   end

   #require "modifStdClasses"
     
   STDOUT.printf("End \"FeResPost\" module initialization.\n")
   STDOUT.printf("\n\n")
   STDOUT.flush
The reason why the modification of standard classes is displaced into a ruby source file rather than in the compiled part of the extension is that one tries to maintain the compiled library in line with the COM component. Moreover, it is not very good practice to modify standard classes in a programming language.


I.7.1 Operators in modified standard classes

The two classes that are modified are ``Float'' and ``Array'' classes. In each case, when an operator is called, the corresponding ``Operator'' method in ``Post'' Module is called. for example, the two following statements are equivalent:

   z=x+y
   z=Post.opAdd(x,y)
Actually, this is true only if $ x$ is an object of the class ``Float'' or ``Array''.

I.7.2 How the standard classes are modified

Practically, the modification of standard classes is done in two steps:

  1. An alias is created for the old version of the operator.
  2. A new operator is created. In the definition of the operator, one tests the second operand to call the appropriate version of the operator, which may be the old one.
The following lines illustrate the modification for the addition operator of the ``Float'' class.
class Float
   
   alias _FeFesPost_old_opAdd +
   ...
   
   def +(second)
      if second.class==Result then
         return Post.opAdd(self,second)
      else
         return self._FeFesPost_old_opAdd(second)
      end
   end
   
   ...
   
end # Float


II. Composite Reference Manual


II.0 Introduction

Four classes specific to Classical Laminate Analysis calculations have been defined in FeResPost module:

Throughout the composite manual pages, the concept of identifier is often used. An identifier can be: This concept is introduced to provide a general way to identify and access materials, laminates or loads stored in a ClaDb object. Indeed, the methods used to access those data must be compatible with several software (ESAComp or finite element solvers...). As entities manipulated by these software are sometimes identified by integers, sometimes by strings and sometimes by both an integer and a String, this peculiar way to identify the entities in a ClaDb object had to be developed. For example, if a ClaLam object has been stored in a ClaDb, it can be retrieved with:
   ...
   db.insertLaminate(lam1)
   ...
   lam2=db.getLaminateCopy(5)
   ...
   lam2=db.getLaminateCopy("panel1")
   ...
   lam2=db.getLaminateCopy([5,"panel1"])
   ...
Note however that the identifier used to retrieve lam2 must match exactly the identifier of lam1. For example, if lam1 has [5,"panel1"] identifier, only the third ``getLaminateCopy'' statement works.

This leads us to a last remark about interfaces with other software. The composite classes are meant to be used with the rest of FeResPost. Among other things, it allows:

The composite capabilities programming is based on the Classical Laminate Analysis as presented widely in literature. The programmer based its developments on [Gay97]. For the in-plane and flexural parts of laminate response, the approximations done in the development of equations are common to what has been found in the rest of literature. On the other hand, few references have been found about the out-of-plane shear behavior of laminates. In [Gay97], this aspect of laminate analysis is presented with a few assumptions. For example, Gay assumes a mirror symmetry of the laminate. This is obviously not a characteristic of all laminates. Therefore, the out-of-plane shear responses calculated by composite classes should be used with care.

More information about the conventions used for FeResPost composite calculations are given in Chapter II.1.


II.0.1 Remarks and limitations

One presents below a list of limitations, which should not be considered as exhaustive:

  1. When a mechanical loading is applied to a laminate, this loading is also characterized by an angle $ \lambda$ giving the orientation of the loading wrt the laminate. Then the definition of the loading angle $ \lambda$ follows the same conventions as the ply angle $ \xi$ represented in Figure II.1.2. This convention for the definition of loading angle may be different of conventions used in other software. For example, ESAComp seems to consider that the angle provided for loading is the angle of the laminate wrt loading. This results in a change of sign of the corresponding angle.

  2. As the composite classes are under development, modifications of ruby functions related to the composite classes are still possible (and likely).


II.1 Theoretical background

The purpose of this Chapter is to summarize the classical laminate theory, and to provide the information needed by the user of composite classes to understand a few conventions that have been assumed for the programming of Classical Laminate Analysis in FeResPost (axes, angles, numbering of layers,...).

The programmer will find a presentation of the classical laminate theory that follows closely what is programmed in C++ language in FeResPost. However those who are interested in studying the theory, or who are not familiar with it are referred to more extensive presentations of the classical laminate theory [Gay97,Pal99]. Only for the out-of-plane shear behavior of the laminate, is the presentation original, even though inspired by information found in [Sof04a].

The Chapter is organized as follows:


II.1.1 Conventions

Figure II.1.1 represents some of the conventions used for the definition of laminate in FeResPost. The laminate coordinate system is defined in such a way that the $ z$ axis is perpendicular to laminate surface and points from bottom to top surface. $ x$ and $ y$ vectors are parallel to the laminate plies. Plies are numbered from the bottom to the top surface. If $ k$ is the index of a ply, one considers that it is limited by $ z$ coordinates $ z_{k-1}$ and $ z_k$ . The origin of the coordinate system is located at mid laminate thickness so that if $ t$ is the laminate total thickness and the laminate has $ N$ plies, top surface of the laminate is located at $ z_N=+t/2$ and bottom surface at $ z_0=-t/2$ . (The plies are numbered from 1 to $ N$ .)

Figure II.1.1: Conventions for the numbering of plies in a laminate and for the definition of the laminate coordinate system. (A six plies laminate is represented.)
\begin{figure}\centerline{%
\input{claManual/theory/xfig/laminate_axes.pstex_t}}
\end{figure}

In the laminate, the plies are characterized by their material, thickness and by their angle in the laminate. Figure II.1.2 shows the convention for the orientation of a ply in a laminate. $ 1$ , $ 2$ and $ 3$ are the ply axes; $ x$ , $ y$ and $ z$ are the laminate axes. Of course, because only 2D laminates are considered here, one has always $ z=3$ . If $ \xi$ is the angle of the ply in the laminate, this angle is as represented in Figure II.1.2: a positive angle corresponds to a rotation from axis $ x$ to axis $ y$ . If the angle is $ 0^\circ$ , the first ply axis 1 is parallel to the first laminate axis $ x$ .

Figure II.1.2: Conventions for the orientation of plies in the laminate.)
\begin{figure}\centerline{%
\input{claManual/theory/xfig/ply_axes.pstex_t}}
\end{figure}


II.1.2 Rotation in XY plane and algebraic notations

One common operation in classical laminate analysis is to rotate vectors, tensors and matrices. One summarizes here the operations one uses in the rest of this Chapter and in FeResPost. This rotation is represented in Figure II.1.3.

Figure: Rotation of angle $ \theta$ around the origin in $ O_{12}$ plane.
\begin{figure}\centerline{%
\input{claManual/theory/xfig/rotation.pstex_t}}
\end{figure}

II.1.2.0.1 Rotation of base vectors

For such a rotation, the vectors $ e$ $ _x$ and $ e$ $ _y$ are expressed as a function of $ e$ $ _1$ and $ e$ $ _2$ as:

$\displaystyle \left(\begin{array}{c}
\mbox{\boldmath$e$}_x \\
\mbox{\boldmat...
...}{c}
\mbox{\boldmath$e$}_1 \\
\mbox{\boldmath$e$}_2
\end{array}\right)\ .
$

To simplify the notations, one introduces the symbols $ c=\cos\theta$ and $ s=\sin\theta$ . Also, one prefers to write the more general 3D version of the transformation:

$\displaystyle \left(\begin{array}{c} \mbox{\boldmath$e$}_x \\ \mbox{\boldmath$e...
...h$e$}_1 \\ \mbox{\boldmath$e$}_2 \\ \mbox{\boldmath$e$}_3 \end{array}\right)\ .$ (II.11)

The inverse relation corresponds to a rotation of angle $ -\theta$ and is obtained by changing the signs of the sinuses in the rotation matrix:

$\displaystyle \left(\begin{array}{c} \mbox{\boldmath$e$}_1 \\ \mbox{\boldmath$e...
...h$e$}_x \\ \mbox{\boldmath$e$}_y \\ \mbox{\boldmath$e$}_z \end{array}\right)\ .$ (II.12)

II.1.2.0.2 Transformation of vector and tensor components

The expressions (II.1.1) and (II.1.2) can be used to transform the components of vectors. For example:

$\displaystyle \left(\begin{array}{c} V_x \\ V_y \\ V_z \end{array}\right) = \le...
...ay}\right) \cdot \left(\begin{array}{c} V_1 \\ V_2 \\ V_3 \end{array}\right)\ .$ (II.13)

For the transformation of 2D tensors, the transformation matrix is used twice. For example, a Cauchy stress tensor is transformed as follows:

$\displaystyle \left(\begin{array}{ccc} \sigma_{xx} & \sigma_{xy} & \sigma_{zx} ...
...t(\begin{array}{ccc} c & -s & 0 \\ s & c & 0 \\ 0 & 0 & 1 \end{array}\right)\ .$ (II.14)

II.1.2.0.3 Matricial notations

As the Cauchy stress tensor is symmetric, expression (II.1.4) is more conveniently written in a matricial form as follows:

$\displaystyle \left(\begin{array}{c} \sigma_{xx} \\ \sigma_{yy} \\ \sigma_{zz} ...
...22} \\ \sigma_{33} \\ \tau_{23} \\ \tau_{13} \\ \tau_{12} \end{array}\right)\ .$ (II.15)

The same expression applies to the components of the strain tensor, which is also symmetric:

$\displaystyle \left(\begin{array}{c}
\epsilon_{xx} \\
\epsilon_{yy} \\
\ep...
...
\epsilon_{23} \\
\epsilon_{13} \\
\epsilon_{12}
\end{array}\right)\ .
$

However, unfortunately, the classical laminate analysis is universally written using angular shear components for the strain tensor:

$\displaystyle \gamma_{ij}=2\epsilon_{ij}\ (i\neq j)\ .
$

Using the angular components, the matricial expression to be used for the rotation becomes:

$\displaystyle \left(\begin{array}{c} \epsilon_{xx} \\ \epsilon_{yy} \\ \epsilon...
...epsilon_{33} \\ \gamma_{23} \\ \gamma_{13} \\ \gamma_{12} \end{array}\right)\ .$ (II.16)

An interesting aspect of the transformations (II.1.5) and (II.1.6) is that one can apply the transformation separately on sub-groups of components: This contributes to justify some of the simplifications of the classical laminate analysis; among others, the decoupling of in-plane and flexural deformation of the laminate on one hand from the out-of-plane shear on the other hand. The third direction is systematically neglected: $ \sigma_{33}=\epsilon_{33}=0$ . The inverse of relation (II.1.7) is obviously;

$\displaystyle \left(\begin{array}{c} \sigma_{11} \\ \sigma_{22} \\ \tau_{12} \e...
...(\begin{array}{c} \sigma_{xx} \\ \sigma_{yy} \\ \tau_{xy} \end{array}\right)\ ,$ (II.110)

$\displaystyle \left(\begin{array}{c} \epsilon_{11} \\ \epsilon_{22} \\ \gamma_{...
...egin{array}{c} \epsilon_{xx} \\ \epsilon_{yy} \\ \gamma_{xy} \end{array}\right)$ (II.111)

II.1.2.0.4 Introduction of a short notation

In order to simplify the notations, one introduces the following notations:

$\displaystyle \left[T_+\right]_{(\theta)} =\left(\begin{array}{ccc} c^2 & s^2 & -2cs \\ s^2 & c^2 & 2cs \\ cs & -cs & c^2-s^2 \end{array}\right)\ ,$ (II.112)

$\displaystyle \left[T_-\right]_{(\theta)} =\left(\begin{array}{ccc} c^2 & s^2 & 2cs \\ s^2 & c^2 & -2cs \\ -cs & cs & c^2-s^2 \end{array}\right)\ ,$ (II.113)

$\displaystyle \left[T_+^\prime\right]_{(\theta)} =\left(\begin{array}{ccc} c^2 & s^2 & cs \\ s^2 & c^2 & -cs \\ -2cs & 2cs & c^2-s^2 \end{array}\right)\ ,$ (II.114)

$\displaystyle \left[T_-^\prime\right]_{(\theta)} =\left(\begin{array}{ccc} c^2 & s^2 & -cs \\ s^2 & c^2 & cs \\ 2cs & -2cs & c^2-s^2 \end{array}\right)\ ,$ (II.115)

$\displaystyle \left[S_-\right]_{(\theta)} =\left(\begin{array}{cc} c & -s \\ s & c \end{array}\right)\ ,$ (II.116)

$\displaystyle \left[S_+\right]_{(\theta)} =\left(\begin{array}{cc} c & s \\ -s & c \end{array}\right)\ .$ (II.117)

These matrices are not independent. For example:

$\displaystyle \left[T_-\right]_{(\theta)}
=\left(\left[T_+\right]_{(\theta)}\right)^{-1}
=\left[T_+\right]_{(-\theta)}\ ,
$

$\displaystyle \left[T_-\right]_{(\theta)}
=\left(\left[T_+\right]_{(\theta)}\right)^{-1}
=\left[T_+\right]_{(-\theta)}\ ,
$

$\displaystyle \left[T_+^\prime\right]_{(\theta)}
=\left(\left[T_+\right]_{(\theta)}\right)^{T}\ ,
$

$\displaystyle \left[S_-\right]_{(\theta)}
=\left(\left[S_+\right]_{(\theta)}\r...
...\right]_{(\theta)}\right)^{-1}
=\left(\left[S_+\right]_{(-\theta)}\right)\ .
$

The transformations of the components of strain tensor (II.1.8) and stress tensor (II.1.10) are then written:

$\displaystyle \left\{\epsilon\right\}_{xy} = \left[T_+^\prime\right]_{(\theta)} \cdot \left\{\epsilon\right\}_{12}\ ,$ (II.118)

$\displaystyle \left\{\sigma\right\}_{12} = \left[T_+\right]_{(\theta)} \cdot \left\{\sigma\right\}_{xy}\ ,$ (II.119)

$\displaystyle \left\{\epsilon\right\}_{12} = \left[T_-^\prime\right]_{(\theta)} \cdot \left\{\epsilon\right\}_{xy}\ ,$ (II.120)

$\displaystyle \left\{\sigma\right\}_{xy} = \left[T_-\right]_{(\theta)} \cdot \left\{\sigma\right\}_{12}\ .$ (II.121)

Similarly, for the out-of-plane shear stresses and strains one writes the following relations:

$\displaystyle \left\{\gamma_s\right\}_{xy} = \left[S_+\right]_{(\theta)} \cdot \left\{\gamma_s\right\}_{12}\ ,$ (II.122)

$\displaystyle \left\{\tau_s\right\}_{xy} = \left[S_+\right]_{(\theta)} \cdot \left\{\tau_s\right\}_{12}\ ,$ (II.123)

$\displaystyle \left\{\gamma_s\right\}_{12} = \left[S_-\right]_{(\theta)} \cdot \left\{\gamma_s\right\}_{xy}\ ,$ (II.124)

$\displaystyle \left\{\tau_s\right\}_{12} = \left[S_-\right]_{(\theta)} \cdot \left\{\tau_s\right\}_{xy}\ .$ (II.125)


II.1.3 Materials and plies

One summarizes in this section a few results that are commonly found in composite litterature.

II.1.3.1 Plies

Each ply is defined by:

The orientation of the ply is given by an angle $ \theta$ .

II.1.3.2 Materials and constitutive equations

When a material is used in the definition of a laminate, assumptions are done about the axes defined in the laminate. Axes 1 and 2 are parallel to the laminate plane and axis 3 is orthogonal to the laminate.

The classical laminate analysis is based on the assumption that the relation between stress and strain tensors is linear. Then, as these two tensors are symmetric, a $ 6\times 6$ matrix contains all the elastic coefficients defining the material:

$\displaystyle \left(\begin{array}{c} \sigma_{11} \\  \sigma_{22} \\  \sigma_...
...33} \\  \gamma_{23} \\  \gamma_{31} \\  \gamma_{12} \end{array}\right) \ .$ (II.126)

One shows that, because the peculiar choice of angular strain tensor components, the matrix $ \left[C_{ijkl}\right]$ containing the elastic coefficients is symmetric. Therefore, the matrix has only 21 independent coefficients. $ \left[C_{ijkl}\right]$ is the stiffness matrix of the material.

Equation (II.1.26)can be reversed as follows:

\begin{multline}
\left(\begin{array}{c}
\epsilon_{11} \\
\epsilon_{22} \\...
...\
\beta_{13} \\
\beta_{12}
\end{array}\right)
\ .
\end{multline}

In expression (II.1.27), one added the thermo-elastic and moisture expansion terms in previous expression. They are characterized by CTE and CME tensors noted $ \left\{\alpha_{kl}\right\}$ and $ \left\{\beta_{kl}\right\}$ respectively. Note that shear components of these two tensors are angular components. Practically, it does not matter much as most materials have zero shear components for CTE or CME tensors. $ \left[c_{ijkl}\right]$ is the compliance matrix of the material. Obviously $ \left[c_{ijkl}\right]=\left[C_{ijkl}\right]^{-1}$ . One often defines laminates with orthotropic materials: For an isotropic material, the definition of $ E$ and either $ G$ or $ \nu$ is sufficient to characterize the material. Then one has:

$\displaystyle E_1=E_2=E_3=E\ ,
$

$\displaystyle G_{12}=G_{23}=G_{13}=G\ ,
$

$\displaystyle \nu_{12}=\nu_{23}=\nu_{13}=\nu\ .
$

$ E$ , $ G$ and $ \nu$ satisfy the following relation:

$\displaystyle E-2G(1+\nu)=0\ .
$

Finally, one introduces shorter notations that allow to rewrite expressions (II.1.26) and (II.1.27) respectively as follows:

$\displaystyle \left\{\epsilon\right\} =  \left[c\right] \cdot \left\{\sigma\right\} +\Delta T \left\{\alpha\right\} +\Delta H \left\{\beta\right\} \ ,$ (II.127)

$\displaystyle \left\{\sigma\right\} =  \left[C\right] \cdot \left\{\epsilon...
...ft\{\alpha\right\} -\Delta H \left[C\right] \cdot \left\{\beta\right\} \ .$ (II.128)

One introduces also the ``Mechanical Strain Tensor'' estimated as follows:

$\displaystyle \left\{\epsilon^{\text{Mech}}\right\} =  \left[c\right] \cdot \left\{\sigma\right\} \ .$ (II.129)

This new strain tensor differs from the one defined by (II.1.29) by the fact that no thermo-elastic or hygro-elastic contribution is taken into account to estimate its components. It is the strain that corresponds to the actual material stress, when no thermo-elastic or hygro-elastic expansion is considered. This ``Mechanical Strain Tensor'' is also sometimes called ``Equivalent Strain Tensor''.

II.1.3.3 In-plane properties

One considers the properties of the ply in a plane parallel to the laminate. Then the constitutive equation (II.1.28) reduces to:

$\displaystyle \left(\begin{array}{c} \epsilon_{11} \\  \epsilon_{22} \\  \ga...
...{array}{c} \beta_{11} \\  \beta_{22} \\  \beta_{12} \end{array}\right) \ .$ (II.130)

The indices in this notation are integers and indicate that the corresponding properties are given in ply coordinate system. The equation (II.1.32) is written more shortly as follows:

$\displaystyle \left\{\epsilon\right\}_{\text{ply}} =  \left[c\right]_{\text{p...
...{\alpha\right\}_{\text{ply}} +\Delta H \left\{\beta\right\}_{\text{ply}} \ .$ (II.131)

One introduces in (II.1.33) the material in-plane compliance matrix $ \left[c\right]_{\text{ply}}$ . In order to avoid too complicated notations, one uses the same notations as for the $ 6\times 6$ full material compliance matrix introduced in (II.1.29). This will be done systematically for the in-plane matricial and vectorial quantities in the rest of the document ( $ \left[c\right]$ , $ \left[C\right]$ , $ \left\{\alpha\right\}$ , $ \left\{\beta\right\}$ , $ \left\{\epsilon\right\}$ ,...

The inverse of expression (II.1.33) is noted:

$\displaystyle \left\{\sigma\right\}_{\text{ply}} =  \left[C\right]_{\text{ply...
...a H \left[C\right]_{\text{ply}} \cdot \left\{\beta\right\}_{\text{ply}} \ .$ (II.132)

In (II.1.34) one introduces the in-plane stiffness matrix $ \left[C\right]_{\text{ply}}=\left[c\right]_{\text{ply}}^{-1}$ .

Plies are characterized by their orientation in the laminate. Let $ \xi$ be the angle of the ply in the laminate axes. Then, the laminate axes are obtained by rotating the ply axes by an angle $ -\xi$ . Equations (II.1.33) and (II.1.34) are expressed in the laminate coordinate system as follows:

$\displaystyle \left\{\epsilon\right\}_{\text{lam}}
=
\left[T_+^\prime\righ...
...\left[T_+^\prime\right]_{(-\xi)}\cdot\left\{\beta\right\}_{\text{ply}}
\ ,
$

\begin{multline}
\left\{\sigma\right\}_{\text{lam}}
=
\left[T_-\right]_{(...
...t{ply}}
\cdot\left\{\beta\right\}_{\text{ply}}\nonumber
\ .
\end{multline}

This leads to the new expression in laminate axes:

$\displaystyle \left\{\epsilon\right\}_{\text{lam}}
=
\left[c\right]_{\text...
...a\right\}_{\text{lam}}
+\Delta H
\left\{\beta\right\}_{\text{lam}}
\ ,
$

$\displaystyle \left\{\sigma\right\}_{\text{lam}}
=
\left[C\right]_{\text{l...
...left[C\right]_{\text{lam}}
\cdot
\left\{\beta\right\}_{\text{lam}}
\ ,
$

where one introduces new notations for in-plane ply properties rotated by an angle $ -\xi$ (in laminate axes):

$\displaystyle \left[c\right]_{\text{lam}}= \left[T_+^\prime\right]_{(-\xi)}\cdot\left[c\right]_{\text{ply}} \cdot\left[T_+\right]_{(-\xi)}\ ,$ (II.133)

$\displaystyle \left\{\alpha\right\}_{\text{lam}}= \left[T_+^\prime\right]_{(-\xi)}\cdot\left\{\alpha\right\}_{\text{ply}}\ ,$ (II.134)

$\displaystyle \left\{\beta\right\}_{\text{lam}}= \left[T_+^\prime\right]_{(-\xi)}\cdot\left\{\beta\right\}_{\text{ply}}\ ,$ (II.135)

$\displaystyle \left[C\right]_{\text{lam}}= \left[T_-\right]_{(-\xi)}\cdot\left[C\right]_{\text{ply}} \cdot\left[T_-^\prime\right]_{(-\xi)}\ ,$ (II.136)

$\displaystyle \left[C\right]_{\text{lam}}\cdot\left\{\alpha\right\}_{\text{lam}...
...i)}\cdot\left[C\right]_{\text{ply}} \cdot\left\{\alpha\right\}_{\text{ply}}\ ,$ (II.137)

$\displaystyle \left[C\right]_{\text{lam}}\cdot\left\{\beta\right\}_{\text{lam}}...
...xi)}\cdot\left[C\right]_{\text{ply}} \cdot\left\{\beta\right\}_{\text{ply}}\ .$ (II.138)

When a matrix is transformed as in (II.1.35) or a vector as in (II.1.36), one says that they are rotated with $ \left[T_+^\prime\right]_{(-\xi)}$ rotation matrix.

II.1.3.4 Out-of-plane shear properties

One makes developments similar to those in the previous section. The out-of-plane shear constitutive equations are written as follows:

$\displaystyle \left\{\tau_s\right\}_{\text{ply}} =  \left[g\right]_{\text{ply...
...H \left[g\right]_{\text{ply}} \cdot \left\{\beta_s\right\}_{\text{ply}} \ ,$ (II.139)

$\displaystyle \left\{\gamma_s\right\}_{\text{ply}} =  \left[g^{-1}\right]_{\t...
...pha_s\right\}_{\text{ply}} +\Delta H \left\{\beta_s\right\}_{\text{ply}} \ .$ (II.140)

If $ \xi$ is the angle of the ply in the laminate, the previous relations can be written in laminate axes by rotating them by an angle $ -\xi$ . For example:

$\displaystyle \left\{\gamma_s\right\}_{\text{lam}}
=
\left[S_+\right]_{(-\xi)}
\cdot
\left\{\gamma_s\right\}_{\text{ply}}\ ,
$

$\displaystyle \left\{\tau_s\right\}_{\text{lam}}
=
\left[S_+\right]_{(-\xi)}
\cdot
\left\{\tau_s\right\}_{\text{ply}}\ ,
$

$\displaystyle \left\{\alpha_s\right\}_{\text{lam}}
=
\left[S_+\right]_{(-\xi)}
\cdot
\left\{\alpha_s\right\}_{\text{ply}}\ ,
$

$\displaystyle \left\{\beta_s\right\}_{\text{lam}}
=
\left[S_+\right]_{(-\xi)}
\cdot
\left\{\beta_s\right\}_{\text{ply}}\ ,
$

$\displaystyle \left\{\gamma_s\right\}_{\text{ply}}
=
\left[S_-\right]_{(-\...
...
\left[S_+\right]_{(\xi)}
\cdot
\left\{\gamma_s\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\tau_s\right\}_{\text{ply}}
=
\left[S_-\right]_{(-\xi...
...
\left[S_+\right]_{(\xi)}
\cdot
\left\{\tau_s\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\alpha_s\right\}_{\text{ply}}
=
\left[S_-\right]_{(-\...
...
\left[S_+\right]_{(\xi)}
\cdot
\left\{\alpha_s\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\beta_s\right\}_{\text{ply}}
=
\left[S_-\right]_{(-\x...
...
\left[S_+\right]_{(\xi)}
\cdot
\left\{\beta_s\right\}_{\text{lam}}\ .
$

Then, one makes consecutive transformations of relations (II.1.41) as follows:

\begin{multline}
\left[S_+\right]_{(\xi)}
\cdot
\left\{\tau_s\right\}_{\te...
...)}
\cdot
\left\{\beta_s\right\}_{\text{lam}}\nonumber
\ ,
\end{multline}

\begin{multline}
\left\{\tau_s\right\}_{\text{lam}}
=
\left[S_+\right]_{(...
...)}
\cdot
\left\{\beta_s\right\}_{\text{lam}}\nonumber
\ ,
\end{multline}

$\displaystyle \left\{\tau_s\right\}_{\text{lam}}
=
\left[g\right]_{\text{l...
...ft[g\right]_{\text{lam}}
\cdot
\left\{\beta_s\right\}_{\text{lam}}
\ ,
$

where one introduced:

$\displaystyle \left[g\right]_{\text{lam}}
=
\left[S_+\right]_{(-\xi)}
\cdot
\left[g\right]_{\text{ply}}
\cdot
\left[S_+\right]_{(\xi)}
\ .
$

One says that tensor $ \left[g\right]$ is rotated by matrix $ \left[S_+\right]_{(-\xi)}$ which corresponds to the expression of the shear stiffness tensor in a new coordinate system obtained by rotating the previous one by an angle $ -\xi$ .

The transformation of the out-of-plane shear compliance tensor by the same angle $ -\xi$ is made with the same expression as for the stiffness tensor:

$\displaystyle \left[g^{-1}\right]_{\text{lam}}
=
\left[S_+\right]_{(-\xi)}...
...
\left[g^{-1}\right]_{\text{ply}}
\cdot
\left[S_+\right]_{(\xi)}
\ .
$


II.1.4 Thickness and mass of laminate

The total laminate thickness is the sum of the thickness of each of its plies:

$\displaystyle t_{\text{lam}}=\sum_{k=1}^N e_k\ .
$

Correspondingly the surfacic mass is given by:

$\displaystyle sm_{\text{lam}}=\sum_{k=1}^N \rho e_k\ .
$

And the laminate average density is:

$\displaystyle \rho_{\text{lam}}=sm_{\text{lam}}/t_{\text{lam}}\ .
$


II.1.5 In-plane and flexural laminate behavior

The classical laminate analysis is based on the assumption that in-plane and flexural behavior of the laminate is not related to out-of-plane shear loading. The corresponding laminate properties can be studied separately. The same remark is true for the load response calculation. In this section, the in-plane and flexural behavior of laminates are studied.

In this section the thermal and moisture expansions are not taken into account. The out-of-plane shear properties and loading of laminates is also discussed in a separate section. One summarizes the results of classical laminate analysis. The reader shall refer to the literature if more information on the developements that lead to these results are needed. In this section, the different equations are written in laminate axes and the corresponding indices are noted $ x$ and $ y$ .

Laminate compliance and stiffness matrices relate the in-plane forces and bending moments on one hand to the average strain and curvatures on the other hand. Those different quantities are defined as follows:

Note that average strain tensor, as well as the true tensor are not ``real'' tensors because their shear components (i.e. non-diagonal components are angular components.)

The relations between the four tensors are then given by two equations:

$\displaystyle \left\{N\right\}_{\text{lam}}=
\left[A\right]_{\text{lam}}\cdot\...
...m}}
+\left[B\right]_{\text{lam}}\cdot\left\{\kappa^0\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{M\right\}_{\text{lam}}=
\left[B\right]_{\text{lam}}\cdot\...
...m}}
+\left[D\right]_{\text{lam}}\cdot\left\{\kappa^0\right\}_{\text{lam}}\ .
$

One defines below the different matrices and vectors introduced in these equations: All the new matrices and vectors are obtained by summation of the ply contributions. In order to obtain the ply stiffness matrix in laminate axes $ \left[C\right]_{\text{lam}}^k$ and the ply thermo-elastic CTE coefficients in thermo-elastic axes $ \left\{\alpha\right\}_{\text{lam}}^k$ , one uses the transformations (II.1.36) and (II.1.38) respectively. Note however that if a ply is characterized by an orientation $ \theta$ wrt to laminate axes, the rotation of ply properties must be of an angle $ -\theta$ .

The laminate compliance matrices $ \left[a\right]_{\text{lam}}$ , $ \left[b\right]_{\text{lam}}$ and $ \left[d\right]_{\text{lam}}$ are obtained by inversion of the $ 6\times 6$ $ \left[ABBD\right]_{\text{lam}}$ matrix:

$\displaystyle \left[\begin{array}{cc} \left[a\right]_{\text{lam}} & \left[b\rig...
...[B\right]_{\text{lam}} & \left[D\right]_{\text{lam}} \end{array}\right]^{-1}\ ,$ (II.142)

Then the average laminate strain and its curvature tensor can be calculated as follows:

$\displaystyle \left\{\epsilon^0\right\}_{\text{lam}}=
\left[a\right]_{\text{la...
...text{lam}}
+\left[b\right]_{\text{lam}}\cdot\left\{M\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\kappa^0\right\}_{\text{lam}}=
{\left[b\right]}^{\rm T}_{...
...text{lam}}
+\left[d\right]_{\text{lam}}\cdot\left\{M\right\}_{\text{lam}}\ .
$

One often calculates equivalent moduli corresponding to the calculated stiffness matrices $ A$ and $ D$ . This is done as follows (we follow the expressions presented in [Pal99]):


II.1.6 Out-of-plane shear of laminate

One presents one version of the out-of-plane shear theory for laminates based on information found in Chapter 13 of [Sof04a]. Only, one presents here a more general version of the calculation that takes $ xy$ and $ yz$ components of the out-of-plane shear stress into account at the same time.

II.1.6.1 Out-of-plane shear equilibrium equations

In Chapter 13 of [Sof04a] one considers the equilibrium in direction $ x$ of a small portion of the material (Figure II.1.4) of lengths $ dx$ and $ dz$ respectively:

$\displaystyle \cfrac{\partial\tau_{xz}}{\partial z}+ \cfrac{\partial\sigma_{xx}}{\partial x}=0\ .$ (II.143)

Similarly, the equilibrium of a portion $ dx$ of the full laminate is given globally by the expression:

$\displaystyle Q_{xz}-\cfrac{\partial M_{xx}}{\partial x}=0\ .$ (II.144)

Figure II.1.4: Out-of-plane XZ shear equilibrium in a laminate (from [Sof04a]).
\begin{figure}\centerline{%
\input{claManual/theory/xfig/transverseShear.pstex_t}}
\end{figure}

Then, in Chapter 13 of [Sof04a], developments are done to calculate the relations between $ Q_{xz}$ and $ \tau_{xz}$ . All the developments are based on the local $ x$ equilibrium relation.

In this document, a more general presentation of the out-of-plane shear behavior of laminates is done. The $ x$ and $ y$ components of in-plane local equilibrium are written as follows:

$\displaystyle \sigma_{xx,x}+\tau_{xy,y}+\tau_{xz,z}=0\ ,$ (II.145)

$\displaystyle \tau_{xy,x}+\sigma_{yy,y}+\tau_{yz,z}=0\ .$ (II.146)

Correspondingly, a global equilibrium is expressed by the two equations:

$\displaystyle M_{xx,x}+M_{xy,y}=Q_{xz}\ ,$ (II.147)

$\displaystyle M_{xy,x}+M_{yy,y}=Q_{yz}\ .$ (II.148)

Those equations shall be developed and will ultimately allow the calculation of $ \tau_{xz}$ and $ \tau_{yz}$ from the global shear $ Q_{xz}$ and $ Q_{yz}$ .

II.1.6.2 Triangular distribution of in-plane stresses

In most expressions below, the components of tensors are expressed in laminate axes. Therefore, the ``lam'' underscore is often added to the different quantities used in the equations.

First, one calculates the components of Cauchy stress tensor. However, a few simplifying assumptions shall be done. The strain tensor components are calculated from the laminate average strain tensor and curvature as follows:

$\displaystyle \left\{\epsilon\right\}_{\text{lam}}=
\left\{\epsilon^0\right\}_{\text{lam}}
+z\left\{\kappa^0\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\epsilon^0\right\}_{\text{lam}}=
\left[a\right]_{\text{la...
...text{lam}}
+\left[b\right]_{\text{lam}}\cdot\left\{M\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\kappa^0\right\}_{\text{lam}}=
{\left[b\right]}^{\rm T}_{...
...text{lam}}
+\left[d\right]_{\text{lam}}\cdot\left\{M\right\}_{\text{lam}}\ .
$

(The thermo-elastic contributions have been neglected.) In most out-of-plane shear theories presented in the literature, one assumes a decoupling between in-plane load response and out-of-plane shear response. This allows us to neglect a few terms in the equations:

$\displaystyle \left\{\epsilon^0\right\}_{\text{lam}}\approx
\left[b\right]_{\text{lam}}\cdot\left\{M\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\kappa^0\right\}_{\text{lam}}\approx
\left[d\right]_{\text{lam}}\cdot\left\{M\right\}_{\text{lam}}\ .
$

One then writes a simple expression of the in-plane laminate deformation tensor:

$\displaystyle \left\{\epsilon\right\}_{\text{lam}}=
\left\{\epsilon^0\right\}_{\text{lam}}
+z\left\{\kappa^0\right\}_{\text{lam}}\ .
$

Then, the components of Cauchy stress tensor are given by:

$\displaystyle \left\{\sigma\right\}_{\text{lam}}(x,y,z)= \left[C\right]_{\text{...
...+z\left[d\right]_{\text{lam}}\right) \cdot\left\{M\right\}_{\text{lam}}(x,y)\ .$ (II.149)

In this last expression, the $ 3\times 3$ matrix $ \left[C\right]_{\text{lam}}(z)$ corresponds to the plies in-plane moduli expressed in laminate axes. It depends on $ z$ because the components generally change from one ply to another. However, one shall assume that the components of the moduli matrix are constant in each ply.

Note that, in the local and global equilibrium relations (II.1.47) to (II.1.50), only partial derivatives of bending moments and Cauchy stress tensor components appear. One assumes the decoupling between the out-of-plane shear behavior and the absolute bending in laminate. However, as shown by expressions (II.1.49) and (II.1.50), the out-of-plane shear is related to the gradient of bending moment. One derives equation (II.1.51) wrt to $ x$ and $ y$ :

$\displaystyle \left\{\begin{array}{c}
\sigma_{xx,x}(x,y,z) \\
\sigma_{yy,x}(...
...y) \\
M_{yy,x}(x,y) \\
M_{xy,x}(x,y)
\end{array}\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\begin{array}{c}
\sigma_{xx,y}(x,y,z) \\
\sigma_{yy,y}(...
...y) \\
M_{yy,y}(x,y) \\
M_{xy,y}(x,y)
\end{array}\right\}_{\text{lam}}\ .
$

At this point, one no longer needs to assume a dependence of the gradient of bending moments wrt $ x$ and $ y$ . The same is true for the gradient of Cauchy stress tensor. One also introduces a new notation:

$\displaystyle \left[F\right]_{\text{lam}}(z)=
\left[C\right]_{\text{lam}}(z)\cdot
\left(\left[b\right]_{\text{lam}}
+z\left[d\right]_{\text{lam}}\right)\ .
$

Then, the components of Cauchy stress tensor gradient are obtained from the components of bending moments gradient with the following expression:

$\displaystyle \left\{\begin{array}{c} \sigma_{xx,x}(z) \\ \sigma_{yy,x}(z) \\ \...
... \\ \hline M_{xx,y} \\ M_{yy,y} \\ M_{xy,y} \end{array}\right\}_{\text{lam}}\ .$ (II.150)


II.1.6.3 Out-of-plane shear stress partial derivative equations

Note that the global equilibrium equation (II.1.49) and (II.1.50) do not contain the components $ M_{xx,y}$ and $ M_{yy,x}$ of the bending moments tensor. Similarly, the local equilibrium equations do not contain the components $ \sigma_{xx,y}$ and $ \sigma_{yy,x}$ of the Cauchy stress tensor. Then, these components can be considered as nil without modifying the result of the developments. The corresponding lines and columns could be removed from the equations (II.1.52).

Actually, one can do better than that. The local equilibrium equations (II.1.47) and (II.1.48) are rewritten as follows:

$\displaystyle \left\{\begin{array}{c} \tau_{xz,z}(z) \\ \tau_{yz,z}(z) \end{arr...
...y}(z) \\ \sigma_{yy,y}(z) \\ \tau_{xy,y}(z) \end{array}\right\}_{\text{lam}}\ .$ (II.151)

Similarly, one writes:

$\displaystyle \left\{\begin{array}{c} M_{xx,x} \\ M_{yy,x} \\ M_{xy,x} \\ \hlin...
..._{xx,x} \\ M_{xy,x} \\ M_{yy,y} \\ M_{xy,y} \end{array}\right\}_{\text{lam}}\ .$ (II.152)

The substitution of (II.1.52) and (II.1.54) in (II.1.53) leads to the following expression:

\begin{multline}
\left\{\begin{array}{c}
\tau_{xz,z}(z) \\
\tau_{yz,z}(z)
\...
...
M_{yy,y} \\
M_{xy,y}
\end{array}\right\}_{\text{lam}}\ .
\end{multline}

One would like to eliminate the four $ x$ and $ y$ partial derivative of bending moment tensor components in the previous expression. For this, one uses the global equilibrium equations (II.1.49) and (II.1.50). This leaves some arbitrary choice in the determination of dependence wrt out-of-plane shear. For example:

$\displaystyle M_{xx,x}$ $\displaystyle =\mu_xQ_{xz}\ ,$    
$\displaystyle M_{xy,y}$ $\displaystyle =(1-\mu_x)Q_{xz}\ ,$    
$\displaystyle M_{yy,y}$ $\displaystyle =\mu_yQ_{yz}\ ,$    
$\displaystyle M_{xy,x}$ $\displaystyle =(1-\mu_y)Q_{yz}\ .$    

$\displaystyle \left\{\begin{array}{c}
M_{xx,x} \\
M_{xy,x} \\
M_{yy,y} \\ ...
...ft\{\begin{array}{c}
Q_{xz} \\
Q_{yz}
\end{array}\right\}_{\text{lam}}\ ,
$

$\displaystyle \left\{\begin{array}{c} M_{xx,x} \\ M_{yy,x} \\ M_{xy,x} \\ \hline M_{xx,y} \\ M_{yy,y} \\ M_{xy,y} \end{array}\right\}_{\text{lam}}$ $\displaystyle = \left[\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 &...
...ot \left\{\begin{array}{c} Q_{xz} \\ Q_{yz} \end{array}\right\}_{\text{lam}}\ ,$    
  $\displaystyle = \left[\begin{array}{cc} \mu_x & 0 \\ 0 & 0 \\ 0 & (1-\mu_x) \\ ...
...ot \left\{\begin{array}{c} Q_{xz} \\ Q_{yz} \end{array}\right\}_{\text{lam}}\ .$    

This allows to find a new expression of the relation between bending moment gradients and out-of-plane shear stress. One first calculates a new matrix as follows:

$\displaystyle \left[X\right]_{\text{lam}}(z)
=-
\left[\begin{array}{rrr\vert ...
... \\
\hline
0 & 0 \\
0 & \mu_y \\
(1-\mu_y) & 0
\end{array}\right]\ .
$

The choice $ \mu_x=\mu_y=1/2$ gives more symmetry to the relation between $ \left\{\tau\right\}_{\text{lam}}(z)$ and $ \left\{Q\right\}_{\text{lam}}(z)$ . This choice leads to:

$\displaystyle \left[X\right]_{\text{lam}}(z)
=-\cfrac{1}{2}
\left[\begin{arra...
...0 \\
0 & 1 \\
\hline
0 & 0 \\
0 & 1 \\
1 & 0
\end{array}\right]\ .
$

The choice $ \mu_x=\mu_y=1$ is the default choice in FeResPost. The same choice seems to have been done in other software, like ESAComp. In the rest of the document, the following notations are used:

$\displaystyle \left[P_1\right]= \left[\begin{array}{rrr\vert rrr} 1 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 & 1 & 0 \\ \end{array}\right]\ ,$ (II.153)

$\displaystyle \left[P_2(\mu_x,\mu_y)\right]= \left[\begin{array}{cc} \mu_x & 0 ...
...& (1-\mu_x) \\ \hline 0 & 0 \\ 0 & \mu_y \\ (1-\mu_y) & 0 \end{array}\right]\ .$ (II.154)

$ \left[X\right]_{\text{lam}}(z)$ is a $ 2\times 2$ matrix that relates the out-of-plane shear stress components partial derivatives wrt $ z$ to the out-of-plane shear force components:

$\displaystyle \left\{\begin{array}{c} \tau_{xz,z}(z) \\ \tau_{yz,z}(z) \end{arr...
...ot \left\{\begin{array}{c} Q_{xz} \\ Q_{yz} \end{array}\right\}_{\text{lam}}\ .$ (II.155)

Note that by replacing the partial derivative of bending moments by out-of-plane shear force components, one has done an approximation that involves much arbitrariness. Actually, Expression (II.1.55) shows that out-of-plane shear stresses in the laminate are related to partial derivative of bending moments, but not directly to out-of-plane shear force components. The approximations that have been done allow us to define a theory that is more in line with what is usually presented in the literature.

Its main advantage is that the decoupling between in-plane and flexural load response on one side and out-of-plane shear response on the other side can be completed. Moreover, estimates of the partial derivatives of bending moments are not always available. For example, no finite element results corresponding to these unknown are commonly available.

Its main disadvantage is that the laminate out-of-plane shear equations lose their objectivity wrt rotations around axis $ z$ as illustrated by the example described in section IV.5.5. This example also allows to estimate the effects of the approximation on the precision of results given by the theory.

The matrix $ \left[X\right]_{\text{lam}}(z)$ depends on $ z$ for two reasons: because of the triangular distribution of strains through the thickness, and because material moduli depend on plies material and orientation. In a given ply of index $ k$ , one has:

$\displaystyle \left[X^k\right]_{\text{lam}}(z)
=\left[X_0^k\right]_{\text{lam}}
+z\left[X_1^k\right]_{\text{lam}}\ ,
$

in which the components of the two matrices $ \left[X_0^k\right]_{\text{lam}}$ and $ \left[X_1^k\right]_{\text{lam}}$ are constant. Similarly one can write a polynomial expression for $ \left[F\right]_{\text{lam}}(z)$ if one splits the definition by plies:

$\displaystyle \left[F^k\right]_{\text{lam}}(z)$ $\displaystyle =\left[C^k\right]_{\text{lam}}\cdot \left(\left[b\right]_{\text{lam}} +z\left[d\right]_{\text{lam}}\right)\ ,$    
  $\displaystyle =\left(\left[C^k\right]_{\text{lam}}\cdot\left[b\right]_{\text{la...
...+\left(\left[C^k\right]_{\text{lam}}\cdot\left[d\right]_{\text{lam}}\right)z\ ,$    
  $\displaystyle =\left[F_0^k\right]_{\text{lam}} +\left[F_1^k\right]_{\text{lam}}z\ .$    

Of course, one has the two relations:

$\displaystyle \left[X_0^k\right]_{\text{lam}}=
-
\left[P_1\right]
\cdot\left...
...ht]_{\text{lam}}
\end{array}\right]
\cdot
\left[P_2(\mu_x,\mu_y)\right]\ ,
$

$\displaystyle \left[X_1^k\right]_{\text{lam}}=
-
\left[P_1\right]
\cdot\left...
...ht]_{\text{lam}}
\end{array}\right]
\cdot
\left[P_2(\mu_x,\mu_y)\right]\ .
$

II.1.6.4 Integration of out-of-plane shear stress equation

The out-of-plane shear stress components are obtained by integration of expression (II.1.58) along the thickness. This leads to the following expression:

$\displaystyle \left\{\begin{array}{c}
\tau_{xz}(z) \\
\tau_{yz}(z)
\end{arr...
...c}
\tau_{xz}(z_0) \\
\tau_{yz}(z_0)
\end{array}\right\}_{\text{lam}}
\ .
$

One assumes zero shear stress along the bottom surface of the laminate. This corresponds to a free surface, or at least to a surface that receives no contact forces in direction $ x$ and $ y$ . This assumption leads to the following expression:

$\displaystyle \left\{\begin{array}{c} \tau_{xz}(z) \\ \tau_{yz}(z) \end{array}\right\}_{\text{lam}}$ $\displaystyle =\left(\int_{z_0}^z\left[X\right]_{\text{lam}}(z)\hspace{0.4em}\t...
...t \left\{\begin{array}{c} Q_{xz} \\ Q_{yz} \end{array}\right\}_{\text{lam}} \ ,$    
  $\displaystyle =\left[Y\right]_{\text{lam}}(z) \cdot \left\{\begin{array}{c} Q_{xz} \\ Q_{yz} \end{array}\right\}_{\text{lam}} \ ,$ (II.156)

where a new matrix has been introduced:

$\displaystyle \left[Y\right]_{\text{lam}}(z)
=\int_{z_0}^z\left[X\right]_{\text{lam}}(z)\hspace{0.4em}\text{d}z\ .
$

An explicit expression of the integrated matrix is calculated ply-by-ply, from bottom layer to top layer. If $ z_{k-1}\leq z \leq z_k$ :

$\displaystyle \left[Y\right]_{\text{lam}}(z)$ $\displaystyle =\left[Y^k\right]_{\text{lam}}(z)\ ,$    
  $\displaystyle =\int_{z_0}^z\left[X^k\right]_{\text{lam}}(z)\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\left[Y^k\right]_{\text{lam}}(z_{k-1}) +\int_{z_{k-1}}^z\left[X^k\right]_{\text{lam}}(z)\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\left[Y^k\right]_{\text{lam}}(z_{k-1}) +\int_{z_{k-1}}^z\left[X_...
...right]_{\text{lam}} +z\left[X_1^k\right]_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\left[Y^k\right]_{\text{lam}}(z_{k-1}) +\left[X_0^k\right]_{\tex...
...ft(z-z_{k-1}\right) +\left[X_1^k\right]_{\text{lam}}\cfrac{z^2-z_{k-1}^2}{2}\ ,$    
  $\displaystyle =\left[Y_0^k\right]_{\text{lam}} +\left[Y_1^k\right]_{\text{lam}}z +\left[Y_2^k\right]_{\text{lam}}z^2\ .$ (II.157)

In expression (II.1.60), one introduced new symbols that are calculated as follows:

$\displaystyle \left[Y_0^k\right]_{\text{lam}}
=\left[Y^k\right]_{\text{lam}}(z...
..._{\text{lam}}z_{k-1}
-\left[X_1^k\right]_{\text{lam}}\cfrac{z_{k-1}^2}{2}\ ,
$

$\displaystyle \left[Y_1^k\right]_{\text{lam}}
=\left[X_0^k\right]_{\text{lam}}\ ,
$

$\displaystyle \left[Y_2^k\right]_{\text{lam}}
=\cfrac{\left[X_1^k\right]_{\text{lam}}}{2}\ .
$

Note that the expression above involve the a priori unknown quantity $ \left[Y^k\right]_{\text{lam}}(z_{k-1})$ . To calculate this expression, one uses the continuity of $ \left[Y^k\right]_{\text{lam}}(z)$ across ply interfaces:

$\displaystyle \left[Y^k\right]_{\text{lam}}(z_{k-1})
=\left[Y^{k-1}\right]_{\text{lam}}(z_{k-1})\ ,
$

This relation corresponds to the continuity of out-of-plane shear stress at ply interfaces. One develops the relation as follows.

$\displaystyle \left[Y_0^k\right]_{\text{lam}}$ $\displaystyle =\left[Y^{k-1}\right]_{\text{lam}}(z_{k-1}) -\left[X_0^k\right]_{\text{lam}}z_{k-1} -\left[X_1^k\right]_{\text{lam}}\cfrac{z_{k-1}^2}{2}\ ,$    
  $\displaystyle =\left[Y_0^{k-1}\right]_{\text{lam}} +\left[Y_1^{k-1}\right]_{\te...
...ht]_{\text{lam}}z_{k-1} -\left[X_1^k\right]_{\text{lam}}\cfrac{z_{k-1}^2}{2}\ ,$    
  $\displaystyle =\left[Y_0^{k-1}\right]_{\text{lam}} +\left(\left[Y_1^{k-1}\right...
...ht]_{\text{lam}} -\cfrac{\left[X_1^k\right]_{\text{lam}}}{2}\right)z_{k-1}^2\ .$ (II.158)

The last line of this development allows to calculate recursively the components of $ \left[Y_0^k\right]_{\text{lam}}$ from bottom ply to top ply. For bottom ply, the condition $ \tau_{xz}(z_0)=\tau_{yz}(z_0)=0$ leads to the following expressions:

$\displaystyle \left[Y^1\right]_{\text{lam}}(z_0)
=\left[Y_0^1\right]_{\text{la...
...left[Y_1^1\right]_{\text{lam}}z_0
+\left[Y_2^1\right]_{\text{lam}}z_0^2=0\ .
$

$\displaystyle \left[Y_0^1\right]_{\text{lam}}
=-\left[Y_1^1\right]_{\text{lam}}z_0
-\left[Y_2^1\right]_{\text{lam}}z_0^2\ .
$

Then, it becomes possible to calculate recursively the $ \left[Y_0^i\right]_{\text{lam}}$ matrices.

One checks easily that the condition $ \tau_{xz}(z_0)=\tau_{yz}(z_0)=0$ ensures also that $ \tau_{xz}(z_N)=\tau_{yz}(z_N)=0$ . Indeed, one has:

$\displaystyle \left[Y\right]_{\text{lam}}(z_N)$ $\displaystyle =\int_{z_0}^{z_N}\left[X\right]_{\text{lam}}(z)\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =- \left[P_1\right] \cdot \int_{z_0}^{z_N} \left[\begin{array}{c\...
...nd{array}\right] \hspace{0.4em}\text{d}z \cdot \left[P_2(\mu_x,\mu_y)\right]\ ,$    
  $\displaystyle =- \left[P_1\right] \cdot \left[\begin{array}{c\vert c} \int_{z_0...
...space{0.4em}\text{d}z \end{array}\right] \cdot \left[P_2(\mu_x,\mu_y)\right]\ .$    

The last line of previous equation contains twice the integral of $ \left[F\right]_{\text{lam}}(z)$ along the laminate thickness. One develops this integral as follows:

$\displaystyle \int_{z_0}^{z_N}\left[F\right]_{\text{lam}}(z)\hspace{0.4em}\text{d}z$ $\displaystyle =\int_{z_0}^{z_N}\left[C\right]_{\text{lam}}(z) \cdot\left(\left[...
...ht]_{\text{lam}} +z\left[d\right]_{\text{lam}}\right)\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\left(\int_{z_0}^{z_N}\left[C\right]_{\text{lam}}(z)\hspace{0.4e...
...\text{lam}}(z)\hspace{0.4em}\text{d}z\right)\cdot\left[d\right]_{\text{lam}}\ ,$    
  $\displaystyle =\left[A\right]_{\text{lam}}\cdot\left[b\right]_{\text{lam}} +\left[B\right]_{\text{lam}}\cdot\left[d\right]_{\text{lam}}\ .$    

On the other hand, equation (II.1.44) allows to write:

$\displaystyle \left[\begin{array}{cc} \left[A\right] & \left[B\right] \\ \left[...
... \left[b\right] \\ {\left[b\right]}^{\rm T} & \left[d\right] \end{array}\right]$ $\displaystyle = \left[\begin{array}{cc} \left[A\right]\cdot\left[a\right] +\lef...
...ht]\cdot\left[b\right] +\left[D\right]\cdot\left[d\right] \end{array}\right]\ ,$    
  $\displaystyle = \left[\begin{array}{cc} \left[I\right] & \left[0\right] \\ \left[0\right] & \left[I\right] \end{array}\right]\ .$    

(The ``lam'' subscript has been omitted for shortness sake.) The identification of the right upper corner of the last expression with the integration of $ \left[F\right]_{\text{lam}}(z)$ along the laminate thickness shows that this integral must be zero. Consequently, one also has:

$\displaystyle \left[Y\right]_{\text{lam}}(z_N)$ $\displaystyle =0\ ,$    
$\displaystyle \tau_{xz}(z_N)$ $\displaystyle =0\ ,$    
$\displaystyle \tau_{yz}(z_N)$ $\displaystyle =0\ .$    

It is interesting to remark that the ply out-of-plane shear moduli have not been used in the calculations to obtain (II.1.59). The out-of-plane shear stresses depend only on out-of-plane shear forces and ply in-plane material properties. One shows in section II.1.6.5 that on the other hand, the calculation of out-of-plane shear strains caused by out-of-plane shear forces requires the knowledge of ply out-of-plane material constants.


II.1.6.5 Out-of-plane laminate shear stiffness

One assumes a linear relation between out-of-plane shear components of strain tensor and the corresponding components of Cauchy stress tensor:

$\displaystyle \left\{\begin{array}{c}
\gamma_{xz}(z) \\
\gamma_{yz}(z)
\end...
...ay}{c}
\tau_{xz}(z) \\
\tau_{yz}(z)
\end{array}\right\}_{\text{lam}}
\ .
$

To this relation corresponds a relation between the average out-of-plane shear strains and the out-of-plane shear force:

$\displaystyle \left\{\begin{array}{c}
\Gamma_{xz} \\
\Gamma_{yz}
\end{array...
...\{\begin{array}{c}
Q_{xz} \\
Q_{yz}
\end{array}\right\}_{\text{lam}}
\ .
$

II.1.6.5.1 Introduction of new notations

In the definition of loadings, the out-of-plane components of shear force $ Q$ can be replaced by average out-of-plane shear stress $ \overline{\tau}$ . Then the conversion between these two types of components is done simply by multiplication or division by laminate total thickness $ t$ :

$\displaystyle \overline{\tau}=\cfrac{Q}{t}\ .
$

One introduces notations that simplifies the writing of equations:

$\displaystyle \left\{\Gamma_s\right\}_{\text{*}}
=\left\{\begin{array}{c}
\Gamma_{xz} \\
\Gamma_{yz}
\end{array}\right\}_{\text{*}}
\ ,
$

$\displaystyle \left\{Q_s\right\}_{\text{*}}
=\left\{\begin{array}{c}
Q_{xz} \\
Q_{yz}
\end{array}\right\}_{\text{*}}
\ ,
$

$\displaystyle \left\{\overline{\tau_s}\right\}_{\text{*}}
=\left\{\begin{array...
...ine{\tau}_{xz} \\
\overline{\tau}_{yz}
\end{array}\right\}_{\text{*}}
\ .
$

In these expressions the $ *$ subscripts can be replaced by a symbol specific to the coordinate system in which the components of the vector are expressed (for example "load", "ply", "lam"...).

II.1.6.5.2 Energetic approach

The components of matrix $ \left[g\right]_{\text{lam}}(z)$ are easily obtained from the orientation and material of plies. The components of $ \left[G\right]_{\text{lam}}$ are obtained by a calculation of out-of-plane shear strain surface energy. One first calculates an estimate of this surfacic energy using the local expression of shear strains:

$\displaystyle W_{\text{shear}}^{\text{local}}$ $\displaystyle =\frac{1}{2}\int_{z_0}^{z_N} {\left\{\gamma_s(z)\right\}}^{\rm T}...
...xt{lam}} \cdot \left\{\tau_s(z)\right\}_{\text{lam}} \hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\frac{1}{2}\int_{z_0}^{z_N} {\left\{\tau_s(z)\right\}}^{\rm T}_{...
...lam}}(z) \cdot \left\{\tau_s(z)\right\}_{\text{lam}} \hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\frac{1}{2}\int_{z_0}^{z_N} {\left\{Q_s\right\}}^{\rm T}_{\text{...
...{\text{lam}}(z) \cdot \left\{Q_s\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\frac{1}{2} {\left\{Q_s\right\}}^{\rm T}_{\text{lam}} \cdot \lef...
...ce{0.4em}\text{d}z\right]_{\text{lam}} \cdot \left\{Q_s\right\}_{\text{lam}}\ .$ (II.159)

similarly, the surfacic energy can be estimated from the out-of-plane shear global equation:

$\displaystyle W_{\text{shear}}^{\text{global}}$ $\displaystyle =\frac{1}{2} {\left\{\Gamma_s(z)\right\}}^{\rm T}_{\text{lam}} \cdot \left\{Q_s\right\}_{\text{lam}} \ ,$    
  $\displaystyle =\frac{1}{2} {\left\{Q_s\right\}}^{\rm T}_{\text{lam}} \cdot \left[G\right]^{-1}_{\text{lam}} \cdot \left\{Q_s\right\}_{\text{lam}} \ .$ (II.160)

As there is only one surfacic energy, $ W_{\text{shear}}^{\text{global}}
=W_{\text{shear}}^{\text{local}}$ and

$\displaystyle \left[G\right]^{-1}_{\text{lam}}$ $\displaystyle =\int_{z_0}^{z_N} {\left[Y\right]}^{\rm T}_{\text{lam}}(z) \cdot ...
...{\text{lam}}(z) \cdot \left[Y\right]_{\text{lam}}(z) \hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\int_{z_0}^{z_N} \left[U\right]_{\text{lam}}(z) \hspace{0.4em}\text{d}z\ .$    

Here again, the integration can be calculated ply-by-ply. More precisely, one calculates on ply $ k$ :

$\displaystyle \left[U^k\right]_{\text{lam}}(z)$ $\displaystyle ={\left[Y^k\right]}^{\rm T}_{\text{lam}}(z) \cdot \left[g^k\right]^{-1}_{\text{lam}} \cdot \left[Y^k\right]_{\text{lam}}(z)\ ,$    
  $\displaystyle =\left[U_0^k\right]_{\text{lam}} +\left[U_1^k\right]_{\text{lam}}...
...}z^2 +\left[U_3^k\right]_{\text{lam}}z^3 +\left[U_4^k\right]_{\text{lam}}z^4\ .$    

where

$\displaystyle \left[U_0^k\right]_{\text{lam}}$ $\displaystyle ={\left[Y_0^k\right]}^{\rm T}_{\text{lam}} \cdot \left[g^k\right]^{-1}_{\text{lam}} \cdot \left[Y_0^k\right]_{\text{lam}}\ ,$    
$\displaystyle \left[U_1^k\right]_{\text{lam}}$ $\displaystyle ={\left[Y_0^k\right]}^{\rm T}_{\text{lam}} \cdot \left[g^k\right]...
...dot \left[g^k\right]^{-1}_{\text{lam}} \cdot \left[Y_0^k\right]_{\text{lam}}\ ,$    
$\displaystyle \left[U_2^k\right]_{\text{lam}}$ $\displaystyle ={\left[Y_0^k\right]}^{\rm T}_{\text{lam}} \cdot \left[g^k\right]...
...dot \left[g^k\right]^{-1}_{\text{lam}} \cdot \left[Y_0^k\right]_{\text{lam}}\ ,$    
$\displaystyle \left[U_3^k\right]_{\text{lam}}$ $\displaystyle ={\left[Y_1^k\right]}^{\rm T}_{\text{lam}} \cdot \left[g^k\right]...
...dot \left[g^k\right]^{-1}_{\text{lam}} \cdot \left[Y_1^k\right]_{\text{lam}}\ ,$    
$\displaystyle \left[U_4^k\right]_{\text{lam}}$ $\displaystyle ={\left[Y_2^k\right]}^{\rm T}_{\text{lam}} \cdot \left[g^k\right]^{-1}_{\text{lam}} \cdot \left[Y_2^k\right]_{\text{lam}}\ .$    

Then the integral above develops as follows:

$\displaystyle \left[G\right]^{-1}_{\text{lam}}$ $\displaystyle =\int_{z_0}^{z_N} \left[U\right]_{\text{lam}}(z) \hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\int_{z_{k-1}}^{z_k} \left[U^k\right]_{\text{lam}}(z) \hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\int_{z_{k-1}}^{z_k}\left( \sum_{i=0}^4\left[U_i^k\right]_{\text{lam}}z^i \right)\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left(\sum_{i=0}^4\left[U_i^k\right]_{\text{lam}} \int_{z_{k-1}}^{z_k}z^i\hspace{0.4em}\text{d}z\right)\ ,$    
  $\displaystyle =\sum_{k=1}^N\sum_{i=0}^4\left(\left[U_i^k\right]_{\text{lam}} \frac{z_k^{i+1}-z_{k-1}^{i+1}}{i+1}\right)\ .$ (II.161)

One notes the stiffness matrix $ \left[G\right]_{\text{lam}}$ and the compliance matrix $ \left[G^{-1}\right]_{\text{lam}}$ . Note that once the laminate out-of-plane shear stiffness and compliance matrices are known, the laminate out-of-plane shear equivalent moduli are calculated from the components of the compliance matrix with the following expressions:

$\displaystyle G_{xz}=\cfrac{1}{t\cdot\left[G^{-1}\right]_{11}}\ ,
$

$\displaystyle G_{yz}=\cfrac{1}{t\cdot\left[G^{-1}\right]_{22}}\ ,
$

in which the $ \left[G^{-1}\right]_{\text{lam}}$ matrix has first been rotated into the appropriate axes.

II.1.6.6 Calculation algorithm for shear stiffness

One describes below the calculation sequences that is used to calculate the laminate out-of-plane shear stiffness properties, and the out-of-plane shear stresses related to a given loading of the laminate.

The calculation sequence is described below. It involves two loops on the laminate layers.

  1. Calculate laminate in-plane and flexural properties. This is necessary because one needs the matrices $ \left[b\right]_{\text{lam}}$ and $ \left[d\right]_{\text{lam}}$ to calculate out-of-plane shear properties.
  2. One initializes the $ 2\times 2$ matrix $ \left[G\right]^{-1}_{\text{lam}}$ to zero.
  3. Then for each layer $ k$ with $ 1\leq k\leq N$ , one performs the following sequence of operations:
    1. One estimates the $ 3\times 3$ matrix of in-plane stiffness coefficients in laminate axes $ \left[C^k\right]_{\text{lam}}$ . For other calculations, one also need properties like the laminate thickness $ t$ and the positions $ z_k$ of different layer interfaces.
    2. This matrix is used to calculate the two matrices $ \left[F_0^k\right]_{\text{lam}}$ and $ \left[F_1^k\right]_{\text{lam}}$ . (See section II.1.6.3 for more details.) One has:

      $\displaystyle \left[F^k\right]_{\text{lam}}(z)
=\left[F_0^k\right]_{\text{lam}}
+z\left[F_1^k\right]_{\text{lam}}\ .
$

    3. Then, one calculates two other $ 2\times 2$ matrices $ \left[X_0^k\right]_{\text{lam}}$ and $ \left[X_1^k\right]_{\text{lam}}$ . (See section II.1.6.3.) One has:

      $\displaystyle \left[X^k\right]_{\text{lam}}(z)
=\left[X_0^k\right]_{\text{lam}}
+z\left[X_1^k\right]_{\text{lam}}\ .
$

    4. Then one calculates the $ \left[Y_i^k\right]_{\text{lam}}$ $ 2\times 2$ matrices:

      $\displaystyle \left[Y_0^k\right]_{\text{lam}}
=\left[Y_0^{k-1}\right]_{\text{l...
..._{\text{lam}}
-\cfrac{\left[X_1^k\right]_{\text{lam}}}{2}\right)z_{k-1}^2\ ,
$

      $\displaystyle \left[Y_1^k\right]_{\text{lam}}
=\left[X_0^k\right]_{\text{lam}}\ ,
$

      $\displaystyle \left[Y_2^k\right]_{\text{lam}}
=\cfrac{\left[X_1^k\right]_{\text{lam}}}{2}\ .
$

      As the expression of $ \left[Y_0^k\right]_{\text{lam}}$ is recursive, one needs another expression for the first value. The expression is:

      $\displaystyle \left[Y_0^1\right]_{\text{lam}}$ $\displaystyle =-\left[Y_1^1\right]_{\text{lam}}z_0 -\left[Y_2^1\right]_{\text{lam}}z_0^2\ .$    
        $\displaystyle =-\left[X_0^1\right]_{\text{lam}}z_0 -\cfrac{1}{2}\left[X_1^1\right]_{\text{lam}}z_0^2\ .$    

      These matrices allow to calculate the out-of-plane shear stress from the global out-of-plane shear force:

      $\displaystyle \left[Y^k\right]_{\text{lam}}(z)
=\left[Y_0^k\right]_{\text{lam}}
+\left[Y_1^k\right]_{\text{lam}}z
+\left[Y_2^k\right]_{\text{lam}}z^2\ ,
$

      $\displaystyle \left\{\tau_s(z)\right\}_{\text{lam}}
=\left[Y\right]_{\text{lam}}(z)
\cdot
\left\{Q_s\right\}_{\text{lam}}
\ .
$

      Actually, one is interested in stresses in ply axes, rather than in laminate axes. If $ \xi$ is the orientation of the ply in laminate axes, then:

      $\displaystyle \left\{\tau_s(z)\right\}_{\text{ply}}
=\left[S_+\right]_{(\xi)}
\cdot
\left\{\tau_s(z)\right\}_{\text{lam}}
\ .
$

      Then, one has simply:

      $\displaystyle \left\{\tau_s(z)\right\}_{\text{ply}}$ $\displaystyle =\left[S_+\right]_{(\xi)} \cdot \left[Y\right]_{\text{lam}}(z) \cdot \left\{Q_s\right\}_{\text{lam}} \ ,$    
        $\displaystyle = \left[Y\right]_{\text{ply}}^{\text{lam}}(z) \cdot \left\{Q_s\right\}_{\text{lam}} \ .$    

      One stores a $ 2\times 2$ matrix $ \left[Y\right]_{\text{ply}}^{\text{lam}}$ for each station through laminate thickness where out-of-plane shear stress might be requested. Actually it is done at top, mid and bottom surfaces in each ply. This means that $ 3N$ $ 2\times 2$ matrices $ \left[Y^j\right]_{\text{ply}}^{\text{lam}}$ are stored in the ClaLam object.

    5. One calculates the $ \left[U_i^k\right]_{\text{lam}}$ $ 2\times 2$ matrix. (See the end of section II.1.6.5 for the expressions to be used.) Then to $ \left[G\right]^{-1}_{\text{lam}}$ , one adds one term:

      $\displaystyle \left[G\right]^{-1}_{\text{lam}}=\left[G\right]^{-1}_{\text{lam}}...
...left[U_i^k\right]_{\text{lam}}
\frac{z_k^{i+1}-z_{k-1}^{i+1}}{i+1}\right)\ .
$

  4. At the end of the loop on layers, the shear stiffness matrix $ \left[G\right]_{\text{lam}}$ is calculated by inversion of $ \left[G\right]^{-1}_{\text{lam}}$ .


II.1.7 CTE and CME calculations

One assumes a linear dependence of the temperature on the location through the laminate thickness:

$\displaystyle T(z)=T_0+zT_{,z}\ .$ (II.162)

Similarly, the water uptake depends linearly on $ z$ :

$\displaystyle H(z)=H_0+zH_{,z}\ .$ (II.163)

The calculation of laminate response to hygrometric loading is very similar to its response to thermo-elastic loading. Therefore, the following developments are done for thermo-elastic loading only. Later, they are transposed to hygrothermal solicitations.


II.1.7.1 In-plane and flexural thermo-elastic behavior

One calculates the stresses induced in plies for a thermo-elastic loading assuming that the material strain components are all constrained to zero. Equation (II.1.34) becomes:

$\displaystyle \left\{\sigma\right\}_{\text{ply}}
=
-\Delta T
\left[C\right]_{\text{ply}}
\cdot
\left\{\alpha\right\}_{\text{ply}}
\ .
$

In laminate axes, the equation is rewritten:

$\displaystyle \left\{\sigma\right\}_{\text{lam}}
=
-\Delta T
\left[C\right]_{\text{lam}}
\cdot
\left\{\alpha\right\}_{\text{lam}}
\ .
$

One substitutes in the equation the assumed temperature profile:

$\displaystyle \left\{\sigma\right\}_{\text{lam}}
=
-[(T_0-T_{\text{ref}})+zT...
...
\left[C\right]_{\text{lam}}
\cdot
\left\{\alpha\right\}_{\text{lam}}
\ .
$

The corresponding laminate in-plane force tensor is obtained by integrating the Cauchy stress tensor along the thickness:

$\displaystyle \left\{N\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}\left\{\sigma\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =-\int_{-h/2}^{h/2}[(T_0-T_{\text{ref}})+zT_{,z}] \left[C\right]_{\text{lam}}\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =-\left(\int_{-h/2}^{h/2}\left[C\right]_{\text{lam}}\cdot \left\{...
...\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\right)T_{,z}\ ,$    
  $\displaystyle =-\left\{\alpha Eh\right\}_{\text{lam}}(T_0-T_{\text{ref}}) -\left\{\alpha Eh^2\right\}_{\text{lam}}T_{,z}\ .$    

In the previous expression, two new symbols have been introduced that are calculated as follows:

$\displaystyle \left\{\alpha Eh\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}\left[C\right]_{\text{lam}}\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[C\right]_{\text{lam}}^k \cdot\left\{\alpha\right\}_{\text{lam}}^k \left(z_k-z_{k-1}\right)\ .$ (II.164)

$\displaystyle \left\{\alpha Eh^2\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}z\left[C\right]_{\text{lam}}\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[C\right]_{\text{lam}}^k \cdot\left\{\alpha\right\}_{\text{lam}}^k \left(\frac{z_k^2-z_{k-1}^2}{2}\right)\ .$ (II.165)

Similarly the bending moment tensor is obtained by integrating the Cauchy stress tensor multiplied by $ z$ along the thickness:

$\displaystyle \left\{M\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}z\left\{\sigma\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =-\int_{-h/2}^{h/2}z[(T_0-T_{\text{ref}})+zT_{,z}] \left[C\right]_{\text{lam}}\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =-\left(\int_{-h/2}^{h/2}z\left[C\right]_{\text{lam}}\cdot \left\...
...\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\right)T_{,z}\ ,$    
  $\displaystyle =-\left\{\alpha Eh^2\right\}_{\text{lam}}(T_0-T_{\text{ref}}) -\left\{\alpha Eh^3\right\}_{\text{lam}}T_{,z}\ .$    

In the previous expression, one new symbol has been introduced:

$\displaystyle \left\{\alpha Eh^3\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}z^2\left[C\right]_{\text{lam}}\cdot \left\{\alpha\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[C\right]_{\text{lam}}^k \cdot\left\{\alpha\right\}_{\text{lam}}^k \left(\frac{z_k^3-z_{k-1}^3}{3}\right)\ .$ (II.166)

Because of the linearity of all the equations, the thermo-elastic loading may be considered as an additional loading applied to the laminate, and if one considers an additional imposition of average in-plane strain and of a curvature, the laminate in-plane forces and bending moments are given by:

\begin{multline}
\left\{\begin{array}{c}
\left\{N\right\}_{\text{lam}} \\
\l...
...\alpha Eh^3\right\}_{\text{lam}}
\end{array}\right\}T_{,z}\ .
\end{multline}

Using relation (II.1.44), the previous expression is reversed as follows:

\begin{multline}
\left\{\begin{array}{c}
\left\{\epsilon^0\right\}_{\text{lam}...
...^3\right\}_{\text{lam}}
\end{array}\right\}T_{,z}
\nonumber\ .
\end{multline}

In the last expression, four new quantities can be identified:

$\displaystyle \left\{\alpha_0^\epsilon\right\}_{\text{lam}} =\left[a\right]_{\t...
...xt{lam}} +\left[b\right]_{\text{lam}}\left\{\alpha Eh^2\right\}_{\text{lam}}\ ,$ (II.167)

$\displaystyle \left\{\alpha_1^\epsilon\right\}_{\text{lam}} =\left[a\right]_{\t...
...xt{lam}} +\left[b\right]_{\text{lam}}\left\{\alpha Eh^3\right\}_{\text{lam}}\ ,$ (II.168)

$\displaystyle \left\{\alpha_0^\kappa\right\}_{\text{lam}} ={\left[b\right]}^{\r...
...xt{lam}} +\left[d\right]_{\text{lam}}\left\{\alpha Eh^2\right\}_{\text{lam}}\ ,$ (II.169)

$\displaystyle \left\{\alpha_1^\kappa\right\}_{\text{lam}} ={\left[b\right]}^{\r...
...xt{lam}} +\left[d\right]_{\text{lam}}\left\{\alpha Eh^3\right\}_{\text{lam}}\ .$ (II.170)

So that finally, the ``compliance'' equation is:

\begin{multline}
\left\{\begin{array}{c}
\left\{\epsilon^0\right\}_{\text{lam}...
..._1^\kappa\right\}_{\text{lam}}
\end{array}\right\}T_{,z}
\ .
\end{multline}


II.1.7.2 Out-of-plane shear thermo-elastic behavior

Starting with the out-of-plane shear constitutive equation (II.1.42) and of the expression defining the out-of-plane shear force vectors $ \left\{Q_s\right\}_{\text{lam}}$ one makes developments similar to those of section II.1.7.1 and defines the following quantities:

$\displaystyle \left\{\alpha_sGh\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}\left[g\right]_{\text{lam}}\cdot \left\{\alpha_s\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[g\right]_{\text{lam}}^k \cdot\left\{\alpha_s\right\}_{\text{lam}}^k \left(z_k-z_{k-1}\right)\ .$ (II.171)

$\displaystyle \left\{\alpha_sGh^2\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}z\left[g\right]_{\text{lam}}\cdot \left\{\alpha_s\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[g\right]_{\text{lam}}^k \cdot\left\{\alpha_s\right\}_{\text{lam}}^k \left(\frac{z_k^2-z_{k-1}^2}{2}\right)\ .$ (II.172)

They are used in the expression:

$\displaystyle \left\{Q\right\}_{\text{lam}} = \left[G\right]_{\text{lam}} \cdot...
...t{lam}}(T_0-T_{\text{ref}}) -\left\{\alpha_sGh^2\right\}_{\text{lam}}T_{,z} \ .$ (II.173)

Correspondingly, one estimates the laminate out-of-plane shear CTE vectors:

$\displaystyle \left\{\alpha_0^s\right\}_{\text{lam}} =\left[G\right]_{\text{lam}}^{-1}\cdot\left\{\alpha Gh\right\}_{\text{lam}}$ (II.174)

$\displaystyle \left\{\alpha_1^s\right\}_{\text{lam}} =\left[G\right]_{\text{lam}}^{-1}\cdot\left\{\alpha Gh^2\right\}_{\text{lam}}$ (II.175)

These two expressions allow to write the expression of the inverse of (II.1.78):

$\displaystyle \left[\Gamma\right]_{\text{lam}}=\left[G\right]_{\text{lam}}^{-1}...
...text{lam}}(T_0-T_{\text{ref}}) +\left\{\alpha_1^s\right\}_{\text{lam}}T_{,z}\ .$ (II.176)


II.1.7.3 Hygrometric behavior of laminates

One transposes below the results for thermo-elastic behavior. It is done simply by replacing the CTE $ \alpha$ by the CME $ \beta$ in the definitions and equations.

$\displaystyle \left\{\beta Eh\right\}_{\text{lam}}$ $\displaystyle =\sum_{k=1}^N\left[C\right]_{\text{lam}}^k \cdot\left\{\beta\right\}_{\text{lam}}^k \left(z_k-z_{k-1}\right)\ ,$ (II.177)

$\displaystyle \left\{\beta Eh^2\right\}_{\text{lam}}$ $\displaystyle =\sum_{k=1}^N\left[C\right]_{\text{lam}}^k \cdot\left\{\beta\right\}_{\text{lam}}^k \left(\frac{z_k^2-z_{k-1}^2}{2}\right)\ ,$ (II.178)

$\displaystyle \left\{\beta Eh^3\right\}_{\text{lam}}$ $\displaystyle =\sum_{k=1}^N\left[C\right]_{\text{lam}}^k \cdot\left\{\beta\right\}_{\text{lam}}^k \left(\frac{z_k^3-z_{k-1}^3}{3}\right)\ ,$ (II.179)

\begin{multline}
\left\{\begin{array}{c}
\left\{N\right\}_{\text{lam}} \\
\l...
...{\beta Eh^3\right\}_{\text{lam}}
\end{array}\right\}H_{,z}\ ,
\end{multline}

$\displaystyle \left\{\beta_0^\epsilon\right\}_{\text{lam}} =\left[a\right]_{\te...
...ext{lam}} +\left[b\right]_{\text{lam}}\left\{\beta Eh^2\right\}_{\text{lam}}\ ,$ (II.180)

$\displaystyle \left\{\beta_1^\epsilon\right\}_{\text{lam}} =\left[a\right]_{\te...
...ext{lam}} +\left[b\right]_{\text{lam}}\left\{\beta Eh^3\right\}_{\text{lam}}\ ,$ (II.181)

$\displaystyle \left\{\beta_0^\kappa\right\}_{\text{lam}} ={\left[b\right]}^{\rm...
...ext{lam}} +\left[d\right]_{\text{lam}}\left\{\beta Eh^2\right\}_{\text{lam}}\ ,$ (II.182)

$\displaystyle \left\{\beta_1^\kappa\right\}_{\text{lam}} ={\left[b\right]}^{\rm...
...ext{lam}} +\left[d\right]_{\text{lam}}\left\{\beta Eh^3\right\}_{\text{lam}}\ ,$ (II.183)

\begin{multline}
\left\{\begin{array}{c}
\left\{\epsilon^0\right\}_{\text{lam}...
..._1^\kappa\right\}_{\text{lam}}
\end{array}\right\}H_{,z}
\ ,
\end{multline}

$\displaystyle \left\{\beta_sGh\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}\left[g\right]_{\text{lam}}\cdot \left\{\beta_s\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[g\right]_{\text{lam}}^k \cdot\left\{\beta_s\right\}_{\text{lam}}^k \left(z_k-z_{k-1}\right)\ ,$ (II.184)

$\displaystyle \left\{\beta_sGh^2\right\}_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{h/2}z\left[g\right]_{\text{lam}}\cdot \left\{\beta_s\right\}_{\text{lam}}\hspace{0.4em}\text{d}z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left[g\right]_{\text{lam}}^k \cdot\left\{\beta_s\right\}_{\text{lam}}^k \left(\frac{z_k^2-z_{k-1}^2}{2}\right)\ ,$ (II.185)

$\displaystyle \left\{Q\right\}_{\text{lam}} = \left[G\right]_{\text{lam}} \cdot...
...xt{lam}}(H_0-H_{\text{ref}}) -\left\{\beta_sGh^2\right\}_{\text{lam}}H_{,z} \ ,$ (II.186)

$\displaystyle \left\{\beta_0^s\right\}_{\text{lam}} =\left[G\right]_{\text{lam}}^{-1}\cdot\left\{\beta Gh\right\}_{\text{lam}}$ (II.187)

$\displaystyle \left\{\beta_1^s\right\}_{\text{lam}} =\left[G\right]_{\text{lam}}^{-1}\cdot\left\{\beta Gh^2\right\}_{\text{lam}}$ (II.188)

$\displaystyle \left[\Gamma\right]_{\text{lam}}=\left[G\right]_{\text{lam}}^{-1}...
...\text{lam}}(H_0-H_{\text{ref}}) +\left\{\beta_1^s\right\}_{\text{lam}}H_{,z}\ .$ (II.189)


II.1.7.4 Full sets of equations

Finally, the full set of constitutive equation written with stiffness matrices looks like:

\begin{multline}
\left[\begin{array}{cc}
\left[A\right]_{\text{lam}} & \left[B...
...{\beta Eh^3\right\}_{\text{lam}}
\end{array}\right\}H_{,z}\ ,
\end{multline}

\begin{multline}
\left[G\right]_{\text{lam}}
\cdot
\left\{\Gamma\right\}_{\te...
...xt{ref}})
+\left\{\beta_sGh^2\right\}_{\text{lam}}H_{,z}
\ .
\end{multline}

The two previous expressions are inversed as follows:

\begin{multline}
\left[\begin{array}{cc}
\left[a\right]_{\text{lam}} & \left[b...
..._1^\kappa\right\}_{\text{lam}}
\end{array}\right\}H_{,z}
\ ,
\end{multline}

\begin{multline}
\left[G\right]_{\text{lam}}^{-1}\cdot\left\{Q\right\}_{\text{l...
...{\text{ref}})
-\left\{\beta_1^s\right\}_{\text{lam}}H_{,z}\ .
\end{multline}


II.1.8 Calculation of load response

One always considered a decoupling of in-plane and flexural of laminates on one side, and the out-of-plane shear of laminates on the other side. These two aspects are discussed in sections II.1.8.1 and II.1.8.2 respectively.


II.1.8.1 In-plane and flexural response

Beside thermo-elastic or hygro-elastic loading, the composite classes of FeResPost allows the definition different types of mechanical loads:

The type of loading is specified component-by-component. This means that a single loading may have some components imposed as normal forces and bending moments, with other components imposed as average strains, and other components as average stresses or flexural stresses. The mechanical part of loading is also characterized by a direction $ \lambda$ wrt laminate axes. The subscript ``load'' indicates that the components are given in loading axes. One explains below how the laminate response is calculated.

  1. The solver first checks if average or flexural stresses are imposed. If such components of the loading are found, they are converted to in-plane forces and bending moments with the following equations:

    $\displaystyle \left\{N\right\}_{\text{load}}
=h\left\{\sigma^0\right\}_{\text{load}}\ ,
$

    $\displaystyle \left\{M\right\}_{\text{load}}
=\frac{h^2}{6}\left\{\sigma^f\right\}_{\text{load}}\ ,
$

    in which $ h$ is the laminate thickness.

  2. The mechanical part of loading is characterized by a direction wrt laminate axes. This direction is given by an angle $ \lambda$ . In order to have laminate properties and loading given in the same coordinate system, the laminate stiffness matrices and CTE vectors are calculated in this new coordinate system. (It is more convenient for the elimination of components imposed as average strains or curvatures.) More precisely, the stiffness matrices and CTE vector are rotated with the following expressions:

    $\displaystyle \left[A\right]_{\text{load}}=
\left[T_-\right]_{(\lambda)}\cdot\left[A\right]_{\text{lam}}
\cdot\left[T_-^\prime\right]_{(\lambda)}\ ,
$

    $\displaystyle \left[B\right]_{\text{load}}=
\left[T_-\right]_{(\lambda)}\cdot\left[B\right]_{\text{lam}}
\cdot\left[T_-^\prime\right]_{(\lambda)}\ ,
$

    $\displaystyle \left[D\right]_{\text{load}}=
\left[T_-\right]_{(\lambda)}\cdot\left[D\right]_{\text{lam}}
\cdot\left[T_-^\prime\right]_{(\lambda)}\ ,
$

    $\displaystyle \left\{\alpha Eh\right\}_{\text{load}}
=
\left[T_-\right]_{(\lambda)}
\cdot
\left\{\alpha Eh\right\}_{\text{lam}}\ ,
$

    $\displaystyle \ldots
$

    $\displaystyle \left\{\beta Eh^3\right\}_{\text{load}}
=
\left[T_-\right]_{(\lambda)}
\cdot
\left\{\beta Eh^3\right\}_{\text{lam}}\ .
$

    The calculation of CTE and CME related quantities is done only if the corresponding temperature or moisture contributions have been defined in the loading. The system of equations looks like:

    \begin{multline}
\left[\begin{array}{cc}
\left[A\right]_{\text{load}} & \left[...
...h^3\right\}_{\text{load}}
\end{array}\right\}H_{,z}\ .\nonumber
\end{multline}

    (Here again the CTE and CME related terms are optional.) Actually, one can write a single set of 6 equations with 6 unknowns. The general form of this system is

    $\displaystyle \sum_{j=1}^n K_{ij}u_j=b_i,\hspace{5mm}i=1...n.
$

  3. Now, one considers a case in which one component of vector $ u_j$ is constrained to be a certain value. For example $ u_k=a$ . This equation replaces the $ k^{\text{th}}$ equation of the system:

    $\displaystyle \sum_{j=1}^n K_{ij}u_j$ $\displaystyle = b_i, \hspace{5mm}i=1...n,\ i\neq k$    
    $\displaystyle u_k$ $\displaystyle =a$    

    The unknown $ u_k$ can be easily eliminated from the linear

    $\displaystyle \sum_{j=1,\j\neq k}^n K_{ij}u_j$ $\displaystyle = b_i-K_{ik}a, \hspace{5mm}i=1...n,\ i\neq k$    
    $\displaystyle u_k$ $\displaystyle =a$    

    The first line above corresponds to a new linear system of $ n-1$ equations with $ n-1$ unknowns. The set of two lines define the algebraic operations that are performed in FeResPost when one imposes an average strain or curvature component.

  4. When all the components of loading imposed as average strains or curvature have been eliminated from the linear system, a classical Gaussian elimination algorithm calculates the other unknowns of the system.

    Then the components of tensors $ \left\{\epsilon^0\right\}$ and $ \left\{\kappa^0\right\}$ are known in loading axes.

  5. The normal forces and bending moments are then calculated in loading axes with the following equations:

    \begin{multline}
\left\{N\right\}_{\text{load}}=
\left[A\right]_{\text{load}}\...
...})
-\left\{\beta Eh^2\right\}_{\text{load}}H_{,z}
\nonumber\ ,
\end{multline}

    \begin{multline}
\left\{M\right\}_{\text{load}}=
\left[B\right]_{\text{load}}\...
...})
-\left\{\beta Eh^3\right\}_{\text{load}}H_{,z}
\nonumber\ .
\end{multline}

    (The CTE and CME related terms are optional.)

  6. If $ \lambda$ is the angle characterizing the loading orientation wrt laminate axes a rotation of $ -\lambda$ of the two vectors gives the average strain and curvature tensors in laminate axes: $ \left\{\epsilon^0\right\}_{\text{lam}}$ and $ \left\{\kappa^0\right\}_{\text{lam}}$ .

    $\displaystyle \left\{\epsilon^0\right\}_{\text{lam}}=
\left[T_+^\prime\right]_{(-\lambda)}
\cdot\left\{\epsilon^0\right\}_{\text{load}}\ ,
$

    $\displaystyle \left\{\kappa\right\}_{\text{lam}}=
\left[T_+^\prime\right]_{(-\lambda)}
\cdot\left\{\kappa^0\right\}_{\text{load}}\ .
$

    Similarly, the normal forces and bending moments components are re-expressed in laminate axes:

    $\displaystyle \left\{N\right\}_{\text{lam}}=
\left[T_-\right]_{(-\lambda)}
\cdot\left\{N\right\}_{\text{load}}\ ,
$

    $\displaystyle \left\{M\right\}_{\text{lam}}=
\left[T_-\right]_{(-\lambda)}
\cdot\left\{M\right\}_{\text{load}}\ .
$

  7. For each ply, one calculates (if required) the stresses and strains as follows:
    1. One rotates the laminate average strain and curvature tensors to obtain them in ply axes. If the ply is characterized by an angle $ \xi$ wrt laminate axes, the two tensors are rotated by the same angle $ \xi$ :

      $\displaystyle \left\{\epsilon^0\right\}_{\text{ply}}=
\left[T_+^\prime\right]_{(\xi)}
\cdot\left\{\epsilon^0\right\}_{\text{lam}}\ ,
$

      $\displaystyle \left\{\kappa^0\right\}_{\text{ply}}=
\left[T_+^\prime\right]_{(\xi)}
\cdot\left\{\kappa^0\right\}_{\text{lam}}\ .
$

      Note that, even though the components of these two tensors are now given in one of the plies coordinate system, they correspond to strain or curvature of the laminate at mid-thickness.
    2. At the different stations through the thickness at which strains and stresses are required, the strain components are calculated with:

      $\displaystyle \left\{\epsilon\right\}_{\text{ply}}(z)=
\left\{\epsilon^0\right\}_{\text{ply}}
+z\left\{\kappa^0\right\}_{\text{ply}}\ .
$

      In FeResPost $ z$ may have the values $ z_{\text{inf}}$ , $ z_{\text{mid}}$ , $ z_{\text{sup}}$ . Then the stress components are given by:

      $\displaystyle \left\{\sigma\right\}_{\text{ply}}(z)
=
\left[C\right]_{\text{...
...y}}(T_0+zT_{,z})
+\left\{\beta\right\}_{\text{ply}}(H_0+zH_{,z})
\right)\ .
$

      (Here again the CTE and CME related terms are optional.) A peculiar version of the ply strain tensor that corresponds to ply stresses, but without thermo-elastic or moisture contribution is calculated as follows:

      $\displaystyle \left\{\epsilon^{\text{Mech}}\right\}_{\text{ply}}(z)
=\left[c\right]_{\text{ply}}
\cdot\left\{\sigma\right\}_{\text{ply}}(z)\ .
$

      This version of the strain tensor is called the ``Mechanical Strain Tensor'' or ``Equivalent Strain Tensor''. This is the version of the strain tensors that is used for the strain failure criteria. Note however that a ``Total Strain'' version of the criteria is proposed as well.
At the end of the calculations, the laminate object which has been used to perform those calculations stores a few results: The ply results may be used later to calculate failure indices or reserve factors.


II.1.8.2 Out-of-plane shear response

Some of the quantities calculated above, and stored in the ClaLam object are used to estimate laminate shear loading response.

The different steps of the calculation are described below:

  1. The first step of the calculation is to resolve the loading in out-of-plane shear forces in loading axes $ \left\{Q\right\}_{\text{load}}$ (or $ \left\{\Gamma\right\}_{\text{load}}$ ). For this, one proceeds as in section II.1.5, but with the following differences: the conversion of average out-of-plane shear strain to out-of-plane shear force components requires the knowledge of out-of-plane shear stiffness matrix in loading axes. This one is readily obtained by transforming the corresponding matrix in laminate axes:

    $\displaystyle \left[G\right]_{\text{load}}
=
\left[S_+\right]_{(\lambda)}
\cdot
\left[G\right]_{\text{lam}}
\cdot
\left[S_-\right]_{(\lambda)}\ .
$

  2. The out-of-plane shear loading can be expressed by specifying the out-of-plane shear forces, or the out-of-plane average shear strain, or a combination of the two. In all cases, the components are specified in loading axes. One distinguishes three cases:

  3. At this stage, whatever the type of loading applied to the laminate, $ \left\{Q\right\}_{\text{load}}$ is known. Then, if necessary, $ \left\{\Gamma\right\}_{\text{load}}$ is then simply calculated with expression (II.1.100) written in loading axes:

    \begin{multline}
\left[\Gamma\right]_{\text{load}}
=\left[G\right]_{\text{load...
...}})
+\left\{\beta_1^s\right\}_{\text{load}}H_{,z}
\ .\nonumber
\end{multline}

    (The CTE and CME related terms are optional.) Once $ \left\{Q\right\}_{\text{load}}$ and $ \left\{\Gamma\right\}_{\text{load}}$ are known, the corresponding loading in laminate axes is obtained with:

    $\displaystyle \left\{Q\right\}_{\text{lam}}
=
\left[S_-\right]_{(\lambda)}
\cdot
\left\{Q\right\}_{\text{load}}\ ,
$

    $\displaystyle \left\{\Gamma\right\}_{\text{lam}}
=
\left[S_-\right]_{(\lambda)}
\cdot
\left\{\Gamma\right\}_{\text{load}}\ .
$

  4. The ply out-of-plane shear stress components are calculated at the different requested locations by:

    $\displaystyle \left\{\tau^j_s\right\}_{\text{ply}}
=\left[Y^j\right]_{\text{ply}}^{\text{lam}}
\cdot
\left\{Q_s\right\}_{\text{lam}}
\ ,
$

    in which the matrix $ \left[Y^j\right]_{\text{ply}}^{\text{lam}}$ is relative to the station at which the stress is requested.

  5. Finally, for the stations where out-of-plane shear stresses have been calculated the out-of-plain shear strain is also calculated using the corresponding ply material coefficients:

    $\displaystyle \left\{\gamma_s(z)\right\}_{\text{ply}}
=
\left[g\right]^{-1}_...
...ply}}(T_0+zT_{,z})
+\left\{\beta\right\}_{\text{ply}}(H_0+zH_{,z})\right)\ .
$

    (The CTE and CME related terms are optional. One takes benefits of the ``decoupling of out-of-plane shear'' assumption.)


II.1.8.3 Out-of-plane T/C deformation

The Classical Lamination Theory is based on the assumption that $ \sigma_{33}=0$ . Consequently, $ \epsilon_{33}$ and $ \epsilon^{\text{Mech}}_{33}$ are generally not zero. These strain tensor components can be estimated from (II.1.27):

$\displaystyle \epsilon^{\text{Mech}}_{33}=
c_{3311}\sigma_{11}+c_{3322}\sigma_...
...3}\sigma_{33}+
c_{3323}\sigma_{23}+c_{3331}\sigma_{31}+c_{3312}\sigma_{12}\ ,
$

$\displaystyle \epsilon_{33}=\epsilon^{\text{Mech}}_{33}+\alpha_{33}\Delta T
+\beta_{33}\Delta H\ .
$


II.1.9 Failure theories

When stresses and strains have been calculated in plies (or some of the plies), the failure indices can be estimated too. One presents below the different failure theories that are proposed in FeResPost, and how these failure theories can be used to estimate laminate reserve factors.

In this section, one conventionally uses integer subscripts to denote that tensor components are given in ply axes and Roman subscripts to indicate principal components. Often, only in-plane components of ply stress or strain tensors are used to estimate criteria. Then, the principal components are estimated as follows:

$\displaystyle \sigma_{\text{I,II}} =\frac{1}{2}\left(\sigma_{11}+\sigma_{22}\r...
...)\pm \sqrt{\frac{1}{4}\left(\sigma_{11}+\sigma_{22}\right)^2 +\tau_{12}^2}\ .$ (II.190)

In the rest of this section all the allowables used in failure criteria have positive values. Even the compressive allowables are $ \ge 0$ .

Table II.1.1 summarizes the criteria available in FeResPost. For each criterion, the Table provides:

  1. A String corresponding to the argument that identifies the selected criterion when derivation is asked.
  2. A description of the type of material (metallic or isotropic, unidirectional tape, fabric,...).
  3. A reference to the section in which the criterion is presented and discussed.
  4. Specification whether an equivalent stress for this criterion can be derived in FeResPost or not.
  5. One specifies whether a failure index can be derived with FeResPost.
  6. One specifies whether a reserve factor can be calculated with FeResPost.


Table II.1.1: Summary of failure criteria available in FeResPost and information on what can be calculated.
Criterion Material Section Derived    
Name Type Number Stress F.I. R.F.
``Tresca2D'' metallic II.1.9.1 yes yes yes
``VonMises2D'' metallic II.1.9.2 yes yes yes
``VonMises3D'' metallic II.1.9.3 yes yes yes
``MaxStress'' tape or fabric II.1.9.4 no yes yes
``MaxStress3D'' tape or fabric II.1.9.5 no yes yes
``MaxStrain'' tape or fabric II.1.9.6 no yes yes
``MaxStrain3D'' tape or fabric II.1.9.7 no yes yes
``CombStrain2D'' tape or fabric II.1.9.8 no yes yes
``MaxTotalStrain'' tape or fabric II.1.9.6 no yes yes
``MaxTotalStrain3D'' tape or fabric II.1.9.7 no yes yes
``CombTotalStrain2D'' tape or fabric II.1.9.8 no yes yes
``TsaiHill'' fabric II.1.9.9 no yes yes
``TsaiHill_b'' fabric II.1.9.10 no yes yes
``TsaiHill_c'' fabric II.1.9.11 no yes yes
``TsaiHill3D'' fabric II.1.9.12 no yes yes
``TsaiHill3D_b'' fabric II.1.9.13 no yes yes
``TsaiWu'' fabric II.1.9.14 no yes yes
``TsaiWu3D'' fabric II.1.9.15 no yes yes
``Hoffman'' fabric II.1.9.16 no yes yes
``Puck'' tape II.1.9.17 no yes yes
``Puck_b'' tape II.1.9.17 no yes yes
``Puck_c'' tape II.1.9.17 no yes yes
``Hashin'' tape II.1.9.18 no yes yes
``Hashin_b'' tape II.1.9.18 no yes yes
``Hashin_c'' tape II.1.9.18 no yes yes
``Hashin3D'' tape II.1.9.19 no yes yes
``Hashin3D_b'' tape II.1.9.19 no yes yes
``Hashin3D_c'' tape II.1.9.19 no yes yes
``YamadaSun'' tape II.1.9.20 no yes yes
``YamadaSun_b'' fabric II.1.9.21 no yes yes
``Honey3D'' honeycomb II.1.9.22 no yes yes
``HoneyShear'' honeycomb II.1.9.23 no yes yes
``HoneyShear_b'' honeycomb II.1.9.24 yes yes yes
``Ilss'' all II.1.9.25 yes yes yes

Note that many of the criteria presented here are particular cases of a general quadratic criterion that requires first the calculation of a failure index:

\begin{multline}
f=F_{11}\sigma_{11}^2+F_{22}\sigma_{22}^2+F_{33}\sigma_{33}^2...
...a_{33}
+F_{4}\sigma_{23}+F_{5}\sigma_{31}+F_{6}\sigma_{12}\ ,
\end{multline}

then a test is done on the calculated value:

$\displaystyle f\leq 1\ .
$

Several failure theories discussed below are obtained by expressing the coefficients in the expressions above by expressions depending on the material allowables. Also for the Tsai-Wu criteria discussed in section II.1.9.14 and II.1.9.15, the parameters $ F_{ij}$ are directly characterized for the material.

Note that the 2D criteria defined in this section often correspond to the failure criteria defined in ESAComp.


Table II.1.2: Correspondence between the ESAComp failure criteria and the failure criteria defined in CLA module.
ESAComp failure criterion CLA criterion ID section
``Maximum Shear Stress (Tresca)'' ``Tresca2D'' II.1.9.1
``Von Mises'' ``VonMises2D'' II.1.9.2
``Maximum Strain'' (in ply axes) ``MaxStrain'' II.1.9.6
``Maximum Stress'' (in ply axes) ``MaxStress'' II.1.9.4
``Tsai-Wu'' ``TsaiWu'' II.1.9.14
``Tsai-Hill'' ``TsaiHill'' II.1.9.9
``Hoffman'' ``Hoffman'' II.1.9.16
``Simple Puck'' ``Puck'' II.1.9.17
``Modified Puck'' ``Puck_b'' II.1.9.17
``Hashin'' ``Hashin'' II.1.9.18


II.1.9.1 Tresca criterion (2D)

Using the stress tensor components a scalar equivalent shear stress is given by:

$\displaystyle \tau_{\text{eq}}^{\text{Tresca2D}}=\max\left( \frac{1}{2}\left\v...
...I}}\right\vert, \frac{1}{2}\left\vert\sigma_{\text{II}}\right\vert \right)\ .$ (II.191)

This equivalent shear stress allows to define a Tresca failure index as follows:

$\displaystyle FI^{\text{Tresca2D}}=\frac{2\cdot\tau_{\text{eq}}^{\text{Tresca2D}}} {\sigma_t^{\text{all}}}\ ,$ (II.192)

and the reserve factor is given by:

$\displaystyle RF^{\text{Tresca2D}}=\frac{1}{FoS\cdot FI^{\text{Tresca2D}}} =\frac{\sigma_t^{\text{all}}} {FoS\cdot 2\cdot\tau_{\text{eq}}^{\text{Tresca2D}}}\ .$ (II.193)

This criterion is referred to as ``Tresca2D'' criterion in FeResPost.


II.1.9.2 Von Mises criterion (2D)

Using the stress tensor components a scalar equivalent shear stress is given by:

$\displaystyle \sigma_{\text{eq}}^{\text{VonMises2D}}=\sqrt{\sigma_{11}^2 +\sigma_{22}^2-\sigma_{11}\sigma_{22}+3\tau_{12}^2}\ .$ (II.194)

The corresponding failure index is:

$\displaystyle FI^{\text{VonMises2D}}=\frac{\sigma_{\text{eq}}^{\text{VonMises2D}}} {\sigma_t^{\text{all}}}\ ,$ (II.195)

and the reserve factor is given by:

$\displaystyle RF^{\text{VonMises2D}}=\frac{1}{FoS\cdot FI^{\text{VonMises2D}}}...
...rac{\sigma_t^{\text{all}}} {FoS\cdot\sigma_{\text{eq}}^{\text{VonMises2D}}}\ .$ (II.196)

This criterion is referred to as ``VonMises2D'' criterion in FeResPost.


II.1.9.3 Von Mises criterion (3D)

Using the stress tensor components a scalar equivalent shear stress is given by:

$\displaystyle \sigma_{\text{eq}}^{\text{VonMises3D}}=\sqrt{\sigma_{11}^2 +\sig...
...\sigma_{33}-\sigma_{33}\sigma_{11} +3\tau_{12}^2+3\tau_{23}^2+3\tau_{31}^2}\ .$ (II.197)

As for the 2D version, the corresponding failure index is given by II.1.107 and the reserve factor by II.1.108. This criterion is referred to as ``VonMises3D'' criterion in FeResPost.


II.1.9.4 Maximum stress criterion

The failure index is calculated as follows:

$\displaystyle FI^{\text{MaxStress}}=\max\left( \left\vert\frac{\sigma_{11}}{\s...
...ert, \left\vert\frac{\tau_{12}}{\tau_{12}^{\text{all}}}\right\vert \right)\ ,$ (II.198)

in which the $ \sigma_{11}^{\text{all}}$ and $ \sigma_{22}^{\text{all}}$ allowables depend on the sign of $ \sigma_{11}$ and $ \sigma_{22}$ respectively. (Generally, tensile and compressive allowables are different for orthotropic materials.) The reserve factor is calculated as follows:

$\displaystyle RF^{\text{MaxStress}}=\frac{1}{FoS\cdot FI^{\text{MaxStress}}}\ .$ (II.199)

This criterion is referred to as ``MaxStress'' criterion in FeResPost.


II.1.9.5 Maximum stress criterion (3D)

The failure index is calculated as follows:

$\displaystyle FI^{\text{MaxStress3D}}=\max\left( \left\vert\frac{\sigma_{11}}{...
...ert, \left\vert\frac{\tau_{31}}{\tau_{31}^{\text{all}}}\right\vert \right)\ ,$ (II.1100)

in which the $ \sigma_{11}^{\text{all}}$ , $ \sigma_{22}^{\text{all}}$ and $ \sigma_{33}^{\text{all}}$ allowables depend on the sign of $ \sigma_{11}$ , $ \sigma_{22}$ and $ \sigma_{33}$ respectively. (Generally, tensile and compressive allowables are different for orthotropic materials.) The reserve factor is calculated as follows:

$\displaystyle RF^{\text{MaxStress3D}}=\frac{1}{FoS\cdot FI^{\text{MaxStress3D}}}\ .$ (II.1101)

This criterion is referred to as ``MaxStress3D'' criterion in FeResPost.


II.1.9.6 Maximum strain criteria (2D)

The criterion is very similar to maximum stress criterion, except that it is calculated from the mechanical (or equivalent) strain tensor components. The failure index is calculated as follows:

$\displaystyle FI^{\text{MaxStrain}}=\max\left( \left\vert\frac{\epsilon_{11}^{...
...rac{\gamma_{12}^{\text{Mech}}}{\gamma_{12}^{\text{all}}}\right\vert \right)\ ,$ (II.1102)

in which the $ \epsilon_{11}^{\text{all}}$ and $ \epsilon_{22}^{\text{all}}$ allowables depend on the sign of $ \epsilon_{11}^{\text{Mech}}$ and $ \epsilon_{22}^{\text{Mech}}$ respectively. The reserve factor is calculated as follows:

$\displaystyle RF^{\text{MaxStrain}}=\frac{1}{FoS\cdot FI^{\text{MaxStrain}}}\ .$ (II.1103)

This criterion is referred to as ``MaxStrain'' criterion in FeResPost.

FeResPost proposes a second version of the criterion where the ``total'' strain tensor $ \left\{\epsilon\right\} $ is used instead of the mechanical strain tensor $ \left\{\epsilon^{\text{Mech}}\right\}$ . This version of the criterion is referred to as ``MaxTotalStrain'' criterion in FeResPost.


II.1.9.7 Maximum strain criterion (3D)

The criterion is very similar to maximum stress criterion, except that it is calculated from the mechanical (or equivalent) strain tensor components. The failure index is calculated as follows:

$\displaystyle FI^{\text{MaxStrain3D}}=\max\left( \left\vert\frac{\epsilon^{\te...
...rac{\gamma^{\text{Mech}}_{31}}{\gamma_{31}^{\text{all}}}\right\vert \right)\ .$ (II.1104)

in which the $ \epsilon_{11}^{\text{all}}$ , $ \epsilon_{22}^{\text{all}}$ and $ \epsilon_{33}^{\text{all}}$ allowables depend on the sign of the corresponding mechanical strain tensor component.

The reserve factor is calculated as follows:

$\displaystyle RF^{\text{MaxStrain3D}}=\frac{1}{FoS\cdot FI^{\text{MaxStrain3D}}}\ .$ (II.1105)

This criterion is referred to as ``MaxStrain3D'' criterion in FeResPost.

FeResPost proposes a second version of the criterion where the ``total'' strain tensor $ \left\{\epsilon\right\} $ is used instead of the mechanical strain tensor $ \left\{\epsilon^{\text{Mech}}\right\}$ . This version of the criterion is referred to as ``MaxTotalStrain3D'' criterion in FeResPost.


II.1.9.8 Combined strain criterion (2D)

The criterion is a strain criterion that uses a combination of several components of the strain tensor. This criterion can be considered as a Tsai-type criterion adapted to strain tensor. The combined strain failure index is calculated as follows:

$\displaystyle FI^{\text{CombStrain2D}}=\max\left[ \sqrt{\left(\frac{\epsilon^{...
...frac{\gamma^{\text{Mech}}_{12}}{\gamma_{12}^{\text{all}}}\right)^2} \right]\ ,$ (II.1106)

in which the $ \epsilon_{11}^{\text{all}}$ and $ \epsilon_{22}^{\text{all}}$ allowables depend on the sign of $ \epsilon^{\text{Mech}}_{11}$ and $ \epsilon^{\text{Mech}}_{22}$ respectively. (The criterion is calculated from the mechanical or equivalent strain tensor components.) The reserve factor is calculated as follows:

$\displaystyle RF^{\text{CombStrain2D}}=\frac{1}{FoS\cdot FI^{\text{CombStrain2D}}}\ .$ (II.1107)

This criterion is referred to as ``CombStrain2D'' criterion in FeResPost.

FeResPost proposes a second version of the criterion where the ``total'' strain tensor $ \left\{\epsilon\right\} $ is used instead of the mechanical strain tensor $ \left\{\epsilon^{\text{Mech}}\right\}$ . This version of the criterion is referred to as ``CombTotalStrain2D'' criterion in FeResPost.


II.1.9.9 Tsai-Hill criterion

The Tsai-Hill criterion is a quadratic criterion. The 2D version of this criterion has a failure index calculated as follows:

$\displaystyle FI^{\text{TsaiHill}}= \left(\frac{\sigma_{11}}{\sigma_{11}^{\tex...
...2 -\frac{\sigma_{11}\sigma_{22}}{\left(\sigma_{11}^{\text{all}}\right)^2} \ .$ (II.1108)

Here again, the allowables $ \sigma_{11}^{\text{all}}$ and $ \sigma_{22}^{\text{all}}$ depend on the signs of $ \sigma_{11}$ and $ \sigma_{22}$ respectively. The Tsai-Hill failure index depends quadratically on the different components of the stress tensor. Therefore, the reserve factor is calculated as follows:

$\displaystyle RF^{\text{TsaiHill}}=\frac{1}{FoS\sqrt{FI^{\text{TsaiHill}}}}\ .$ (II.1109)

This criterion is referred to as ``TsaiHill'' criterion in FeResPost.


II.1.9.10 Tsai-Hill criterion (version b)

This criterion is very similar to the one described in section II.1.9.10. It differs by the fact that only the tensile allowables $ \sigma_{11}^{\text{t,all}}$ and $ \sigma_{22}^{\text{t,all}}$ are considered for the calculations.

The calculation of reserve factor is as for the more classical Tsai-Hill criterion (II.1.121). This criterion is referred to as ``TsaiHill_b'' criterion in FeResPost.


II.1.9.11 Tsai-Hill criterion (version c)

This criterion is very similar to the one described in section II.1.9.9. The criterion has a failure index calculated as follows:

$\displaystyle FI^{\text{TsaiHill\_c}}= \left(\frac{\sigma_{11}}{\sigma_{11}^{\...
...rac{\sigma_{11}\sigma_{22}}{\left(\sigma_{11}^{\prime\text{all}}\right)^2} \ .$ (II.1110)

The criterion differs from the previous one by the fact that the allowable $ \sigma_{11}^{\prime\text{all}}$ is used in the calculation. This allowable is set to $ \sigma_{11}^{\text{t,all}}$ or $ \sigma_{11}^{\text{c,all}}$ depending on the sign of $ \sigma_{11}\sigma_{22}$ .

The calculation of reserve factor is as for the more classical Tsai-Hill criterion (II.1.121). This criterion is referred to as ``TsaiHill_c'' criterion in FeResPost.


II.1.9.12 Tsai-Hill criterion (3D)

The Tsai-Hill criterion is a quadratic criterion. The 3D version of this criterion has a failure index calculated as follows:

\begin{multline}
FI^{\text{TsaiHill3D}}=
\left(\frac{\sigma_{11}}{\sigma_{11...
...\text{all}}\right)^2}
\right)\sigma_{33}\sigma_{11}
\ .
\end{multline}

The allowables $ \sigma_{11}^{\text{all}}$ , $ \sigma_{22}^{\text{all}}$ and $ \sigma_{33}^{\text{all}}$ depend on the signs of $ \sigma_{11}$ , $ \sigma_{22}$ and $ \sigma_{33}$ respectively. The Tsai-Hill failure index depends quadratically on the different components of the stress tensor. The reserve factor is calculated as follows:

$\displaystyle RF^{\text{TsaiHill3D}}=\frac{1}{FoS\sqrt{FI^{\text{TsaiHill3D}}}}\ .$ (II.1111)

This criterion is referred to as ``TsaiHill3D'' criterion in FeResPost.


II.1.9.13 Tsai-Hill criterion (3D version b)

This criterion is very similar to the one described in section II.1.9.13. It differs by the fact that only the tensile allowables $ \sigma_{11}^{\text{t,all}}$ , $ \sigma_{22}^{\text{t,all}}$ and $ \sigma_{33}^{\text{t,all}}$ are considered for the calculations.

The calculation of reserve factor is as for the more classical Tsai-Hill criterion (II.1.124). This criterion is referred to as ``TsaiHill3D_b'' criterion in FeResPost.


II.1.9.14 Tsai-Wu criterion

The Tsai-Wu criterion is a quadratic criterion. The 2D version of this criterion has a failure index calculated as follows:

\begin{multline}
FI^{\text{TsaiWu}}=
\frac{\sigma_{11}^2}{\sigma_{11}^{\text...
...gma_{22}
+2F_{12}^{\text{TW}}\sigma_{11}\sigma_{22}
\ .
\end{multline}

In this expression, $ F_{12}^{\text{TW}}$ is a material parameter to be obtained by characterization tests. This parameter must satisfy the following relation:

$\displaystyle \left(F_{12}^{\text{TW}}\right)^2<
\cfrac{1}{\sigma_{11}^{\text...
...1}^{\text{c,all}}
\sigma_{22}^{\text{t,all}}\sigma_{22}^{\text{c,all}}}\ .
$

Its units are, for example, $ \left[{\text{Pa}}^{-2}\right]$ . Sometimes the corresponding dimensionless parameter is used instead:

$\displaystyle F_{12}^{*}=F_{12}^{\text{TW}}
\sqrt{\sigma_{11}^{\text{t,all}}\...
...1}^{\text{c,all}}
\sigma_{22}^{\text{t,all}}\sigma_{22}^{\text{c,all}}}\ .
$

This dimensionless parameter must satisfy the relation:

$\displaystyle -1\leq F_{12}^{*}\leq 1\ .
$

The value $ F_{12}^{*}=-1/2$ corresponds to a generalized Von Mises criterion. The value

$\displaystyle F_{12}^{\text{TW}}
=\cfrac{-1}{2\sigma_{11}^{\text{t,all}}\sigma_{11}^{\text{c,all}}}
$

leads to the Hoffman criterion discussed in section II.1.9.16.

In some of the terms of expression (II.1.125) the components of Cauchy stress tensor appear linearly, and other terms, they appear quadratically. Therefore, the reserve factor expression is a little more complicated. FeResPost calculates it as follows:

$\displaystyle a=\frac{\sigma_{11}^2}{\sigma_{11}^{\text{t,all}}
\sigma_{11}^{...
...}}{\tau_{12}^{\text{all}}}\right)^2
+2F_{12}^{TW}\sigma_{11}\sigma_{22}\ ,
$

$\displaystyle b=\left(
\frac{1}{\sigma_{11}^{\text{t,all}}}
-\frac{1}{\sigm...
...{\text{t,all}}}
-\frac{1}{\sigma_{22}^{\text{c,all}}}\right)\sigma_{22}\ ,
$

$\displaystyle c=-1\ ,
$

$\displaystyle RF^{\text{TsaiWu}}=\frac{-b+\sqrt{b^2-4ac}}{2\cdot FoS\cdot a}\ .$ (II.1112)

This criterion is referred to as ``TsaiWu'' criterion in FeResPost.


II.1.9.15 Tsai-Wu criterion (3D)

The 3D version of Tsai-Wu failure criterion leads to the following expression of the failure index:

\begin{multline}
FI^{\text{TsaiWu3D}}=
\frac{\sigma_{11}^2}{\sigma_{11}^{\te...
...gma_{33}
+2F_{31}^{\text{TW}}\sigma_{33}\sigma_{11}
\ .
\end{multline}

The values of $ F_{23}^{\text{TW}}$ and $ F_{31}^{\text{TW}}$ are submitted to the same limitations as $ F_{12}^{\text{TW}}$ in section II.1.9.14. The RF calculation is done as follows:

\begin{multline}
a=\frac{\sigma_{11}^2}{\sigma_{11}^{\text{t,all}}
\sigma_{1...
...{33}
+2F_{31}^{\text{TW}}\sigma_{33}\sigma_{11} \nonumber \ ,
\end{multline}

$\displaystyle b=\left(
\frac{1}{\sigma_{11}^{\text{t,all}}}
-\frac{1}{\sigm...
...{\text{t,all}}}
-\frac{1}{\sigma_{33}^{\text{c,all}}}\right)\sigma_{33}\ ,
$

$\displaystyle c=-1\ ,
$

$\displaystyle RF^{\text{TsaiWu3D}}=\frac{-b+\sqrt{b^2-4ac}}{2\cdot FoS\cdot a}\ .$ (II.1113)

This criterion is referred to as ``TsaiWu3D'' criterion in FeResPost.


II.1.9.16 Hoffman criterion

The Hoffman criterion is very similar to the Tsai-Wu criterion. Only the last term of failure index is different:

\begin{multline}
FI^{\text{Hoffman}}=
\frac{\sigma_{11}^2}{\sigma_{11}^{\tex...
...\sigma_{11}^{\text{t,all}}\sigma_{11}^{\text{c,all}}}
\ .
\end{multline}

In some of the terms of previous expression the components of Cauchy stress tensor appear linearly, and other terms, they appear quadratically. Therefore, the reserve factor expression is a little more complicated. FeResPost calculates it as follows:

$\displaystyle a=\frac{\sigma_{11}^2}{\sigma_{11}^{\text{t,all}}
\sigma_{11}^{...
...{11}\sigma_{22}}
{\sigma_{11}^{\text{t,all}}\sigma_{11}^{\text{c,all}}}\ ,
$

$\displaystyle b=\left(
\frac{1}{\sigma_{11}^{\text{t,all}}}
-\frac{1}{\sigm...
...{\text{t,all}}}
-\frac{1}{\sigma_{22}^{\text{c,all}}}\right)\sigma_{22}\ ,
$

$\displaystyle c=-1\ ,
$

$\displaystyle RF^{\text{Hoffman}}=\frac{-b+\sqrt{b^2-4ac}}{2\cdot FoS\cdot a}$ (II.1114)

This criterion is referred to as ``Hoffman'' criterion in FeResPost.


II.1.9.17 Puck criteria

This criterion is adapted to the justification of laminates with unidirectional plies. This criterion distinguishes two failure mode: one fiber failure mode in direction 1 and one matrix failure mode. One distinguishes three versions of the Puck criterion.

The first version of Puck failure index is calculated as follows:

$\displaystyle FI^{\text{Puck}}=\max\left( \left\vert\cfrac{\sigma_{11}}{\sigma...
...ight)^2 +\left(\cfrac{\tau_{12}}{\tau_{12}^{\text{all}}}\right)^2} \right)\ ,$ (II.1115)

in which the allowables $ \sigma_{11}^{\text{all}}$ and $ \sigma_{22}^{\text{all}}$ depend on the signs of $ \sigma_{11}$ and $ \sigma_{22}$ respectively. The reserve factor is simply given by:

$\displaystyle RF^{\text{Puck}}=\cfrac{1}{FoS\cdot\max\left( \left\vert\cfrac{\...
...ght)^2 +\left(\cfrac{\tau_{12}}{\tau_{12}^{\text{all}}}\right)^2} \right)\ .}$ (II.1116)

This criterion is referred to as ``Puck'' criterion in FeResPost.

A modified version of Puck criterion is defined as follows:

$\displaystyle FI^{\text{Puck\_b}}=\max\left( \left\vert\cfrac{\sigma_{11}}{\si...
...{22}^{\text{t,all}}} -\cfrac{1}{\sigma_{22}^{\text{c,all}}}\right) \right)\ .$ (II.1117)

The reserve factor is calculated as follows:

$\displaystyle RF_a=\cfrac{\sigma_{11}^{\text{all}}}{FoS\cdot\sigma_{11}}\ ,
$

$\displaystyle a=\cfrac{\sigma_{22}^2}{\sigma_{22}^{\text{c,all}}\sigma_{22}^{\text{t,all}}}
+\left(\cfrac{\tau_{12}}{\tau_{12}^{\text{all}}}\right)^2\ ,
$

$\displaystyle b=\sigma_{22}\left(\frac{1}{\sigma_{22}^{\text{t,all}}}
-\frac{1}{\sigma_{22}^{\text{c,all}}}\right)\ ,
$

$\displaystyle c=-1\ ,
$

$\displaystyle RF_b=\frac{-b+\sqrt{b^2-4ac}}{2\cdot FoS\cdot a}\ ,
$

$\displaystyle RF^{\text{Puck\_b}}=\min\left(RF_a,RF_b\right)\ .$ (II.1118)

The calculation of failure index is based on the calculation of the reserve factor:

$\displaystyle FI^{\text{Puck\_b}}=\cfrac{1}{RF^{\text{Puck\_2}}}\ ,$ (II.1119)

in which the safety factor used in the calculation of the RF is 1. The advantage of this new expression is that the failure index is proportional to the components of stress tensor. This criterion is referred to as ``Puck_b'' criterion in FeResPost.

Sometimes, an additional term is given in the expression corresponding to the fiber failure and the modified version of Puck criterion is defined as follows:

$\displaystyle FI^{\text{Puck\_c}}=\max\left( \left\vert\cfrac{\sigma_{11}}{\si...
...{22}^{\text{t,all}}} -\cfrac{1}{\sigma_{22}^{\text{c,all}}}\right) \right)\ .$ (II.1120)

The calculation of reserve factor is done as for version ``b'' of Puck criterion, but one uses a modified expression for $ a$ parameter:

$\displaystyle a=\left(\cfrac{\sigma_{11}}{2\sigma_{11}^{\text{t,all}}}\right)^2...
...text{t,all}}}
+\left(\cfrac{\tau_{12}}{\tau_{12}^{\text{all}}}\right)^2\ .
$

This criterion is referred to as ``Puck_c'' criterion in FeResPost.


II.1.9.18 Hashin criteria

This criterion is meant to be used for uni-directional materials. Direction 1 is assumed to be direction of fibers. One first presents the way the reserve factor is calculated:

Finally, the reserve factor is given by:

$\displaystyle RF^{\text{Hashin}}=\min\left(RF_b,RF_c\right)$ (II.1121)

Here again, the calculation of failure index is based on the calculation of the reserve factor:

$\displaystyle FI^{\text{Hashin}}=\cfrac{1}{RF^{\text{Hashin}}}\ ,$ (II.1122)

in which the safety factor used in the calculation of the RF is 1.

The criterion presented above is referred to by ``Hashin'' criterion in FeResPost. Correspondingly, one defines version ``Hashin_b'' in which only the fiber failure is checked and ``Hashin_c'' in which only the matrix failure is checked. (These correspond to the values $ RF_b$ and $ RF_c$ calculated above.)


II.1.9.19 Hashin criteria (3D)

A 3D version of the criterion defined in section II.1.9.18 is defined as follows

Finally, the reserve factor is given by:

$\displaystyle RF^{\text{Hashin3D}}=\min\left(RF_b,RF_c\right)$ (II.1123)

Here again, the calculation of failure index is based on the calculation of the reserve factor:

$\displaystyle FI^{\text{Hashin3D}}=\cfrac{1}{RF^{\text{Hashin3D}}}\ ,$ (II.1124)

in which the safety factor used in the calculation of the RF is 1.

The criterion presented above is referred to by ``Hashin3D'' criterion in FeResPost. Correspondingly, one defines version ``Hashin3D_b'' in which only the fiber failure is checked and ``Hashin3D_c'' in which only the matrix failure is checked. (These correspond to the values $ RF_b$ and $ RF_c$ calculated above.)


II.1.9.20 Yamada-Sun criterion

The Yamada-Sun criterion is a kind of Tsai criterion adapted to tape (unidirectional) materials. Its failure index is calculated as follows:

$\displaystyle FI^{\text{YamadaSun}}= \left(\frac{\sigma_{11}}{\sigma_{11}^{\text{all}}}\right)^2 +\left(\frac{\tau_{12}}{\tau_{12}^{\text{all}}}\right)^2 \ .$ (II.1125)

The allowable $ \sigma_{11}^{\text{all}}$ depends on the sign of $ \sigma_{11}$ . The reserve factor is calculated as follows:

$\displaystyle RF^{\text{YamadaSun}} =\frac{1}{FoS\sqrt{FI^{\text{YamadaSun}}}}\ .$ (II.1126)

This criterion is referred to as ``YamadaSun'' in FeResPost.


II.1.9.21 Yamada-Sun criterion (version b)

A second version of Yamada-Sun criterion more adapted to fabrics is proposed. The ``tape'' version of Yamada-Sun criterion is calculated in two directions, and the worst direction is considered for failure. The failure index is calculated as follows:

$\displaystyle FI^{\text{YamadaSun\_b}}= {\text{max}}\left[ \left(\frac{\sigma...
...\right)^2 +\left(\frac{\tau_{12}}{\tau_{12}^{\text{all}}}\right)^2 \right]\ .$ (II.1127)

The allowables $ \sigma_{11}^{\text{all}}$ and $ \sigma_{22}^{\text{all}}$ depends on the signs of $ \sigma_{11}$ and $ \sigma_{22}$ respectively. The reserve factor is calculated as follows:

$\displaystyle RF^{\text{YamadaSun\_b}} =\frac{1}{FoS\sqrt{FI^{\text{YamadaSun\_b}}}}\ .$ (II.1128)

This criterion is referred to as ``YamadaSun_b'' in FeResPost.


II.1.9.22 3D honeycomb criterion

A general honeycomb criterion uses the out-of-plane tension/compression and the two out-of-plane shear components of the Cauchy stress tensor. The criterion read as follows:

$\displaystyle FI^{\text{Honey3D}}=\sqrt{ \left(\frac{\sigma_{33}}{\sigma_{33}^...
...all}}}\right)^2 +\left(\frac{\tau_{31}}{\tau_{31}^{\text{all}}}\right)^2} \ .$ (II.1129)

The allowable $ \sigma_{33}^{\text{all}}$ depends on the sign of $ \sigma_{33}$ (Generally, the compressive allowable is significantly smaller than the tensile one). The honeycomb material is generally defined in such a way that the allowable $ \tau_{31}^{\text{all}}=\tau_L$ is in ribbon direction (longitudinal allowable) and $ {\tau_{23}^{\text{all}}}$ is the transverse allowable $ \tau_W$ .

The reserve factor is calculated as follows:

$\displaystyle RF^{\text{Honey3D}} =\frac{1}{FoS\cdot FI^{\text{Honey3D}}}\ .$ (II.1130)

This criterion is referred to as ``Honey3D'' in FeResPost.


II.1.9.23 Honeycomb shear criterion

Depending of the modeling, the component $ \sigma_{33}$ of Cauchy stress tensor is sometimes zero. Then a simplified ``shear'' criterion is often used:

$\displaystyle FI^{\text{HoneyShear}}=\sqrt{ \left(\frac{\tau_{23}}{\tau_{23}^{...
...all}}}\right)^2 +\left(\frac{\tau_{31}}{\tau_{31}^{\text{all}}}\right)^2} \ .$ (II.1131)

The reserve factor is calculated as follows:

$\displaystyle RF^{\text{HoneyShear}} =\frac{1}{FoS\cdot FI^{\text{HoneyShear}}}\ .$ (II.1132)

This criterion is referred to as ``HoneyShear'' in FeResPost.


II.1.9.24 Honeycomb simplified shear criterion

Sometimes, one simplifies the criterion described in section II.1.9.23 by using the smallest shear allowable $ \tau_W$ . This new criterion is referred to as ``HoneyShear_b''.

As a single allowable is used, an equivalent shear stress can be defined:

$\displaystyle \tau_{\text{shear}}=\sqrt{\tau_{13}^2+\tau_{23}^2}\ .$ (II.1133)

The failure index is then calculated as follows:

$\displaystyle FI^{\text{HoneyShear\_b}}= \frac{\tau_{\text{shear}}}{\tau_{23}^{\text{all}}} \ .$ (II.1134)

The reserve factor is calculated as follows:

$\displaystyle RF^{\text{HoneyShear\_b}} =\frac{1}{FoS\cdot FI^{\text{HoneyShear\_b}}}\ .$ (II.1135)

This criterion is referred to as ``HoneyShear_b'' in FeResPost.


II.1.9.25 Inter-laminar shear criterion

The inter-laminar shear criterion is based on the comparison of inter-laminar shear stress with resin shear allowable:

$\displaystyle FI^{\text{Ilss}}=\cfrac{\tau_{\text{inter-laminar}}} {\tau_{\text{inter-laminar}}^{\text{all}}}\ ,$ (II.1136)

In which the inter-laminar shear stress is a scalar stress calculated as follows:

$\displaystyle \tau_{\text{inter-laminar}}=\sqrt{\tau_{xz}^2+\tau_{yz}^2}\ .
$

The reserve factor is of course:

$\displaystyle RF^{\text{Ilss}} =\frac{1}{FoS\cdot FI^{\text{Ilss}}}\ .$ (II.1137)

This criterion is different from the other criteria in this that it does not use ply material allowables. Instead, the ply ilss allowable or the laminate ilss allowable is used.

Note also that FeResPost calculates the inter-laminar shear criterion on the lower face of plies only.

This criterion is referred to as ``Ilss'' in FeResPost.

II.1.10 Temperature diffusion in laminates

The thermal conservation equation in a solid material is written as follows:

$\displaystyle \rho C_p \cfrac{\partial T}{\partial t}=-\nabla\cdot$$\displaystyle \mbox{\boldmath$q$}$$\displaystyle +r\ ,$ (II.1138)

where $ T$ is the temperature, $ C_p$ is the heat capacity of the material and vector $ q$ is the heat flux. Note that $ C_p$ and $ \rho$ are used for transient thermal calculations only. Generally, the heat flux is related to the gradient of temperature by Fourrier's law:

$\displaystyle \mbox{\boldmath$q$}$$\displaystyle =-$$\displaystyle \mbox{\boldmath$\lambda^T$}$$\displaystyle \cdot\nabla T\ ,$ (II.1139)

where $ \lambda$ $ ^T$ is the tensor of thermal conductivity coefficients.

When thermal conductivity calculations are performed with laminates, two homogenized quantities must first be calculated:

These two quantities are obtained by integrating material properties along laminate thickness.

II.1.10.1 Material thermal parameters

Two scalar parameters influence the transient thermal behavior of laminates: the density $ \rho$ and the heat capacity (per unit of mass) $ C_p$ . As these two parameters are scalar, their characteristics do not depend on the possible anisotropy of the material.

On the other hand, the thermal conductivity $ \lambda$ $ ^T$ is a $ 2^{\text{nd}}$ order tensor. Generally, for an anisotropic material, the tensor may be written as follows:

$\displaystyle \left(\begin{array}{c}
q_1 \\
q_2 \\
q_3
\end{array}\right)...
...31} & \lambda^T_{32} & \lambda^T_{33}
\end{array}\right)
\cdot
\nabla T\ .
$

The tensor $ \lambda^T$ is symmetric, so that only 6 components must be defined:

$\displaystyle \left(\begin{array}{c} q_1 \\ q_2 \\ q_3 \end{array}\right) =-\le...
...a^T_{31} & \lambda^T_{23} & \lambda^T_{33} \end{array}\right) \cdot \nabla T\ .$ (II.1140)

For an orthotropic material, the previous equations reduces to:

$\displaystyle \left(\begin{array}{c} q_1 \\ q_2 \\ q_3 \end{array}\right) =-\le...
...ambda^T_{22} & 0 \\ 0 & 0 & \lambda^T_{33} \end{array}\right) \cdot \nabla T\ .$ (II.1141)

Then, only three material parameters define the thermal conductivity. Finally, for an isotropic material the thermal conductivity is defined by a single parameter $ \lambda^T$ :

$\displaystyle \left(\begin{array}{c} q_1 \\ q_2 \\ q_3 \end{array}\right) =-\le...
... \\ 0 & \lambda^T & 0 \\ 0 & 0 & \lambda^T \end{array}\right) \cdot \nabla T\ .$ (II.1142)

II.1.10.2 In-plane and out-of-plane components

As has been done for the motion equations, one assumes a decoupling of in-plane laminate thermal conductivity and out-of-plane conductivity. Therefore, the thermal flux is separated into an in-plane flux:

$\displaystyle \left\{q_{12}\right\}
=\left(\begin{array}{c}
q_1 \\
q_2
\end{array}\right)\ ,
$

and the out-of-plane component $ q_3$ .

Correspondingly, the tensor of thermal conductivity coefficients is separated into an in-plane conductivity tensor:

$\displaystyle \left[\lambda^T\right]_{12}
=\left(\begin{array}{cc}
\lambda^T_...
...& \lambda^T_{12} \\
\lambda^T_{12} & \lambda^T_{22}
\end{array}\right)\ ,
$

and the out-of-plane conductivity $ \lambda^T_{33}$ . The ``shear'' components $ \lambda^T_{31}$ and $ \lambda^T_{23}$ are neglected in the homogenization theory. (This means that out-of-plane and in-plane conductivities are decoupled.)

II.1.10.3 In-plane rotations of vectorial and tensorial properties

The material scalar properties are left unmodified by in-plane rotations. The same is true for the out-of-plane quantities $ q_3$ and $ \lambda^T_{33}$ . The transformation of components for $ \left\{q\right\}$ and $ \left[\lambda^T\right]$ is noted with the transformation matrices defined in expressions (II.1.12) to (II.1.17):

$\displaystyle \left[\lambda^T\right]_{12} = \left[S_-\right]_{(\theta)} \cdot \left[\lambda^T\right]_{xy} \cdot \left[S_+\right]_{(\theta)}\ ,$ (II.1143)

$\displaystyle \left[\lambda^T\right]_{xy} = \left[S_+\right]_{(\theta)} \cdot \left[\lambda^T\right]_{12} \cdot \left[S_-\right]_{(\theta)}\ ,$ (II.1144)

$\displaystyle \left\{q\right\}_{xy} = \left[S_+\right]_{(\theta)} \cdot \left\{q\right\}_{12}\ ,$ (II.1145)

$\displaystyle \left\{q\right\}_{12} = \left[S_-\right]_{(\theta)} \cdot \left\{q\right\}_{xy}\ .$ (II.1146)

II.1.10.4 Integration along the laminate thickness

One considers separately the laminate thermal in-plane conductivity, thermal out-of-plane conductivity and thermal capacity.

II.1.10.4.1 In-plane conductivity

To calculate the laminate in-plane thermal conductivity properties, one assumes that temperature is constant along the laminate thickness. Consequently, the temperature gradient does not depend on $ z$ . The thermal flux $ \left\{q\right\}_{xy}$ however depends on $ z$ because the thermal conductivity does:

$\displaystyle \left\{q\right\}_{xy}(z) =\left[\lambda^T\right]_{xy}(z) \cdot\left\{\nabla T\right\}_{xy}\ .$ (II.1147)

The laminate in-plane thermal conductivity is calculated as follows:

$\displaystyle \left\{Q\right\}_{xy}$ $\displaystyle =\int_{-h/2}^{-h/2}\left\{q\right\}_{xy}(z)$   d$\displaystyle z\ ,$    
  $\displaystyle =\int_{-h/2}^{-h/2}\left[\lambda^T\right]_{xy}(z) \cdot\left\{\nabla T\right\}_{xy}$   d$\displaystyle z\ ,$    
  $\displaystyle =\left(\int_{-h/2}^{-h/2}\left[\lambda^T\right]_{xy}(z)\hspace{0.4em}\text{d}z\right) \cdot\left\{\nabla T\right\}_{xy} \ ,$    
  $\displaystyle =\left(\int_{-h/2}^{-h/2} \left[S_+\right]_{(\theta)}(z) \cdot \l...
...\theta)}(z)\hspace{0.4em}\text{d}z\right) \cdot\left\{\nabla T\right\}_{xy} \ ,$    
  $\displaystyle =\left[\Lambda^T\right]_{xy}\cdot\left\{\nabla T\right\}_{xy} \ .$    

In the previous equation, one introduced the laminate in-plane thermal conductivity:

$\displaystyle \left[\Lambda^T\right]_{xy}$ $\displaystyle =\int_{-h/2}^{-h/2} \left[S_+\right]_{(\theta)}(z) \cdot \left[\lambda^T\right]_{12}(z) \cdot \left[S_-\right]_{(\theta)}(z)$   d$\displaystyle z\ ,$    
  $\displaystyle =\sum_{k=1}^N \left[S_+\right]_{(\theta_k)} \cdot \left[\lambda_k^T\right]_{12} \cdot \left[S_-\right]_{(\theta_k)}\ e_k\ ,$ (II.1148)

where $ e_k$ is the thickness of ply $ k$ .

II.1.10.4.2 Out-of-plane conductivity

One assumes that out-of-plane thermal flux is constant across laminate thickness. Then, as thermal conductivity depends on $ z$ , so will the out-of-plane gradient of temperature:

$\displaystyle \nabla T_z=\cfrac{q_z}{\lambda^T_{33}}\ .$ (II.1149)

The integration across the thickness gives the difference of temperature between upper and lower laminate surfaces:

$\displaystyle T_{\text{sup}}-T_{\text{inf}}$ $\displaystyle =\int_{-h/2}^{-h/2}\nabla T_z$   d$\displaystyle z\ ,$    
  $\displaystyle =\int_{-h/2}^{-h/2}\cfrac{q_z}{\lambda^T_{33}}$   d$\displaystyle z\ ,$    
  $\displaystyle =\left(\int_{-h/2}^{-h/2}\cfrac{1}{\lambda^T_{33}}\hspace{0.4em}\text{d}z\right) q_z\ ,$    
  $\displaystyle =R^T_{33}\ q_z\ .$    

In previous expression, one introduced the out-of-plane thermal resistance:

$\displaystyle R^T_{33}$ $\displaystyle =\int_{-h/2}^{-h/2}\cfrac{1}{\lambda^T_{33}}$   d$\displaystyle z\ ,$    
  $\displaystyle =\sum_{k=1}^N\cfrac{1}{(\lambda^T_{33})_k}\ e_k\ .$ (II.1150)

II.1.10.4.3 Thermal capacity

To estimate the laminate thermal capacity, one again assumes a temperature constant across the laminate thickness. Then, the heat energy stored per unit of surface is:

$\displaystyle U$ $\displaystyle =\int_{-h/2}^{-h/2}\rho C_p T$   d$\displaystyle z\ ,$    
  $\displaystyle =\left(\int_{-h/2}^{-h/2}\rho C_p\hspace{0.4em}\text{d}z\right) T\ ,$    
  $\displaystyle =\left(\rho C_p h\right)_{\text{lam}} T\ .$    

In previous expression, one introduced the surfacic thermal capacity

$\displaystyle \left(\rho C_p h\right)_{\text{lam}}$ $\displaystyle =\int_{-h/2}^{-h/2}\rho C_p$   d$\displaystyle z\ ,$    
  $\displaystyle =\sum_{k=1}^N\left(\rho C_p\right)_k\ e_k\ .$ (II.1151)

Note that in Nastran, when a thermal material MAT4 or MAT5 is defined, the density $ \rho$ and the heat capacity per unit of mass $ C_p$ are defined separately. So it is the responsibility of the user to select appropriate values for these two quantities. Also, in Nastran, the thickness is defined separately in the PSHELL property card. (PCOMP or PCOMPG cards do not accept thermal materials.)

II.1.11 Moisture diffusion in laminates

The moisture conservation equation in a solid material is written as follows:

$\displaystyle \cfrac{\partial M}{\partial t}=-\nabla\cdot$$\displaystyle \mbox{\boldmath$q$}$$\displaystyle _M\ ,$ (II.1152)

where $ M$ is the moisture content (for example in [kg/m$ ^3$ ]) and vector $ q$ $ _M$ is the massic flux of moisture (in [kg/m$ ^2$ s]). When several materials are present in a structure, as often in laminates, it is more practical to work with moisture percentage $ H$ (in [%w]). The moisture percentage is related to moisture content by the following expression:

$\displaystyle M=c\cdot H\ ,$ (II.1153)

where $ c$ is the moisture coefficient in [kg/(m$ ^3$ %w)].

Generally, the moisture flux is related to the gradient of moisture by Fick's law, and the moisture diffusion equation can be written:

$\displaystyle \cfrac{\partial H}{\partial t} =\nabla\cdot\left(\mbox{\boldmath$\lambda$}^H\cdot\nabla H\right)\ .$ (II.1154)

here $ \lambda$ $ ^H$ is the tensor of moisture conductivity coefficients. This expression is very similar to the equation of thermal diffusion: As one works with moisture percentages, nothing equivalent to the laminate thermal capacity $ \left(\rho C_p h\right)_{\text{lam}}$ is defined for moisture.


II.1.12 Units

All the quantities introduced in this Chapter have been given without dimensions. Since version 3.0.1, units can be attributed to all the CLA quantitities defined in FeResPost, except of course the dimensionless quantities. This allows the user to express all the CLA quantities in a units system compatible, for example, with the unit system used for finite element modeling.

An engineer should be able to figure out the units of the different quantities introduced in this Chapter from the definition given for the quantities or from the expressions used for their calculations. However, we think it might be useful to remind the units of the different quantities to avoid ambiguities.

In the rest of the section, one assumes a consistent set of units compatible with MKS system is used. This is what we recommend for FeResPost, as well as finite element models. The default ``base'' units are:

One notes that units have been defined for force and energy, despite the fact that they can be derived from mass, length and time units. Practically, the definition of additional base units for the force and energy are of interest for mechanical engineers.

All the other units of FeResPost are obtained by combining these base units. The most important ones are summarized in Tables II.1.3, II.1.4 and II.1.5.

If one of the base units above is modified, the user is responsible for modifying the derived units coherently. For example, we expressed the moisture content in [%w]. This influences the units of moisture content $ H$ as well as the units of coefficients of moisture expansion $ \beta$ .


Table II.1.3: Units of the different quantities related to loading, stresses or load responses.
Quantities Symbols Units
Strains $ \epsilon$ , $ \gamma$ or $ \Gamma$ [L/L] or [-]
Stresses $ \sigma$ or $ \tau$ [F/L$ ^2$ ]
Curvatures $ \kappa$ [1/L]
Forces $ \{N\}$ or $ \{Q\}$ [F/L]
Moments $ \{M\}$ [FL/L] or [F]
Temperatures $ T$ [T]
Moistures $ H$ [W] (always [%w])
Failure indices $ FI$ []
Reserve factors $ RF$ []


Table II.1.4: Units of the different quantities related to material properties.
Quantities Symbols Units
Materials stiffnesses or moduli $ C_{ijkl}$ , $ [C]$ , $ E$ or $ G$ [F/L$ ^2$ ]
Materials compliance matrices $ c_{ijkl}$ , $ [c]$ , $ [g]$ [L$ ^2$ /F] ]
Poisson coefficients $ \nu_{ij}$ [-]
Thermal conductivity $ \lambda^T_{ij}$ [E/(LT)]
Coefficients of thermal expansion $ \alpha$ [L/(LT)] or [1/T]
Moisture conductivity $ \lambda^H_{ij}$ [1/(Lt)]
Coefficients of moisture expansion $ \beta$ [L/(LW)] or [1/W]
Density $ \rho$ [M/L$ ^3$ ]
Heat specific capacity $ C_p$ [E/(MT)]
Coefficients of quadratic failure criteria $ F_i$ [L$ ^2$ /F]
Coefficients of quadratic failure criteria $ F_{ij}$ [L$ ^4$ /F$ ^2$ ]


Table II.1.5: Units of the different quantities related to laminate properties.
Quantities Symbols Units
Thicknesses $ t$ [L]
Membrane stiffness matrix $ [A]$ [F/L]
Membrane-bending coupling stiffness matrix $ [B]$ [F]
Bending stiffness matrix $ [D]$ [FL]
Out-of-plane shear stiffness matrix $ [G]$ [F/L]
Membrane compliance matrix $ [a]$ [L/F]
Membrane-bending coupling compliance matrix $ [b]$ [1/F]
Bending compliance matrix $ [d]$ [1/(FL)]
Out-of-plane shear compliance matrix $ [g]$ [L/F]
In-plane thermal conductivity matrix $ \left[\Lambda^T\right]$ [E/(tT)]
Out-of-plane thermal resistance $ R^T_{33}$ [L$ ^2$ Tt/E]
Surfacic heat capacity $ \left(\rho C_p h\right)_{\text{lam}}$ [E/L$ ^2$ /T]
In-plane moisture conductivity matrix $ \left[\Lambda^H\right]$ [1/t]
Out-of-plane moisture resistance $ R^H_{33}$ [L$ ^2$ t]

Other units systems can be used with the CLA classes. Each CLA object has an attribute corresponding to the units system in which all its characteristics are defined.

The units of CLA object can be obtained with ``getUnits'' method that returns a Hash containing pairs of Strings. The first String describes the kind of dimension: ``L'' for length, ``M'' for mass, ``t'' for time, ``T'' for temperature, ``E'' for energy, ``W'' for moisture and ``F'' for force. The second String corresponds to one of the unit listed above for the selected quantity.

The units of a CLA object can also be modified by calling ``setUnits'' or ``changeUnits'' methods. The ``setUnits'' method change the units attributed to an object without modifying the values of the different quantities defining the object. (No unit conversion is done.) The ``changeUnits'' method performs the units conversion. Both ``setUnits'' and ``changeUnits'' methods has an Hash argument corresponding to the value returned by ``getUnits'' method.


II.2 The ``ClaDb'' class

A ClaDb object may be considered as an object in which collections of materials, laminates and loads are stored. The ClaDb Class also provides the ``glue'' that bonds the objects of the other composite Classes together.

Table II.2.1 gives the list of methods defined in ``ClaDb'' class.

Table II.2.1: The different methods that have been defined in ``ClaDb'' class. CLA.ClaDb.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
new II.2.1 IV.5.1
initialize II.2.1  
clone II.2.8  
Manipulation of data defining ClaDb object
insertMaterial II.2.3 IV.5.2
eraseMaterial II.2.3  
getMaterialsNbr II.2.3  
getMaterialCopy II.2.3 IV.5.2
insertLaminate II.2.3 IV.5.2
eraseLaminate II.2.3  
getLaminatesNbr II.2.3  
getLaminateCopy II.2.3 IV.5.4.2
insertLoad II.2.3  
eraseLoad II.2.3  
getLoadsNbr II.2.3  
getLoadCopy II.2.3 IV.5.4.2
Management of units methods
getDbUnits II.2.4  
setDbUnits II.2.4  
setUnitsAllEntities II.2.4  
setUnitsAllMaterials II.2.4  
setUnitsAllLaminates II.2.4  
setUnitsAllLoads II.2.4  
changeUnitsAllEntities II.2.4  
changeUnitsAllMaterials II.2.4  
changeUnitsAllLaminates II.2.4  
changeUnitsAllLoads II.2.4  
Iterators
each_material II.2.7  
each_materialId II.2.7  
each_laminate II.2.7 IV.5.4.3
each_laminateId II.2.7  
each_load II.2.7  
each_loadId II.2.7  
Disk IO methods
readEdf II.2.5 IV.5.1
writeNeutral II.2.5 IV.5.1
readNeutral II.2.5 IV.5.1
NDF lines
initWithNeutralLines II.2.6  
getNeutralLines II.2.6  
Attributes
Id II.2.2  
     


II.2.1 Creation of an object

The singleton method ``new'' is used to create ClaDb objects. This method has no argument. (Nor has the ``initialize'' method an argument.)


II.2.2 Identifying a ClaDb

Two methods allow the manipulation of the identifier of ClaDb objects (``Id'' attribute):


II.2.3 Manipulating entities stored in a ClaDb

The ClaDb class provides three methods to insert objects in the collections, and three methods to retrieve objects stored in the collections:

The six methods described above create copies of the entities they store to, or retrieve from the ClaDb.

Internally, the ClaDb manages 3 associative containers that associate identifiers to materials, laminates or loads respectively. When an object is stored into the ClaDb, the key which allows to retrieve the object is the identifier one attributed to it with the ``Id'' attributes. (See Chapters II.3 to II.5.) Note that the identifier used to retrieve an object from the ClaDb must match exactly the key to which the object is associated. For example, if the identifier of a load is [17,"QS_and_bending"], then 17 or "QS_and_bending" will not allow to retrieve a copy of the object. [17,"QS_and_bending"] must be used as argument of the `getMaterialCopy'' method.

When a ClaLam object is stored into the ClaDb, its properties are calculated automatically. (Stiffness matrix and $ \left<\alpha Eh\right>$ vector.)

Note also that when a CLA object is extracted from the database, or inserted into the database, the object keeps the units that are attributed to it. These units may be different than the database units. (See also section II.2.4.)


II.2.4 Management of Units

Units are associated to the database, and to all the entities stored in the database. The units associated to the stored entities are independent of each other, and of the database units.

The ``ClaDb'' class defines several methods for the management of units:

The ``Hash'' arguments or return values mentioned above have String keys and values as explained in section II.1.12. The difference between the ``setUnits'' and ``changeUnits'' methods is also explained in the same section.


II.2.5 Saving to or retrieving from a disk file

Presently, three interface functions are defined:

Note that the neutral data files (``ndf'' files) mentioned above are files with a format specific to the FeResPost.


II.2.6 Saving or initializing with NDF lines

Two methods allow to save or read ClaDb objects from an Array of Strings in neutral format. For each of these two methods, instead of reading or saving the lines from or to a disk file, each line is saved or read from or to an Array of Strings. The two methods are:


II.2.7 Iterators

The ClaDb class provides 6 iterators:

These iterators have no argument.


II.2.8 Other methods

``clone'' method has no argument and returns a copy of the ClaDb object.


II.3 The ``ClaMat'' class

The ``ClaMat'' class is used to store the materials used in the definition of laminates. Each material is characterized by:

Several methods of the ClaMat class allow to access to data stored in an object. Table II.3.1 gives the list of methods defined in the class.

Table II.3.1: The different methods that have been defined in ``ClaMat'' class. CLA.ClaMat.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
new II.3.1 IV.5.2
initialize II.3.1  
clone II.3.7  
Manipulation of data defining ClaMat object
clearModuli II.3.3  
insertModuli II.3.3  
fillModuli II.3.3 IV.5.2
getDataModuli II.3.3  
clearCTEs II.3.3  
insertCTEs II.3.3  
fillCTEs II.3.3 IV.5.2
getDataCTEs II.3.3  
clearCMEs II.3.3  
insertCMEs II.3.3  
fillCMEs II.3.3  
getDataCMEs II.3.3  
clearAllowables II.3.3  
insertAllowables II.3.3  
fillAllowables II.3.3  
getDataAllowables II.3.3  
clearThermalData II.3.3  
insertThermalData II.3.3  
fillThermalData II.3.3 IV.5.3
getThermalData II.3.3  
clearMoistureData II.3.3  
insertMoistureData II.3.3  
fillMoistureData II.3.3  
getMoistureData II.3.3  
Extraction of calculated material properties
getCompliance II.3.4 ``EX12/testCla.rb''
getStiffness II.3.4 IV.5.2
getInPlaneCompliance II.3.4 ``EX13/extendedCLA.rb''
getInPlaneStiffness II.3.4 ``EX13/extendedCLA.rb''
getInPlaneAlfaE II.3.4 ``EX13/extendedCLA.rb''
getInPlaneBetaE II.3.4 ``EX13/extendedCLA.rb''
getInPlaneAlfa II.3.4 ``EX13/extendedCLA.rb''
getInPlaneBeta II.3.4 ``EX13/extendedCLA.rb''
getOOPSCompliance II.3.4 ``EX13/extendedCLA.rb''
getOOPSStiffness II.3.4 ``EX13/extendedCLA.rb''
getOOPSAlfaG II.3.4 ``EX13/extendedCLA.rb''
getOOPSBetaG II.3.4 ``EX13/extendedCLA.rb''
getOOPSAlfa II.3.4 ``EX13/extendedCLA.rb''
getOOPSBeta II.3.4 ``EX13/extendedCLA.rb''
getInPlaneLambdaT II.3.4 IV.5.3
getRho II.3.4 IV.5.3
getCp II.3.4 IV.5.3
getRhoCp II.3.4 IV.5.3
getInPlaneLambdaH II.3.4  
Management of units methods
getUnits II.3.5  
setUnits II.3.5  
changeUnits II.3.5  
Attributes
Id II.3.2  
Type II.3.2  
TypeName II.3.2 (read only)
NDF lines
initWithNeutralLines II.3.6  
getNeutralLines II.3.6  
     


II.3.1 Creation of an object

The singleton method ``new'' is used to create ClaMat objects. This method has no argument. (Nor has the ``initialize'' method an argument.)


II.3.2 Identifier and type

Two attributes are defined for the ``ClaMat'' object: ``Id'' and ``Type''. Five methods allow the manipulation of the identifier of material and of its type:

Note that for the type definition, the integers are 0, 1, 2 or 3 and correspond to "NONE", "isotropic", "orthotropic" or "anisotropic" respectively.


II.3.3 Manipulating Data

Twelve methods allow to set moduli and Poisson's coefficients, thermal expansion coefficients and allowables. These methods have one Hash argument that associates String keys to real values.

  1. ``clearModuli'' has no arguments and erases all the moduli stored in a ClaMat object.
  2. ``insertModuli'' is used to specify moduli and Poisson coefficients of the material. The keys used to insert mechanical data depend on the type of material:
  3. ``fillModuli'' is used to set material moduli and Poisson coefficients. This method has the same arguments as ``insertModuli'' but differs by the fact that moduli and Poisson coefficients are re-initialized before insertion of values.

  4. ``clearCTEs'' has no arguments and erases all the CTEs stored in a ClaMat object.
  5. ``insertCTEs'' is used to define different components of the thermal expansion coefficients. For orthotropic and anisotropic materials, possible keys are "alfa1", "alfa2", "alfa3", "alfa12", "alfa23" and "alfa31". For isotropic materials, key "alfa" only can be used.
  6. ``fillCTEs'' is used to set material CTEs. This method has the same arguments as ``insertCTEs'' but differs by the fact that CTEs are re-initialized before insertion of values.

  7. ``clearCMEs'' has no arguments and erases all the CMEs stored in a ClaMat object.
  8. ``insertCMEs'' is used to define different components of the moisture expansion coefficients. For orthotropic and anisotropic materials, possible keys are "beta1", "beta2", "beta3", "beta12", "beta23" and "beta31". For isotropic materials, key "beta" only can be used.
  9. ``fillCMEs'' is used to set material CMEs. This method has the same arguments as ``insertCMEs'' but differs by the fact that CMEs are re-initialized before insertion of values.

  10. ``clearAllowables'' has no arguments and erases all the allowables stored in a ClaMat object.
  11. ``insertAllowables'' is used to add material allowables. The possible keys are "sc", "st", "ss", "ec", "et", "gs", "s1c", "s1t", "s2c", "s2t", "s12", "s23", "s31", "e1c", "e1t", "e2c", "e2t", "e3c", "e3t", "g12", "g23", "g31", "F12", "F23" and "F31". "st" is used to calculate isotropic stress criteria or reserve factors. "F12" "F23" and "F31" correspond to the $ F_{12}^{\text{TW}}$ , $ F_{23}^{\text{TW}}$ and $ F_{31}^{\text{TW}}$ of the Tsai-Wu failure criteria (sections II.1.9.14 and II.1.9.15). Note that the "ilss" allowable defined at material level has no effect because for Ilss criterion calculation, the allowable is always extracted from the laminate definition. (More precisely, the ilss laminate allowable, or the ply allowables are used.)
  12. ``fillAllowables'' is used to set material allowables. This method has the same arguments as ``insertAllowables'' but differs by the fact that material allowables are re-initialized before insertion of values.

  13. ``clearThermalData'' has no arguments and erases all the thermal data stored in a ClaMat object.
  14. ``insertThermalData'' is used to define the thermal data. For orthotropic and anisotropic materials, possible keys are "lambdaT1", "lambdaT2", "lambdaT3", "lambdaT12", "lambdaT23" and "lambdaT31". For isotropic materials, key "lambdaT" only can be used. For all types of materials "rho" and "Cp" keys can be used.
  15. ``fillThermalData'' is used to set material thermal data. This method has the same arguments as ``insertThermalData'' but differs by the fact that thermal data are re-initialized before insertion of values.

  16. ``clearMoistureData'' has no arguments and erases all the Moisture data stored in a ClaMat object.
  17. ``insertMoistureData'' is used to define the moisture data. For orthotropic and anisotropic materials, possible keys are "lambdaH1", "lambdaH2", "lambdaH3", "lambdaH12", "lambdaH23" and "lambdaH31". For isotropic materials, key "lambdaH" only can be used.
  18. ``fillMoistureData'' is used to set material Moisture data. This method has the same arguments as ``insertMoistureData'' but differs by the fact that moisture data are re-initialized before insertion of values.
The type of ClaMat object must have been set prior to the use of any of the three previous methods. (See ``Type'' attribute described in section II.3.2.) Several methods allow to retrieve the data that define a material:
  1. ``getDataModuli'' returns the moduli that define the ClaMat object.
  2. ``getDataCTEs'' returns the CTEs that define the ClaMat object.
  3. ``getDataCMEs'' returns the CMEs that define the ClaMat object.
  4. ``getDataAllowables'' returns the allowables that characterize the ClaMat object.
  5. ``getThermalData'' returns the thermal data that define the ClaMat object.
  6. ``getMoistureData'' returns the moisture data that define the ClaMat object.
Each of these ``get'' methods returns a Hash that associates String and Real objects. (See the ``fill'' corresponding methods for possible values.)

Obviously, the different data inserted in, or retrieved from the ClaMat 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.3.4 Calculated results

Several methods allow to recover stiffness, compliance or conductivity matrices in a specified direction.

All these methods have one optional argument: an angle corresponding to the direction of observation wrt material axes, and in which the components of the matrix are expressed.

On the other hand, three methods return material scalar characteristics and have no argument:

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


II.3.5 Management of Units

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

The ``Hash'' arguments or return values mentioned above have String keys and values as explained in section II.1.12. The difference between the ``setUnits'' and ``changeUnits'' methods is also explained in the same section.


II.3.6 Saving or initializing with NDF lines

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

However, the lines transmitted to ``initWithNeutralLines'' or returned by ``getNeutralLines'' correspond to a single ClaMat object definition.


II.3.7 Other methods

``clone'' method has no argument and returns a copy of the ClaMat object.


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. CLA.ClaLam.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods table.ClaLam.methods
new II.4.2 IV.5.2
initialize II.4.2  
clone II.4.13  
Class single methods
setMuxMuy II.4.1  
getMuxMuy II.4.1  
Manipulations of the laminate plies
clearPlies II.4.4  
addPly II.4.4 IV.5.2
setNbrPlies II.4.4  
setPly II.4.4  
getNbrPlies II.4.4  
getPlyData II.4.4  
Other lamiante data
clearAllowables II.4.5  
insertAllowables II.4.5 IV.5.6
fillAllowables II.4.5  
getDataAllowables II.4.5  
setRefT II.4.5  
getRefT II.4.5  
setRefH II.4.5  
getRefH II.4.5  
setLaminateIlss II.4.5 IV.5.4.3
setAllPliesIlss II.4.5 IV.5.4.3
Laminate properties
calcLaminateProperties II.4.6 IV.5.3
get_thickness II.4.6  
get_surfacicMass II.4.6  
get_averageDensity II.4.6  
get_ABBD II.4.6 IV.5.2
get_G II.4.6 IV.5.5
get_alfaEh1 II.4.6 IV.5.2
get_alfaEh2 II.4.6  
get_alfaEh3 II.4.6  
get_alfaGh1 II.4.6  
get_alfaGh2 II.4.6  
get_betaEh1 II.4.6  
get_betaEh2 II.4.6  
get_betaEh3 II.4.6  
get_betaGh1 II.4.6  
get_betaGh2 II.4.6  
get_abbd_complMat II.4.6  
get_g_complMat II.4.6  
get_alfae0 II.4.6  
get_alfae1 II.4.6  
get_alfak0 II.4.6  
get_alfak1 II.4.6  
get_alfas0 II.4.6  
get_alfas1 II.4.6  
get_betae0 II.4.6  
get_betae1 II.4.6  
get_betak0 II.4.6  
get_betak1 II.4.6  
get_betas0 II.4.6  
get_betas1 II.4.6  
get_engineering II.4.6 IV.5.4.1
get_LambdaT II.4.6 IV.5.3
get_R33T II.4.6 IV.5.3
get_RhoCpH II.4.6 IV.5.3
get_LambdaH II.4.6  
get_R33H II.4.6  
Laminate load response
calcResponse II.4.7.1 IV.5.4.2
isThermalLoadingDefined II.4.7.2  
getDeltaT II.4.7.2 IV.5.4.1
getT0 II.4.7.2  
getGradT II.4.7.2  
isMoistureLoadingDefined II.4.7.2  
getDeltaH II.4.7.2  
getH0 II.4.7.2  
getGradH II.4.7.2  
isMechanicalLoadingDefined II.4.7.2  
getNormalForces II.4.7.2 IV.5.4.1
getMoments II.4.7.2 IV.5.4.1
getShearForces II.4.7.2 IV.5.4.1
getNormalStrains II.4.7.2 IV.5.4.1
getCurvatures II.4.7.2 IV.5.4.1
getShearStrains II.4.7.2 IV.5.4.1
getAverageInPlaneStresses II.4.7.2 IV.5.4.1
getFlexuralStresses II.4.7.2 IV.5.4.1
getAverageShearStresses II.4.7.2 IV.5.4.1
getAverageInPlaneStrains II.4.7.2 IV.5.4.1
getFlexuralStrains II.4.7.2 IV.5.4.1
getAverageShearStrains II.4.7.2 IV.5.4.1
getPliesStrains II.4.7.3 IV.5.4.1
getPliesStresses II.4.7.3 IV.5.4.1
getPliesMechanicalStrains II.4.7.3 IV.5.4.1
getPliesStrainsWrtLamAxes II.4.7.3  
getPliesStressesWrtLamAxes II.4.7.3  
getPliesMechanicalStrainsWrtLamAxes II.4.7.3  
getPliesT II.4.7.4  
getPliesDeltaT II.4.7.4  
getPliesH II.4.7.4  
getPliesDeltaH II.4.7.4  
getDerived II.4.7.5 IV.5.4.1
getMaxDerived II.4.7.5  
getMinDerived II.4.7.5  
getFailureIndices II.4.7.5 IV.5.4.1
getMaxFailureIndices II.4.7.5  
getMinFailureIndices II.4.7.5  
getReserveFactors II.4.7.5 IV.5.4.1
getMaxReserveFactors II.4.7.5  
getMinReserveFactors II.4.7.5  
calcFiniteElementResponse II.4.8  
calcFiniteElementCriteria II.4.9 IV.5.6
Management of units methods
getUnits II.4.10  
setUnits II.4.10  
changeUnits II.4.10  
Iterators
each_ply II.4.12 IV.5.5
NDF lines
initWithNeutralLines II.4.11  
getNeutralLines II.4.11  
Attributes
Id 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 ``new'' is used to create ClaLam objects. This method has no argument.


II.4.3 Identifying a laminate

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


II.4.4 Manipulation of plies

The ``clearPlies'' 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 ``addPly'' 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 ``addPly'' method. Of course each call of the method ``addPly'' increases the number of plies of the laminate by one.

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

As the ``PlyId'' second argument is optional, the method has 5 or 6 arguments. The ``setPly'' 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 ``setPly'' method, but then the number of plies must first be set... ``setNbrPlies'' 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 initalization of the data.


II.4.6 Laminate properties

The method ``calcLaminateProperties'' 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 ``calcLaminateProperties'' 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 ``calcResponse'' 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 ``calcResponse'' 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 ``calcResponse'' 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 ``calcResponse'':

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:

``getDerived'' and ``getFailureIndices'' have the same parameters: So for example, ``getFailureIndices'' method may be called as follows:
    criteria=["TsaiHill2D","MaxStress2D"]
    ...
    fiRes=getFailureIndices(criteria)
    ...
    fiRes=getFailureIndices(db,criteria)
    ...
    fiRes=getFailureIndices(db,criteria,[4,"Sup"],[7,"Inf"])
Note that several criteria can be calculated by a single call. The method ``getReserveFactors'' has 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
    criteria=["TsaiHill2D","MaxStress2D"]
    ...
    rfRes=getReserveFactors(db,criteria,1.25,[4,"Sup"],[7,"Inf"])
Each of the three 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 three methods ``getDerived'', ``getFailureIndices'' and ``getReserveFactors'' have ``Min'' and ``Max'' variants. This makes six additional methods: ``getMinDerived'', ``getMinFailureIndices'', ``getMinReserveFactors'', ``getMaxDerived'', ``getMaxFailureIndices'' and ``getMaxReserveFactors''. 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.1.


II.4.8 Laminate finite element load response

The ``calcFiniteElementResponse'' 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 eight 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 ``calcResponse'' 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. This parameter is used by the method only for the calculation of reserve factors. (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 ``calcFiniteElementResponse'' method.
    2. A String corresponding to the name of the criterion. This name must one of the names defined in Table II.1.1.
    3. A string defining the type of Result that shall be defined. Values can be ``FI'', ``RF'', ``EQ''. They correspond to the calculation of failure indices, reserve factors or Scalar Derived values respectively. If a reserve factor 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.
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.

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]
   theta=0.0
   
   outputs=lam.calcFiniteElementResponse(compDb,theta,ld,[true,true,true],
      ["Shell Forces","Shell Moments", "Shell Curvatures",
       "Average Strain Tensor"],
      ["Stress Tensor","Strain Tensor","Mechanical Strain Tensor",
       "Ply Temperature Variation"],
      1.5,criteria)


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 ``calcFiniteElementCriteria'' 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 ``Hash'' arguments or return values mentioned above have String keys and values as explained in section II.1.12. The difference between the ``setUnits'' and ``changeUnits'' 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 ``initWithNeutralLines'' and ``getNeutralLines'' that work in a similar way as the corresponding methods in ``ClaDb'' class (section II.2.6).

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


II.4.12 One iterator

The ClaLam class provides the iterator ``each_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 ``getPlyData'' method.


II.4.13 Other methods

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


II.5 The ``ClaLoad'' class

The ``ClaLoad'' class is used to define, store and manipulate loadings to be applied to laminates. A loading is characterized by:

A list of the methods defined in ``ClaLoad'' class is given in Table II.5.1.

Table II.5.1: The different methods that have been defined in ``ClaLoad'' class. CLA.ClaLoad.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
Method Name Description Example
     
Creation and initialization methods
new II.5.1 IV.5.4.4
initialize II.5.1  
clone II.5.9  
Manipulation of data defining ClaLoad object
setT II.5.3 IV.5.4.4
getTinf II.5.3  
getTsup II.5.3  
isTdefined II.5.3  
unsetT II.5.3  
setH II.5.3  
getHinf II.5.3  
getHsup II.5.3  
isHdefined II.5.3  
unsetH II.5.3  
setMembrane II.5.4 IV.5.4.4
setFlexural II.5.4 IV.5.4.4
setOutOfPlane II.5.4  
getMembrane II.5.4  
getFlexural II.5.4  
getOutOfPlane II.5.4  
setToCombili II.5.5  
setShellForces II.5.6 IV.5.6
getShellForcesCopy II.5.6  
clearShellForces II.5.6  
setShellMoments II.5.6 IV.5.6
getShellMomentsCopy II.5.6  
clearShellMoments II.5.6  
setShellStrains II.5.6 IV.5.6
getShellStrainsCopy II.5.6  
clearShellStrains II.5.6  
setShellCurvatures II.5.6 IV.5.6
getShellCurvaturesCopy II.5.6  
clearShellCurvatures II.5.6  
setShellTemperatures II.5.6  
getShellTemperaturesCopy II.5.6  
clearShellTemperatures II.5.6  
setShellMoistures II.5.6  
getShellMoisturesCopy II.5.6  
clearShellMoistures II.5.6  
Management of units methods
getUnits II.5.7  
setUnits II.5.7  
changeUnits II.5.7  
NDF lines
initWithNeutralLines II.5.8  
getNeutralLines II.5.8  
Attributes
Id II.5.2  
     


II.5.1 Creation of an object

The singleton method ``new'' is used to create ClaLoad objects. This method has no argument. (Nor has the ``initialize'' method an argument.)


II.5.2 Identifying a ClaLoad

Two methods allow the manipulation of the identifier of ClaLoad objects (``Id'' attribute):


II.5.3 Thermo-elastic and hygro-elastic contributions

Ten methods allow the manipulation of scalar characteristics of the loadings. (The scalar characteristics are the thermo-elastic and hygro-elastic contributions to loading.) The methods are:

Obviously, the different data inserted in, or retrieved from the ClaLoad 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.5.4 Setting and getting mechanical parts

Three methods are used to set the mechanical part of loading stored in the ClaLoad object:

Each of the three ``set'' methods described above has a corresponding ``get'' method: Each of these three ``get'' methods returns an Array containing the arguments of the respective ``set'' methods. The first element of this Array is an Array of 3 or 2 Real values. Then follow 3 or 2 Strings corresponding to the types of solicitation of each component.

Obviously, the different data inserted in, or retrieved from the ClaLoad 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.5.5 Linear combinations of loads

``setToCombili'' method allows to define a ClaLoad as a linear combination of pre-defined ClaLoads. This method has four arguments:

  1. A reference temperature. This Real parameter is necessary because the top and bottom temperatures of the combined ClaLoad are calculated as follows:

    $\displaystyle T_{\text{tot}}=T_{\text{ref}}
+\sum_{i=1}^N f_i\cdot\left(T_i-T_{\text{ref}}\right)\ .
$

  2. A reference moisture. (Same remarks as for the reference temperature.)
  3. An Array of Reals corresponding to the coefficients of the linear combination.
  4. An Array of ClaLoad objects.
The sizes of the two Array arguments must match. Also the types of the different components of mechanical part of the loadings must be the same.


II.5.6 Finite element Results

Eighteen methods are devoted to the manipulation of loading components defined as finite element Results. Six member data correspond to these methods: ``Shell Forces'', ``Shell Moments'', ``Shell Strains'', ``Shell Curvatures'', ``Shell Temperatures'' and ``Shell Moistures''.

The mechanical components of loading correspond to non-layered Results. ``Shell Temperatures'' and ``Shell Moistures'' are defined at Shell lower and upper surfaces (layers ``Z1'' and ``Z2'' respectively). When calculating laminate load response, FeResPost does not check or considers the coordinate system to which mechanical loading components are associated. This means that all the components are assumed to be given in loading axes. It is the responsibility of the user to first transform the components in such a way that their use by FeResPost makes sense.

Three methods allow the manipulation of Shell Forces stored in the ClaLoad object:

  1. ``setShellForces'' inserts a copy of the Result argument inside the ClaLoad object.
  2. ``getShellForcesCopy'' has no argument and returns a copy of the ``Shell Forces'' Result stored in the ClaLoad object. The method returns ``Nil'' if the ``Shell Forces'' are not initialized.
  3. ``clearShellForces'' erases the ``Shell Forces'' Result stored in the ClaLoad object.
For the other Results, the manipulation methods are build similarly. The other methods are: Obviously, the different data inserted in, or retrieved from the ClaMat 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.5.7 Management of Units

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

The ``Hash'' arguments or return values mentioned above have String keys and values as explained in section II.1.12. The difference between the ``setUnits'' and ``changeUnits'' methods is also explained in the same section.


II.5.8 Saving or initializing with NDF lines

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

However, the lines transmitted to ``initWithNeutralLines'' or returned by ``getNeutralLines'' correspond to a single ClaLoad object definition.


II.5.9 Other methods

``clone'' method has no argument and returns a copy of the ClaLoad object.


III. Solver Preferences

III.0 Introduction

In this Part of the document, one describes the preferences for the different solvers supported by FeResPost. Most preferences are defined as methods and member data of the classes specializing the ``DataBase'' class defined Chapter I.1. Presently two solvers are supported: Nastran and Samcef. The corresponding classes specializing ``DataBase'' class are ``NastranDb'' and ``SamcefDb'' classes. The corresponding preferences are described in Chapters III.1 and III.2 respectively. The diagram of Figure I.1.1 representing the ``DataBase'' hierarchy can be more precisely represented as in Figure 1.

Figure 1: Finite element DataBase classes hierarchy.
\begin{figure}\centerline{%
\input{solvers/intro/XFIG/DbTree.pstex_t}}
\end{figure}


III.1 Nastran Preferences

Most methods peculiar to the post-processing of Nastran finite element Results and models are defined in class ``NastranDb'' that inherits the ``DataBase'' class. This class is described in section III.1.1. A list of the methods defined in ``NastranDb'' class is given in Table III.1.1.

Table III.1.1: The different methods that have been defined in ``NastranDb'' class. See also the methods defined in generic DataBase class (Table I.1.1). userManual.Nastran.DB.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
(See also methods in userManual.DataBase.methods.tabgeneric DataBase class.)
Method Name Description Example
     
Creation and initialization methods
new III.1.1 IV.2.2.1
initialize III.1.1  
Reading model or Results
readBdf III.1.1.1 IV.2.2.1
readOp2 III.1.1.2, III.1.1.6 IV.2.4.1
getXdbLcNames III.1.1.7  
getXdbScNames III.1.1.7  
getXdbResNames III.1.1.7  
getXdbLcScNames III.1.1.7  
getXdbLcScResNames III.1.1.7 IV.2.4.5
getXdbLcInfos III.1.1.7 IV.2.4.5
readXdb III.1.1.7 IV.2.4.5
attachXdb III.1.1.8  
detachXdb III.1.1.8  
removeAllAttachments III.1.1.8  
getNbrAttachments III.1.1.8  
getAttachmentNames III.1.1.8  
checkAttachmentExists III.1.1.8  
getAttachmentLcInfos III.1.1.8  
getAttachmentNbrLoadCases III.1.1.8  
getAttachmentLcNames III.1.1.8  
getAttachmentLcScNames III.1.1.8  
getAttachmentLcScResNames III.1.1.8  
getAttachmentNbrSubCases III.1.1.8  
getAttachmentScNames III.1.1.8  
getAttachmentNbrResults III.1.1.8  
getAttachmentResIds III.1.1.8  
getAttachmentResNames III.1.1.8  
getAttachmentResults III.1.1.8  
getAttachmentResultsCombili III.1.1.8  
getAttachmentDesVarHistory III.1.1.8  
getAttachmentConstrDefinitions III.1.1.8  
getAttachmentConstrHistory III.1.1.8  
getAttachmentObjectiveHistory III.1.1.8  
getAttachmentDesRespHistory III.1.1.8  
setStorageBufferMaxCapacity III.1.1.8  
getStorageBufferMaxCapacity III.1.1.8  
enableBulkCards III.1.1.6  
disableBulkCards III.1.1.6  
enableNastResElems III.1.1.6  
disableNastResElems III.1.1.6  
Coordinate system methods
getCoordSysCopy III.1.1.4  
addCoordSys III.1.1.4  
makeAllCoordSysWrt0 III.1.1.4  
Group manipulation methods
getNodesAssociatedToElements III.1.1.5 IV.2.5.3
getNodesAssociatedToRbes III.1.1.5  
getElementsAssociatedToNodes III.1.1.5 IV.2.5.3
getRbesAssociatedToNodes III.1.1.5  
getElementsAssociatedToMaterials III.1.1.5  
getElementsAssociatedToPlies III.1.1.5  
getElementsAssociatedToProperties III.1.1.5  
Iterators
each_coordSysId III.1.1.10  
each_elemId III.1.1.10 IV.2.3
each_nodeId III.1.1.10  
each_rbeId III.1.1.10  
each_materialId III.1.1.10  
each_propertyId III.1.1.10  
each_nodeOfElement III.1.1.10 IV.2.3
each_cornerNodeOfElement III.1.1.10  
Write methods
writeBdfLines III.1.1.3  
writeNastranCard III.1.1.3 IV.2.5.1
writeNastranCards III.1.1.3 IV.2.5.1
Other methods
getNbrRbes III.1.1.11  
getElementPropertyId III.1.1.11  
getNodeRcId III.1.1.11  
getNodeAcId III.1.1.11  
getNodeCoords III.1.1.11  
     


III.1.1 ``NastranDb'' class

A ``NastranDb'' object can be created by a statement like:

    db=NastranDb.new()
Method ``initialize'' initializes or clears a NastranDb object. This class is a specialization of the FeResPost ``DataBase'' class.

The model can be defined by reading a bulk Data File, or an op2 file. (See the corresponding methods below.)


III.1.1.1 Reading a BDF

The finite element model can be imported from a Nastran Bulk Data File with method ``readBdf''. The method has up to five arguments.

  1. A String containing the name of the main Nastran Bulk Data File.
  2. An Array of Strings containing the list of directories in which files specified by ``include'' statements shall be searched. Its default value is a void Array.
  3. The name of an extension that may be added to the file names specified in include statements. Its default value is a void String. (This argument corresponds to the jidtype in Nastran.)
  4. A Hash with String keys and values corresponding to the list of ``symbols'' that can be used in ``include'' statements in the Bulk Data Files. The default value is a void Hash.
  5. A Logical that specifies verbosity for the reading of the Nastran Bulk Data File. Its default value is ``false''. This parameter is redundant with ``setVerbosityLevel'' of ``Post'' Module: to set the parameter to ``true'' is equivalent to set ``Post'' verbosity level to 1.
Only the first argument of the method is mandatory. More information about the method is given in section III.1.1.1. Examples of valid ``readBdf'' statements follow:
    db.readBdf("../../MODEL/MAINS/unit_xyz.bdf",
                  [],"",{},true)
    db.readBdf("Z:/RD/ALCAS/TESTSAT/MODEL/MAINS/unit_xyz.bdf",
                  [],"",{},true)
    db.readBdf("//CALC01/TESTSAT/MODEL/MAINS/unit_xyz.bdf",
                  [],"",{},true)
The format of Nastran cards defined in a bulk data file is described in [Sof04b]. The user must take the following limitations of the interface into account: At the end of reading, the method issues an information message with a list of cards that have been skipped.

The correct working of method ``readBdf'' has not been tested for many of the Nastran cards listed above. So, bugs are likely to occur when testing FeResPost for new finite element models. In order to reduce the severity of such bugs, Four singleton methods defined in NastranDb class to disable or (re-)enable some of the Nastran Cards. See section III.1.1.6 for the use of that method. Note that the disabling of Nastran cards also influences the ``readOp2'' method when model entities are read.


III.1.1.2 ``OP2'' methods for reading a FEM

It is also possible to read a finite element model from an ``op2'' file with ``readOp2'' method. The model stored in the file is imported into the NastranDb if the second string argument of the method is ``Model'' or ``Model/Results''. The first String argument is the name of the ``op2'' file.

The format of these files is described in [Rey04]. One describes in section III.1.1.2 the reading of finite element entities, and in section III.1.1.6 the reading of Results. Note that only the reading of 32bits ``op2'' files is possible. There is no support for 64bits output files.

Note that the reading of ``op2'' files also checks the endianness of the file and, if needed, does corrections to the binary data. For example, it can switch the reading from little endians to big endians or reversely. This allows ``op2'' files produced on a machine to be read on another machine with different ``endianness'' so that the portability of results is improved.

Finite element entities are read into the NastranDb with method ``readOp2'' if one specifies ``Model'' or ``Model/Results'' for the entities to read. The finite element entities recognized by the method corresponding to the Nastran cards supported by the ``readBdf'' method (see section III.1.1.1). The corresponding Data Blocks in the ``op2'' file are ``GEOM1'', ``GEOM2'', ``GEOM3'', ``GEOM4'', ``EPT'' and ``MPT'' (see [Rey04]).

Note that one generally prefers to read FE entities from a Bulk Data File than from an ``op2'' file because the data stored are sometimes ambiguous in the ``op2'' file (orientation of material properties on 2D elements,...). However, the reading of op2 files is faster than the reading of BDF files.

The correct working of method ``readOp2'' has not been tested for many of the Nastran cards listed above. So, bugs are likely to occur when testing FeResPost for new finite element models. In order to reduce the gravity of such bugs, The NastranDb class allows to disable or enable some of the Nastran Cards. See section III.1.1.6 for the use of the corresponding singleton methods. Note that the disabling of Nastran cards also influences the ``readBdf'' method.


III.1.1.3 Writing Bulk lines

Method ``writeBdfLines'' is used to output the model or part of the model into a text file with a format compatible with Nastran BDF cards. The method has 5 or 6 arguments :

  1. A string containing the name of the file to which the Nastran cards are printed.
  2. A string corresponding to the opening mode for the file. Valid values are ``w'' and ``w+'' (for append mode).
  3. A first format String argument specifying whether the fields in the cards output are left or right aligned. This argument may have three values: ``left'', ``right'' or a void String. If the String is void, the format defaults to ``left''.
  4. A second format String argument specifying whether the fields in the cards output are narrow or wide. This argument may have three values: ``short'', ``wide'' or a void String. If the String is void, the format defaults to ``short''.
  5. A third String argument corresponding to the type of entities that must be printed. The method scans the String argument and searches sub-strings that specify whether an entity type is to be printed or not. The sub-strings that are searched are ``All'', ``CoordSys'', ``Nodes'', ``Elements'', ``RBEs'', ``MPCs'', ``Properties'', ``Materials''.
  6. The last argument is optional and corresponds to the Group for which cards are to be printed. It can be a String or a Group argument. If its type is String, then the corresponding Group defined in the DataBase is considered. Note that ``Properties'' and ``Materials'' are not printed if the Group argument is provided.
The ``writeBdfLines'' method must be used for debugging purposes only. The user must keep in mind that some entities are not totally supported and their output may be problematic.

One singleton method may be used to output formatted Nastran Cards. This method can be used, for example, to produce Nastran cards for inclusion in a Bulk Data File. The method name is ``writeNastranCard'' and has six arguments:

  1. A String containing the name of the file to which the Nastran card is printed.
  2. A String corresponding to the opening mode for the output file. Valid values are ``w'' and ``w+'' (for append mode).
  3. A first format String argument specifying whether the fields in the card output are left or right aligned. This argument may have three values: ``left'', ``right'' or a void String. If the String is void, the format defaults to ``left''.
  4. A second format String argument specifying whether the fields in the card output are narrow or wide. This argument may have three values: ``short'', ``wide'' or a void String. If the String is void, the format defaults to ``short''.
  5. A String corresponding to the name of the output card. This name cannot have more than 8 characters and should correspond to a valid Nastran BDF card name.
  6. An Array containing the fields to be printed. Possible types for the elements of this Array are Real, Integer and String.
Another singleton method called ``writeNastranCards'' allows to output several Nastran cards. This method has the same arguments as ``writeNastranCard'' except that the last argument is an Array of Arrays, each element of the ``big'' Array corresponding to one Nastran card.


III.1.1.4 ``CoordSys'' methods

The ``CoordSys'' class allows the manipulation of coordinate systems for post-processing purpose. This class is presented in Chapter I.2. One presents below the methods of NastranDb class devoted to the manipulation of coordinate systems.

III.1.1.4.1 ``getCoordSysCopy''

The ``getCoordSysCopy'' method returns a CoordSys object which is a copy of a coordinate system stored in the DataBase. The method has one integer argument which is the index of the coordinate system.

Note that the CoordSys returned by the method may be a ``generic'' CoordSys as presented in Chapter I.2, or a Nastran coordinate system.

III.1.1.4.2 ``addCoordSys''

The ``addCoordSys'' method is used to add a coordinate system to the DataBase. The argument of the method is the CoordSys object. In the DataBase, the object is referenced by its index.

If a coordinate system with the same index already exists in the NastranDb, it is replaced by the new coordinate system. In that case, the user is responsible for all the modifications involved in the finite element model by the possible modification of the NastranDB coordinate system. Therefore, it is considered as a good practice not to modify a coordinate involved in the finite element model definition.

Note that the coordinate system index must be a strictly positive integer. Also, the CoordSys inserted by the method may be a ``generic'' CoordSys as presented in Chapter I.2, or a Nastran coordinate system.

III.1.1.4.3 ``makeAllCoordSysWrt0''

This method updates the definition wrt 0 (most basic coordinate system) of all the coordinate systems stored in a NastranDB. This operation is necessary when a coordinate system of the NastranDB has been modified, because the definitions of other coordinate systems wrt 0 may be affected.


III.1.1.5 Construction of Groups by associations

The list of ``NastranDb'' methods returning Groups defined by association follows:


III.1.1.6 ``OP2'' methods for reading Results

Several methods allow the reading of results from an ``op2'' file or to tune the behavior of reading this file. These methods are described below. Note that only the reading of 32bits ``op2'' files is possible. There is no support for 64bits output files.

Presently, only some of the result data blocks of the file can be read: The correspondence between the Nastran output requests and the DMAP data blocks written in the ``op2'' file is given in Tables III.1.3 to III.1.9. Also one gives in the Tables the type names of Results generated in the NastranDb by ``readOp2'' method. The solution sequences for which Results can be read from an ``op2'' are:


III.1.1.7 ``XDB'' methods for reading Results into DataBase

Several methods allow the reading of Result entities or characteristics stored in an xdb file. Real Results as well as Complex ones can be read from xdb files. This last format of Results can for example be read from a Nastran ``xdb'' result file corresponding to a SOL107, SOL108 or SOL111.

The reading of 64bits XDB files, as well as 32bits XDB files is possible. Note however that the results that are read are stored in 32bits integer/real values so that there is no advantage in using 64bits XDB files with FeResPost. (Actually, it probably slows down the XDB access.)

III.1.1.7.1 ``getdXdbLcNames'' method

``getdXdbLcNames'' returns an Array of String containing the list of load cases to which Results found in an xdb file correspond. The arguments are:

  1. A String specifying the access path to the xdb file.
  2. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
The second argument is optional.

III.1.1.7.2 ``getdXdbScNames'' method

``getdXdbScNames'' returns an Array of String containing the list of sub-cases to which Results found in an xdb file correspond. The arguments are:

  1. A String specifying the access path to the xdb file.
  2. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
The second argument is optional.

III.1.1.7.3 ``getdXdbResNames'' method

``getdXdbResNames'' returns an Array of String containing the Result type names to which Results found in an xdb file correspond. The arguments are:

  1. A String specifying the access path to the xdb file.
  2. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
The second argument is optional.

III.1.1.7.4 ``getdXdbLcScNames'' method

``getdXdbLcScNames'' returns an Array of two elements containing:

  1. An Array of Strings containing the list of load cases to which Results found in the xdb file correspond.
  2. An Array of Strings containing the list of sub-cases to which Results found in the xdb file correspond.
The arguments are:
  1. A String specifying the access path to the xdb file.
  2. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
The second argument is optional.

III.1.1.7.5 ``getdXdbLcScResNames'' method

``getdXdbLcScResNames'' returns an Array of three elements containing:

  1. An Array of Strings containing the list of load cases to which Results found in the xdb file correspond.
  2. An Array of Strings containing the list of sub-cases to which Results found in the xdb file correspond.
  3. An Array of Strings containing the list of Result types to which Results found in the xdb file correspond.
The arguments are:
  1. A String specifying the access path to the xdb file.
  2. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
The second argument is optional.


III.1.1.7.6 ``getdXdbLcInfos'' method

``getXdbLcInfos'' returns information about the load cases and sub-cases for which Results are stored in a xdb file. The arguments are:

  1. A String specifying the access path to the xdb file.
  2. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
The second argument is optional.

The method returns an Array of Arrays. Each element of the Array contains the information for one load case and sub-case identification:

III.1.1.7.7 ``readXdb'' method

The ``readXdb'' method is used to read Results into the DataBase from an ``xdb'' file generated by Nastran. (Only Results can be read from a Nastran ``xdb'' file.) The method has up to four arguments:

  1. A String argument that corresponds to the name of the file from which Results are read.
  2. A String or an Array of Strings corresponding to the names of load cases for which Results are imported into the DataBase. If the Array is void or the parameter is omitted, all load cases in xdb result files are considered when results are read.
  3. A String or an Array of Strings corresponding to the names of subcases for which Results are imported into the DataBase. If the Array is void or the parameter is omitted, all sub-cases in xdb result files are considered when results are read.
  4. A String or an Array of Strings corresponding to the identifiers of Results for which Results are imported into the DataBase. If the Array is void or the parameter is omitted, all Results of xdb result files are considered when results are read.
  5. A Boolean value specifying whether one forces the swap of endianness when reading the XDB file.
All parameters, except the first one, can be omitted. Then the method assumes that a void Array has been passed as argument.

Presently the support of ``xdb'' Results reading is more limited than the corresponding support for ``op2'' reading. Results that can be read are:

Composite failure indices do not seem to be output in the xdb file. Only a few elements are supported. However, the most important ones are read: The different characteristics of imported Results correspond to the characteristics of corresponding Results read from ``op2'' files.

Note however, that Complex Results can also be read from xdb files. Generally, the complex Results are the same as the real Results. More information can be found in section IX.C.2.

Four methods devoted to the enabling or disabling composite layered Results are defined in the generic ``DataBase'' class. These methods are presented in section I.1.3.2.


III.1.1.7.8 A note on ``endianness''

The different methods devoted to XDB files access allow to specify a force on swap endianness. When the corresponding parameter is set to ``TRUE'', FeResPost considers that the endianness of binary XDB file does not correspond to the endianness of the machine on which FeResPost executes. Then, a swap of endianness is performed when the binary file is read.

If the ``SwapEndianness'' parameter is set to false, no modification of endianness is done when the file is read.

If the ``SwapEndianness'' parameter is not given, FeResPost checks the endiannes of the file and, if needed, does corrections to the binary data that are read. The test is the following: FeResPost reads the first word of the XDB binary file. This word is the size of the blocks in the XDB file. (1024 by default, but this size can be modified by the RECL parameter in ASSIGN Nastran statement and set to a maximum value of 65536.) A check on the value allows to determine whether the endiannes of the file corresponds to the endianness of the machine on which FeResPost is run. The check works if the size is smaller than 65536. If the size of blocks is 65536, the check fails and the ``SwapEndianness'' parameter must be specified in the calls to methods accessing XDB files.


III.1.1.8 Attaching ``XDB'' files to a Nastran DataBase

Since version 3.4.0, FeResPost allows a random access to XDB result files. This method is more efficient than the methods that import XDB Results into the DataBase, and extracting copies of these Results. A peculiar case in which the random access methods will be more efficient is when only some small parts of the XDB file are of interest to the programmer.

The principle of random access is the same as the attachment of XDB files to a Patran DataBase:

The different methods called to perform these operations are described in the following sub-sections. These methods correspond more or less to the methods described in section III.1.1.7.

III.1.1.8.1 Managing XDB file attachments

The method ``attachXdb'' is used to attach an XDB file to the Nastran DataBase. This method has up to two arguments:

  1. The first argument is a String containing the name of the XDB file. (Full path name must be provided.)
  2. The second argument is an optional Boolean parameter specifying whether the endianness must be swapped when XDB file content is read. If the parameter is not given, the endianness of the file is automatically detected. Note however that this check might fail. (See also page [*] for more information.)

Several other methods are used to manage the Xdb attachments to a DataBase:

III.1.1.8.2 Extracting information of XDB file attachments

The following methods extract information related to the Results stored in an XDB file attached to the DataBase:

All these methods have a single String argument containing the name of the XDB file that must have been previously attached to the DataBase. On the other hand, the following methods have one or two arguments: The first argument is the name of the XDB file that must have been previously attached to the DataBase. The second argument is optional and corresponds to the name of a load case found in the attached XDB file. If the argument is not provided, all the load cases are investigated to build the list of sub-cases or Result names or IDs. If the argument is provided, only the sub-cases or Results of the corresponding load case are considered. If the provided load case does not exist in XDB attachment an error message is issued.

III.1.1.8.3 Extracting Results From XDB file attachments

The method ``getAttachmentResults'' is used to read Results from the XDB file. The Results are directly returned by the method to the caller in a Hash object. They are not inserted in the DataBase from which the method is called.

The method has minimum four arguments:

  1. A String corresponding to the name of XDB file attachment from which Results are read. (This file must have been previously attached to the DataBase.)
  2. A String corresponding to the name of the load case for which Results are read.
  3. A String or an Array of Strings corresponding to the names of sub-cases for which Results are read.
  4. A String or an Array of Strings corresponding to the names of Results for which Results are read.
The other arguments are optional and correspond to the specification of target entities for which Results are read. Actually, the reading operation from an XDB combines the reading and some of the extraction operations described in section I.4.2. For example: If only four parameters are provided in the call to ``getAttachmentResults'' method, all the pairs of key-values found in the XDB file are inserted in the list of returned Results.

Only lists below the list of valid calls to ``getAttachmentResults'':

        h=db.getAttachmentResults(xdbName,lcName,scNames,resNames,
                method,grpTarget[,layers[,subLayers]])
        h=db.getAttachmentResults(xdbName,lcName,scNames,resNames,
                resTarget)
        h=db.getAttachmentResults(xdbName,lcName,scNames,resNames,
                rklTarget)
        h=db.getAttachmentResults(xdbName,lcName,scNames,resNames
                [,layers[,subLayers]])
When Results are extracted from an XDB attachment on a Group, the ``Method'' argument may influence the efficiency of Results extraction. When possible, a real random access is performed, otherwise, entire tables must be read to ensure that all eligible Result values are loaded. For example: It is the responsibility of the post-processing programmer to try to provide the arguments in order to select the most efficient algorithm for Results extraction.

Note that ``Grid Point Forces'' are always sorted by nodes. This is true for the applied loads, the MPC/SPC forces and moments, as well as for the internal forces and moments. (Even though these last contain forces by elements and nodes.) This mean that for the selection of extraction algorithm, ``Grid Point Forces'' should always be considered as nodal Results.

As several Result types, and sub-case names can be given as argument to ``getAttachmentResults'' method, this method can return several Results. This is why Results are returned in a Hash:

For example, the list of extracted Result sizes can be printed with the following statements:
    h=db.getAttachmentResults(xdbFileName,lcName,scNames,resNames,"Nodes",grp)
    h.each do |id,res|
        lcName=id[0]
        scName=id[1]
        resName=id[2]
        size=res.Size
        STDOUT.printf("%s - %s - %s : %d\n",lcName,scName,resName,size)
        #~ Util::printRes(STDOUT,"brol",res)
    end

The method ``getAttachmentResultsCombili'' is used to extract linear combinations of elementary Results found in one or several XDB files. As for method ``getAttachmentResults'' the Results are directly returned by the method to the caller. They are not inserted in the DataBase from which the method is called. This method is more or less a combination of the methods ``getAttachmentResults'' and ``buildLoadCasesCombili'' of the generic DataBase class.

Practically, the main difference between ``getAttachmentResults'' and ``getAttachmentResultsCombili'' is that the first argument is no longer an Xdb file name. This argument is removed. Instead, one provides a ``Combili'' argument that describes the linear combination corresponding to extracted Results. This ``Combili'' argument is the second argument. The first argument is the ``LcName'' argument corresponding to the load case name attributed to the generated Results. This load case name is not supposed to correspond to any load case name found in the attached XDB file(s).

The method has minimum four arguments:

  1. A String corresponding to the name of the load case for which Results are read.
  2. A ``Combili'' Array containing the description of the linear combination of elementary load case Results. The Array is an Array of Arrays. Each secondary Array contains three elements:
  3. A String or an Array of Strings corresponding to the names of sub-cases for which Results are read.
  4. A String or an Array of Strings corresponding to the names of Results for which Results are read.
The other arguments are optional and correspond to the specification of target entities for which Results are read. Actually, the reading operation from an XDB combines the reading and some of the extraction operations described in section I.4.2. For example: If only four parameters are provided in the call to ``getAttachmentResultsCombili'' method, all the pairs of key-values found in the XDB file are inserted in the returned Results.

Only lists below the list of valid calls to ``getAttachmentResultsCombili'':

        h=db.getAttachmentResultsCombili(lcName,combili,scNames,resNames,
                method,grpTarget[,layers[,subLayers]])
        h=db.getAttachmentResultsCombili(lcName,combili,scNames,resNames,
                resTarget)
        h=db.getAttachmentResultsCombili(lcName,combili,scNames,resNames,
                rklTarget)
        h=db.getAttachmentResultsCombili(lcName,combili,scNames,resNames
                [,layers[,subLayers]])
The Hash object returned by the method has a structure identical to the one returned by ``getAttachmentResults'' and can be manipulated the same way.

III.1.1.8.4 Getting optimization data from XDB

It is possible to obtain some of the Nastran optimization (SOL200) results from an XDB attachment. Four methods have been defined in NastranDb class:

  1. ``getAttachmentDesVarHistory'' returns the history of design variables and has three parameters: Parameters 2 and 3 are optional and can be omitted or replaced by a ``nil'' argument. If they are not defined, all the steps or design variables are returned in the results. The method returns a N X 3 array. For each line, the three colunns correspond to:

  2. ``getAttachmentConstrDefinitions'' returns the definition of constraints and has two arguments: Parameters 2 is optional and can be omitted or replaced by a ``nil'' argument. The method returns a N X 6 array. For each line, the three columns correspond to:

  3. ``getAttachmentConstrHistory'' returns the history of constrains and has three parameters: Parameters 2 and 3 are optional and can be omitted or replaced by a ``nil'' argument. If they are not defined, all the steps or design responses are returned in the results. The method returns a N X 3 array. For each line, the three columns correspond to:

  4. ``getAttachmentObjectiveHistory'' returns the history of constrains and has two parameters: Parameter 2 is optional and can be omitted or replaced by a ``nil'' argument. If it is not defined, all the steps are returned in the results. The method returns a N X 3 array. For each line, the three columns correspond to:

  5. ``getAttachmentDesRespHistory'' returns the history of design responses and has three parameters: Parameters 2 and 3 are optional and can be omitted or replaced by a ``nil'' argument. If they are not defined, all the steps or design variables are returned in the results. The method returns a N X 3 array. For each line, the three columns correspond to:

So far, the reading of optimization results is experimental and might be changed in future version.

III.1.1.8.5 Storage buffers for XDB result files random access

In order to reduce the number of accesses to disk, it may be useful to store some of the blocks read from binary result files into memory. FeResPost provides an algorithm that allows to store the blocks most recently read for later usage. Two singleton methods of the ``NastranDb'' class allow the to tune the capacity of the buffer area:

Note that all buffers are now common to all the methods that provide random access to XDB result files. In particular, the method is used in management of the binary file access for XDB attachment or reading. This means that if one Result file attached to one DataBase is more used, the storage will contain a majority of buffers for this Result file and progressively delete the other buffers.

The default capacity for storage buffer is 0Mb. Note that the two methods described above can be called from any class derived from the generic ``DataBase'' class.


III.1.1.9 GMSH outputs

The method ``writeGmshMesh'' defined in DataBase Class exports nodes, elements and RBEs into the mesh file. RBEs are exported with a negative integer ID. The three tags attributed to the elements are the property ID (twice) and the laminate ID. This means that the three tags have sometimes the same value.


III.1.1.10 Iterators

A first group of iterators iterate on finite element entities of the finite element model stored in the DataBase.

The elements produced by the iterator are single integers. Each of these iterators has 0, 1 or 2 arguments. The two optional arguments are the integer bounds considered for the iteration: ``IdMin'' and ``IdMax''.

Two iterators loop on the nodes defining an element:

These two iterators have one integer argument corresponding to the index of the element. The return the integer indices of nodes.


III.1.1.11 Other methods

Several other methods allow to obtain model information.


III.1.2 Nastran Result characteristics

When a Result object is read from an ``op2'' or an ``xdb'' file, integer and/or real identifiers are associated to the object. These identifiers depend on the solution sequence to which the Results correspond:

The ``load case name'' identifier associated to read or accessed results correspond to the ``SUBTITLE'' associated to the SUBCASE defined in Nastran data file. If this SUBTITLE is not define, the SUBCASE ID is used to generate a default load case identifier as follows:
    lcName="Load Case "+ID
Finally, the results found in the op2 file are presented by blocks corresponding to the different ``result element types''. Unfortunately, those element types do not correspond exactly to the element bdf cards presented in section III.1.1.1. The supported result element types are: ``ROD'', ``BEAM'', ``TUBE'', ``SHEAR'', ``CONROD'', ``ELAS1'', ``ELAS2'', ``ELAS3'', ``ELAS4'', ``DAMP1'', ``DAMP2'', ``DAMP3'', ``DAMP4'', ``VISC'', ``MASS1'', ``MASS2'', ``MASS3'', ``MASS4'', ``CONM1'', ``CONM2'', ``PLOTEL'', ``QUAD4'', ``BAR'', ``GAP'', ``TETRA'', ``BUSH1D'', ``QUAD8'', ``HEXA'', ``PENTA'', ``BEND'', ``TRIAR'', ``TRIA3'', ``TRIA6'', ``QUADR'', ``TETRANL'', ``GAPNL'', ``TUBENL'', ``TRIA3NL'', ``RODNL'', ``QUAD4NL'', ``PENTANL'', ``CONRODNL'', ``HEXANL'', ``BEAMNL'', ``QUAD4LC'', ``QUAD8LC'', ``TRIA3LC'', ``TRIA6LC'', ``BUSH'', ``FAST'', ``QUAD144'', ``QUADRNL'', ``TRIARNL'', ``ELAS1NL'', ``ELAS3NL'', ``BUSHNL'', ``QUADRLC'' and ``TRIARLC''. (More information on the result element types can be found in [Rey04].)

Here again, some of the element result types can be disabled or enabled (section III.1.1.1). The arguments given to the enabling or disabling methods correspond to a String object, or an Array of Strings, the values of Strings corresponding to some of the Result element types given just above.

The negative node values corresponding to Results on specific Nastran elements are summarized in Table III.1.2. (This Table is a complement to Table I.4.2.)


Table III.1.2: Correspondence between special nodes for element Results and their integer ids (peculiar to Nastran solver).
For Nastran CSHEAR element
"F4to1" -201
"F2to1" -202
"F1to2" -203
"F3to2" -204
"F2to3" -205
"F4to3" -206
"F3to4" -207
"F1to4" -208
"kickOn1" -211
"kickOn2" -212
"kickOn3" -213
"kickOn4" -214
"shear12" -221
"shear23" -222
"shear34" -223
"shear41" -224
For Nastran CBEAM element
"CbeamSt1" -101
"CbeamSt2" -102
"CbeamSt3" -103
"CbeamSt4" -104
"CbeamSt5" -105
"CbeamSt6" -106
"CbeamSt7" -107
"CbeamSt8" -108
"CbeamSt9" -109

III.1.2.1 General Results

The correspondence between the Nastran output requests and the DMAP data blocks written in the ``op2'' file is given in Tables III.1.3 to III.1.11. Note that in all the examples presented in Part IV, the results are printed in the ``op2'' file with ``SORT1'' option. This means that no test has been done with ``SORT2'' option.


Table III.1.3: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Displacements read from OUG data blocks.)
Nastran ``op2'' Generated
Statement Data Block Result
DISPL OUG
``Displacements, Translational''
``Displacements, Rotational''
``Displacements, Scalar''
VELO OUG
``Velocities, Translational''
``Velocities, Rotational''
``Velocities, Scalar''
ACCEL OUG
``Accelerations, Translational''
``Accelerations, Rotational''
``Accelerations, Scalar''


Table III.1.4: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Applied loads read from OPG data blocks.)
Nastran ``op2'' Generated
Statement Data Block Result
OLOAD (3) OPG
``Applied Loads, Forces''
``Applied Loads, Moments''


Table III.1.5: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (MPC and SPC forces read from OQG data blocks.)
Nastran ``op2'' Generated
Statement Data Block Result
MPCFORCES (3) OPG
``MPC Forces, Forces''
``MPC Forces, Moments''
``MPC Forces, Scalar''
SPCFORCES (3) OPG
``SPC Forces, Forces''
``SPC Forces, Moments''
``SPC Forces, Scalar''
MPCFORCES
SPCFORCES
OPG
``Reaction Forces, Forces'' (1)
``Reaction Forces, Moments'' (1)
``Reaction Forces, Scalar'' (1)


Table III.1.6: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Grid point forces read from OGF data blocks.)
Nastran ``op2'' Generated
Statement Data Block Result
GPFORCES (3) OGF
``Grid Point Forces, Internal Forces''
``Grid Point Forces, Internal Moments''
``Grid Point Forces, MPC Forces'' (3)
``Grid Point Forces, MPC Moments'' (3)
``Grid Point Forces, SPC Forces'' (3)
``Grid Point Forces, SPC Moments'' (3)
``Grid Point Forces, Reaction Forces'' (1)
``Grid Point Forces, Reaction Moments'' (1)
``Grid Point Forces, Applied Forces'' (3)
``Grid Point Forces, Applied Moments'' (3)
``Grid Point Forces, Total Forces''
``Grid Point Forces, Total Moments''


Table III.1.7: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Strains read from OES data blocks and corresponding to ``STRAIN'' output requests..)
Nastran ``op2'' Generated
Statement Data Block Result
STRAIN OES
``Strain Tensor'' (4, 2))
``Beam Axial Strain for Axial Loads''
``Beam Axial Strain for Bending Loads''
``Beam Axial Strain for Total Loads'' (7)
``Beam Shear Strain for Torsion Loads''
``Beam Deformations'' (13)
``Beam Velocities'' (13)
``Gap Slips'' (14)
``Spring Scalar Strain''
``Bush Forces Strain Tensor'' (11 and 12)
``Bush Moments Strain Tensor'' (11 and 12)
``Bush Plastic Strain'' (11 and 12)
``Curvature Tensor'' (4, 6)
``Effective Plastic Strain'' (8)
``Effective Creep Strain'' (8)
``Shear Panel Strain, Max''
``Shear Panel Strain, Average''


Table III.1.8: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Stresses read from OES data blocks and corresponding to ``STRESS'' output requests.)
Nastran ``op2'' Generated
Statement Data Block Result
STRESS OES
``Stress Tensor'' (1 in section III.1.2.2)
``Beam Axial Stress for Axial Loads''
``Beam Axial Stress for Bending Loads''
``Beam Axial Stress for Total Loads'' (7)
``Beam Shear Stress for Torsion Loads''
``Beam Forces'' (11 and 12)
``Beam Moments'' (11 and 12)
``Beam Deformations'' (13)
``Beam Velocities'' (13)
``Gap Slips'' (14)
``Spring Scalar Stress''
``Bush Forces Stress Tensor'' (11 and 12)
``Bush Moments Stress Tensor'' (11 and 12)
``Bush Stress, Axial'' (13)
``Bush Strain, Axial'' (13)
``Bush Plastic Strain'' (13)
``Shear Panel Stress, Max''
``Shear Panel Stress, Average''


Table III.1.9: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Element forces read from OEF data blocks or other ``FORCE'' output.)
Nastran ``op2'' Generated
Statement Data Block Result
FORCE (2, 13) OEF
``Shell Forces''
``Shell Moments'' (5)
``Beam Forces'' (9, 10)
``Beam Moments'' (9, 10)
``Beam Warping Torque''
``Beam Deformations''
``Beam Velocities''
``Gap Slips''
``Spring Scalar Forces''
``Bush Plastic Strain''


Table III.1.10: Correspondence between the Nastran output cards and the ``op2'' result data blocks. (Element forces read from OEE data blocks or ``ESE'', ``EKE'' and ``EDE'' output.)
Nastran ``op2'' Generated
Statement Data Block Result
ESE OEE
``Element Strain Energy''
``Element Strain Energy (Density)''
``Element Strain Energy (Percent of Total)''
EKE OEE
``Element Kinetic Energy''
``Element Kinetic Energy (Density)''
``Element Kinetic Energy (Percent of Total)''
EDE OEE
``Element Energy Loss''
``Element Energy Loss (Density)''
``Element Energy Loss (Percent of Total)''


Table III.1.11: Nastran Results for thermal calculations.
Nastran ``op2'' Generated
Statement Data Block Result
TEMPERATURE OUG ``Temperature''
FLUX OEF ``Temperature Gradient''
FLUX OEF ``Conductive Heat Flux''

One can make a few remarks about the information given in Tables III.1.3 to III.1.11:

  1. ``Reaction Forces'' Results are obtained by merging the contributions of MPC and SPC forces. This result has been added to harmonize Nastran and Samcef importation of Results.

  2. The Nastran ``CELASi'' and ``CDAMPi'' elements produce scalar forces or moments that are stored in ``Beam Scalar Forces'' Results.

  3. ``Applied Loads'' are available both with the ``OLOAD'' and ``GPFORCE'' Nastran statements. The first one provides forces and moments on nodes. The second one produces the same Results at element corners.

    A similar remark can be done for ``MPC Forces'' and ``SPC Forces''.

  4. The shear components of strain tensor output by Nastran are the angular deformations: $ \gamma_{ij}=2\epsilon_{ij}$ . When these results are imported in a NastranDb, the corresponding components are divided by two in such a way that a ``physical'' tensor is stored into the NastranDb. The same remark applies for the non-diagonal components of the curvature tensor (shell elements).

    The ``STRAIN'' Nastran output statement with ``FIBER'' option outputs the strain tensor at Z1 and Z2, but do not produce the curvature tensor.

  5. When shell bending moments are imported from Nastran finite element results, the sign of each component is changed. This has been done to ensure that a positive component of the bending moment results in a positive values of the corresponding strain tensor component on the upper face of the shell.

  6. When Nastran shell curvature Results are imported, two modifications are brought to the components:

  7. ``Axial Strain'' or ``Axial Stress'' for ``Total Loads'' and CBAR elements are produced by combined axial loads to bending loads. This has been done to harmonize CBAR Results with CBEAM Results. For CBEAM Results, Stresses or Strains are recovered on the extremities only.

  8. Plastic deformation results are produced for non-linear results only.

  9. Nastran ``beam'' type elements (CBAR, CBEAM, CBEND, CBUSH,...) do not output vectorial or tensorial forces or moments. Instead, the different components are expressed in different coordinate systems (axial, plane 1 and plane 2). When importing these Results, a conversion into tensorial format is done as follows:

       $\displaystyle \mbox{\boldmath$F$}$$\displaystyle =\left(
\begin{array}{ccc}
F_{xx} & F_{xy} & F_{xz} \\
F_{...
...} & V_{2} \\
V_{1} & 0 & 0 \\
V_{2} & 0 & 0
\end{array}
\right)\ ,
$

       $\displaystyle \mbox{\boldmath$M$}$$\displaystyle =\left(
\begin{array}{ccc}
M_{xx} & M_{xy} & M_{xz} \\
M_{...
... & M_{1} \\
-M_{2} & 0 & 0 \\
M_{1} & 0 & 0
\end{array}
\right)\ .
$

  10. For CBAR elements, ``Beam Forces'' are always produced at the center of elements, and ``Beam Moments'' at the two end nodes.

  11. Bush result types for OEF and OES outputs depend on the kind of BUSH elements to which they correspond: The element forces and moments are stored in ``Beam Forces'' and ``Beam Moments'' tensorial Results.

  12. The result types generated for CFAST elements are the same as for CBUSH elements.

    Note that FeResPost cannot determine the CFAST element coordinate system When grids A and B are coincident. This may cause problems when transformation of reference coordinate systems are required. (This is the case when gmsh outputs of results are requested.) Note also that Patran also seems to experience some difficulties to calculate CFAST element axes.

  13. Nastran ``CBUSH1D'' elements produce scalar results in OEF and OES blocks. By this we means that each type of result has only one single component. However, the scalar force is stored in ``Beam Forces'' tensorial result. Most components of the tensor are zero:

       $\displaystyle \mbox{\boldmath$F$}$$\displaystyle =\left(
\begin{array}{ccc}
F_{xx} & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 0
\end{array}
\right)\ .
$

    No bending moments are produced by ``CBUSH1D'' elements.

  14. Nastran ``CGAP'' elements produces various results. Results are tensorial and:

  15. Various Nastran elements refer scalar points instead of grids. Nevertheless, Nastran considers the scalar point as a kind of element rather than as a kind of grid. This is, in our opinion, an unfortunate choice! FeResPost considers SPOINT objects as a peculiar type of GRID. This has implications for the definition of keys when importing Results with from Nastran op2 files. One hopes that this will not lead to problems!


III.1.2.2 Composite Results

This section is more specifically devoted to the composite Results (failure indices). Failure indices can be imported from ``op2'' files only. The different Results that can be imported from Nastran are summarized in Table III.1.12. One can make a few remarks about the information given in those Tables:

  1. Since version 3.4.2, the stress tensor in plies is produced in ``Mid'' sub-layer only. This means that the out-of-plane shear stress that Nastran calculates at bottom skin of each ply is displaced at mid-thickness of the ply. This is an approximation. (This out-of-plane shear stress can be used to calculate inter-laminar shear stress in composite.)

    Note also that, as out-of-plane shear stresses represent interlaminar stresses, the components are expressed in laminate axes rather than in one of the plies coordinate system. This means that, even though stress tensor values are assumed to be given in ply axes, the out-of-plane shear stresses are given in laminate axes. This is an additional reason to be careful when using these components.

  2. When Nastran composite strains are read, values are produced for Mid thickness of each ply only.

  3. The remarks done about the conversion of angular shear strain components to tensorial shear strain components are of course also valid for layered strain Results.

  4. Failure indices can be read from ``op2'' files only. Corresponding Results do not seem to be stored in ``xdb'' files.
The indices given in Table III.1.12 refer to the remarks above.

Four methods devoted to the enabling or disabling of composite layered Results are defined in the generic ``DataBase'' class. These methods are presented in section I.1.3.2.


Table III.1.12: Correspondence between the Nastran output cards and composite stresses and strains
Nastran ``op2'' Generated
Statement Data Block Result
STRAIN OES ``Strain Tensor'' (2, 3)
STRESS OES ``Stress Tensor'' (1)

The correspondence between the failure indices read from Nastran ``op2'' files and Results produced by CLA classes is as in Table III.1.13.


Table III.1.13: Correspondence between the Nastran failure indices imported from ``op2'' files and the failure criteria defined in CLA module.
Nastran Result CLA criterion ID section
``Composite Failure Index, Tsai-Hill'' ``TsaiHill_c'' II.1.9.11
``Composite Failure Index, Tsai-Wu'' ``TsaiWu'' II.1.9.14
``Composite Failure Index, Hoffman'' ``Hoffman'' II.1.9.16
``Composite Failure Index, Maximum Strain, CompMax'' ``MaxStrain'' II.1.9.6
``Composite Failure Index, Interlaminar Shear Stress'' ``Ilss'' II.1.9.25


III.1.3 Interaction with CLA classes

When a PCOMP or a PCOMPG property card is translated into a ClaLam object by a call to ``getClaDb'' method, the value of LAM parameter is not taken into account. This means that the values of this parameter set to ``MEM'', ``BEND'', ``SMEAR'' or ``SMCORE'' is without effect. There is one exception to this rule: the value ``SYM'' is taken into account in PCOMP property cards. (But not in PCOMPG cards for which this parameter value is illegal.)


III.2 Samcef Preferences

Most methods peculiar to the post-processing of Samcef finite element Results and models are defined in class ``SamcefDb'' that inherits the ``DataBase'' class. This class is described in section III.2.1.

Table III.2.1: The different methods that have been defined in ``SamcefDb'' class. See also the methods defined in generic DataBase class (Table I.1.1). userManual.Samcef.DB.methods.tab
(FeResPost list of classes is given in Table 1 page [*].)
(See also methods in userManual.DataBase.methods.tabgeneric DataBase class.)
Method Name Description Example
     
Creation and initialization methods
new III.2.1 III.2.1
initialize III.2.1  
Reading model or Results
readSamcefDat III.2.1.1  
readDesFac III.2.1.4  
desFacResetFlags III.2.1.4  
desFacSetFlag III.2.1.4  
desFacUnsetFlag III.2.1.4  
desFacGetFlag III.2.1.4  
enableSamcefResCodes III.2.1.4  
disableSamcefResCodes III.2.1.4  
attachDesFac III.2.1.5