@database Ami2D.guide

@Master ami2d.texinfo

@Width 72


This is the AmigaGuide file Ami2D.guide, produced by Makeinfo-1.48 from 
the input file ami2d.texinfo.

   This file documents Ami2D, a collection of codes developed as tools
for modeling and post-processing "plane" and axisymmetric two
dimensional finite element analysis problems.

   Copyright (C) 1992,1993,1994 Russell Leighton

   This is the second edition of the Ami2D documentation.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.


@Node Main "Ami2D.guide"
@Next "Copying"

Ami2D
*****

   This is Edition  of the Ami2D documentation, , for
Ami2D Version .


 @{" Copying " Link "Copying"}                      Your rights.
 @{" Disclaimer " Link "Disclaimer"}                   Your responsibility.

 @{" Introduction " Link "Introduction"}                 A brief encounter.

 @{" Command Reference " Link "Command Reference"}            The mysteries revealed.
 @{" Discussion " Link "Discussion"}                   Lets discuss it.
 @{" Example Problem " Link "Example Problem"}              Just to get you started.

 @{" References " Link "References"}                   Give credit where credit is due.
 @{" Acknowledgments " Link "Acknowledgments"}              My thanks.

 @{" Ami2D Macros " Link "Ami2D Macros"}                 Here's where to find em.
 @{" Lin2D " Link "Lin2D"}                        The linear solver.
 @{" Nln2D " Link "Nln2D"}                        The nonlinear solver.
 @{" Post2D " Link "Post2D"}                       The post-processor.
 @{" Equ2D " Link "Equ2D"}                        Some equivalencing never hurt.
 @{" Opt2D " Link "Opt2D"}                        A little optimizer.
 @{" Rem2D " Link "Rem2D"}                        For some additional model cleanup.
 @{" Rexxcon " Link "Rexxcon"}                      The little window that could.
 @{" Rexxbar " Link "Rexxbar"}                      Drinks are on the house.

 @{" Concept Index " Link "Concept Index"}                Look it up here.
 @{" Command Index " Link "Command Index"}                Where is that command anyway?


@EndNode

@Node "Copying" "Ami2D.guide/Copying"
@Next "Disclaimer"
@Prev "Main"
@Toc "Main"

Ami2D Copying Conditions
************************

   Permission is granted to any individual or institution to use, copy,
and distribute this software, provided that the copyright and permission
notice is maintained, intact, in all copies and supporting
documentation. The original distribution of this software must remain
intact and specifically must include all documentation, supporting
software/data, and disclaimer.

   No charge may be made for distribution, except for costs of media
and/or shipping.


@EndNode

@Node "Disclaimer" "Ami2D.guide/Disclaimer"
@Next "Introduction"
@Prev "Copying"
@Toc "Main"

Disclaimer
**********

   This software is provided on an "as is" basis without expressed or
implied warranty.  The author of this code and documentation takes no
responsibility for inappropriate use of this code and does not warrant
the code in any fashion.  In other words, use of this code is done
solely at the users risk and any problems resulting due to misuse or
coding errors is strictly the users responsibility.

   This code was developed for research and educational uses.  Any
other use of this code (particularly in the areas of design and
analysis of direct or indirect man-rated systems) without prior
verification of the software on similar problems is strongly
discouraged.  The author of this code is not responsible or liable for
any consequences or results that occur from the use (or misuse) of this
code.

   This code and associated document(s) and/or portions of the material
and data furnished herewith, was developed under sponsorship of the U.S.
Government.  Neither the U.S.  nor the U.S.A.F., nor the Phillips
Laboratory, nor their employees, nor their respective contractors,
subcontractors, or their employees, makes any warranty, expressed or
implied, or assumes any liability or responsibility for accuracy,
completeness or usefulness of any information, apparatus, product or
process disclosed, or represents that its use will not infringe
privately-owned rights.  Mention of any product, its manufacturer, or
suppliers shall not, nor is it intended to, imply approval,
disapproval, or fitness for any particular use.  The U.S.A.F.  and the
Phillips Laboratory at all times retain the right to use and
disseminate same for any purpose whatsoever.


@EndNode

@Node "Introduction" "Ami2D.guide/Introduction"
@Next "Command Reference"
@Prev "Disclaimer"
@Toc "Main"

Introduction
************

   `Ami2D' forms the core of a collection of codes developed to perform
various analyses on structures using the finite element technique.
Specifically, `Ami2D' is a pre/post-processor used to create two
dimensional finite element models and to interpret the results from
subsequent solutions.  It was developed to handle both "plane" and
axisymmetric two dimensional finite element analysis problems.  It is a
fairly general capability in the sense that a wide variety of two
dimensional problems can be modeled by `Ami2D'.  Other codes are
included to provide a fairly complete analysis capability.  These codes
include the solvers (see @{"Lin2D" Link "Lin2D"} and @{"Nln2D" Link "Nln2D"}), a node equivalence code (see
@{"Equ2D" Link "Equ2D"}), a node order optimizer (see @{"Opt2D" Link "Opt2D"}), and a couple of ancillary
codes (see @{"Rexxcon" Link "Rexxcon"} and @{"Rexxbar" Link "Rexxbar"}).  Of course, the user is free to
utilize other utility codes to enhance the operation and functionality
of this collection.

   The main features of the `Ami2D' collection are as follows:

   * may be run in the background or interactively

   * two-dimensional plane or axisymmetric problems

   * cartesian or polar coordinate systems

   * uses `ARexx' macro language

   * linear and quadratic isoparametric elements available

   * no limit on number of nodes, elements, materials, or boundary
     conditions (only limited by memory)

   * no need to specify problem size (determined at run time)

   * group (part) definition/manipulation

   * Dirichlet (constraint) or Neumann (flux), point or distributed
     boundary conditions

   * globally or locally referenced material properties

   * laminated materials

   * graphical interface

   * definable post-processing functions

   * command aliases for customized uses

   * linear and nonlinear (geometric) solvers provided

   * solvers use a symmetric banded matrix storage format

   * solvers can handle coupled analyses

   * node order optimizer for bandwidth reduction

   * node equivalence code for part "welding"

   * ancillary codes provided for integrated, interactive environment


@EndNode

@Node "Command Reference" "Ami2D.guide/Command Reference"
@Next "Discussion"
@Prev "Introduction"
@Toc "Main"

Command Reference
*****************

   This chapter is included as a reference to the commands available for
use in `ARexx' macros.


 @{" Macros and Syntax " Link "Macros and Syntax"}                Details, details
 @{" Problem Type " Link "Problem Type"}                     What kind of problem are we dealing with?
 @{" Materials " Link "Materials"}                        What is it made out of?
 @{" Geometry " Link "Geometry"}                         What does it look like?
 @{" Boundary Conditions " Link "Boundary Conditions"}              How is it loaded?
 @{" Results Processing " Link "Results Processing"}               How about a little data interpretation?
 @{" Utility Commands " Link "Utility Commands"}                 Just to make life easier
 @{" Graphic Interactive Commands " Link "Graphic Interactive Commands"}     ... and more colorful


@EndNode

@Node "Macros and Syntax" "Ami2D.guide/Macros and Syntax"
@Next "Problem Type"
@Toc "Command Reference"

Macros and Syntax
=================

   `Ami2D' accepts `ARexx' commands passed to its message port (address
ami2d).  These include all necessary commands to completely define the
two dimensional finite element model, material properties, and boundary
conditions.  It is possible (and often most desirable) to create a model
completely from these commands (saved in an `ARexx' macro file).
However, it is also possible to create a complete model interactively
through the graphical interface provided in the `Ami2D'
pre/post-processor.  The model, in either case, should then be saved to
a binary model file which can then be read back into `Ami2D' at a later
time or read into and processed by a solver (see @{"Lin2D" Link "Lin2D"} and @{"Nln2D" Link "Nln2D"}),
post-processor (see @{"Post2D" Link "Post2D"}), or other utility codes.  In turn, the
results produced by other codes can be saved back into the model file
which in turn can be graphically displayed by `Ami2D'.  The complete
process can be performed in an integrated, interactive session using
some ancillary codes developed to interface these processing codes.  A
good example of how `Ami2D' can be used in an interactive mode is
through the use of the `ARexx' macro `ami2d.rexx' provided.  Use of
this macro will be discussed later.

   In general the command line syntax for executing `Ami2D' as a
stand-alone program is:

         -> [run] Ami2D [SCRIPT]

where SCRIPT is the name of an input `ARexx' script to be processed. If
no script is specified then the code will wait until it receives a
command, presumably from a subsequently executed `ARexx' command or
script.

   Commands for `Ami2D', placed in an `ARexx' macro, consist of a
command keyword followed by arguments. The arguments may be separated
from the command keyword with parentheses and delimited with commas
(analogous to a function call) or may be separated (and delimited) with
spaces. If parentheses and commas are used then the command line must be
surrounded by single quotes or else `ARexx' will interpret the command
as a library function call (rather than a command meant for the host).
The use of spaces to delimit the command keyword and arguments is
recommended for most commands, however, the use of parentheses and
commas is recommended when defining aliases (see
@{"Utility Commands - alias" Link "Utility Commands"}). Also any expressions that are meant to be
evaluated internally by `Ami2D' should be surrounded by single quotes
(see @{"Utility Commands - set" Link "Utility Commands"}). For example, the lines below show a
sequence of `ARexx' commands for `Ami2D'.

     /* this is a simple example of an ARexx macro for Ami2D */
     
     address ami2d
     
     set 'struct 0'
     set 'la=a2*a3/((1+a3)*(1-2*a3))'
     set 'mu=a2/(2*(1+a3))'
     alias 'iso=mat(a1,0,0,la+2*mu,la+2*mu,la+2*mu,mu,la,la,0.0,la)'
     alias 'quad4=elem(a1,a2,4,4,a3,a4,a5,a6)'
     
     reset
     problem 'struct'
     axisym
     iso 1 1.0 0.0
     h = 0.25
     do i=0 to 4
         do j=1 to 5
             k = i*5 + j
             node k j*h i*h
         end
     end
     do i=0 to 3
         do j=1 to 4
             k = i*4 + j
             n = i*5 + j
             quad4 k 1 n n+1 n+6 n+5
         end
     end

Note that the `alias' and `set' commands always require expressions as
arguments (to be evaluated internally by `Ami2D') and, therefore, the
arguments must be surrounded by single quotes. Also note that in the
`problem' command the argument is also surrounded by single quotes
since `'struct'' is an internally defined variable (which is not known
to `ARexx'). The general rule is to surround expressions (which can be
single variables), which are to be interpreted internally by `Ami2D',
with single quotes. Otherwise, expressions (and variables) will be
interpreted by `ARexx' before being sent to `Ami2D'.

   The above example shows the command `node k j*h i*h' where `i', `j',
`k', and `h' are `ARexx' variables. In the first pass through the loop
containing this command the actual command line issued to `Ami2D' is
`node 1 0.25 0.0' which results in the creation of node 1 at
coordinates (0.25,0.0). For further details on the `ARexx' macro
language the interested reader should refer to texts (see @{"References" Link "References"})
that specifically address the `ARexx' language. `ARexx' is a complete
macro programming language and as such cannot not be described in
adequate detail here. The following section, however, describes the
commands available within `ARexx' macros for use with `Ami2D'.  A
detailed example is also included in a later chapter.

   It is important to note that all identification numbers are one
based. That is all material, node, element and element side
identification numbers must start at one or greater. The use of zero is
reserved to flag interactive specification (which will be discussed
later) and will cause an error if used in a non-interactive session.

   Most examples shown (as well as most of the commands in the scripts
included) use parentheses and commas to delimit commands and arguments.
However, this is done only for clarity. In addition, to help clarify
commands as well as to demonstrate the flexibility of the codes, many of
the examples show the use of the `alias' and `set' commands. It is
through the use of these commands that `Ami2D' can be tailored to many
different engineering applications. More on this will be discussed
later.


@EndNode

@Node "Problem Type" "Ami2D.guide/Problem Type"
@Next "Materials"
@Prev "Macros and Syntax"
@Toc "Command Reference"

Problem Type
============

   These commands specify the kind of problem to be modeled and the type
of assumption used to restrict the problem to two dimensions.


 @{" problem " Link "problem"}                      Problem Kind and Degrees of Freedom
 @{" plane " Link "plane"}                        Plane
 @{" axisym " Link "axisym"}                       Axisymmetry


@EndNode

@Node "problem" "Ami2D.guide/problem"
@Next "plane"
@Prev "Problem Type"
@Toc "Problem Type"

 -- Command: problem KIND NDOF
     `problem' requires an argument specifying the KIND of problem. The
     problem KIND can be set to any desired value.  This value is used
     to associate materials, boundary conditions and solutions (with the
     KIND corresponding to the problem KIND). The second argument
     (NDOF) may be used to specify the number of degrees of freedom per
     node.  For instance, in structural problems (in two dimensions) two
     displacements for each node are the degrees of freedom.  In
     thermal (heat conduction) problems one temperature for each node
     is solved for.  If this argument is not given then it is assumed
     that for a problem KIND set to an even number the degrees of
     freedom is set at two, otherwise, it is assumed to be one.

          'set thermal=1'
          'problem(thermal)'


@EndNode

@Node "plane" "Ami2D.guide/plane"
@Next "axisym"
@Prev "problem"
@Toc "Problem Type"

 -- Command: plane
     `plane' is used to specify a "plane" assumption (i.e. the problem
     solution is independent of the out-of-plane direction). There are
     no arguments to `plane'.


@EndNode

@Node "axisym" "Ami2D.guide/axisym"
@Next "(dir)"
@Prev "plane"
@Toc "Problem Type"

 -- Command: axisym
     `axisym' is used to specify an axisymmetric assumption (i.e. the
     problem solution is independent of the circumferential direction).
     There are no arguments to `axisym'.


@EndNode

@Node "Materials" "Ami2D.guide/Materials"
@Next "Geometry"
@Prev "Problem Type"
@Toc "Command Reference"

Materials
=========

   The following commands are used for specification of material
properties.


 @{" mat " Link "mat"} 
 @{" lam " Link "lam"} 


@EndNode

@Node "mat" "Ami2D.guide/mat"
@Next "lam"
@Prev "Materials"
@Toc "Materials"

 -- Command: mat ID TYPE KIND C[10] CKIND F[2] REF CKIND F[2] REF
     `mat' requires specification of the material identification number
     (ID), material TYPE, material KIND, material coefficients (C[10]),
     and two sets of body force terms consisting of couple problem kind
     (CKIND), body force coefficients (F[2]), and reference value (REF).

     The material TYPE currently has two possible meaningful values. If
     the value is set to zero (0) then the material properties are
     referenced to the global coordinate system.  If the value is set
     to one (1) then the material properties are referenced to the
     local element coordinate system (see @{"Geometry" Link "Geometry"}).  The latter choice
     is useful for defining non-isotropic material properties whose
     principal orientation varies with element orientation (for
     example, a filament wound composite bottle) and is especially
     useful when used in conjunction with the `lam' command (see
     @{"Materials - lam" Link "Materials"}).

     The couple problem kind may be specified in order to couple the
     solution from a previous analysis with the body force coefficients
     used in the current analysis. If no coupling is desired then these
     values should be set to the material KIND. The body force
     coefficients are used to define properties associated with body
     forces. The reference value can be used to specify a reference
     temperature, species concentration, etc. A reference temperature,
     for example, could be used to determine a change in temperature
     due to heat conduction thereby coupling the solution obtained from
     a heat transfer analysis with a structural analysis.

     The use of these values is dependent on the solver (see
     @{"Lin2D - Model Requirements" Link "Model Requirements"}) used to
     calculate a solution. Therefore, to determine what is required for
     input the documentation for the specific solver must be consulted.

          'set la=a2*a3/((1+a3)*(1-2*a3))'
          'set mu=a2/(2*(1+a3))'
          'alias iso=mat(a1,0,0,la+2*mu,la+2*mu,la+2*mu,mu,la,la,0.0,la)'
          'iso(1,10.e6,0.32)'


@EndNode

@Node "lam" "Ami2D.guide/lam"
@Next "(dir)"
@Prev "mat"
@Toc "Materials"

 -- Command: lam ID KIND MID FRAC MANG
     `lam' requires specification of the laminate identification number
     (ID), material KIND, reference material identification (MID),
     fraction of laminate (FRAC), and lamina material angle (MANG).

     This command is used to define a laminate by building up laminae. 
     Each lamina is defined by a single instance of `lam'.  Subsequent
     `lam' commands issued with the same laminate identification number
     will add laminae to any current laminate sequence.  The material
     KIND specified is used to define the overall laminate material
     kind as well as to define the expected material kind for the
     reference material.  The reference material identification number
     must refer to an existing material.  It is assumed that the
     reference material is at most a transversely isotropic material
     (the material properties are invariant only in the 2-3 plane). 
     This also implies that the primary (1) direction is the principal
     material direction (the stiffer or fiber direction).  The FRAC
     argument is used to specify the fraction that this lamina takes in
     the overall thickness of the laminate.  The total sum of all the
     FRAC arguments for every lamina defined in the laminate should
     equal 1.0.  The lamina material angle (MANG) is used to define the
     fiber orientation (in the 1-3 material plane).  This material
     angle may be defined as a constant value or as a function
     specified by name (previously defined by the `set' command, see
     @{"Utility Commands - set" Link "Utility Commands"}). This
     capability to specify a function for the fiber angle can be used
     to effectively model filament wound composite pressure vessels
     with domes where the fiber angle varies with position along the
     dome.

          'set fang1=asin(1.7365/r0)'
          'set fang2=-fang1'
          'lam 2 0 8 1/2 fang1'
          'lam 2 0 8 1/2 fang2'
          'lam 7 0 8 1/3  20.0'
          'lam 7 0 8 1/3 -20.0'
          'lam 7 0 8 1/3 90.0'


