Previous Up Next

2  PREPARATION OF THE INPUT DATA

INT.30


Rule 1:


All the data may be coded in FREE format (unless a fixed format is explicitly chosen by the user for specific data, e.g. the geometry). One or more blanks and/or an end of line act as a separator between data items.


Only columns 1 to 72 of each ‘data card’ are analysed. A data card is a record, i.e. a sequence of up to 72 characters terminated by a new line character.


Rule 2:


The data consist in a sequence of instructions or DIRECTIVES, (each one possibly including a number of OPTIONS and SUBOPTIONS) that can be specified using keywords.


Only the FIRST FOUR LETTERS ARE COMPULSORY for the coding of keywords, since these are unique in each situation. EUROPLEXUS ignores characters beyond the fourth one when decoding a keyword.


Rule 3:


Numeric values are coded with or without a decimal point:


Example:

        12  24.  .3   1.3E-4   1E4  .5D+2   -.4E 00

Rule 4:


Comment ’cards’ (records, in the sense defined above) can be freely interspersed with the data, except that the first record of a data file cannot be a comment (it is the problem title, see below).

A comment card begins with a dollar ($) or an asterisk (*) in column 1. Alternatively, it is possible to use an exclamation point (!) which may be placed at any position in the ‘card’ and not only in column 1.

Any characters that follow one of these special characters on an input card are ignored by EUROPLEXUS. By using an exclamation point, it is therefore possible to add comments on the same line as the data.

Note that the program does include in the input data echo comments written at the beginning of the output listing.

A semicolon is considered as the end of a card.


Example:

        "TRID"  "ALE"      !  3D ALE computation

2.1  WRITING CONVENTIONS

INT.40


Object:

To ensure that the necessary keywords, optional key-words as well as the numerical values to be entered show up clearly in the syntax of the instructions, the following conventions have been adopted.


Description of language conventions:

Keywords are enclosed in quotation marks: "TRIDIM".


Anything not enclosed in quotation marks represents numerical values or something else to be described. Names representing character strings are enclosed in apostrophes:

        < "SAUVE"  nb  ifreq  < "PROT"  'mykey'  > >

When a sequence is optional, it is enclosed in angle brackets: (<...>).


If there is a choice between several sequences among which ONE ONLY is compulsory, the sequences are enclosed between ( |[...]|) symbols, each of them separated by semicolons (;). The list of sequences can be written on several lines, for example:

        |[ "DEPL" ; "VITE" ; "ACCE" ]|

        or

        |[
           "DEPL" ;
           "VITE" ;
           "ACCE"
        ]|

If there is a choice between several sequences among which ONE AT MOST is compulsory, the sequences are enclosed between ( $[...]$) symbols, each of them separated by semicolons (;). Again, the list of sequences can be written on several lines, for example:

        $[  "ECHO" ; "NOEC" ]$

        or

        $[
           "ECHO" ;
           "NOEC"
        ]$

If a sequence can be repeated as many times as wanted, it is enclosed in parentheses: (...).


If a sequence must be repeated, for example nf times, it is framed by: nf*(...). The reading of nf must precede immediately the first sequence:

     ( "VMIS" "ISOT"  "RO" rho  "YOUNG" e  "NU" nu  ...
             ... "TRAC" nf*( sig eps ) /LECTURE/ )

In this case, the input data should contain an integer (nf), immediately followed by nf couples of values. For example, if nf=3, the sequence nf*( sig eps) could be written as:

        3     0. 0.     1.E8 1.E-3     1.E9 1.E-1

In order to simplify the writing, a symbolic name is sometimes assigned to frequently used sequences, that are described only once and then referred to simply by their name enclosed in /, as in:

        "MASSE" ( /LECDDL/   xm /LECTURE/  )

These named sequences are sometimes called procedures. It should be stressed that these names should not appear as such in an input data, but have to be replaced by the appropriate sequence of keywords and values. Named sequences should not be confused with keywords or directives. Their names therefore do not obey to the 4-character rule like keywords.

2.2  USE OF LITERAL VARIABLES

INT.45


Object :

It is possible to replace any data (a number, a keyword or a text) by a literal variable.


The name of this variable must start by % (per cent), followed by at most 16 alphanumeric characters.


Before being used for the first time, a literal variable must be assigned a value.


In order to assign a value to a literal varaible, type its name followed by the equals sign (=) and then by the value, like in the Fortran programming language.