@EndNode

@Node "Geometry" "Ami2D.guide/Geometry"
@Next "Boundary Conditions"
@Prev "Materials"
@Toc "Command Reference"

Geometry
========

   The following commands are used to create the geometry of the model
in terms of nodes and elements. For element specification the nodes
must be specified in the order shown in
@{"elements.iff" system "sys:Utilities/display ami2d:doc/elements.iff"}.


 @{" node " Link "node"}                         The basic building block
 @{" elem " Link "elem"}                         How to connect them nodes


@EndNode

@Node "node" "Ami2D.guide/node"
@Next "elem"
@Prev "Geometry"
@Toc "Geometry"

 -- Command: node ID X Y
     `node' will create a node located at a specified coordinate.  The
     arguments are the node identification number (ID) and the
     coordinate pair (X, Y).  The coordinate pair is interpreted
     depending on the coordinate setting (see @{"Utility Commands - coord" Link "Utility Commands"}).
     If the coordinate is not given then the node will be placed at
     (0,0).  However, if the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the node will be placed at the selected location (using the
     mouse pointer). If the identification number is not given (or is
     zero) the next largest node number will be used.

          'node(1,0.5,1.0)'


@EndNode

@Node "elem" "Ami2D.guide/elem"
@Next "(dir)"
@Prev "node"
@Toc "Geometry"

 -- Command: elem ID MAT NNODES NINT NODES[9]
     `elem' is used to create elements based on isoparametric shape
     functions.  The required arguments are the element identification
     number (ID), material identification number (MAT, referring to an
     existing material), number of nodes (NNODES), number of integration
     points (NINT) and the node numbers (NODES[9], also referring to
     existing nodes). The following are possible element specifications.

          nnodes  nint   order       shape    integration rule
          
               3     1   linear      tri      1 point
               6     1   quadratic   tri      1 point
               6     3   quadratic   tri      3 point
               4     1   linear      quad     1 point
               4     4   linear      quad     2x2 point
               8     1   quadratic   quad     1 point   (not recommended)
               8     4   quadratic   quad     2x2 point
               8     9   quadratic   quad     3x3 point
               9     1   quadratic   quad     1 point   (not recommended)
               9     4   quadratic   quad     2x2 point
               9     9   quadratic   quad     3x3 point

     If any node numbers are not specified and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the node (or nodes) can be selected using the mouse pointer
     (in the correct order).  If the material number is not given then
     material one will be used. If the identification number is not
     given (or is zero) the next largest element number will be used. 
     It should be pointed out that some combinations of element order
     and integration order result in element instabilities whose effect
     can be highly dependent on the problem being solved (see
     @{"Element Instability" Link "Element Instability"} for more
     information).

          'alias quad4=elem(a1,a2,4,4,a3,a4,a5,a6)'
          'quad4(1,1,1,2,3,4)'


@EndNode

@Node "Boundary Conditions" "Ami2D.guide/Boundary Conditions"
@Next "Results Processing"
@Prev "Geometry"
@Toc "Command Reference"

Boundary Conditions
===================

   The following commands allow specification of the boundary
conditions. A sufficient specification of the boundary conditions is
necessary to result in a solvable problem. If during the solve phase of
the analysis an error occurs it is most likely due to insufficient or
improper application of boundary conditions.


 @{" pbc " Link "pbc"}                          Point (nodal) boundary conditions
 @{" dbc " Link "dbc"}                          Distributed (element) boundary conditions


@EndNode

@Node "pbc" "Ami2D.guide/pbc"
@Next "dbc"
@Prev "Boundary Conditions"
@Toc "Boundary Conditions"

 -- Command: pbc NODE TYPE KIND DIR VAL
     `pbc' specifies boundary conditions applied at nodes.  This
     boundary condition may be either a Dirichlet or flux type boundary
     condition.  The first argument is the identification number for
     the node at which the boundary condition is applied (NODE).  If
     zero is input and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the node is selected using the mouse pointer.  The second
     argument is used to specify the TYPE of boundary condition.  A
     Dirichlet boundary condition is TYPE 1.  A flux boundary condition
     is TYPE 2.  The next argument specifies the KIND of boundary
     condition and should correspond to the problem kind.  Different
     kinds of boundary conditions may be applied to a single node.  The
     appropriate boundary condition will be selected by the solver (see
     @{"Lin2D" Link "Lin2D"} and @{"Nln2D" Link "Nln2D"}) depending on the problem kind
     being solved. Also, depending on the currently specified problem
     kind `Ami2D' will display only the corresponding boundary
     conditions.  The next argument is used to specify the global
     direction (DIR) for the boundary condition. For scalar boundary
     conditions use 1.  For vector boundary conditions use 1 or 2 to
     specify the global direction (1 for `x' or `r', 2 for `y' or `z').
     The last argument is the boundary condition value (VAL).  If not
     specified then the boundary condition will be removed (if it
     exists).

          'alias dispx=pbc(a1,1,0,1,a2)'
          'dispx(5,0.0)'
          'alias forcr=pbc(a1,2,0,1,a2)'
          'forcr(10,100.0)'
          'alias temp=pbc(a1,1,1,1,a2)'
          'temp(2,77)'


@EndNode

@Node "dbc" "Ami2D.guide/dbc"
@Next "(dir)"
@Prev "pbc"
@Toc "Boundary Conditions"

 -- Command: dbc ELEM TYPE KIND DIR SIDE VAL[3]
     `dbc' specifies boundary conditions applied along element sides.
     This boundary condition may be either Dirichlet or flux TYPE
     boundary conditions. The first argument is the identification
     number for the element (ELEM). The second argument is used to
     specify the TYPE of boundary condition. A Dirichlet boundary
     condition is TYPE 1. A flux boundary condition is TYPE 2. The next
     argument specifies the KIND of boundary condition and should
     correspond to the problem kind. Different kinds of boundary
     conditions may be applied to an element side. The appropriate
     boundary condition will be selected by the solver (see @{"Lin2D" Link "Lin2D"} and
     @{"Nln2D" Link "Nln2D"}) depending on the problem kind being
     solved. Also, depending on the currently specified problem kind
     `Ami2D' will display only the corresponding boundary conditions.
     The next argument is used to specify the local direction DIR for
     the boundary condition. For scalar boundary conditions use 1. For
     vector boundary conditions use 1 or 2 to specify the local
     direction (1 for normal to element side, 2 for tangent to element
     side). The next argument is the element SIDE number. If zero is
     input for the element number and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the element is selected using the mouse pointer. If the side
     number is also input as zero then the side closest to the point
     where the element was selected will be used. The succeeding
     arguments specify the value of the boundary condition at each
     nodal location (VAL[3]). If one value is specified the boundary
     condition value is assumed to be constant across the element side.
     If two or more values are given the value will vary either
     linearly or quadraticly depending on the order of the element. If
     no values are specified then the boundary condition will be
     removed (if it exists).

          'alias press=dbc(a1,2,0,1,a2,a3)'
          'press(20,1,-1000.0)'
          'alias slope=dbc(a1,1,0,1,a2,a3)'
          'slope(12,3,0.0)'


@EndNode

@Node "Results Processing" "Ami2D.guide/Results Processing"
@Next "Utility Commands"
@Prev "Boundary Conditions"
@Toc "Command Reference"

Results Processing
==================

   These commands are included to evaluate results as specific locations
as well as to select result functions for processing through an external
post-processor (see @{"Post2D" Link "Post2D"}).


 @{" select " Link "select"}                       Select results for subsequent post-processing
 @{" eval " Link "eval"}                         Evaluate results at a point


@EndNode

@Node "select" "Ami2D.guide/select"
@Next "eval"
@Prev "Results Processing"
@Toc "Results Processing"

 -- Command: select FUNCTION LOCATION
     Given a solution calculated by a solver (see @{"Lin2D" Link "Lin2D"} and @{"Nln2D" Link "Nln2D"})
     `select' will select functions to be subsequently used to
     post-process the solution (see @{"Post2D" Link "Post2D"}).  Any previously defined
     FUNCTION (see @{"Utility Commands - set" Link "Utility Commands"}) may be given in the first
     argument.  The second argument indicates where the solution will
     be evaluated in each element (LOCATION).  If `gauss' is specified
     then the solution will be processed at the Gaussian quadrature
     points.  If `node' is specified then processing will occur at the
     node locations.  Finally, if `ave' is specified then the solution
     will be processed at the nodes and averaged across element
     boundaries (unless it is a material boundary).  If this argument
     is not given then `gauss' is assumed.  More accurate stress/strain
     results (for that matter any result based on solution derivatives)
     can be expected using the `gauss' option.  No results are actually
     calculated until the model is processed through the post-processor.

          'set flux=-c1*(x1*x1+y1*y1)^0.5'
          'select(flux,ave)'


@EndNode

@Node "eval" "Ami2D.guide/eval"
@Next "(dir)"
@Prev "select"
@Toc "Results Processing"

 -- Command: eval EXPR ELEM NP XI YI
     Given a solution calculated by a solver (see @{"Lin2D" Link "Lin2D"} and @{"Nln2D" Link "Nln2D"})
     `eval' is used to evaluate the solution at specified locations. Any
     valid expression (see @{"Utility Commands - set" Link "Utility Commands"}) may be given in the
     first argument (EXPR). The second argument, if given, specifies
     the element (ELEM) by order number (greater than or equal to zero)
     or by identification number (less than zero). The third argument
     (NP) indicates either the local node number (greater than zero),
     the Gaussian quadrature point (less than zero) or if given as zero
     the next two arguments are used to specify the local coordinates
     (see @{"Geometry" Link "Geometry"}). If the element number (and all subsequent
     arguments) are not given then the expression will be evaluated as
     a stand-alone expression (no solution values will be valid). In
     this way `eval' may be used as an online calculator (though
     somewhat limited). If the third argument (and all subsequent
     arguments) are not given and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the location for solution evaluation is given by selecting it
     with the mouse. The computed value for the specified location and
     the expression given is returned in RESULT (assuming `options
     results' is used in the macro).

          'eval(sig1,101,0,0.0,0.0)'


@EndNode

@Node "Utility Commands" "Ami2D.guide/Utility Commands"
@Next "Graphic Interactive Commands"
@Prev "Results Processing"
@Toc "Command Reference"

Utility Commands
================

   These commands are included for additional capability and
interactivity.


 @{" save " Link "save"}                         Save everything to a file
 @{" read " Link "read"}                         Read everything from a file
 @{" coord " Link "coord"}                        Set coordinate system
 @{" cd " Link "cd"}                           Change directories
 @{" reset " Link "reset"}                        Deallocate memory
 @{" check " Link "check"}                        Perform simple model check
 @{" info " Link "info"}                         Get information on model
 @{" version " Link "version"}                      Get version and compilation date
 @{" stop " Link "stop"}                         Stop program
 @{" set " Link "set"}                          Set function or variable value
 @{" get " Link "get"}                          Get function or variable value
 @{" group " Link "group"}                        Group manipulation
 @{" alias " Link "alias"}                        Define command alias
 @{" why " Link "why"}                          Return last error message


@EndNode

@Node "save" "Ami2D.guide/save"
@Next "read"
@Prev "Utility Commands"
@Toc "Utility Commands"

 -- Command: save FILE
     The complete model, problem type, material properties, geometry,
     boundary conditions, solutions, results, functions and aliases may
     be saved to a file using `save'. The file format used is an
     Interchange File Format (IFF) type developed specifically for this
     code. It is a binary file format and therefore cannot be edited
     conventionally. The only argument to this command is the name of
     the FILE to store the data. If no argument is given and the screen
     is open (see @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"}) then a file
     requester will be displayed.

          'save(ram:model.dat)'


@EndNode

@Node "read" "Ami2D.guide/read"
@Next "coord"
@Prev "save"
@Toc "Utility Commands"

 -- Command: read FILE
     The file produced by the `save' command (see
     @{"Utility Commands - save" Link "Utility Commands"}) can be read
     in by `read'. The only argument to this command is the name of the
     FILE containing the data. If no argument is given and the screen
     is open (see @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"}) then a file
     requester will be displayed.

          'read(results.dat)'


@EndNode

@Node "coord" "Ami2D.guide/coord"
@Next "cd"
@Prev "read"
@Toc "Utility Commands"

 -- Command: coord SYSTEM XORG YORG
     `coord' sets the coordinate SYSTEM to either the cartesian or
     polar coordinate systems.  It also allows specification of the
     coordinate system origin (XORG, YORG).  `coord' affects all
     commands that accept or return coordinate data.  It will also
     affect the display of coordinates in the screen title bar as well
     as the `grid' command if the screen is open (see
    
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"}).
     It should be noted that even if a model is not inherently
     cylindrical many circular features can be modeled more effectively
     using the polar coordinate system (with an origin offset). The
     coordinate system may be changed at any point during the modeling
     process with no effect on previously issued commands.

          'coord(polar,5,5)'


@EndNode

@Node "cd" "Ami2D.guide/cd"
@Next "reset"
@Prev "coord"
@Toc "Utility Commands"

 -- Command: cd DIR
     `cd' changes the directory path used by the `read' (see
     @{"Utility Commands - read" Link "Utility Commands"}) and `save'
     (see @{"Utility Commands - save" Link "Utility Commands"}) commands.  The argument is the new
     directory path (DIR) and must be a complete path specification. 
     If no argument is given then the current directory path will be
     returned (if it was previously specified).

          'cd(ami2d:test)'


@EndNode

@Node "reset" "Ami2D.guide/reset"
@Next "check"
@Prev "cd"
@Toc "Utility Commands"

 -- Command: reset FLAG FUNCTION
     `reset' will selectively clear (deallocate) memory.  If no
     arguments are given then all memory will be deallocated except for
     functions and aliases.  This should always be done before starting
     a new problem.  If `all' is specified for the FLAG then all memory
     is deallocated (should only be done when beginning a completely
     different kind of problem). Specifying `solutions', `groups',
     `functions' or `aliases' for the FLAG will deallocate the
     associated sections of memory.  If `results' is specified for the
     FLAG then the next argument (if given) indicates the FUNCTION name
     of the result to deallocate.  If this argument is not given then
     all results are deallocated.



@EndNode

@Node "check" "Ami2D.guide/check"
@Next "info"
@Prev "reset"
@Toc "Utility Commands"

 -- Command: check
     `check' will perform a check of model integrity. It will check for
     undefined nodes, elements and materials over elements and boundary
     conditions. These checks do not insure that the resulting system
     will be solvable, nor does it insure that element mapping is
     invertible (a necessary condition). However, if errors occur
     during formation of the global stiffness matrix that is generally
     an indication that the mesh is malformed, therefore, check the
     model for elements that are misshapen or misnumbered. Also, if
     errors occur in the solver check the boundary conditions for
     completeness (do not allow rigid body motion or rotation). Model
     statistics and memory requirements will also be output with this
     command. There are no arguments to `check'.



@EndNode

@Node "info" "Ami2D.guide/info"
@Next "version"
@Prev "check"
@Toc "Utility Commands"

 -- Command: info
     `info' gives information on the overall model and optionally on
     materials, nodes, elements, boundary conditions, solutions, groups
     and window settings. If no argument is given then the number of
     nodes, elements, groups and solutions is returned in the `ARexx'
     variable RESULT (assuming `options results' is used).

 -- Command: info "MAT" N
     If the first argument is `mat' then information is returned for the
     material specified by the second argument. A material is
     referenced by its identification number and by the currently
     specified problem kind (see @{"Problem Type - problem" Link "Problem Type"}). The data
     returned is the material order number, material id, type, kind,
     material coefficients (10), and two sets of body force terms
     consisting of the couple problem kind, body force coefficients (2),
     and reference value. If the material identification number is not
     given and the screen is open (see
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the material is selected using the mouse pointer.

 -- Command: info "NODE" N
     If the first argument is `node' then information is returned for
     the node specified by the second argument. A node can be referred
     to by its order number or assigned identification number (the
     number you originally assigned). In this way information can be
     obtained without knowledge of the original assigned numbering. If
     the order number is used then the argument must be positive (or
     zero since order numbers are zero based). Otherwise, negative
     numbers are interpreted as identification numbers (indicated by
     the absolute value). If MAX is specified for the second argument
     then information will be returned for the node with the maximum
     identification number.  If LAST is specified then information is
     returned for the node last defined. The data returned is the order
     number, node id, and the node x,y coordinates (referenced to the
     coordinate origin). If the polar coordinate system is set (see
     @{"Utility Commands - coord" Link "Utility Commands"}) then the
     coordinate data returned will be in polar form (a radius and
     angle, referenced to the coordinate system origin). If the node
     identification number is not specified and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the node is selected using the mouse pointer.

 -- Command: info "ELEM" N
     If the first argument is `elem' then information is returned for
     the element specified by the second argument. An element can be
     referred to by its order number or assigned identification number
     (the number you originally assigned, as above). If MAX is
     specified for the second argument then information will be
     returned for the element with the maximum identification number. 
     If LAST is specified then information is returned for the element
     last defined. The data returned is the order number, element id,
     material id, number of nodes, and the node order numbers (not the
     node ids). If the element identification number is not specified
     and the screen is open (see @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the element is selected using the mouse pointer.

 -- Command: info "PBC" DOF N
     If the first argument is `pbc' then information is returned for the
     point boundary condition on the node specified by the second
     argument (see above) for the degree of freedom specified. The data
     returned is the node order number, node id, boundary condition
     type, kind, degree of freedom, and the boundary condition value.
     If no boundary conditions (associated with the current problem
     kind) exist for the node then only the node order number and node
     identification number are returned. If the node identification
     number is not specified and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the node is selected using the mouse pointer.

 -- Command: info "DBC" DOF N SIDE
     If the first argument is `dbc' then information is returned for the
     distributed boundary condition on the element, side, and degree of
     freedom specified. The data returned is the element order number,
     element id, element side, boundary condition type, kind, degree of
     freedom, and the boundary condition values (one for each node
     along the element side).  If no boundary conditions (associated
     with the current problem kind) exist for the element side then
     only the element order number, identification number, and side are
     returned. If the element identification number is not specified
     and the screen is open (see @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the element side is selected using the mouse pointer.

 -- Command: info "SOLN" DOF N
     If the first argument is `soln' then a solution value is returned
     for the degree of freedom and node specified. The data returned is
     the node order number, node id, and solution value (associated
     with the current problem kind). If the node identification number
     is not specified and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the node is selected using the mouse pointer.

 -- Command: info "RESULT" NAME
     If the first argument is `result' then information on results is
     returned. The second argument (if specified) is the function name
     of the result. The data returned is the result kind, number of
     degrees of freedom, location flag, the minimum and maximum
     computed result values. If the function name is not specified then
     a list of result function names is returned. If any names are
     prepended with an `*' then that result has computed values
     otherwise the result function is only selected (ready for
     post-processing, see @{"Post2D" Link "Post2D"}).

 -- Command: info "FUNCTIONS"
     If the first argument is `function' then a list of defined
     function names is returned.

 -- Command: info "GROUP" NAME
     If the first argument is `group' then information on groups is
     returned. The second argument (if specified) is the name of the
     group. The data returned is the number of nodes contained in the
     group. If the group name is not specified then a list of group
     names is returned.

 -- Command: info "WINDOW"
     If the first argument is `window' then data is returned containing
     the window maximum and minimum coordinates in the form of xmin,
     xmax, ymin, ymax (as specified in the `window' command).



@EndNode

@Node "version" "Ami2D.guide/version"
@Next "stop"
@Prev "info"
@Toc "Utility Commands"

 -- Command: version
     `version' returns the version and the compilation date and time
     for `Ami2D'.



@EndNode

@Node "stop" "Ami2D.guide/stop"
@Next "set"
@Prev "version"
@Toc "Utility Commands"

 -- Command: stop
     `stop' will signals the code to exit thereby removing the code
     from memory. Any subsequently issued macros that reference this
     program will fail unless it is restarted. There are no arguments to
     `stop'.



@EndNode

@Node "set" "Ami2D.guide/set"
@Next "get"
@Prev "stop"
@Toc "Utility Commands"

 -- Command: set FUNCTION EXPR
     `set' is used to define functions used to post-process solution
     data and to store intermediate data for exchange between macros. 
     Pre-defined variable names may be used in the function expression
     (EXPR) as well as any other defined FUNCTION names.  Material
     coefficients may be referenced by using the pre-defined variables,
     C1 through C10 (the global material properties), which refer to
     the coefficients as input in the `mat' command and L1 through L10
     (the local lamina material properties) which refer to transformed
     coefficients referenced to the local element orientation.  The
     latter variables will only be defined for laminates (defined by
     the `lam' command) and will vary depending on location within the
     laminate (the material angle used to transform the properties is
     obtained from the lamina at the specified location). Also, element
     and material angles may be used through the predefined variables
     M1 and M2.  The variable M1 will contain the element principal
     orientation and M2 will contain the lamina material angle (in
     degrees). Both of these angles will vary with location and are
     most useful for transforming results to coincide with these
     natural orientations (for example, they could be used to calculate
     the fiber stress in a composite laminate). Body force components
     may be accessed through the pre-defined variables, F1 through F4
     (see @{"Materials - mat" Link "Materials"}).  Additionally, the variables P1 and P2 are
     defined as the local parametric coordinates of the element and
     range from 0.0 to 1.0 (note that these coordinates may be used to
     interpolate within an element and only make sense when a function
     is evaluated within an element, see @{"Results Processing - eval" Link "Results Processing"}).
     The pre-defined variables for `plane' (see @{"Problem Type - plane" Link "Problem Type"})
     problems are:

          u# - solution value
          x# - solution derivative with respect to 'x' or 'x' coordinate
          y# - solution derivative with respect to 'y' or 'y' coordinate

     The pre-defined variables for `axisym' (see @{"Problem Type - axisym" Link "Problem Type"})
     problems are:

          u# - solution value
          r# - solution derivative with respect to 'r' or 'r' coordinate
          z# - solution derivative with respect to 'z' or 'z' coordinate
          t# - solution derivative with respect to 't'

     Where the # symbol is replaced by the desired degree of freedom or
     is specified as zero (0) if coordinate values are desired.

     The function expression (EXPR) may be any valid algebraic
     expression which can contain any combination of operators,
     pre-defined variables and other defined functions. The expressions
     may also contain parenthesized sub-expressions, nested to any
     level. The allowed operators are `+', `-', `*', `/', and `^' (real
     exponent). Also built-in functions `abs', `sin', `cos', `tan',
     `asin', `acos', and `atan' (which takes two arguments separated by
     a comma) are available as well as the variable `pi'.  Note that
     all angle arguments for all functions and the return values from
     the `asin', `acos', and `atan' functions are in degrees.

     The FUNCTION name may be given as the first argument or as the
     left hand side of the expression separated by an `='. The latter
     option should be used for functions while the previous option
     should be used for defining constants. Also, no parentheses should
     be used to delimit the arguments because of possible conflicts
     with parentheses used in functions.

          'set tau12=(0.25*(sigr-sigz)^2+taurz^2)^0.5'
          'set sigf=cos(m2)*cos(m2)*sigz+sin(m2)*sin(m2)*sigt'
          'set material 2'


@EndNode

@Node "get" "Ami2D.guide/get"
@Next "group"
@Prev "set"
@Toc "Utility Commands"

 -- Command: get FUNCTION
     `get' is used to retrieve a FUNCTION or alias expression defined
     by the `set' (see @{"Utility Commands - set" Link "Utility Commands"}) and `alias' (see
     @{"Utility Commands - alias" Link "Utility Commands"}) commands.
     The argument is the FUNCTION or alias name. The FUNCTION or alias
     expression is returned in the `ARexx' variable RESULT (assuming
     that `options results' was specified in the macro).

          'get(material)'


@EndNode