Example :
   . . .
  %diameter_1 = 0.0548      %diameter_2 = 0.2027
  %tube_1 = lig_ent         %tube_2 = lig_tot
   . . .
COMPLEMENT
    DIAMETRE DROIT %diameter_1  LECT %tube_1 TERM
    DIAMETRE DROIT %diameter_2  LECT %tube_2 TERM
   . . .

Comments :

It is possible to re-define a literal variable (i.e., change its ‘contents’), at any place in the input data set.


The assignment sign ‘=’ must lie on the same input line as the variable name in the input data set.


A literal variable represents JUST ONE data: in the previous example, %tube_1 and %tube_2 represent each one a single word, that is an object name.

2.3  PROCEDURE /LECTURE/

INT.50


Object:


Procedure used to define a set of integers. Most of the time it is used to specify a list of nodes or of elements.


Syntax:


Explicit definition (direct list of values):

        |   "LECT"  n1  n2  . . .  nk  "TERM"              |


Implicit definition (by using an increment npas):

        |   "LECT"  ndeb  "PAS"  npas  nfin  "TERM"        |


Definition using the objects created by the mesh generator "GIBI":

        |   "LECT"    (  'nomobjet'  )   "TERM"            |


Definition using the “permanent groups” created by the mesh generator "I-DEAS":

        |   "LECT"    (  'nomgroup'  )   "TERM"            |

Definition using the selections created by the LS-DYNA k-file format":

        |   "LECT"    (  'kfileselections'  )   "TERM"            |


All the elements or all the nodes are concerned (special keyword TOUS):

        |   "LECT" "TOUS" "TERM"                           |


None of the elements or none of the nodes are concerned (special keyword NONE). This can be useful to avoid an error message in directives where the specification of elements or nodes is optional:

        |   "LECT" "NONE" "TERM"                           |


Difference, intersection or symmetric difference between two sets (each set being defined by one of the above syntaxes):

        |   "LECT" <first_set> "DIFF" <second_set> "TERM"  |
        |   "LECT" <first_set> "INTR" <second_set> "TERM"  |
        |   "LECT" <first_set> "SDIF" <second_set> "TERM"  |

’kfileselections’:

The selection of entities from the LS-DYNA k-file can be done with the following commands

  $[PART partnr; NSET nsetnr; ESET esetnr; NODE nodenr; ELEM elemnr]$

Comments:


The explicit and implicit syntaxes can be linked together. For example, to obtain the integers 3, 5, 2, 4, 6, 8, 10, 14, 15, 18, 21, 24, write:

        LECT 3 5 2 PAS 2 10 14 15 PAS 3 24 TERM


For the implicit syntax, the step npas can be negative.


In the case of GIBI objects, the procedure extracts, if necessary, the indexes of the nodes or of the elements that constitute the objects/groups defined by the user. The directive where the procedure /LECTURE/ appears determines if the indexes indicate nodes or elements.


If the DIFF, INTR or SDIF keywords are used, they must be at the end of the directive, as shown in the examples below. In other words, first the basic set must be defined, followed by one of these three keywords and then by the definition of the second set.


From now on this procedure will be called /LECTURE/ or /LECT/.


Remarks:


EUROPLEXUS systematically checks the coherence of the indexes taking into account the expected type (nodes or elements).


Once they have been read, the indexes are classified in ascending order (if this does not harm the concerned directive).


If GIBI object names are mixed up with EUROPLEXUS numbers, separate the sequences by the keyword SUIT.


I-DEAS permanent group names can be freely mixed up with EUROPLEXUS indexes.


The keywords DIFF, INTR and SDIF may only be used in /LECT/ures that return lists of elements or nodes ordered in growing sequence and without repeated items. These are the vast majority in the code.


In any case, the finale result of the /LECT/ure may not be the empty set. An error is issued in this case.


To indicate all the elements or all the nodes in the model, the advised syntax is, as indicated above: LECT TOUS TERM. Other (obsolete) forms of the same directive are also accepted sometimes, for example the short syntax TOUS (i.e. without the keyword LECT). These alternative syntaxes are still accepted for compatibility with old input files, but might become unsupported in the short future. Note that the full syntax (LECT TOUS TERM) is the only supported syntax for use in conjunction with operations introduced by the keywords DIFF, INTR or SDIF.


Examples:
        LECT 3 5 2 4 6 8 10 14 15 18 21 24 TERM
        LECT 3 5 2 PAS 2 10 14 15 PAS 3 24 TERM
        LECT 3 5 10 PAS -2 2 14 15 PAS 3 24 TERM
        LECT objet1 objet2 SUIT 25 27 TERM
        LECT objet1 SUIT 25 27 SUIT objet2 TERM
        LECT toto tata DIFF titi tutu TERM
        LECT TOUS DIFF titi tutu TERM
        LECT 1 PAS 3 25 INTR titi tutu TERM
        LECT toto tata SDIF 1 5 PAS 2 28 TERM

Warning concerning the DIFF operator:


Pay attention in the use of the DIFF operator in /LECT/ures where a set of nodes is required. For example, the expression:

        LECT coco DIFF caca TERM

used in a context where a set of nodes is expected, and when coco is an object composed of elements, is evaluated as follows:


Note that this might not be the result you want or expect. In particular, in the case that both coco and caca contain elements, the resulting set of nodes is different from (smaller than) the set of nodes belonging to the difference between the two element sets. If the latter is what you want, proceed as follows: first, define a named group of elements (say edif) containing the difference of the elements, by using the COMP GROU directive; then, use directly the name edif in the /LECT/ expecting the nodes:

        COMP GROU 1 'edif' LECT coco DIFF caca TERM ! element group
        . . .
       !LINK COUP BLOQ 1 LECT coco DIFF caca TERM   ! wrong !!!
        LINK COUP BLOQ 1 LECT edif TERM             ! ok : nodes of the
                                                    ! element group


The following example may also help clarify the matter. Assume the following simple mesh:

                         4-------5-------6
                         |       |       |
                         |   1   |   2   |
                         |       |       |
                         1-------2-------3

and assume that the Cast3m object mesh contains elements 1 and 2, while the object right contains element 2.

Then, in a /LECT/ directive looking for nodes (e.g. the following blockage directive), the expression:

     LINK COUP ... BLOQ 1 LECT mesh DIFF right TERM

will return nodes 1 and 4 (but not nodes 2 and 5). This is because: first the nodes of mesh are extracted (nodes 1 to 6); then the nodes of right are extracted (nodes 2, 3, 5 and 6); and finally these are subtracted from the first set, thus leaving only nodes 1 and 4.

If one wants instead to select all the nodes of the difference between the element sets (i.e. nodes 1, 2, 4 and 5), one can proceed as follows:

     COMP GROU 1 'edif' LECT mesh DIFF right TERM
      . . .
     LINK COUP ... BLOQ 1 LECT edif TERM

The first directive builds up the element group containing the difference between the two element sets (difference between elements), which results into element 1. The second directive then extracts all the nodes of such element set, i.e. nodes 1, 2, 4 and 5.

2.4  PROCEDURE /PROGRESSION/

INT.55


Object:


Procedure used to prescribe a group of real numbers. For example, it can be used to specify the values of the physical times at which the solution has to be printed or stored.


Syntax:


Explicit definition :

        |   "PROG"  r1  r2  . . .  rk  "TERM"             |


Implicit definition :

        |   "PROG"  rdeb  "PAS"  rpas  rfin  "TERM"       |

Comments:


The explicit and implicit syntaxes can be linked together. For example, to obtain the values 3., 5., 2., 4., 6., 8., 10., 14., 15., 18., 21., 24. write:

        "PROG"  3. 5. 2. "PAS" 2. 10. 14. 15. "PAS" 3. 24. "TERM"


For the implicit syntax, the step rpas can be negative.


From now on this procedure will be called /PROG/.


Remark:


Once they have been read, the values are classified in ascending order (if this does not harm the instruction concerned).

2.5  PROCEDURE /CTIME/

INT.57


Object:

Procedure used to choose time values in the form of equidistant values (in time steps or in time values) or user-defined values. Typically, this can be used to specify the times at which output operations such as printouts, storage of data for restart or post-processing, etc., should take place during a computation.


Syntax:
   < "FREQ" ifreq  > < "TFRE" tfreq  >
   < "NUPA" /LECT/ > < "TIME" /PROG/ >
FREQ

A fixed frequency in time steps is chosen.
ifreq

Value of the frequency in time steps, starting from step 0.
TFRE

A fixed frequency in time is chosen.
tfreq

Value of the frequency in time units, starting from the initial time.
NUPA

A series of time steps is specified by the user.
/LECT/

Definition of the series of time step numbers.
TIME

A series of time values is specified by the user.
/PROG/