@Node "group" "Ami2D.guide/group"
@Next "alias"
@Prev "get"
@Toc "Utility Commands"

 -- Command: group
     The `group' commands allow for manipulation of groups of nodes and
     associated elements. In general, groups are composed of nodes only,
     however, elements and boundary conditions associated with nodes
     contained in a group will be affected by group manipulation. Group
     names may be any length, but only the first nine characters are
     significant.

 -- Command: group NAME "ADD" N1 N2
     The `add' option is used for group creation.  If the group
     specified (NAME) does not exist then a new group is created
     otherwise the existing group will be added to.  The two subsequent
     arguments specify the nodes (by identification number) to be added
     as a sequence of nodes starting with node N1 and ending with node
     N2.  If N2 is given as zero then all nodes starting at N1 up to
     the last node in the model will be added.  If neither argument is
     given and the screen is open (see
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the nodes are selected by use of the mouse.  Nodes are
     selected by dragging rectangles around nodes to be added.  To
     terminate the selection process press the right mouse button.

 -- Command: group NAME "REM" N1 N2
     The `rem' option is used to remove nodes from an existing group
     (NAME).  This command is not destructive (no nodes are deleted).
     The two subsequent arguments specify the nodes (by identification
     number) to be removed as a sequence of nodes starting with node N1
     and ending with node N2.  If N2 is given as zero then all nodes
     starting at N1 up to the last node in the model will be removed. 
     If neither argument is given and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the nodes are selected by use of the mouse.  Nodes are
     selected by dragging rectangles around nodes to be removed.  To
     terminate the selection process press the right mouse button.

 -- Command: group NAME "TRAN" X1 Y1 X2 Y2
     The `tran' option is used to translate an existing group (NAME).
     The subsequent arguments specify the starting coordinate (X1, Y1)
     and ending coordinate (X1, Y1) for the translation. These
     coordinates are specified in either cartesian or polar form
     depending on the setting given in the `coord' command (see
     @{"Utility Commands - coord" Link "Utility Commands"}). It should
     be noted that the meaning of "translation" is different depending
     on the coordinate form.  In cartesian coordinates a translation is
     defined as a movement in the global `x' and `y' directions.  In
     polar coordinates a translation is defined as a movement in the
     radial and angular directions.  This effectively will result in
     rotation, translation and scaling in the most general use.  This
     feature can be utilized with great effectiveness if used properly.
      If no arguments are given and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then the two positions are selected by use of the mouse.

 -- Command: group NAME "DEL"
     The `del' option is used to delete nodes contained in an existing
     group (NAME). This command is destructive (so beware). All nodes
     and associated elements and boundary conditions will be deleted
     from the model.

 -- Command: group NAME "SAVE"
     The `save' option is used to save a group (NAME) to an IFF binary
     file (see @{"Utility Commands - save" Link "Utility Commands"}). Only nodes and associated
     elements (elements whose nodes are all contained in the group) are
     saved.

 -- Command: group NAME "READ"
     The `read' option is used to read in a group from an IFF binary
     file (see @{"Utility Commands - save" Link "Utility Commands"}). If the named group (NAME)
     exists then the nodes (and elements) read in will be added to the
     group. If the group does not exist a new group will be created.
     The node (and element) identification numbers will start after the
     maximum identification number in the current model (in other
     words, no nodes or elements will be overwritten).

 -- Command: group NAME "OFF"
     The `off' option is used to remove a group temporarily. If a group
     is "turned off" most subsequent element operations will ignore
     elements contained in this group.  Additionally, results will not
     be calculated by the post-processor (see @{"Post2D" Link "Post2D"}) for any of the
     associated elements. If the model is displayed (see
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - plot - fill" Link "Graphic Interactive Commands"})
     the elements, contained in the group, will be ghosted.

 -- Command: group NAME "ON"
     The `on' option is used to return a group to the processing list. 
     Subsequent element operations will now effect this group.
     Additionally, post-processing will result in values being
     calculated for the associated elements.  Note that if results were
     calculated previously with the group "turned off" then no results
     are available for the affected group even if the group is "turned
     on".  In this case, the result function would have to be reselected
     (see @{"Results Processing - select" Link "Results Processing"}) and the model post-processed
     (see @{"Post2D" Link "Post2D"}).



@EndNode

@Node "alias" "Ami2D.guide/alias"
@Next "why"
@Prev "group"
@Toc "Utility Commands"

 -- Command: alias NAME EXPR
     `alias' is used to create aliases for built-in commands. In this
     manner `Ami2D' may be customized to many different applications.
     Aliases are defined through the use of the pre-defined variables
     A1 through A#. These pre-defined variables contain the argument
     entries of the alias command. For example, the alias `iso' shown
     below will have its arguments placed in the pre-defined variables
     A1 through A3. These arguments are then used in the alias
     definition as well as in functions used in the alias definition.
     In this case, an isotropic material definition command was created
     from the more complex `mat' command. In actual use the `iso' alias
     command might look like the following.

          'set la=a2*a3/((1+a3)*(1-2*a3))'
          'set mu=a2/(2*(1+a3))'
          'alias iso=mat(a1,0,0,la+2*mu,la+2*mu,la+2*mu,mu,la,la,0.0,la)'
          'iso(1,10.e6,0.3)'

     Note that functions may be used in aliases with no restrictions
     (although some uses may not make any sense). Aliases, however, may
     not be used in other aliases or functions.  Also note that
     functions containing the pre-defined variables A1 through A# only
     make sense when used with aliases.


@EndNode

@Node "why" "Ami2D.guide/why"
@Next "(dir)"
@Prev "alias"
@Toc "Utility Commands"

 -- Command: why
     `why' will return the last error message associated with an error
     condition in the `ARexx' variable RESULT (assuming `options
     results' is used in the macro). If an error occurs the `ARexx'
     variable RC will contain a severity level. Refer to references on
     the `ARexx' language for details on error handling (see
     @{"References" Link "References"}). Upon receiving an error
     condition this command can be used to help determine what error
     actually occurred.


@EndNode

@Node "Graphic Interactive Commands" "Ami2D.guide/Graphic Interactive Commands"
@Prev "Utility Commands"
@Toc "Command Reference"

Graphic Interactive Commands
============================

   The following commands comprise the graphical interactive interface
builtin to `Ami2D'. Of course, all previously discussed commands will
also function, but these commands (except `open' and `window') are only
valid for use with the public screen opened by the `open' command.

   It should be noted that most interactive commands may be aborted by
pressing the right mouse button. This includes all previously discussed
model creation commands.


 @{" open " Link "open"}                         Open public screen
 @{" close " Link "close"}                        Close public screen
 @{" view " Link "view"}                         Open a new view
 @{" plot " Link "plot"}                         Plot model or boundary conditions
 @{" fill " Link "fill"}                         Fill plot model
 @{" window " Link "window"}                       Set view dimensions for window
 @{" grid " Link "grid"}                         Set restricted coordinate grid
 @{" find " Link "find"}                         Reset view window to full model
 @{" zoom " Link "zoom"}                         Expand or shrink view
 @{" move " Link "move"}                         Move view window
 @{" clear " Link "clear"}                        Clear view window
 @{" show " Link "show"}                         Show me
 @{" hard " Link "hard"}                         Let's see that on paper
 @{" color " Link "color"}                        So you don't like my default colors


@EndNode

@Node "open" "Ami2D.guide/open"
@Next "close"
@Prev "Graphic Interactive Commands"
@Toc "Graphic Interactive Commands"

 -- Command: open XOFF YOFF MODE
     `open' will open the public screen for `Ami2D'. The name of the
     screen is `AMI2D' (what else) and can be accessed by other
     applications. Typically, this command will only be used from
     within a startup macro (see `ami2d.rexx' for an example of a
     startup macro for `Ami2D'). The size of the screen will be set to
     the maximum display size and the depth of the screen will be 4
     bit-planes (16 displayable colors). The arguments to this command
     specify offsets (XOFF, YOFF) to the root window (i.e. the area
     where all graphics are rendered) left hand side and top edge in
     pixels. If either offset is negative then the offset will be
     relative to the right hand side and bottom edge respectively. The
     window will also be reduced by the amount of the offsets. This
     allows for placement of other windows without obscuring the
     display.

     The argument, MODE allows specification of the display mode to use
     for the screen.  If not specified then the display mode that the
     `Workbench' is set to will be used.

     If no arguments are given then the screen will be opened (if it is
     not already open) with the offsets set to zero and the display
     mode set to match the `Workbench'.  If the screen was previously
     opened (and no arguments are given) then the size of the screen is
     returned in `RESULT'.  If offsets are given and the screen has
     been previously opened then the root window will be adjusted
     accordingly.

          'open(50,40)'
          'open(-68,-50,PICASSO:1024x768)'


@EndNode

@Node "close" "Ami2D.guide/close"
@Next "view"
@Prev "open"
@Toc "Graphic Interactive Commands"

 -- Command: close
     `close' will close the public screen, if possible. The screen will
     not close if visiting windows are still open on the screen. This
     command will have to be reissued, if the screen could not be
     closed, after all visiting windows are closed. There are no
     arguments to this command.


@EndNode

@Node "view" "Ami2D.guide/view"
@Next "plot"
@Prev "close"
@Toc "Graphic Interactive Commands"

 -- Command: view ID SCALE
     `view' will open or select a view on the public screen. The first
     argument is used to specify the identification number (1 - 9) for
     the view and also serves to initially place the view.  If this
     argument (and following argument) are not specified then the root
     window will be selected.  If the `scale' argument is given then a
     new view will be opened (closing any existing view with the same
     identification number) at the scale specified.  If zero is given
     for the scale then the view will be closed.  Any subsequent
     graphics output will be directed to the currently selected view. 
     Any interactive graphical input will always be referenced to the
     root window.


@EndNode

@Node "plot" "Ami2D.guide/plot"
@Next "fill"
@Prev "view"
@Toc "Graphic Interactive Commands"

 -- Command: plot
 -- Command: plot "MODEL"
     `plot' will plot the nodes and elements of the model.  If no
     arguments are specified then the model will be plotted.

 -- Command: plot "DEFORM" SCALE
     If `deform' is specified for the first argument then displacements
     (actually, any solution with two degrees of freedom will be
     treated as displacements by this command, so beware) are added to
     the nodal coordinates.  Optionally, a third argument specifies a
     deformation SCALE which by default is 1 (giving actually
     deformation).

          'plot(deform,2.0)'

 -- Command: plot "BCS"
     If `bcs' is specified for the first argument then all boundary
     conditions are plotted.

          'plot(bcs)'

 -- Command: plot "BOUND"
     If `bound' is used then free boundaries (unconnected element
     edges) will be highlighted.  The last option is useful for
     determining if any nodes need to be equivalenced (see @{"Equ2D" Link "Equ2D"}).

          'plot(bound)'

 -- Command: plot "RESULT" FUN1 FUN2 SUBD RMIN RMAX
     If `result' is specified for the first argument then results will
     be plotted within each element.  The first result function
     specified (FUN1) is assumed to be a magnitude with the second
     (FUN2) assumed to define a direction.  The combination of these two
     results are plotted as vectors with corresponding magnitude
     (indicated by color) and direction.  The specified result
     functions must have been previously processed (see @{"Post2D" Link "Post2D"}).  A
     direction result is assumed to have units of degrees (such as
     would be returned by the `atan' builtin function, see
     @{"Utility Commands - set" Link "Utility Commands"}). If an
     element subdivision (SUBD) is given and the results were processed
     at the nodes (see @{"Results Processing - select" Link "Results Processing"}) then each element
     is subdivided into equal regions each of which will have a vector
     plotted at the centroid corresponding to the interpolated result
     at that location.  If results were processed at the Gaussian
     quadrature points then vectors will only be plotted at those
     points within each element (and this argument will be ignored.  If
     this argument is not specified then 0 is assumed.  Finally, a
     range of values may be given by specifying the minimum (RMIN) and
     maximum (RMAX) result values.  If not given then the range is set
     to include the the full range of values processed.

          'set flux=-c1*(x1*x1+y1*y1)^0.5'
          'set fdir=atan(y1,x1)'
                  .
                  .
                  .
          --- run Post2D ---
                  .
                  .
                  .
          'plot(result,flux,fdir,2)'


@EndNode

@Node "fill" "Ami2D.guide/fill"
@Next "window"
@Prev "plot"
@Toc "Graphic Interactive Commands"

 -- Command: fill
 -- Command: fill "MODEL"
     `fill' will plot the elements of the model and fill them with a
     color dependent on the material assigned to the element or results
     computed.  If no arguments are specified then the model will be
     plotted.

 -- Command: fill "DEFORM" SCALE
     If `deform' is specified for the first argument then displacements
     (actually, any solution with two degrees of freedom will be
     treated as displacements by this command, so beware) are added to
     the nodal coordinates.  Optionally, an additional argument
     specifies a deformation SCALE which by default is 1 (giving
     actually deformation).

          'fill(deform,2.0)'

 -- Command: fill "RESULT" FUN COMB RMIN RMAX
     If `result' is specified for the first argument then the elements
     will be filled with a color dependent on the results (given by the
     function name, FUN) calculated by the post-processor (see @{"Post2D" Link "Post2D"}).
      Additional arguments may be given to indicate how to combine the
     results within an element and to give the range of result values. 
     Result combination (COMB) may be specified as `max', `min', `ave'
     or an integer.  These options will give either the maximum,
     minimum or average value of the results calculated within each
     element respectively.  If an integer value (> 0) is given for COMB
     then each element is subdivided into equal regions each of which
     are filled according to the interpolated result at the center of
     the subregion.  Since result interpolation is used in this option
     results must have been processed at the nodes (see
     @{"Results Processing - select" Link "Results Processing"}). If
     this argument is not specified then `max' is assumed.  Finally, a
     range of values may be given by specifying the minimum (RMIN) and
     maximum (RMAX) result values.  If not given then the range is set
     to include the the full range of values calculated by the
     post-processor.

          'fill(result,temp,ave,0.0,100.0)'
          'fill(result,sigd,4)'


@EndNode

@Node "window" "Ami2D.guide/window"
@Next "grid"
@Prev "fill"
@Toc "Graphic Interactive Commands"

 -- Command: window XMIN XMAX YMIN YMAX
     `window' is used to specify world coordinates for the window.  If
     no arguments are given then the window is selected using the mouse
     by pressing and holding the left mouse button and dragging the box
     until the region of interest is enclosed.  The arguments are the
     minimum x (XMIN), maximum x (XMAX), minimum y (YMIN) and maximum y
     (YMAX) coordinates in that order.

          'window(-10.0,20.0,0.0,30.0)'


@EndNode

@Node "grid" "Ami2D.guide/grid"
@Next "find"
@Prev "window"
@Toc "Graphic Interactive Commands"

 -- Command: grid XINC YINC
     With `grid' an invisible grid is created.  Subsequent node, element
     and boundary condition selection will be restricted to coordinates
     that fall on the grid points.  The arguments are the `x' and `y'
     (or `r' and `t' if the coordinate system is set to `polar', see
     @{"Utility Commands - coord" Link "Utility Commands"}) grid
     increments (XINC, YINC) specified in world coordinates.

          'grid(0.5,0.25)'


@EndNode

@Node "find" "Ami2D.guide/find"
@Next "zoom"
@Prev "grid"
@Toc "Graphic Interactive Commands"

 -- Command: find
     `find' will reset the window to include the full model. The model
     will be replotted. There are no arguments to `find'.


@EndNode

@Node "zoom" "Ami2D.guide/zoom"
@Next "move"
@Prev "find"
@Toc "Graphic Interactive Commands"

 -- Command: zoom FACTOR
     `zoom' will increase or decrease the window size dependent on the
     specified FACTOR. A value of one will cause no change. Values less
     than one will shrink the window (zoom in) whereas values greater
     than one will expand the window (zoom out).  If no argument is
     given then the window is expanded or shrunk interactively by
     pressing and holding the left mouse button and moving the mouse.

          'zoom(0.5)'


@EndNode

@Node "move" "Ami2D.guide/move"
@Next "clear"
@Prev "zoom"
@Toc "Graphic Interactive Commands"

 -- Command: move XFRACT YFRACT
     `move' is used to move the window along the x and y directions. 
     The arguments specify the x and y move in terms of screen fraction
     (XFRACT, YFRACT).  Values of zero cause no change for that
     direction.  A value of one will cause a shift of a full screen
     width or height (depending on the direction specified) in the
     positive direction (right or up).  If no argument is given then
     the window is moved interactively by pressing and holding the left
     mouse button and moving the mouse.

          'move(-.5,0.0)'


@EndNode

@Node "clear" "Ami2D.guide/clear"
@Next "show"
@Prev "move"
@Toc "Graphic Interactive Commands"

 -- Command: clear
     `clear' will clear the screen. There are no arguments to `clear'.


@EndNode

@Node "show" "Ami2D.guide/show"
@Next "hard"
@Prev "clear"
@Toc "Graphic Interactive Commands"

 -- Command: show
 -- Command: show "NODE" N FLAG
 -- Command: show "ELEM" N FLAG
 -- Command: show "GROUP" NAME
     `show' will plot (in complementary mode) the requested item(s).  If
     FLAG is set to `1' then the corresponding node or element
     identification number (N) will be plotted next to the item.  If the
     `group' option is specified all nodes in the group (specified by
     NAME) will be plotted.

          'show(group,part)'


@EndNode

@Node "hard" "Ami2D.guide/hard"
@Next "color"
@Prev "show"
@Toc "Graphic Interactive Commands"

 -- Command: hard FILE
     `hard' initiates and terminates hardcopy output.  When first
     issued a FILE will be opened for writing hardcopy output.  If no
     argument is given and the screen is open (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - open" Link "Graphic Interactive Commands"})
     then a file requester will be displayed.  Subsequent plot (see
    
    
    
    
    
    
    
    
    
    
     @{"Graphic Interactive Commands - plot" Link "Graphic Interactive Commands"})
     and fill (see @{"Graphic Interactive Commands - fill" Link "Graphic Interactive Commands"}) commands issued
     will result in hardcopy output (as well as screen output). Color
     Postscript commands are used as the output format and should
     result in a complete Postscript file readable by any Postscript
     capable software.  If `hard' is issued again, hardcopy output will
     be closed allowing for multiple hardcopy invocations in any
     session.

          'hard(ram:model.ps)'


@EndNode

@Node "color" "Ami2D.guide/color"
@Next "(dir)"
@Prev "hard"
@Toc "Graphic Interactive Commands"

 -- Command: color ID R G B
     `color' allows for the specification of the screen (and hardcopy)
     color spectrum.  The first argument (ID) is the identification
     number of the color to be changed.  It is recommended that only
     colors between identification number 4 and 15 (inclusive) be
     altered since colors 0 through 3 are pen colors used by Intuition.
      Also, in hardcopy output, only colors 4 through 15 are used (color
     0 is always assumed to be white and colors 1 through 3 are black).
     The subsequent arguments (R, G, B) are integers between the values
     0 and 15 (inclusive).

          'color(4,10,5,8)'


@EndNode

@Node "Discussion" "Ami2D.guide/Discussion"
@Next "Example Problem"
@Prev "Command Reference"
@Toc "Main"

Discussion
**********

   The following sections discuss some of the finer details concerning
the use of `Ami2D'.


 @{" Modeling Considerations " Link "Modeling Considerations"} 
 @{" Element Instability " Link "Element Instability"} 
 @{" Post-Processing Accuracy " Link "Post-Processing Accuracy"} 
 @{" Graphic Interaction with Ami2D " Link "Graphic Interaction with Ami2D"} 


@EndNode

@Node "Modeling Considerations" "Ami2D.guide/Modeling Considerations"
@Next "Element Instability"
@Toc "Discussion"

Modeling Considerations
=======================

   Since the stiffness matrix resulting from the finite element
descretization is generally large, sparse and is always symmetric,
storage space and computational requirements can be reduced by
minimizing the bandwidth of the stiffness matrix. The bandwidth of the
stiffness matrix is directly related to the maximum separation in node
order in each element. It should be noted that the node ordering, not
the assignment of node identification numbers, affects the bandwidth.
For rectangular grids the minimum bandwidth can be achieved by defining
the nodes in the direction defined by the shorter side. For
non-rectangular grids it is not so apparent how to order the grid to
achieve the minimum bandwidth. A rule of thumb is to try to keep the
difference between the earliest defined node and latest defined node
within any element to a minimum. The absolute worst ordered grid would
be to have an element that contains both the first defined node and the
last defined node.

   It is also important to keep local node numbering within all elements
ordered in a counterclockwise direction to avoid negative Jacobians. It
is also good practice to number this way as a habit in order to
maintain model consistency.

   A node order optimizer called `Opt2D' is included with this
distribution. For poorly ordered grids this optimizer can significantly
reduce the bandwidth and therefore reduce memory requirements and
execution times. However, for low aspect ratio rectangular grids with
well ordered nodes the optimizer can increase the bandwidth.
Documentation is provided for `Opt2D'.


@EndNode

@Node "Element Instability" "Ami2D.guide/Element Instability"
@Next "Post-Processing Accuracy"
@Prev "Modeling Considerations"
@Toc "Discussion"

Element Instability
===================

   All element configurations exhibit "spurious" modes (instabilities)
which can typically be prevented through proper boundary condition
specification. These modes can be described as zero energy modes where
certain nontrivial solutions produce no energy. An example of a zero
energy mode is rigid body motion (translation and/or rotation). Through
proper application of displacement (Dirichlet) boundary conditions,
rigid body motions can be prevented. However, some element
configurations exhibit additional "spurious" modes some of which render
the element unusable. Proper selection of element order and number of
integration points can prevent these extra modes from occurring,
however, over-integration is also undesirable due to the additional
(typically unnecessary) computational requirements.

   To determine if an element is usable one must solve the eigenvalue
problem associated with the particular element configuration (that is
find all eigenvalues and associated eigenvectors that satisfy the
equation `Ku = cu', where `K' is the element stiffness matrix and `c'
and `u' are the eigenvalues and eigenvectors). The eigenvectors
associated with any zero eigenvalues represent a basis defining
(spanning) the null space of `K' (i.e. any vectors contained in this
space may be represented as a linear combination of the basis vectors
defining the space). That is these eigenvectors (and any linear
combination of these vectors), if operated on by `K', result in no
reactive force (no energy produced). Applying these zero energy
eigenvectors to the nodal coordinates one obtains a visual
representation of the zero energy modes.

   To illustrate, consider the vector valued displacement problem using
the eight node element with a `2x2' integration rule. The number of zero
energy modes, for this element, is four (found by subtracting the rank
of the element stiffness matrix from its order). These modes correspond
to the expected three rigid body motions (two translations and one
rotation) plus an extra "spurious" mode. However, this element is still
usable since this extra mode is not communicable (adjoining elements
provide constraint against this mode).  It can also be shown that for
scalar valued problems (such as heat conduction problems) this element
is over-integrated and exhibits no extra "spurious" modes.

   For the same element order, but with a `3x3' integration rule
instead, the number of zero energy modes is three which corresponds to
the three possible rigid body motions. This element is in fact
over-integrated thereby resulting in no extra "spurious" modes but at a
cost of doing more calculations (and not necessarily gaining any
accuracy).

   To further illustrate, consider the vector valued displacement
problem using the nine node element with a `2x2' integration rule. The
number of zero energy modes, for this element, is six. The extra zero
energy modes found for this element are all "spurious" modes some of
which are communicable thereby rendering this element unusable. With a
`3x3' integration rule this element is over-integrated but is the
element of choice since the `2x2' integration rule results in an
unusable element.


@EndNode

@Node "Post-Processing Accuracy" "Ami2D.guide/Post-Processing Accuracy"
@Next "Graphic Interaction with Ami2D"
@Prev "Element Instability"
@Toc "Discussion"

Post-Processing Accuracy
========================

   The accuracy of the results obtained from the finite element method
can depend heavily on where evaluation of the solution is performed. The
locations, within a particular element, where the results (based on
solution derivatives) are the most accurate have been shown to coincide
with the Gaussian quadrature points with the order of the Gaussian rule
chosen to be the same as the order of the element. The capability to
compute results at these locations is an option in the external
post-processor (see @{"Post2D" Link "Post2D"} and @{"Utility Commands - select" Link "Utility Commands"}) and should be
used when the solution derivative is known to be changing rapidly
across an element. Unfortunately, the Gaussian quadrature points are
typically interior points which do not coincide with the nodal point
locations. Therefore, if results must be output for nodal point
locations it is suggested that the mesh be refined in areas where the
solution derivatives are expected to vary significantly.


@EndNode

@Node "Graphic Interaction with Ami2D" "Ami2D.guide/Graphic Interaction with Ami2D"
@Prev "Post-Processing Accuracy"
@Toc "Discussion"

Graphic Interaction with Ami2D
==============================

   `Ami2D' contains commands that allow you to graphically interact with
the code through its `ARexx' port.  These commands were discussed above
in detail, but it should be apparent that more is needed to integrate
your input with this graphical interface.  Hence the inclusion of the
ancillary codes - `rexxcon' and `rexxbar'.  The code `rexxcon' simply
provides a console window which accepts input in a command line shell
environment.  For `Ami2D' an `ARexx' macro is provided (called
`ami2d.rexx') that starts up `Ami2D' and uses `rexxcon' to open a
console window on the `Ami2D' public screen. Commands typed in this
console window are read by the `ARexx' macro and then issued to
`Ami2D'.  This allows you to type commands directly in the console
without the need to address `Ami2D' or surround the commands with
quotes.  The `ami2d.rexx' macro also allows any AmigaDOS command to be
issued by preceding the command with a `!'. `ARexx' macros may be
executed by preceding the macro name (with or without the `.rexx'
extension) with a `!rx' (assuming the system path includes a path to
the `rx' command, usually the `sys:REXXC' directory).

   The other code provided is `rexxbar' which `ami2d.rexx' uses to open
another window on the `Ami2D' screen. This window contains buttons that
when selected cause other `ARexx' macros to be executed. The macros
associated with these buttons in turn send commands to `Ami2D'.

   Both `rexxcon' and `rexxbar' are completely tailorable. For
`rexxcon' the window specification can be altered to any preferred size
and placement. Also any valid console device can be specified (for
example WShell or the conman console devices by William Hawes may be
used thereby providing the full capabilities of those devices in the
`rexxcon' window).  The buttons and associated macros used in `rexxbar'
can also be tailored as well as the size and placement of the window. A
description of the interface as provided by the `ami2d.rexx' macro
would be futile because of this flexibility (for information on
specific macros read the comments contained in the macro files). Also
separate appendices are provided for `rexxcon' (see @{"Rexxcon" Link "Rexxcon"}) and
`rexxbar' (see @{"Rexxbar" Link "Rexxbar"}) which give a general description of the codes
for use in applications. A flow diagram illustrating the interaction of
all the components set up by the `ami2d.rexx' macro is shown in
@{"ami2d.iff" system "sys:Utilities/display ami2d:doc/ami2d.iff"}.


@EndNode

@Node "Example Problem" "Ami2D.guide/Example Problem"
@Next "References"
@Prev "Discussion"
@Toc "Main"

Example Problem
***************

   The following macro is included as a simple example to illustrate the
use of an `ARexx' macro to generate a model. The advantages of using an
`ARexx' macro are ease of debugging and the use of parametric variation
to name a couple. This macro can be executed as any `ARexx' macro and
will produce a model file ready to be solved by `Lin2D'. `Ami2D' is
automatically invoked, by the macro, if it is not already running.

     /* simple beam */
     options results
     
     address command
     if ~show('ports', "AMI2D") then do
         'run ami2d:bin/ami2d ami2d:rexx/init'
         'waitforport AMI2D'
     end
     
     address ami2d
     
     h = 0.5
     L = 10.0
     E = 10.0e6
     nu = 0.3000
     
     reset
     problem 'struct'
     plane
     iso 1 E nu
     do i=0 to 20
         xx = L*i/20
         node i+1 xx 0.0
         node i+31 xx h
     end
     do i=0 to 19
         quad4 i+1 1 i+1 i+2 i+32 i+31
     end
     dispx 1 0.0
     dispy 1 0.0
     dispx 31 0.0
     dispy 31 0.0
     forcy 51 (-100.0)
     check
     say result
     save 'beam.dat'
     exit


@EndNode

@Node "References" "Ami2D.guide/References"
@Next "Acknowledgments"
@Prev "Example Problem"
@Toc "Main"

References
**********

  1. Hawes, William S., *ARexx User's Reference Manual*

  2. Becker, Eric B., Carey, Graham F., Oden, J. Tinsley, *Finite
     Elements, An Introduction*, Volume 1, Prentice-Hall Inc., 1981

  3. Zienkiewicz, O.C., Taylor, R.L., *The Finite Element Method*,
     Volumes 1 & 2, Fourth Edition, McGraw-Hill Book Company, 1991

  4. Schildt, H., *C, The Complete Reference*, Second Edition, Osborne
     McGraw-Hill, 1990


@EndNode

@Node "Acknowledgments" "Ami2D.guide/Acknowledgments"
@Next "Ami2D Macros"
@Prev "References"
@Toc "Main"

Acknowledgments
***************

   I acknowledge Commodore and the Amiga crew for producing the
hardware and operating system of unmatched elegance that makes up the
Amiga line of computers.  The power and flexibility of this hardware
and software combination makes possible the development of
sophisticated and efficient programs that are only possible on this
platform.  I would also like to acknowledge William Hawes and Willy
Langeveld for their contributions to the power of the Amiga's operating
system through the development of `ARexx' and the `rexxmathlib',
`rexxarplib' libraries.  The addition of `ARexx' to the current
operating system has, in my opinion, placed the Amiga's operating
system in the forefront of OS technology and provides unparalleled
programming flexibility when combined with the truly multitasking
environment of the Amiga computers.  As a programmer and engineer I
have found (especially with the development of `Ami2D') that I have
become very spoiled by the Amiga's capabilities. There literally is no
other computer platform which I would choose to attempt to produce code
for.

   I would also like to acknowledge Dr.  Eric Becker and Dr.  Linda
Hayes, of the Aerospace Engineering and Engineering Mechanics
Department of The University of Texas at Austin, for passing on the
knowledge of the finite element method directly and indirectly through
course work and research assistance.  It is this knowledge that made
possible the development of `Lin2D' and `Nln2D'.  In fact, both codes
started out as course term projects directed by Dr.  Hayes and Dr. 
Becker.

   Finally, I acknowledge the United States Air Force, Phillips
Laboratory for providing the support and funding for my graduate work
and hence the development of this software.


@EndNode

@Node "Ami2D Macros" "Ami2D.guide/Ami2D Macros"
@Next "Lin2D"
@Prev "Acknowledgments"
@Toc "Main"

Ami2D Macros
************


 @{" General Macros " Link "General Macros"}               General macros found in Ami2D:rexx
 @{" Geometry Macros " Link "Geometry Macros"}              Macros found in Ami2D:macros/geom
 @{" Boundary Condition Macros " Link "Boundary Condition Macros"}    Macros found in Ami2D:macros/bcs
 @{" Solve Macros " Link "Solve Macros"}                 Macros found in Ami2D:macros/solve
 @{" Process Macros " Link "Process Macros"}               Macros found in Ami2D:macros/process
 @{" Help Macros " Link "Help Macros"}                  Macros found in Ami2D:macros/help


@EndNode

@Node "General Macros" "Ami2D.guide/General Macros"
@Next "Geometry Macros"
@Toc "Ami2D Macros"

General Macros
==============

   The following are general macros for code startup, problem
initialization, cleanup, etc.  They can be found in "Ami2D:rexx".

   * ami2d (see @{"ami2d.rexx" Link "ami2d:rexx/ami2d.rexx/Header"}).

   * axisym (see @{"axisym.rexx" Link "ami2d:rexx/axisym.rexx/Header"}).

   * bcsbar (see @{"bcsbar.rexx" Link "ami2d:rexx/bcsbar.rexx/Header"}).

   * caxisym (see @{"caxisym.rexx" Link "ami2d:rexx/caxisym.rexx/Header"}).

   * cleanup (see @{"cleanup.rexx" Link "ami2d:rexx/cleanup.rexx/Header"}).

   * cstrain (see @{"cstrain.rexx" Link "ami2d:rexx/cstrain.rexx/Header"}).

   * cstress (see @{"cstress.rexx" Link "ami2d:rexx/cstress.rexx/Header"}).

   * geombar (see @{"geombar.rexx" Link "ami2d:rexx/geombar.rexx/Header"}).

   * helpbar (see @{"helpbar.rexx" Link "ami2d:rexx/helpbar.rexx/Header"}).

   * init (see @{"init.rexx" Link "ami2d:rexx/init.rexx/Header"}).

   * mainbar (see @{"mainbar.rexx" Link "ami2d:rexx/mainbar.rexx/Header"}).

   * movebar (see @{"movebar.rexx" Link "ami2d:rexx/movebar.rexx/Header"}).

   * plstrain (see @{"plstrain.rexx" Link "ami2d:rexx/plstrain.rexx/Header"}).

   * plstress (see @{"plstress.rexx" Link "ami2d:rexx/plstress.rexx/Header"}).

   * procbar (see @{"procbar.rexx" Link "ami2d:rexx/procbar.rexx/Header"}).

   * pstrain (see @{"pstrain.rexx" Link "ami2d:rexx/pstrain.rexx/Header"}).

   * pstress (see @{"pstress.rexx" Link "ami2d:rexx/pstress.rexx/Header"}).

   * rexxcon (see @{"rexxcon.rexx" Link "ami2d:rexx/rexxcon.rexx/Header"}).

   * solstat (see @{"solstat.rexx" Link "ami2d:rexx/solstat.rexx/Header"}).

   * solvebar (see @{"solvebar.rexx" Link "ami2d:rexx/solvebar.rexx/Header"}).

   * tutorial (see @{"tutorial.rexx" Link "ami2d:rexx/tutorial.rexx/Header"}).

   * tutrbar (see @{"tutrbar.rexx" Link "ami2d:rexx/tutrbar.rexx/Header"}).


@EndNode

@Node "Geometry Macros" "Ami2D.guide/Geometry Macros"
@Next "Boundary Condition Macros"
@Prev "General Macros"
@Toc "Ami2D Macros"

Geometry Macros
===============

   The following are macros for the creation and manipulation of
geometry. They can be found in "Ami2D:macros/geom".

   * genline (see @{"genline.rexx" Link "ami2d:macros/geom/genline.rexx/Header"}).

   * genquad4 (see @{"genquad4.rexx" Link "ami2d:macros/geom/genquad4.rexx/Header"}).

   * genquad8 (see @{"genquad8.rexx" Link "ami2d:macros/geom/genquad8.rexx/Header"}).

   * genregion (see @{"genregion.rexx" Link "ami2d:macros/geom/genregion.rexx/Header"}).

   * quad4 (see @{"quad4.rexx" Link "ami2d:macros/geom/quad4.rexx/Header"}).

   * quad8 (see @{"quad8.rexx" Link "ami2d:macros/geom/quad8.rexx/Header"}).

   * quad9 (see @{"quad9.rexx" Link "ami2d:macros/geom/quad9.rexx/Header"}).

   * refine (see @{"refine.rexx" Link "ami2d:macros/geom/refine.rexx/Header"}).

   * transition (see @{"transition.rexx" Link "ami2d:macros/geom/transition.rexx/Header"}).

   * tri3 (see @{"tri3.rexx" Link "ami2d:macros/geom/tri3.rexx/Header"}).

   * tri6 (see @{"tri6.rexx" Link "ami2d:macros/geom/tri6.rexx/Header"}).


@EndNode

@Node "Boundary Condition Macros" "Ami2D.guide/Boundary Condition Macros"
@Next "Solve Macros"
@Prev "Geometry Macros"
@Toc "Ami2D Macros"

Boundary Condition Macros
=========================

   The following are macros for the creation and manipulation of
boundary conditions.  They can be found in "Ami2D:macros/bcs".

   * dispx (see @{"dispx.rexx" Link "ami2d:macros/bcs/dispx.rexx/Header"}).

   * dispy (see @{"dispy.rexx" Link "ami2d:macros/bcs/dispy.rexx/Header"}).

   * forcx (see @{"forcx.rexx" Link "ami2d:macros/bcs/forcx.rexx/Header"}).

   * forcy (see @{"forcy.rexx" Link "ami2d:macros/bcs/forcy.rexx/Header"}).

   * gendispx (see @{"gendispx.rexx" Link "ami2d:macros/bcs/gendispx.rexx/Header"}).

   * gendispy (see @{"gendispy.rexx" Link "ami2d:macros/bcs/gendispy.rexx/Header"}).

   * genpress (see @{"genpress.rexx" Link "ami2d:macros/bcs/genpress.rexx/Header"}).

   * press (see @{"press.rexx" Link "ami2d:macros/bcs/press.rexx/Header"}).

   * remdispx (see @{"remdispx.rexx" Link "ami2d:macros/bcs/remdispx.rexx/Header"}).

   * remdispy (see @{"remdispy.rexx" Link "ami2d:macros/bcs/remdispy.rexx/Header"}).

   * rempress (see @{"rempress.rexx" Link "ami2d:macros/bcs/rempress.rexx/Header"}).

   * remtemp (see @{"remtemp.rexx" Link "ami2d:macros/bcs/remtemp.rexx/Header"}).

   * tract (see @{"tract.rexx" Link "ami2d:macros/bcs/tract.rexx/Header"}).


@EndNode

@Node "Solve Macros" "Ami2D.guide/Solve Macros"
@Next "Process Macros"
@Prev "Boundary Condition Macros"
@Toc "Ami2D Macros"

Solve Macros
============

   These macros can be found in "Ami2D:macros/solve".

   * equ2d (see @{"equ2d.rexx" Link "ami2d:macros/solve/equ2d.rexx/Header"}).

   * lin2d (see @{"lin2d.rexx" Link "ami2d:macros/solve/lin2d.rexx/Header"}).

   * nln2d (see @{"nln2d.rexx" Link "ami2d:macros/solve/nln2d.rexx/Header"}).

   * nlsolve (see @{"nlsolve.rexx" Link "ami2d:macros/solve/nlsolve.rexx/Header"}).

   * opt2d (see @{"opt2d.rexx" Link "ami2d:macros/solve/opt2d.rexx/Header"}).

   * rem2d (see @{"rem2d.rexx" Link "ami2d:macros/solve/rem2d.rexx/Header"}).

   * rlin2d (see @{"rlin2d.rexx" Link "ami2d:macros/solve/rlin2d.rexx/Header"}).

   * rnln2d (see @{"rnln2d.rexx" Link "ami2d:macros/solve/rnln2d.rexx/Header"}).

   * solve (see @{"solve.rexx" Link "ami2d:macros/solve/solve.rexx/Header"}).


@EndNode

@Node "Process Macros" "Ami2D.guide/Process Macros"
@Next "Help Macros"
@Prev "Solve Macros"
@Toc "Ami2D Macros"

Process Macros
==============

   The following are macros for post-processing results. They can be
found in "Ami2D:macros/process".

   * fillres (see @{"fillres.rexx" Link "ami2d:macros/process/fillres.rexx/Header"}).

   * plotres (see @{"plotres.rexx" Link "ami2d:macros/process/plotres.rexx/Header"}).

   * post2d (see @{"post2d.rexx" Link "ami2d:macros/process/post2d.rexx/Header"}).

   * range (see @{"range.rexx" Link "ami2d:macros/process/range.rexx/Header"}).

   * rpost2d (see @{"rpost2d.rexx" Link "ami2d:macros/process/rpost2d.rexx/Header"}).

   * switch (see @{"switch.rexx" Link "ami2d:macros/process/switch.rexx/Header"}).


@EndNode

@Node "Help Macros" "Ami2D.guide/Help Macros"
@Prev "Process Macros"
@Toc "Ami2D Macros"

Help Macros
===========

   These macros can be found in "Ami2D:macros/help".

   * help (see @{"help.rexx" Link "ami2d:macros/help/help.rexx/Header"}).

   * read (see @{"read.rexx" Link "ami2d:macros/help/read.rexx/Header"}).

   * undo (see @{"undo.rexx" Link "ami2d:macros/help/undo.rexx/Header"}).


@EndNode

@Node "Lin2D" "Ami2D.guide/Lin2D"
@Next "Nln2D"
@Prev "Ami2D Macros"
@Toc "Main"

Lin2D
*****

   Lin2D - a linear solver for "plane" and axisymmetric two dimensional
finite element analysis problems.

   Copyright (C) 1992,1993,1994 by Russell Leighton

   date:    Mar 20, 1993 version: 1.0


 @{" Introduction to Lin2D " Link "Introduction to Lin2D"}        A brief encounter
 @{" Model Requirements " Link "Model Requirements"}           Modeling specifics
 @{" Lin2D Commands " Link "Lin2D Commands"}               Command specifics


@EndNode

@Node "Introduction to Lin2D" "Ami2D.guide/Introduction to Lin2D"
@Next "Model Requirements"
@Toc "Lin2D"

Introduction to Lin2D
=====================

   `Lin2D' is a general linear solver developed to handle "plane" and
axisymmetric two dimensional finite element analysis problems. It is a
fairly general capability in the sense that a wide variety of two
dimensional problems can be handled by `Lin2D' limited only by
computational resources. Specific attention was given to efficient
memory and resource management, however, the minimum recommended amount
of memory needed to solve moderate problems, using `Lin2D', is 6
megabytes (although simple problems can be run with considerably less).
A hard disk is also recommended.

   It is important to note that any engineer, planning to use a finite
element code for actual application, understand fully the concepts and
implementation of the finite element method. Therefore, the prospective
user should consider an in-depth study of the method and ideally some
training. This document should not be considered appropriate for
training users in the use of the finite element method.

   The main features of `Lin2D' are as follows:

   * runs as a background task

   * two-dimensional plane or axisymmetric problems

   * uses ARexx macro language

   * linear and quadratic elements available

   * no limit on number of nodes, elements, materials, or boundary
     conditions (only limited by memory)

   * no need to specify problem size (determined at run time)

   * choice of Dirichlet (constraint) or Neumann (flux), point or
     distributed boundary conditions

   * symmetric banded matrix storage format

   In general the command line syntax for executing `Lin2D':

         -> [run] Lin2D [SCRIPT]

where SCRIPT is the name of an input `ARexx' script to be processed. If
no script is specified then the code will wait until it receives a
command, presumably from a subsequently executed `ARexx' command or
script.

   `Lin2D' accepts `ARexx' commands passed to its message port (address
lin2d). Commands for `Lin2D', placed in an `ARexx' macro, consist of a
command keyword followed by arguments. The arguments may be separated
from the command keyword with parentheses and delimited with commas
(analogous to a function call) or may be separated (and delimited) with
spaces. If parentheses and commas are used then the command line must be
surrounded by single quotes or else `ARexx' will interpret the command
as a library function call (rather than a command meant for the host).
The general rule is to surround expressions (which can be single
variables), which are to be interpreted internally by `Lin2D', with
single quotes. Otherwise, expressions (and variables) will be
interpreted by `ARexx' before being sent to `Lin2D'.


@EndNode

@Node "Model Requirements" "Ami2D.guide/Model Requirements"
@Next "Lin2D Commands"
@Prev "Introduction to Lin2D"
@Toc "Lin2D"

Model Requirements
==================

   The constitutive law implemented in `Lin2D' (relating stress and
strain in structural problems, for example) consists of a linear matrix
operator with up to ten independent constants. These constants are input
in the `mat' command in `Ami2D' as the material coefficients. For
structural problems the components of stress and strain, relevant to
plane or axisymmetric problems, are the three normal components plus the
in-plane shear component. This requires that the material matrix
operator be a four by four matrix. This results in sixteen constants
but, due to elastic symmetry, only ten of these constants are
independent. The material coefficients allow for specification of
materials ranging from isotropic (properties invariant to material
direction) to monoclinic (properties symmetric about one plane). The
coefficients are specified in diagonal order and the matrix is
symmetric. In other words, if the coefficients are arranged in matrix
form they would appear as follows.

                 C0  C4  C7  C9
                 C4  C1  C5  C8
                 C7  C5  C2  C6
                 C9  C8  C6  C3

   Body forces are also input with the `mat' command.  `Lin2D' treats
the two sets of body forces differently.  The first set of body force
terms are for body forces arising from internal energy.  For example,
thermal strain in a material develops as a result of a change in
temperature in the material which can be treated as a body force due to
a change in internal energy.  In this case the body force (thermal
strain) is computed through the following equation:

                 eT[] = f1[]*(Ti - Tref)

   where `f1[]' is the first set of body force coefficients (thermal
coefficients of expansion, one for each geometric degree of freedom),
`Tref' is the reference value (temperature), and `Ti' is the computed
value (temperature found from a previous heat transfer analysis).

   The second set of body force terms are for body forces arising from
potential energy such as conservative force fields (gravity or
acceleration being an example).  Furthermore, for axisymmetric problems
the radial component of this conservative body force is multiplied by
the radial location.  This, for example, allows for a radial force
component that depends on the radial acceleration arising from the
steady state rotation of an axisymmetric body.  In this case the body
forces are computed through the following equations:

                 F[r] = f2[r]*r^2*density
                 F[a] = f2[a]*r*density

   where `f2[r]' is the first (radial) body force coefficient in the
second set (representing the angular velocity), `f2[a]' is the second
(axial) coefficient (which represents an axial acceleration), `r' is
the radial location, and `density' may be either a constant (input by
specifying a negative reference value) or a computed value (obtained
from a previous diffusion analysis and setting the reference value to
zero).


@EndNode

@Node "Lin2D Commands" "Ami2D.guide/Lin2D Commands"
@Prev "Model Requirements"
@Toc "Lin2D"

Lin2D Commands
==============

   The commands are functionally equivalent to commands available in
`Ami2D'. Additional commands are also provided which are described in
the following sections.

   * save      (see @{"Utility Commands - save" Link "Utility Commands"})

   * read      (see @{"Utility Commands - read" Link "Utility Commands"})

   * reset     (see @{"Utility Commands - reset" Link "Utility Commands"})

   * version   (see @{"Utility Commands - version" Link "Utility Commands"})

   * stop      (see @{"Utility Commands - stop" Link "Utility Commands"})

   * why       (see @{"Utility Commands - why" Link "Utility Commands"})


 @{" formkf " Link "formkf"}                       Form the stiffness matrix and load vector
 @{" solve " Link "solve"}                        Solve the system

 @{" status " Link "status"}                       Assembly and solution status
 @{" abort " Link "abort"}                        Abort assembly or solution


@EndNode

@Node "formkf" "Ami2D.guide/formkf"
@Next "solve"
@Prev "Lin2D Commands"
@Toc "Lin2D Commands"

 -- Command: formkf IPRINT
     `formkf' forms the stiffness matrix and load vector.  The stiffness
     matrix and load vector are assembled from the individual element
     contributions which results in a linear system of equations to be
     subsequently solved.  The only argument to this command is a print
     flag (IPRINT).  A value of 1 indicates that the stiffness matrix
     and load vector will be printed to the standard output.  This is
     not recommended for problems resulting in large systems.  A value
     of 0 will result in no matrix/vector output (the default setting).

          'formkf(0)'


@EndNode

@Node "solve" "Ami2D.guide/solve"
@Next "status"
@Prev "formkf"
@Toc "Lin2D Commands"

 -- Command: solve IPRINT
     `solve' will attempt to solve the system assembled using the
     `formkf' command (see @{"Lin2D Commands - formkf" Link "Lin2D Commands"}). Simple checks of
     the model are performed at various stages, but this does not
     insure that the system can be solved.  The user must pay special
     attention to correctness of model geometry and boundary
     conditions.  If the system is not solvable it is most probably due
     to errors in the geometry and/or boundary conditions.  The only
     argument to this command is a print flag (IPRINT).  A value of 1
     indicates that the solution vector will be printed to the standard
     output. This is not recommended for large problems.  A value of 0
     will result in no solution output (the default setting).

          'solve(0)'


@EndNode

@Node "status" "Ami2D.guide/status"
@Next "abort"
@Prev "solve"
@Toc "Lin2D Commands"

 -- Command: status
     `status' allows the user to check on the status of the currently
     executing command.  A descriptive string will be returned to the
     calling macro.  There are no arguments to `status'.


@EndNode

@Node "abort" "Ami2D.guide/abort"
@Next "(dir)"
@Prev "status"
@Toc "Lin2D Commands"

 -- Command: abort
     `abort' will cause the currently executing command to abort.  There
     are no arguments to `abort'.


@EndNode

@Node "Nln2D" "Ami2D.guide/Nln2D"
@Next "Post2D"
@Prev "Lin2D"
@Toc "Main"

Nln2D
*****

   Nln2D - a nonlinear solver for "plane" and axisymmetric two
dimensional finite element analysis problems.

   Copyright (C) 1993,1994 by Russell Leighton

   date:    Jul 4, 1993 version: 1.0

   This solver is equivalent to `Lin2D' except that it is restricted --
results are only valid for -- structural analysis problems where large
displacements (and/or rotations) are expected, but small strain theory
still applies. A good example would be the large deflection of a thin
cantilever beam. The functional difference between `Nln2D' and `Lin2D'
is the solution process. The first iteration through `formkf' and
`solve' will result in a linear solution (equivalent to the solution
given by `Lin2D'). Subsequent executions of `formkf' and `solve' will
produce results that represent a lower total energy state (the internal
energy approaches the external energy of the system). After "enough"
iterations have been performed the total energy should be zero (that is
an equilibrium state should have been reached). The command `formkf'
returns the maximum (absolute value) nodal residual force in the
system. This value can be checked against a tolerance value (typically
around 0.01, but depends on loading conditions) as a stopping criteria.
Also, the `solve' command returns the maximum (absolute value) change
in nodal displacement. This value may also be checked against a
tolerance value (typically around 0.0001) as a stopping criteria. The
following is an example script showing a solution procedure.

     /* example script for nln2d */
     options results
     
     address nln2d 'read(ram:temp.dat)'
     
     do i=0 to 20
         address nln2d 'formkf'
         address nln2d 'solve'
         parse var result du
         if du < 1e-4 then leave
     end
     
     address nln2d 'save(ram:temp.dat)'
     exit

   This code can be more effectively used when run in conjunction with
`Ami2D'. For instance, intermediate results can be viewed graphically
thereby given a visual indication of solution convergence. It is even
possible (and often desirable) to assemble an animation consisting of
these intermediate results. This animation would show, very
effectively, the convergence process.

   Also, convergence of the solution may require incremental loading
which can be accomplished with the aid of `Ami2D'. This would be done by
applying a fraction of the appropriate load(s), performing an iterative
solution with `Nln2D' until convergence, then increasing the load
fraction using `Ami2D' and repeating the solution procedure. This whole
process is repeated until the full load is reached.

   Currently, only a linear elastic stress-strain material law is
implemented thereby restricting problems to those where small strains
are expected. However, future additional material constitutive laws
will be implemented thereby extending the code applicability to more
general nonlinear problems.


@EndNode

@Node "Post2D" "Ami2D.guide/Post2D"
@Next "Equ2D"
@Prev "Nln2D"
@Toc "Main"

Post2D
******

   Post2D - a post processor for two dimensional finite element
analysis problems.

   Copyright (C) 1993,1994 by Russell Leighton

   date:    Feb 17, 1994 version: 1.0


 @{" Introduction to Post2D " Link "Introduction to Post2D"}        A brief encounter
 @{" Post2D Commands " Link "Post2D Commands"}               Command specifics


@EndNode

@Node "Introduction to Post2D" "Ami2D.guide/Introduction to Post2D"
@Next "Post2D Commands"
@Toc "Post2D"

Introduction to Post2D
======================

   `Post2D' is a general two dimensional finite element solution
post-processor. The main features of `Post2D' are as follows:

   * runs as a background task

   * uses `ARexx' macro language

   * definable post-processing functions

   In general the command line syntax for executing `Post2D':

         -> [run] Post2D [SCRIPT]

where SCRIPT is the name of an input `ARexx' script to be processed. If
no script is specified then the code will wait until it receives a
command, presumably from a subsequently executed `ARexx' command or
script.

   `Post2D' accepts `ARexx' commands passed to its message port (address
post2d). Commands for `Post2D', placed in an `ARexx' macro, consist of
a command keyword followed by arguments. The arguments may be separated
from the command keyword with parentheses and delimited with commas
(analogous to a function call) or may be separated (and delimited) with
spaces. If parentheses and commas are used then the command line must be
surrounded by single quotes or else `ARexx' will interpret the command
as a library function call (rather than a command meant for the host).
The general rule is to surround expressions (which can be single
variables), which are to be interpreted internally by `Post2D', with
single quotes. Otherwise, expressions (and variables) will be
interpreted by `ARexx' before being sent to `Post2D'.


@EndNode

@Node "Post2D Commands" "Ami2D.guide/Post2D Commands"
@Prev "Introduction to Post2D"
@Toc "Post2D"

Post2D Commands
===============

   The commands are functionally equivalent to commands available in
`Ami2D' and `Lin2D'.  Additional commands are also provided which are
described in the following sections.

   * problem   (see @{"Problem Type - problem" Link "Problem Type"})

   * save      (see @{"Utility Commands - save" Link "Utility Commands"})

   * read      (see @{"Utility Commands - read" Link "Utility Commands"})

   * reset     (see @{"Utility Commands - reset" Link "Utility Commands"})

   * version   (see @{"Utility Commands - version" Link "Utility Commands"})

   * stop      (see @{"Utility Commands - stop" Link "Utility Commands"})

   * set       (see @{"Utility Commands - set" Link "Utility Commands"})

   * get       (see @{"Utility Commands - get" Link "Utility Commands"})

   * why       (see @{"Utility Commands - why" Link "Utility Commands"})

   * status    (see @{"Lin2D Commands - status" Link "Lin2D Commands"})

   * abort     (see @{"Lin2D Commands - abort" Link "Lin2D Commands"})


 @{" post " Link "post"} 


@EndNode

@Node "post" "Ami2D.guide/post"
@Next "(dir)"
@Prev "Post2D Commands"
@Toc "Post2D Commands"

 -- Command: post FUN LOCATION
     Given a solution calculated by a solver (see @{"Lin2D" Link "Lin2D"} and @{"Nln2D" Link "Nln2D"})
     `post' will post-process the solution over the complete model.  Any
     previously defined function (see @{"Utility Commands - set" Link "Utility Commands"}) may be
     given in the first argument (FUN).  The second argument (LOCATION)
     indicates where the solution will be evaluated in each element. 
     If `gauss' is specified then the solution will be processed at the
     Gaussian quadrature points.  If `node' is specified then
     processing will occur at the node locations.  Finally, if `ave' is
     specified then the solution will be processed at the nodes and
     averaged across element boundaries (unless it is a material
     boundary).  If this argument is not given then `gauss' is assumed.
      More accurate stress/strain results (for that matter any result
     based on solution derivatives) can be expected using the `gauss'
     option.  If no arguments are given then all selected (see
     @{"Results Processing - select" Link "Results Processing"})
     functions will be post-processed.

          'post(sig1)'


@EndNode

@Node "Equ2D" "Ami2D.guide/Equ2D"
@Next "Opt2D"
@Prev "Post2D"
@Toc "Main"

Equ2D
*****

   Equ2D - a node equivalencing program for 2D FE meshes.

   Copyright (C) 1993,1994 by Russell Leighton

   date:    Jan 21, 1993 version: 1.0a

   Given a two-dimensional finite element mesh (stored in the IFF format
currently used by `Ami2D') `Equ2D' will equivalence nodes that fall
within a specified tolerance apart. Either an inclusion or exclusion
node group may be given to restrict the equivalence operation.

   The equivalence operation is typically used as a modeling tool to
"weld" separate parts together or to close gaps. This operation is
particularly useful during interactive modeling since complex assemblies
are easier to build from parts.

   The command line syntax for `Equ2D' is:

         -> [run] equ2d [-iGROUP] [-xGROUP] [-tTOL] <INPUT> [OUTPUT]

where INPUT is the input data file containing the finite element data
(in the form produced by the save command in `Ami2D'). This input data
file is a required argument. The output data file, if specified, will be
the name of the file that will contain the equivalenced finite element
data. If not specified then the data will be written back to the input
file (thereby overwriting the previous data). If the `-i' option is
used then GROUP specifies the group containing the nodes to be included
in the equivalence search. Likewise, if the `-x' option is used then
GROUP specifies the group containing nodes to be excluded from the
equivalence search. If the `-t' option is given then TOL specifies the
tolerance to be used to determine equivalence (the default is 1.0e-5).


@EndNode

@Node "Opt2D" "Ami2D.guide/Opt2D"
@Next "Rem2D"
@Prev "Equ2D"
@Toc "Main"

Opt2D
*****

   Opt2D - a 2D finite element mesh optimization program.

   Copyright (C) 1992,1993,1994 by Russell Leighton

   date:    Aug 5, 1992 version: 1.0a

   `Opt2D' is a node order optimization program for arbitrary two
dimensional finite element meshes. The algorithm used to optimize the
mesh is fairly simplistic but may result in a smaller bandwidth for some
problems. For simple rectangular meshes, if the node ordering is
consistent, then `Opt2D' will probably give a node ordering with a
bandwidth that is larger than the original. However, for irregular
meshes, very high aspect ratio meshes, or inconsistently ordered meshes,
`Opt2D' can reduce the bandwidth significantly. A side effect of
`Opt2D' is that all unreferenced nodes will be removed resulting in a
further reduction in model size and memory requirements.

   The command line syntax for `Opt2D' is:

         -> [run] opt2d [-nELEMENT] <INPUT> [OUTPUT]

where INPUT is the input data file containing the finite element data
(in the form produced by the save command in `Ami2D'). This input data
file is a required argument. The output data file, if specified, will be
the name of the file that will contain the optimized finite element
data. If not specified then the optimized data will be written back to
the input file (thereby overwriting the previous data). If the `-n'
option is used then ELEMENT specifies the identification number of the
element where the optimization search is to begin. Proper selection of
the starting element can dramatically improve the resulting
optimization.


@EndNode

@Node "Rem2D" "Ami2D.guide/Rem2D"
@Next "Rexxcon"
@Prev "Opt2D"
@Toc "Main"

Rem2D
*****

   Rem2D - a 2D finite element node removal program.

   Copyright (C) 1993,1994 by Russell Leighton

   date:    Oct 27, 1993 version: 1.0a

   `Rem2D' is a simple code to remove all unreferenced nodes from a
model resulting in a reduction in model size and memory requirements
without a reordering of the node numbers.

   The command line syntax for `Rem2D' is:

         -> [run] rem2d <INPUT> [OUTPUT]

where INPUT is the input data file containing the finite element data
(in the form produced by the save command in `Ami2D'). This input data
file is a required argument. The output data file, if specified, will be
the name of the file that will contain the optimized finite element
data. If not specified then the optimized data will be written back to
the input file (thereby overwriting the previous data).


@EndNode

@Node "Rexxcon" "Ami2D.guide/Rexxcon"
@Next "Rexxbar"
@Prev "Rem2D"
@Toc "Main"

Rexxcon
*******

   rexxcon - a REXX console

   Copyright (C) 1992,1993,1994 by Russell Leighton

   date:    July 28, 1992 version: 1.2b


 @{" Introduction to Rexxcon " Link "Introduction to Rexxcon"} 
 @{" Example Script for Rexxcon " Link "Example Script for Rexxcon"} 
 @{" Rexxcon Commands " Link "Rexxcon Commands"} 


@EndNode

@Node "Introduction to Rexxcon" "Ami2D.guide/Introduction to Rexxcon"
@Next "Example Script for Rexxcon"
@Toc "Rexxcon"

Introduction to Rexxcon
=======================

   `rexxcon' is a very simple `ARexx' host program who's only function
is to read lines from a console and return them to the calling macro.
The primary function of this program is to serve as an interactive
front-end to other `ARexx' hosts.

   The command line syntax for `rexxcon' is:

         -> [run] rexxcon [-hHOSTNAME] [SCRIPT]

where SCRIPT is the name of an input `ARexx' script to be processed. If
no script is specified then the code will wait until it receives a
command, presumably from a subsequently executed `ARexx' command or
script. The -h option will set the `rexxcon' host address to HOSTNAME.


@EndNode

@Node "Example Script for Rexxcon" "Ami2D.guide/Example Script for Rexxcon"
@Next "Rexxcon Commands"
@Prev "Introduction to Rexxcon"
@Toc "Rexxcon"

Example Script for Rexxcon
==========================

   Commands for `rexxcon', placed in an `ARexx' macro, consist of a
command keyword followed by arguments. The arguments may be separated
from the command keyword with parentheses and delimited with commas
(analogous to a function call) or may be separated (and delimited) with
spaces. If parentheses and commas are used then the command line must be
surrounded by single quotes or else `ARexx' will interpret the command
as a library function call (rather than a command meant for the host).
The general rule is to surround expressions (which can be single
variables), which are to be interpreted internally by `rexxcon', with
single quotes. Otherwise, expressions (and variables) will be
interpreted by `ARexx' before being sent to `rexxcon'. For example the
lines below show a sequence of `ARexx' commands for `rexxcon'.

     /* this is an ARexx macro for rexxcon */
     options results
     parse arg host
     
     hostname = upper(host)
     address command
     if ~show('ports',hostname) then do
         'run ami2d:bin/'host
         'waitforport' hostname
     end
     
     address VALUE hostname
     
     hostname = 'RXC_'hostname
     say hostname
     
     if ~show('ports',hostname) then do
         'run ami2d:bin/rexxcon -h'hostname
         'waitforport' hostname
     end
     
     address VALUE hostname
     
     'alias quit=stop'
     'open(cnc,0,-50,-52,50,'host'/noclose,'host')'
     do forever
         'read'
         comm = result
         drop result
         address
         comm
         address
         if comm = 'stop' then leave
         if result ~= "RESULT" then 'write('result')'
     end
     'stop'
     exit

   The above example is in fact an `ARexx' script that could used to run
a code (with an `ARexx' port) interactively.  It illustrates the use of
`rexxcon' as a "front end" to `ARexx' hosts.


@EndNode

@Node "Rexxcon Commands" "Ami2D.guide/Rexxcon Commands"
@Prev "Example Script for Rexxcon"
@Toc "Rexxcon"

Rexxcon Commands
================


 @{" open(rexxcon) " Link "open(rexxcon)"} 
 @{" close(rexxcon) " Link "close(rexxcon)"} 
 @{" alias(rexxcon) " Link "alias(rexxcon)"} 
 @{" read(rexxcon) " Link "read(rexxcon)"} 
 @{" write(rexxcon) " Link "write(rexxcon)"} 
 @{" prompt(rexxcon) " Link "prompt(rexxcon)"} 
 @{" stop(rexxcon) " Link "stop(rexxcon)"} 


@EndNode

@Node "open(rexxcon)" "Ami2D.guide/open(rexxcon)"
@Next "close(rexxcon)"
@Prev "Rexxcon Commands"
@Toc "Rexxcon Commands"

 -- Command: open CONSPEC LEFT TOP WIDTH HEIGHT FLAGS SCREEN
     `open' will open the `rexxcon' console window. The command
     requires arguments defining the console specification. The
     arguments are the console device name  (CONSPEC, without the
     colon), LEFT (or right) edge offset, TOP (or bottom) edge offset,
     WIDTH (can be relative to screen width), HEIGHT (can be relative
     to screen height), FLAGS and public SCREEN name. The edge offsets
     will be relative to the LEFT and/or TOP edges if positive or zero
     otherwise they are relative to the right and/or bottom edges
     respectively. The WIDTH and/or HEIGHT, if positive, directly
     specify the window width and/or height. If they are negative then
     they will be relative to the screen width and/or height. If the
     public SCREEN name is not specified then the window will be opened
     on the Workbench screen.

          'open(con,0,1,640,200,rexxcon/noclose)'


@EndNode

@Node "close(rexxcon)" "Ami2D.guide/close(rexxcon)"
@Next "alias(rexxcon)"
@Prev "open(rexxcon)"
@Toc "Rexxcon Commands"

 -- Command: close
     `close' will close the console window.


@EndNode

@Node "alias(rexxcon)" "Ami2D.guide/alias(rexxcon)"
@Next "read(rexxcon)"
@Prev "close(rexxcon)"
@Toc "Rexxcon Commands"

 -- Command: alias NAME EXPR
     `alias' is used to create aliases for read-in (see
     @{"Rexxcon Commands - read" Link "Rexxcon Commands"}) commands.
     Commands (the first word of a read-in string) that match an alias
     will be replaced with the assigned string.  The rest of the typed
     in string is just appended verbatim.

          'alias quit=stop'


@EndNode

@Node "read(rexxcon)" "Ami2D.guide/read(rexxcon)"
@Next "write(rexxcon)"
@Prev "alias(rexxcon)"
@Toc "Rexxcon Commands"

 -- Command: read
     `read' will read a line from the `rexxcon' console (or file). The
     line will be returned in the `ARexx' variable RESULT if `options
     results' was specified in the `ARexx' macro.  If the first word of
     the read-in string matches any defined aliases (see
     @{"Rexxcon Commands - alias" Link "Rexxcon Commands"}) then that
     word will be replaced with the string assigned to the alias before
     being passed to the calling macro.


@EndNode

@Node "write(rexxcon)" "Ami2D.guide/write(rexxcon)"
@Next "prompt(rexxcon)"
@Prev "read(rexxcon)"
@Toc "Rexxcon Commands"

 -- Command: write STRING
     `write' will write a STRING to the `rexxcon' console.

          'write("this line")'


@EndNode

@Node "prompt(rexxcon)" "Ami2D.guide/prompt(rexxcon)"
@Next "stop(rexxcon)"
@Prev "write(rexxcon)"
@Toc "Rexxcon Commands"

 -- Command: prompt STRING
     The prompt given when a read command is issued may be set with
     `prompt'. By default the prompt is `->'.

          'prompt("by your command: ")'


@EndNode

@Node "stop(rexxcon)" "Ami2D.guide/stop(rexxcon)"
@Next "(dir)"
@Prev "prompt(rexxcon)"
@Toc "Rexxcon Commands"

 -- Command: stop
     `stop' will close the window and exit the program.


@EndNode

@Node "Rexxbar" "Ami2D.guide/Rexxbar"
@Next "Concept Index"
@Prev "Rexxcon"
@Toc "Main"

Rexxbar
*******

   rexxbar - a REXX button bar

   Copyright (C) 1992,1993,1994 by Russell Leighton

   date:    July 28, 1992 version: 1.0b


 @{" Introduction to Rexxbar " Link "Introduction to Rexxbar"} 
 @{" Example Script for Rexxbar " Link "Example Script for Rexxbar"} 
 @{" Rexxbar Commands " Link "Rexxbar Commands"} 


@EndNode

@Node "Introduction to Rexxbar" "Ami2D.guide/Introduction to Rexxbar"
@Next "Example Script for Rexxbar"
@Toc "Rexxbar"

Introduction to Rexxbar
=======================

   `rexxbar' is a very simple `ARexx' host program who's only function
is to set up a window with gadgets and to wait for gadget selection. If
a gadget is selected then a macro associated with the gadget is
executed. The primary function of this program is to serve as an
interactive front-end to other `ARexx' hosts.

   The command line syntax for `rexxbar' is:

         -> [run] rexxbar [-pREXXHOST] [-hHOSTNAME] [SCRIPT]

where SCRIPT is the name of an input `ARexx' script to be processed. If
no script is specified then the code will wait until it receives a
command, presumably from a subsequently executed `ARexx' command or
script. The -p option is used to specify an alternate rexx host (aside
from the `ARexx' interpreter) to issue commands to directly. The -h
option will set the `rexxbar' host address to HOSTNAME.


@EndNode

@Node "Example Script for Rexxbar" "Ami2D.guide/Example Script for Rexxbar"
@Next "Rexxbar Commands"
@Prev "Introduction to Rexxbar"
@Toc "Rexxbar"

Example Script for Rexxbar
==========================

   Commands for `rexxbar', placed in an `ARexx' macro, consist of a
command keyword followed by arguments. The arguments may be separated
from the command keyword with parentheses and delimited with commas
(analogous to a function call) or may be separated (and delimited) with
spaces. If parentheses and commas are used then the command line must be
surrounded by single quotes or else `ARexx' will interpret the command
as a library function call (rather than a command meant for the host).
The general rule is to surround expressions (which can be single
variables), which are to be interpreted internally by `rexxbar', with
single quotes. Otherwise, expressions (and variables) will be
interpreted by `ARexx' before being sent to `rexxbar'. For example the
lines below show a sequence of `ARexx' commands for `rexxbar'.

     /* example script for rexxbar */
     
     address command
     if ~show('ports',"RXB_AMI2D") then do
         'run ami2d:bin/rexxbar -hRXB_AMI2D -pAMI2D'
         'waitforport RXB_AMI2D'
     end
     
     address rxb_ami2d
     
     'button(1,equ2d,ami2d:macros/solve/equ2d)'
     'button(2,pbnd,"plot bound")'
     
     'button(4,rem2d,ami2d:macros/solve/rem2d)'
     'button(5,opt2d,ami2d:macros/solve/opt2d)'
     'button(7,lnsol,ami2d:macros/solve/solve)'
     'button(8,nlsol,ami2d:macros/solve/nlsolve)'
     'button(9,pdef,"plot deform scale")'
     'button(10,fdef,"fill deform scale")'
     
     'text(12,"scale:")'
     'string(13,1.0,"set scale %s")'
     'open(-68,63,68,-158,AMI2D,solve)'
     
     exit


@EndNode

@Node "Rexxbar Commands" "Ami2D.guide/Rexxbar Commands"
@Prev "Example Script for Rexxbar"
@Toc "Rexxbar"

Rexxbar Commands
================


 @{" open(rexxbar) " Link "open(rexxbar)"} 
 @{" close(rexxbar) " Link "close(rexxbar)"} 
 @{" button(rexxbar) " Link "button(rexxbar)"} 
 @{" cycle(rexxbar) " Link "cycle(rexxbar)"} 
 @{" radio(rexxbar) " Link "radio(rexxbar)"} 
 @{" checkbox(rexxbar) " Link "checkbox(rexxbar)"} 
 @{" string(rexxbar) " Link "string(rexxbar)"} 
 @{" text(rexxbar) " Link "text(rexxbar)"} 
 @{" slider(rexxbar) " Link "slider(rexxbar)"} 
 @{" signal(rexxbar) " Link "signal(rexxbar)"} 
 @{" disable(rexxbar) " Link "disable(rexxbar)"} 
 @{" enable(rexxbar) " Link "enable(rexxbar)"} 
 @{" stop(rexxbar) " Link "stop(rexxbar)"} 


@EndNode

@Node "open(rexxbar)" "Ami2D.guide/open(rexxbar)"
@Next "close(rexxbar)"
@Prev "Rexxbar Commands"
@Toc "Rexxbar Commands"

 -- Command: open LEFT TOP WIDTH HEIGHT SCREEN TITLE MACRO
     `open' will open the `rexxbar' window.  The command accepts
     arguments defining the window specification.  The arguments are
     LEFT (or right) edge offset, TOP (or bottom) edge offset, WIDTH
     (can be relative to screen width), HEIGHT (can be relative to
     screen height), FLAGS and public SCREEN name.  The edge offsets
     will be relative to the LEFT and/or TOP edges if positive or zero
     otherwise they are relative to the right and/or bottom edges
     respectively. The WIDTH and/or HEIGHT, if positive, directly
     specify the window width and/or height.  If they are negative then
     they will be relative to the screen width and/or height.  If the
     public SCREEN name is not specified then the window will be opened
     on the Workbench screen.  A window TITLE may also be given which
     will result in a draggable window.  The MACRO argument, if given,
     specifies a macro that is to be executed if the window position is
     changed.  This allows for programmatic control of a group of
     windows (depending on the position of a draggable window other
     windows can be made to follow, for example).

     If any size arguments are not given and the window has not been
     previously opened then the window will be automatically sized.  If
     the width is not given then the window width will be set to
     accommodate the largest length string specified for a `button'. 
     If the height is not given then the window height will be set to
     be able to include all specified gadgets. Additionally, if the
     left edge is not specified then the window will be positioned
     flush with the right edge of the screen.  Likewise, if the top
     edge is not specified then the window will be positioned flush
     with the bottom edge of the screen.  Note that this automatic
     sizing is dependent on the font used which will always be set to
     the font specified for the system default font (set in the font
     preferences program).  If the window has been previously opened
     then all specified arguments will result in a resizing and/or
     repositioning of the window.  If no arguments are given and the
     window was previously opened then the window position and size
     will be returned in `RESULT'.

          'open(-52,0,52,0,AMI2D)'
          'open(,0,,,WorkBench,title,"movemacro")'


@EndNode

@Node "close(rexxbar)" "Ami2D.guide/close(rexxbar)"
@Next "button(rexxbar)"
@Prev "open(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: close
     `close' will close the window (if one is currently open).


@EndNode

@Node "button(rexxbar)" "Ami2D.guide/button(rexxbar)"
@Next "cycle(rexxbar)"
@Prev "close(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: button ID TEXT MACRO
     `button' will set up a button gadget.  The arguments are the button
     number (ID, also used for placement), button TEXT and MACRO
     specification.  If the button TEXT and MACRO are not specified and
     the gadget already exists then the text will be returned as a
     result (if `options results' is specified in the issuing macro).
     Additionally, if the TEXT is specified and the gadget exists then
     the button text will be replaced with the new TEXT.  This allows a
     macro to set the condition of the gadget and can be used to link
     gadget actions together.  With a MACRO defined if the gadget is
     selected the MACRO name is first searched for as an external
     `ARexx' macro.  If the external program is not found (either in
     the current directory or in the REXX: directory) then the MACRO
     string is passed to the alternate host message port (see
     @{"Introduction to Rexxbar" Link "Introduction to Rexxbar"}).

          'button(2,wind,ami2d:macros/window)'


@EndNode

@Node "cycle(rexxbar)" "Ami2D.guide/cycle(rexxbar)"
@Next "radio(rexxbar)"
@Prev "button(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: cycle ID LABEL MACRO
     `cycle' will set up a cycle gadget.  The arguments are the cycle
     identification number (ID, also used for placement), cycle LABEL
     and MACRO specification (optional).  Each subsequent command with
     the same identification number will add the LABEL to the list of
     labels for the cycle gadget.  This will result in a gadget that
     when selected will cycle through the list of labels.  If the cycle
     LABEL and MACRO are not specified and the gadget already exists
     then the currently visible label will be returned as a result (if
     `options results' is specified in the issuing macro). 
     Additionally, if the LABEL is specified and the gadget exists with
     the LABEL already defined then the gadget will be set to that
     LABEL.  This allows a macro to set the condition of the gadget and
     can be used to link gadget actions together.  With a MACRO defined
     if the gadget is selected the MACRO name is first searched for as
     an external `ARexx' macro.  If the external program is not found
     (either in the current directory or in the REXX:  directory) then
     the MACRO string is passed to the alternate host message port (see
     @{"Introduction to Rexxbar" Link "Introduction to Rexxbar"}).
     Also, the MACRO string may contain a `%s' which will be replaced
     with the current cycle label before issuing the MACRO string for
     execution.

          'cycle(2,sig1)'
          'cycle(2,sig2)'
          'cycle(2,sigd)'


@EndNode

@Node "radio(rexxbar)" "Ami2D.guide/radio(rexxbar)"
@Next "checkbox(rexxbar)"
@Prev "cycle(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: radio ID LABEL MACRO
     `radio' will set up a radio gadget (actually a sequence of mutually
     exclusive buttons).  The arguments are the radio identification
     number (ID, also used for placement), radio LABEL and MACRO
     specification (optional). Each subsequent command with the same
     identification number will add the LABEL to the list of labels for
     the radio gadget.  This will result in a sequence of gadgets that
     are selectable but only one will be selected (active) at any time.
      If the radio LABEL and MACRO are not specified and the gadget
     already exists then the currently selected label will be returned
     as a result (if `options results' is specified in the issuing
     macro).  Additionally, if the LABEL is specified and the gadget
     exists with the label already defined then the gadget will be set
     to that LABEL.  This allows a macro to set the condition of the
     gadget and can be used to link gadget actions together.  With a
     MACRO defined if the gadget is selected the MACRO name is first
     searched for as an external `ARexx' macro.  If the external
     program is not found (either in the current directory or in the
     REXX:  directory) then the MACRO string is passed to the alternate
     host message port (see @{"Introduction to Rexxbar" Link "Introduction to Rexxbar"}). Also, the MACRO
     string may contain a `%s' which will be replaced with the current
     radio label before issuing the MACRO string for execution.

          'radio(3,max)'
          'radio(3,min)'
          'radio(3,ave)'


@EndNode

@Node "checkbox(rexxbar)" "Ami2D.guide/checkbox(rexxbar)"
@Next "string(rexxbar)"
@Prev "radio(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: checkbox ID TEXT MACRO
     `checkbox' will set up a checkbox gadget.  The arguments are the
     checkbox number (ID, also used for placement), checkbox TEXT and
     MACRO specification. If the checkbox TEXT and MACRO are not
     specified and the gadget already exists then the active state will
     be returned as a result (0 for not selected or 1 for selected). 
     Additionally, if the TEXT is specified and the gadget exists then
     the active state will be toggled.  This allows a macro to set the
     condition of the gadget and can be used to link gadget actions
     together.  With a MACRO defined if the gadget is selected the MACRO
     name is first searched for as an external `ARexx' macro.  If the
     external program is not found (either in the current directory or
     in the REXX:  directory) then the MACRO string is passed to the
     alternate host message port (see @{"Introduction to Rexxbar" Link "Introduction to Rexxbar"}). Also,
     the MACRO string may contain a `%d' which will be replaced with
     the current checkbox status before issuing the MACRO string for
     execution.

          'checkbox(5,auto)'


@EndNode

@Node "string(rexxbar)" "Ami2D.guide/string(rexxbar)"
@Next "text(rexxbar)"
@Prev "checkbox(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: string ID TEXT MACRO
     `string' will set up a string gadget.  The arguments are the string
     number (ID, also used for placement), string TEXT and MACRO
     specification.  If the string TEXT and MACRO are not specified and
     the gadget already exists then the current string text will be
     returned as a result.  Additionally, if the TEXT is specified and
     the gadget exists then the string text will be replaced with the
     new TEXT.  This allows a macro to set the condition of the gadget
     and can be used to link gadget actions together.  With a MACRO
     defined if the gadget is selected the MACRO name is first searched
     for as an external `ARexx' macro.  If the external program is not
     found (either in the current directory or in the REXX:  directory)
     then the MACRO string is passed to the alternate host message port
     (see @{"Introduction to Rexxbar" Link "Introduction to Rexxbar"}). Also, the MACRO string may contain
     a `%s' which will be replaced with the current string text before
     issuing the MACRO string for execution.

          'string(5,1.0,"set scale %s")'


@EndNode

@Node "text(rexxbar)" "Ami2D.guide/text(rexxbar)"
@Next "slider(rexxbar)"
@Prev "string(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: text ID LABEL
     `text' will set up a text gadget.  The arguments are the text
     number (ID, also used for placement) and the text LABEL.  If the
     text LABEL is not specified and the gadget already exists then the
     current text label will be returned as a result.  Additionally, if
     the LABEL is specified and the gadget exists then the text label
     will be replaced with the new LABEL. This allows a macro to set
     the condition of the gadget and can be used to link gadget actions
     together.  Note, due to a bug text gadgets must be specified
     twice, once before the `open' command is given and again after.

          'text(4,scale)'
          'open(-52,0,52,0,AMI2D)'
          'text(4,scale)'


@EndNode

@Node "slider(rexxbar)" "Ami2D.guide/slider(rexxbar)"
@Next "signal(rexxbar)"
@Prev "text(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: slider ID LEVEL MIN MAX MACRO
     `slider' will set up a slider gadget.  The arguments are the slider
     number (ID, also used for placement), initial slider LEVEL, slider
     MIN value, slider MAX value and MACRO specification.  If the
     slider LEVEL and subsequent arguments are not specified and the
     gadget already exists then the current level will be returned as a
     result (if `options results' is specified in the issuing macro).
     Additionally, if the LEVEL is specified and the gadget exists then
     the slider level will be set to the new LEVEL.  This allows a
     macro to set the condition of the gadget and can be used to link
     gadget actions together.  With a MACRO defined if the gadget is
     selected the MACRO name is first searched for as an external
     `ARexx' macro.  If the external program is not found (either in
     the current directory or in the REXX: directory) then the MACRO
     string is passed to the alternate host message port (see
     @{"Introduction to Rexxbar" Link "Introduction to Rexxbar"}).

          'slider(3,0,-10,10,ami2d:macros/slider)'


@EndNode

@Node "signal(rexxbar)" "Ami2D.guide/signal(rexxbar)"
@Next "disable(rexxbar)"
@Prev "slider(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: signal PORT
     This command allows specification of an `ARexx' port to be
     notified of gadget selection.  Specifically, if this command is
     issued, with a PORT argument, then all gadget selections will
     result in a message being sent to this port prior to execution of
     any macro attached to the gadget.  If the program receiving this
     message does not want the macro to be executed then a reply is
     issued with a non-zero return code.  Otherwise, the associated
     macro will be executed and another message will be issued to the
     port to indicate completion of the macro (successful or not).  A
     good example of use of this command is illustrated by the macro
     `tutorial.rexx' which makes use of this capability by limiting
     user interaction.



@EndNode

@Node "disable(rexxbar)" "Ami2D.guide/disable(rexxbar)"
@Next "enable(rexxbar)"
@Prev "signal(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: disable
     This command disables the `rexxbar' which can be reactivated by the
     `enable' command (see @{"Rexxbar Commands - enable(rexxbar)" Link "Rexxbar Commands"}).



@EndNode

@Node "enable(rexxbar)" "Ami2D.guide/enable(rexxbar)"
@Next "stop(rexxbar)"
@Prev "disable(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: enable
     This command enables the `rexxbar' which was previously disabled by
     the `disable' command (see @{"Rexxbar Commands - disable(rexxbar)" Link "Rexxbar Commands"}).



@EndNode

@Node "stop(rexxbar)" "Ami2D.guide/stop(rexxbar)"
@Next "(dir)"
@Prev "enable(rexxbar)"
@Toc "Rexxbar Commands"

 -- Command: stop
     `stop' will close the window and exit the program.


@EndNode

@Node "Concept Index" "Ami2D.guide/Concept Index"
@Next "Command Index"
@Prev "Rexxbar"
@Toc "Main"

Concept Index
*************



 @{" ARexx " Link "Acknowledgments"}                                Acknowledgments
 @{" ARexx macros " Link "Graphic Interaction with Ami2D"}                         Graphic Interaction with Ami2D
 @{" ARexx macros " Link "Macros and Syntax"}                         Macros and Syntax
 @{" Aborting a command " Link "abort"}                   abort
 @{" Aborting an interactive command " Link "Graphic Interactive Commands"}      Graphic Interactive Commands
 @{" Aliases " Link "alias"}                              alias
 @{" Aliases " Link "get"}                              get
 @{" Ami2d.rexx " Link "Macros and Syntax"}                           Macros and Syntax
 @{" Ami2d.rexx " Link "Graphic Interaction with Ami2D"}                           Graphic Interaction with Ami2D
 @{" Amiga " Link "Acknowledgments"}                                Acknowledgments
 @{" Assembly status " Link "status"}                      status
 @{" Assumptions " Link "Problem Type"}                          Problem Type
 @{" Axisymmetry " Link "axisym"}                          axisym
 @{" Bandwidth " Link "Modeling Considerations"}                            Modeling Considerations
 @{" Binary file " Link "read"}                          read
 @{" Binary file " Link "save"}                          save
 @{" Body force coefficients " Link "mat"}              mat
 @{" Boundary condition direction " Link "dbc"}         dbc
 @{" Boundary condition direction " Link "pbc"}         pbc
 @{" Boundary condition kind " Link "pbc"}              pbc
 @{" Boundary condition kind " Link "dbc"}              dbc
 @{" Boundary condition specification " Link "Boundary Conditions"}     Boundary Conditions
 @{" Boundary condition type " Link "dbc"}              dbc
 @{" Boundary condition type " Link "pbc"}              pbc
 @{" Buttons " Link "Graphic Interaction with Ami2D"}                              Graphic Interaction with Ami2D
 @{" Cartesian coordinate system " Link "coord"}          coord
 @{" Color setting " Link "color"}                        color
 @{" Command line " Link "Graphic Interaction with Ami2D"}                         Graphic Interaction with Ami2D
 @{" Command line syntax " Link "Macros and Syntax"}                  Macros and Syntax
 @{" Commodore " Link "Acknowledgments"}                            Acknowledgments
 @{" Conditions for copying Ami2D " Link "Copying"}         Copying
 @{" Console window " Link "Graphic Interaction with Ami2D"}                       Graphic Interaction with Ami2D
 @{" Constants " Link "get"}                            get
 @{" Coordinate pair " Link "node"}                      node
 @{" Coordinate system origin " Link "coord"}             coord
 @{" Copying conditions " Link "Copying"}                   Copying
 @{" Coupling analyses " Link "mat"}                    mat
 @{" Deformation scale " Link "plot"}                    plot
 @{" Deformation scale " Link "fill"}                    fill
 @{" Deformed model filled plot " Link "fill"}           fill
 @{" Deformed model plot " Link "plot"}                  plot
 @{" Degrees of freedom " Link "problem"}                   problem
 @{" Directory path " Link "cd"}                       cd
 @{" Display mode " Link "open"}                         open
 @{" Distributed boundary condition information " Link "info"} info
 @{" Distribution " Link "Copying"}                         Copying
 @{" Element identification number " Link "dbc"}        dbc
 @{" Element identification number " Link "elem"}        elem
 @{" Element information " Link "info"}                  info
 @{" Element side number " Link "dbc"}                  dbc
 @{" Error message " Link "why"}                        why
 @{" Errors " Link "check"}                               check
 @{" Errors " Link "solve"}                               solve
 @{" Exchanging data between macros " Link "set"}       set
 @{" Expression evaluation " Link "eval"}                eval
 @{" Expressions " Link "set"}                          set
 @{" Features of Ami2D " Link "Introduction"}                    Introduction
 @{" Finite element analysis " Link "Introduction"}              Introduction
 @{" Free boundaries " Link "plot"}                      plot
 @{" Function information " Link "info"}                 info
 @{" Functions " Link "alias"}                            alias
 @{" Functions " Link "get"}                            get
 @{" Functions " Link "set"}                            set
 @{" Gaussian quadrature " Link "eval"}                  eval
 @{" Gaussian quadrature " Link "Post-Processing Accuracy"}                  Post-Processing Accuracy
 @{" Gaussian quadrature " Link "select"}                  select
 @{" Graphical interface " Link "Graphic Interactive Commands"}                  Graphic Interactive Commands
 @{" Grid points " Link "grid"}                          grid
 @{" Group addition " Link "group"}                       group
 @{" Group deletion " Link "group"}                       group
 @{" Group information " Link "info"}                    info
 @{" Group removal " Link "group"}                        group
 @{" Group translation " Link "group"}                    group
 @{" Hardcopy " Link "hard"}                             hard
 @{" Integration points " Link "elem"}                   elem
 @{" Integration rule " Link "Element Instability"}                     Element Instability
 @{" Interactivity " Link "Utility Commands"}                        Utility Commands
 @{" Interchange File Format (IFF) " Link "save"}        save
 @{" Isoparametric shape functions " Link "elem"}        elem
 @{" Lamina properties " Link "lam"}                    lam
 @{" Laminate properties " Link "lam"}                  lam
 @{" Load vector " Link "formkf"}                          formkf
 @{" Local coordinates " Link "eval"}                    eval
 @{" Local node number " Link "eval"}                    eval
 @{" Material " Link "fill"}                             fill
 @{" Material boundaries " Link "plot"}                  plot
 @{" Material identification number " Link "elem"}       elem
 @{" Material identification number " Link "mat"}       mat
 @{" Material identification number " Link "lam"}       lam
 @{" Material information " Link "info"}                 info
 @{" Material properties " Link "Materials"}                  Materials
 @{" Matrix solver " Link "Modeling Considerations"}                        Modeling Considerations
 @{" Memory deallocation " Link "reset"}                  reset
 @{" Model checks " Link "solve"}                         solve
 @{" Model filled plot " Link "fill"}                    fill
 @{" Model geometry " Link "Geometry"}                       Geometry
 @{" Model information " Link "info"}                    info
 @{" Model integrity " Link "check"}                      check
 @{" Model plot " Link "plot"}                           plot
 @{" Model statistics " Link "check"}                     check
 @{" Mouse pointer " Link "elem"}                        elem
 @{" Mouse pointer " Link "dbc"}                        dbc
 @{" Mouse pointer " Link "node"}                        node
 @{" Mouse pointer " Link "pbc"}                        pbc
 @{" Negative Jacobians " Link "Modeling Considerations"}                   Modeling Considerations
 @{" Node identification number " Link "pbc"}           pbc
 @{" Node identification number " Link "elem"}           elem
 @{" Node identification number " Link "node"}           node
 @{" Node information " Link "info"}                     info
 @{" Node order " Link "Geometry"}                           Geometry
 @{" Node order optimizer " Link "Modeling Considerations"}                 Modeling Considerations
 @{" Phillips Laboratory " Link "Acknowledgments"}                  Acknowledgments
 @{" Plane assumption " Link "plane"}                     plane
 @{" Plotting boundary conditions " Link "plot"}         plot
 @{" Plotting results " Link "plot"}                     plot
 @{" Point boundary condition information " Link "info"} info
 @{" Polar coordinate system " Link "coord"}              coord
 @{" Post-process " Link "Results Processing"}                         Results Processing
 @{" Post-process solution data " Link "set"}           set
 @{" Postscript " Link "hard"}                           hard
 @{" Pre-defined variables " Link "alias"}                alias
 @{" Pre-defined variables " Link "set"}                set
 @{" Problem kind " Link "problem"}                         problem
 @{" Public screen " Link "close"}                        close
 @{" Public screen " Link "view"}                        view
 @{" Public screen " Link "open"}                        open
 @{" Reading groups " Link "group"}                       group
 @{" Reference values " Link "mat"}                     mat
 @{" Reset window " Link "find"}                         find
 @{" Restriction of problem " Link "Problem Type"}               Problem Type
 @{" Result information " Link "info"}                   info
 @{" Result processing " Link "select"}                    select
 @{" Results " Link "fill"}                              fill
 @{" Rexxbar " Link "Graphic Interaction with Ami2D"}                              Graphic Interaction with Ami2D
 @{" Rexxcon " Link "Graphic Interaction with Ami2D"}                              Graphic Interaction with Ami2D
 @{" Rigid body motion " Link "check"}                    check
 @{" Rigid body motion " Link "Element Instability"}                    Element Instability
 @{" Root window " Link "view"}                          view
 @{" Root window " Link "open"}                          open
 @{" Saving groups " Link "group"}                        group
 @{" Software warranty " Link "Disclaimer"}                    Disclaimer
 @{" Solution accuracy " Link "Post-Processing Accuracy"}                    Post-Processing Accuracy
 @{" Solution evaluation " Link "select"}                  select
 @{" Solution evaluation " Link "eval"}                  eval
 @{" Solution information " Link "info"}                 info
 @{" Solution status " Link "status"}                      status
 @{" Starting a new problem " Link "reset"}               reset
 @{" Stiffness coefficients " Link "mat"}               mat
 @{" Stiffness matrix " Link "formkf"}                     formkf
 @{" Stopping the code " Link "stop"}                    stop
 @{" Storing intermediate data " Link "set"}            set
 @{" System assembly " Link "formkf"}                      formkf
 @{" Transversely isotropic material " Link "lam"}      lam
 @{" United States Air Force " Link "Acknowledgments"}              Acknowledgments
 @{" University of Texas at Austin " Link "Acknowledgments"}        Acknowledgments
 @{" User's responsibility " Link "Disclaimer"}                Disclaimer
 @{" Variables " Link "set"}                            set
 @{" Variables " Link "get"}                            get
 @{" Variables " Link "alias"}                            alias
 @{" View window " Link "view"}                          view
 @{" Window information " Link "info"}                   info
 @{" Window offsets " Link "open"}                       open
 @{" Window shift " Link "move"}                         move
 @{" Window size " Link "zoom"}                          zoom
 @{" World coordinates " Link "window"}                    window
 @{" Zero energy modes " Link "Element Instability"}                    Element Instability


@EndNode

@Node "Command Index" "Ami2D.guide/Command Index"
@Prev "Concept Index"
@Toc "Main"

Command Index
*************



 @{" abort " Link "abort"}                                abort
 @{" alias " Link "alias(rexxcon)"}                                alias(rexxcon)
 @{" alias " Link "alias"}                                alias
 @{" axisym " Link "axisym"}                               axisym
 @{" button " Link "button(rexxbar)"}                               button(rexxbar)
 @{" cd " Link "cd"}                                   cd
 @{" check " Link "check"}                                check
 @{" checkbox " Link "checkbox(rexxbar)"}                             checkbox(rexxbar)
 @{" clear " Link "clear"}                                clear
 @{" close " Link "close(rexxcon)"}                                close(rexxcon)
 @{" close " Link "close"}                                close
 @{" close " Link "close(rexxbar)"}                                close(rexxbar)
 @{" color " Link "color"}                                color
 @{" coord " Link "coord"}                                coord
 @{" cycle " Link "cycle(rexxbar)"}                                cycle(rexxbar)
 @{" dbc " Link "dbc"}                                  dbc
 @{" disable " Link "disable(rexxbar)"}                              disable(rexxbar)
 @{" elem " Link "elem"}                                 elem
 @{" enable " Link "enable(rexxbar)"}                               enable(rexxbar)
 @{" eval " Link "eval"}                                 eval
 @{" fill " Link "fill"}                                 fill
 @{" fill " Link "fill"}                                 fill
 @{" fill " Link "fill"}                                 fill
 @{" fill " Link "fill"}                                 fill
 @{" find " Link "find"}                                 find
 @{" formkf " Link "formkf"}                               formkf
 @{" get " Link "get"}                                  get
 @{" grid " Link "grid"}                                 grid
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" group " Link "group"}                                group
 @{" hard " Link "hard"}                                 hard
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" info " Link "info"}                                 info
 @{" lam " Link "lam"}                                  lam
 @{" mat " Link "mat"}                                  mat
 @{" move " Link "move"}                                 move
 @{" node " Link "node"}                                 node
 @{" open " Link "open"}                                 open
 @{" open " Link "open(rexxcon)"}                                 open(rexxcon)
 @{" open " Link "open(rexxbar)"}                                 open(rexxbar)
 @{" pbc " Link "pbc"}                                  pbc
 @{" plane " Link "plane"}                                plane
 @{" plot " Link "plot"}                                 plot
 @{" plot " Link "plot"}                                 plot
 @{" plot " Link "plot"}                                 plot
 @{" plot " Link "plot"}                                 plot
 @{" plot " Link "plot"}                                 plot
 @{" plot " Link "plot"}                                 plot
 @{" post " Link "post"}                                 post
 @{" problem " Link "problem"}                              problem
 @{" prompt " Link "prompt(rexxcon)"}                               prompt(rexxcon)
 @{" radio " Link "radio(rexxbar)"}                                radio(rexxbar)
 @{" read " Link "read(rexxcon)"}                                 read(rexxcon)
 @{" read " Link "read"}                                 read
 @{" reset " Link "reset"}                                reset
 @{" save " Link "save"}                                 save
 @{" select " Link "select"}                               select
 @{" set " Link "set"}                                  set
 @{" show " Link "show"}                                 show
 @{" show " Link "show"}                                 show
 @{" show " Link "show"}                                 show
 @{" show " Link "show"}                                 show
 @{" signal " Link "signal(rexxbar)"}                               signal(rexxbar)
 @{" slider " Link "slider(rexxbar)"}                               slider(rexxbar)
 @{" solve " Link "solve"}                                solve
 @{" status " Link "status"}                               status
 @{" stop " Link "stop"}                                 stop
 @{" stop " Link "stop(rexxbar)"}                                 stop(rexxbar)
 @{" stop " Link "stop(rexxcon)"}                                 stop(rexxcon)
 @{" string " Link "string(rexxbar)"}                               string(rexxbar)
 @{" text " Link "text(rexxbar)"}                                 text(rexxbar)
 @{" version " Link "version"}                              version
 @{" view " Link "view"}                                 view
 @{" why " Link "why"}                                  why
 @{" window " Link "window"}                               window
 @{" write " Link "write(rexxcon)"}                                write(rexxcon)
 @{" zoom " Link "zoom"}                                 zoom

@EndNode