Definition of the series of time values.

Comments:

The above optional forms of specifying time values can be freely combined. For example:

        FREQ 10 NUPA LECT 10 15 35 TERM TFRE 1.E-3
        TIME PROG 0.5E-3 PAS 1.E-3 3.5E-3 TERM

is a valid specification and prescribes that the concerned event (e.g., a printout) will take place each 10 steps, and at steps 15 and 35, and each 1.E-3 time units, and at time values of 0.5E-3, 1.5E-3, 2.5E-3 and 3.5E-3.


If repeated values occur (such as in the above example for step number 10), they are automatically dealt with, i.e. only one event takes place for repeated values.


Note that if a time frequency is specified (keyword TFRE), the resulting time values take into account the initial time of the calculation declared in directive CALC by the TINI keyword. For example, if TFRE 2.E-3 and TINI 0.0, then the corresponding event will take place at times 2.E-3, 4.E-3, 6.E-3 etc. But if TFRE 2.E-3 and TINI 1.0E-3, then the corresponding event will take place at times 3.E-3, 5.E-3, 7.E-3 etc.


In a few instances, the keyword "TEMPS" can be used as an alias for "NUPA". This keyword has been maintained for backwards compatibility, but should no longer be used in newly-written input data.


Warning

Be aware that values given in time units with the above "TFRE" and "TIME" keywords are rounded to the closest number of ’time normalization units’, as described below in the directive "OPTION", see page H.20. The default value of time normalization unit is 1 picosecond (1.D-12 s). If necessary, this can be changed by the OPTI TION option described on page H.20.

2.6  PROCEDURE /LCHP/

INT.58


Object:


Procedure used to read a field of values (‘champoint’) generated by CASTEM2000.


Syntax:
   "LCHP" nomobjet "TERM"


Reads a CASTEM2000 object called nomobjet, of the type ‘champoint’, previously stored in CASTEM2000 with the directive "SAUV". The object is read and stored for successive use by other directives (see e.g. "EPAI").

2.7  PROCEDURE /LECDDL/

INT.60


Object:

It often occurs in a set of EUROPLEXUS input data that one has to define, for some nodes, the degrees of freedom according to which it is necessary to add a mass, prescribe the direction of a velocity, set a displacement to zero, and so on.


These degrees of freedom are identified by the numbers from 1 to 7 as described hereafter. See also the description of the available elements.


Meaning of the numbers:

AXISYMMETRIC CASE (see AXIS):

Solid elements:

Shell elements:


TWO DIMENSIONAL CASES (see CPLA and DPLA):

Same as for the axisymmetric case (but with X and Y instead of R and Z).


THREE DIMENSIONAL CASE (see TRID):

Solid elements:

Shell, beam and pipe elements:


Conventions:

The degrees of freedom are specified by the corresponding numbers, one immediately after the other, i.e. without blanks.


Examples:

        346   ===>  d.o.f.  3, 4, and 6;
        1426  ===>  d.o.f.  1, 4, 2, and 6.

The number of degrees of freedom described must correspond to the problem type (plane, axisymmetric, tridimensional) and to the element type.


In the following this procedure is called /LECDDL/.

2.8  MPI PARALLEL CALCULATIONS

INT.75


Parallel calculations on distributed memory clusters yield the following requirements:


One subdomain is attached to each thread of the parallel simulation. Data between subdomains are exchanged through MPI messages.


For details about parallel algorithms implemented in EUROPLEXUS, please consult:

2.9  READING DATA FROM EXTERNAL FILES

INT.77


For convenience, it is sometimes useful to read some (bulky) input data for EPX not from the normal input file (.EPX) but from an external file.


For example, consider the case where a complex set of initial conditions or of external loads must be specified, with thousands of input lines. Sometimes, such complex files can be produced by some external software, which has no relation to (and is not interfaced with) EPX.


In order not to clutter the (main) input file .EPX, the use may proceed as follows:


When EPX encounters the INCLUDE directive, it continues reading the input from the specified external file. When it encounters the RETURN keyword in the external file, it goes back to reading from the main input file, at the line immediately following the INCLUDE statement.


Comments:


At the moment, this mechanism can be used for all main directives of EPX, except the GEOM directive in a direct calculation and the SORT directive during post-processing of results with EPX (but work is ongoing for these directives).


The inclusion mechanism is not recursive, i.e. an included file cannot call another included file.


Previous Up Next