# doc-cache created by Octave 10.3.0
# name: cache
# type: cell
# rows: 3
# columns: 74
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
AxiStress


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1259
 -- function file[UR,UZ]: = AxiStress(MESH,E,NU,F,GD,GN)

     solve an axisymmetric elasticity problem

        equation    in domain
                    u = gD    on Gamma_1
        force density = gN    on Gamma_2
        force density = 0     on Gamma_3

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • F = {F1,F2} a cell array with the two components of the volume
          forces
        • GD = {GD1,GD2} a cell array with the two components of the
          prescribed displacements on the boundary section Gamma_1
        • GN = {GN1,GN2} a cell array with the two components of the
          surface forces on the boundary section Gamma_2
        • Any constant function can be given by its scalar value
        • Any function can be given by a string with the function name
        • The functions E, NU, F1 and F2 may also be given as vectors
          with the values of the function at the Gauss points

     return values
        • UR vector with the values of the r-displacement at the nodes
        • UZ vector with the values of the z-displacement at the nodes

     See also: PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
solve an axisymmetric elasticity problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
AxiStressEquationCubicM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 149
  [gMat,gVec] = AxiStressEquationCubicM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)

  setup the equation for an axisymmetric problem with cubic elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
  [gMat,gVec] = AxiStressEquationCubicM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
AxiStressEquationM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 145
  [gMat,gVec] = AxiStressEquationM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)

  setup the equation for an axisymmetric problem with linear elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
  [gMat,gVec] = AxiStressEquationM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
AxiStressEquationQuadM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 152
  [gMat,gVec] = AxiStressEquationQuadM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)

  setup the equation for an axisymmetric problem with quadratic elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
  [gMat,gVec] = AxiStressEquationQuadM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
BVP1D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1039
 -- function file[X,U]: = BVP1D(INTERVAL,A,B,C,D,F,BCLEFT,BCRIGHT)

     solve a 1D boundary value problem (BVP)

     -(a(x)*u'(x))' + b(x)*u'(x) + c(x)*u(x) = d(x)*f(x)

     with boundary conditions at the two endpoints
        • Dirichlet: u(x) = g_D
        • Neumann: a(x)*u'(x) = g_N1 + g_N2*u(x)

     parameters:
        • INTERVAL the discretized interval for the BVP
        • A constant, vector or function handle to evaluate a(x)
        • B constant, vector or function handle to evaluate b(x)
        • C constant, vector or function handle to evaluate c(x)
        • D constant, vector or function handle to evaluate d(x)
        • F constant, vector or function handle to evaluate f(x)
        • BCLEFT and BCRIGHT the two boundary conditions
             • for a Dirichlet condition specify a single value G_D
             • for a Neumann condition specify the values [G_N1,G_N2]

     return values
        • X the nodes in the given interval
        • U the values of the solution at the nodes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
solve a 1D boundary value problem (BVP)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
BVP1DNL


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3608
 -- function file[X,U,INFORM]: =
          BVP1DNL(INTERVAL,A,B,C,D,F,BCLEFT,BCRIGHT,U0,OPTIONS)

     solve a nonlinear 1D boundary value problem (BVP)

     -(a(x,u,u')*u'(x))' + b(x)*u'(x) + c(x)*u(x) = d(x)*f(x,u,u')

     with boundary conditions at the two endpoints
        • Dirichlet: u(x) = g_D
        • Neumann: a(x,u,u')*u'(x) = g_N1 + g_N2*u(x)

     parameters:
        • INTERVAL the discretized interval for the BVP
        • A constant, vector or function handle to evaluate a(x), a(x,u)
          or a(x,u,u') at the Gauss points.
             • A a constant or vector of values of a(x).
             • A = @(X) a function handle to evaluate f(x).
             • A = @(X,U) assumes that the function a(x,u) depends on x
               and u.
             • A = @(X,U,U') assumes that a(x,u,u') depends on x, u and
               u'.
        • B constant, vector or function handle to evaluate b(x) at
          Gauss points
        • C constant, vector or function handle to evaluate c(x) at
          Gauss points
        • D constant, vector or function handle to evaluate d(x) at
          Gauss points
        • F constant, vector or function handle to evaluate f(x), f(x,u)
          or f(x,u,u') and the partial derivatives at nodes
             • F a constant or vector of values of f(x) at the nodes.
             • F = @(X) a function handle to evaluate f(x) at the nodes.
             • F = {@(X,U), @(X,U)} assumes that the function f depends
               on x and u.  The two function handles evaluate f(x,u) and
               the partial derivative f_u(x,u).
             • F = {@(X,U,U'), @(X,U,U') , @(X,U,U')} assumes that f
               depends on x, u and u'.  The three function handles
               evaluate f(x,u,u') and the partial derivatives
               f_u(x,u,u') and f_u'(x,u,u').
        • BCLEFT and BCRIGHT the two boundary conditions
             • for a Dirichlet condition specify a single value G_D
             • for a Neumann condition specify the two values
               [G_N1,G_N2]
        • U0 constant, vector or function handle to evaluate u0(x) at
          the nodes.  This is the starting value for the iteration.
        • OPTIONS additional options, given as pairs name/value.
             • "TOL" the tolerance for the iteration to stop, given as
               pair [TOLREL,TOLABS] for the relative and absolute
               tolerance.  The iteration stops if the absolute or
               relative error is smaller than the specified tolerance.
               RMS (root means square) values are used.  If only TOLREL
               is specified TOLABS=TOLREL is used.  The default values
               are TOLREL = TOLABS = 1E-5.
             • "MAXITER" the maximal number of iterations to be used.
               The default value is 10.
             • "DISPLAY" should information be displayed for the
               iterations
                  • "OFF" no display, default
                  • "ITER" display the number of the iteration and the
                    RMS size of the update

     return values
        • X the nodes in the given interval
        • U the values of the solution at the nodes
        • INFORM a structure with information on the performance of the
          algorithm
             • INFORM.INFO = 1 if the algorithm converged with the
               desired tolerance, -1 if not.
             • INFORM.ITER the number of iterations used.
             • INFORM.ABSERROR the RMS value of the last correction
               applied.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
solve a nonlinear 1D boundary value problem (BVP)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
BVP1Deig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1278
 -- function file[X,EVAL,EVEC,ERRORBOUND]: =
          BVP1Deig(INTERVAL,A,B,C,W,BCLEFT,BCRIGHT,NVEC,TOL)

     determine the smallest eigenvalues EVAL and eigenfunctions EVEC for
     the BVP

     -(a(x)*u'(x))' + b(x)*u'(x) + c(x)*u(x) = eVal*w(x)*u(x)

     u = 0 on Dirichlet boundary

     a*u' = g_N2*u on Neumann boundary

     parameters:
        • INTERVAL the discretized interval for the BVP
        • A constant, vector or function handle to evaluate a(x)
        • B constant, vector or function handle to evaluate b(x)
        • C constant, vector or function handle to evaluate c(x)
        • W constant, vector or function handle to evaluate d(x)
        • BCLEFT and BCRIGHT the two boundary conditions
             • for a Dirichlet condition specify a single value G_D=0
             • for a Neumann condition specify the values
               [G_N1,G_N2]=[0,G_N2]
        • NVEC the number of smallest eigenvalues to be computed
        • TOL tolerance for the eigenvalue iteration, default 1e-5

     return values
        • X the nodes in the given interval
        • EVAL the eigenvalues
        • EVEC the matrix of eigenvectors of the solutions at the nodes
        • ERRORBOUND a matrix with error bounds of the eigenvalues


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
determine the smallest eigenvalues EVAL and eigenfunctions EVEC for the
BVP



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
BVP2D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1475
 -- function file U: = BVP2D(MESH,A,B0,BX,BY,F,GD,GN1,GN2,OPTIONS)

     Solve an elliptic boundary value problem

      -div(a*grad u - u*(bx,by))+ b0*u = f         in domain
                                     u = gD        on Dirichlet boundary
              n*(a*grad u - u*(bx,by)) = gN1+gN2*u on Neumann boundary

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • A,B0,BX,BY,F,GD,GN1,GN2 are the coefficients and functions
          describing the PDE.
          Any constant function can be given by its scalar value.
          The functions A,B0,BX,BY and F may also be given as vectors
          with the values of the function at the Gauss points.
        • The coefficient A can also be a symmetric matrix
          A=[axx,axy;axy,ayy] given by the row vector [axx,ayy,axy].  It
          can be given as row vector or as string with the function name
          or as nx3 matrix with the values at the Gauss points.
        • OPTIONS additional options, given as pairs name/value.
          Currently only real or complex coefficient problems can be
          selected by "TYPE" and the possible values are
             • "REAL": all coefficients are real (default)
             • "COMPLEX": some coefficients might be complex

     return value
        • U is the vector with the values of the solution at the nodes

     See also: BVP2Dsym, BVP2eig, IBVP2D, CreateMeshRect,
     CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 40
Solve an elliptic boundary value problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
BVP2Deig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1655
 -- function file[EVAL,EVEC,ERRORBOUND]: =
          BVP2Deig(MESH,A,B0,W,GN2,NVEC,TOL,OPTIONS)

     determine the smallest eigenvalues EVAL and eigenfunctions EVEC for
     the BVP

         -div(a*grad u) + b0*u = Eval*w*u  in domain
                            u  = 0         on Dirichlet boundary
                 n*(a*grad u)  = gN2*u on  Neumann boundary

     parameters:
        • MESH the mesh describing the domain and the boundary types
        • A,B0,W,GN2 the coefficients and functions describing the PDE.
          Any constant function can be given by its scalar value.
          The functions A,B0 and W may also be given as vectors with the
          values of the function at the Gauss points.
        • The coefficient A can also be a symmetric matrix
          A=[axx,axy;axy,ayy] given by the row vector [axx,ayy,axy].  It
          can be given as row vector or as string with the function name
          or as nx3 matrix with the values at the Gauss points.
        • NVEC number of smallest eigenvalues to be computed
        • OPTIONS additional options, given as pairs name/value.
             • TOL tolerance for the eigenvalue iteration, default 1e-5
             • "TYPE" select real or complex coefficients
                  • "REAL": all coefficients are real (default)
                  • "COMPLEX": some coefficients might be complex

     return values:
        • EVAL is the vector with the eigenvalues
        • EVEC is the matrix with the eigenvectors as columns
        • ERRORBOUND is a matrix with error bounds of the eigenvalues

     See also: BVP2D, BVP2sym, IBVP2D, IBVP2Dsym, I2BVP2D.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
determine the smallest eigenvalues EVAL and eigenfunctions EVEC for the
BVP



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
BVP2Dsym


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1198
 -- function fileU: = BVP2Dsym(MESH,A,B0,F,GD,GN1,GN2)

     Solve a symmetric, elliptic boundary value problem

         -div(a*grad u)+ b0*u = f            in domain
                            u = gD           on Dirichlet boundary
                 n*(a*grad u) = gN1 + gN2*u  on Neumann boundary

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • The element type (linear, qudratic, cubic) is selected by MESH
        • A,B0,F,GD,GN1,GN2 are the coefficients and functions
          describing the PDE.
          Any constant function can be given by its scalar value.
          The functions A,B0 and F may also be given as vectors with the
          values of the function at the Gauss points.
        • The coefficient A can also be a symmetric matrix
          A=[axx,axy;axy,ayy] given by the row vector [axx,ayy,axy].  It
          can be given as row vector or as string with the function name
          or as nx3 matrix with the values at the Gauss points.

     return value
        • U is the vector with the values of the solution at the nodes

     See also: BVP2D, BVP2eig, IBVP2D, CreateMeshRect,
     CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Solve a symmetric, elliptic boundary value problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
CreateMeshRect


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2234
 -- function fileMesh: = CreateMeshRect(X,Y,BLOW,BUP,BLEFT,BRIGHT)

     Create a rectangular mesh nodes at (x_i,y_j)

     parameters:
        • X,Y are the vectors containing the coodinates of the nodes to
          be generated.
        • BLOW, BUP, BLEFT, BRIGHT indicate the type of boundary
          condition at lower, upper, left and right edge of the
          rectangle
             • for scalar problems
                  • B* = -1: Dirichlet boundary condition
                  • B* = -2: Neumann or Robin boundary condition
             • for elasticity problems
                  • bi = -xy : with two digits for x and y directions
                  • x/y = 1 : given displacement
                  • x/y = 2 : force free
                  • x/y = 3 : given force density

     return values
        • MESH is a a structure with the information about the mesh.
          The mesh consists of n_e elements, n_n nodes and n_ed edges.
             • MESH.TYPE a string with the type of triangle: linear
             • MESH.ELEM n_e by 3 matrix with the numbers of the nodes
               forming triangular elements
             • MESH.ELEMAREA n_e vector with the areas of the elements
             • MESH.ELEMT n_e vector with the type of elements (not
               used)
             • MESH.NODES n_n by 2 matrix with the coordinates of the
               nodes
             • MESH.NODEST n_n vector with the type of nodes
             • MESH.EDGES n_ed by 2 matrix with the numbers of the nodes
               forming edges
             • MESH.EDGEST n_ed vector with the type of edge
             • MESH.GP n_e*3 by 2 matrix with the coordinates of the
               Gauss points
             • MESH.GPT n_e*3 vector of integers with the type of Gauss
               points
             • MESH.NDOF number of DOF, degrees of freedom
             • MESH.NODE2DOF n_n vector or n_n by 2 matrix of integers,
               mapping nodes to DOF

     Sample call:
     Mesh = CreateMeshRect(linspace(0,1,10),linspace(-1,2,20),-1,-1,-2,-2)
             will create a mesh with 200 nodes and 0<=x<=1, -1<=y<=+2

     See also: CreateMeshTriangle, BVP2D, BVP2Dsym, BVP2eig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
Create a rectangular mesh nodes at (x_i,y_j)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
CreateMeshTriangle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3517
 -- function fileMESH: = CreateMeshTriangle(NAME,XY,AREA,OPTIONS)

     Generate files with a mesh with linear elements using the external
     code triangle

     parameters:
        • NAME the base filename: the file NAME.poly will be generated
          then triangle will generate files NAME.1.* with the mesh
        • XY vector containing the coordinates of the nodes forming the
          outer boundary.  The last given node will be connected to the
          first given node to create a closed curve.
          The format for XY is [x1,y1,b1;x2,y2,b2;...;xn,yn,bn] where
             • xi x-coordinate of node i
             • yi y-coordinate of node i
             • bi boundary marker for segment from node i to node i+1
                  • for scalar problems
                       • bi = -1 Dirichlet boundary condition
                       • bi = -2 Neumann or Robin boundary condition
                  • for elasticity problems
                       • B* = -xy : with two digits for x and y
                         directions
                       • x/y = 1 : given displacement
                       • x/y = 2 : force free
                       • x/y = 3 : given force density
             • AREA the typical area of the individual triangles to be
               used
             • OPTIONS additional options to be used when calling
               triangle.  The options "pa" and the area will be added
               automatically.  Default options are "q" resp.  "qpa".  To
               suppress the verbose information use "Q"


               More options are available to adapt mesh sizes and create
               holes.  See the documentation in FEMdoc.pdf

     The information on the mesh generated is written to files and
     returned in the structure MESH, if the return argument is provided.

        • The information can then be read and used by
          Mesh = ReadMeshTriangle('NAME.1');
        • MESH is a structure with the information about the mesh.
          The mesh consists of n_e elements, n_n nodes and n_ed edges.
             • MESH.TYPE a string with the type of triangle: linear,
               quadratic or cubic
             • MESH.ELEM n_e by 3 (or 6/10) matrix with the numbers of
               the nodes forming triangular elements
             • MESH.ELEMAREA n_e vector with the areas of the elements
             • MESH.ELEMT n_e vector with the type of elements (not
               used)
             • MESH.NODES n_n by 2 matrix with the coordinates of the
               nodes
             • MESH.NODEST n_n vector with the type of nodes (not used)
             • MESH.EDGES n_ed by 2 (or 3/4) matrix with the numbers of
               the nodes forming edges
             • MESH.EDGEST n_ed vector with the type of edge
             • MESH.GP n_e*(3/7) by 2 matrix with the coordinates of the
               Gauss points
             • MESH.GPT n_e*(3/7) vector of integers with the type of
               Gauss points
             • MESH.NDOF number of DOF, degrees of freedom
             • MESH.NODE2DOF n_n vector of integer, mapping nodes to DOF

     Sample call:
     Mesh = CreateMeshTriangle('Test',[0,-1,-1;1,-1,-2;1,2,-1;0,2,-2],0.01)
       will create a mesh with 0<=x<=1, -1<=y<=+2
       and a typical area of 0.01 for each triangle
     Could be read by Mesh = ReadMeshTriangle('Test.1')

     See also: ReadMeshTriangle, CreateMeshRect, BVP2D, BVP2Dsym,
     BVP2eig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Generate files with a mesh with linear elements using the external code
trian...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
Delaunay2Mesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 316
 -- function fileFEMMESH: = Delaunay2Mesh(TRI,X,Y)

     generate a mesh with elements of order 1, using a Delaunay
     triangulation

     parameters:
        • TRI the Delaunay triangulation
        • X, Y the coodinates of the points

     return value
        • FEMMESH is the mesh to be used by FEMoctave


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
generate a mesh with elements of order 1, using a Delaunay triangulation



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
EvaluateEnergyDensity


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1061
 -- function fileW: =
          EvaluateEnergyDensity(MESH,EPS_XX,EPS_YY,EPS_XY,E,NU,OPTIONS)

     evaluate the elastic energy density at the nodes for a plane stress
     or strain setup

     parameters:
        • MESH is the mesh describing the domain
        • EPS_XX, EPS_YY, EPS_XY vectors with the values of the strains
          at the nodes
        • E Young's modulus of elasticity, either as constant or as
          string with the function name
        • NU Poisson's ratio, either as constant or as string with the
          function name
        • OPTIONS additional options, given as pairs name/value.
          Currently only plain stress or strain be can selected as
          "MODEL" and the possible values
             • "PSTRESS" for the plain stress assumption (default)
             • "PSTRAIN" for the plain strain assumption

     return value:
        • W values of the elastic energy density at the nodes

     See also: EvaluateStrain, EvaluateStress, EvaluateVonMises,
     EvaluateTresca, EvaluatePrincipalStress.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
evaluate the elastic energy density at the nodes for a plane stress or
strain...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
EvaluateEnergyDensityAxi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 780
 -- function fileW: =
          EvaluateEnergyDensityAxi(MESH,EPS_XX,EPS_YY,EPS_ZZ,EPS_XZ,E,NU)

     evaluate the elastic energy density at the nodes for an axially
     symmetric setup

     parameters:
        • MESH is the mesh describing the domain
        • EPS_XX, EPS_YY, EPS_ZZ, EPS_XZ vectors with the values of the
          strains at the nodes in the plane y=0
        • E Young's modulus of elasticity, either as constant or as
          string with the function name
        • NU Poisson's ratio, either as constant or as string with the
          function name

     return value:
        • W values of the elastic energy density at the nodes

     See also: EvaluateStrain, EvaluateStress, EvaluateVonMises,
     EvaluateTresca, EvaluatePrincipalStress.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 79
evaluate the elastic energy density at the nodes for an axially
symmetric setup



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
EvaluatePrincipalStress


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 584
 -- function file[SIGMA_1,SIGMA_2]: =
          EvaluatePrincipalStress(SIGMA_X,SIGMA_Y,TAU_XY)

     evaluate the first two principal stresses at the nodes

     parameters:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • TAU_XY values of shearing strain at the nodes

     return values:
        • SIGMA_1 first principal stress at the nodes
        • SIGMA_2 second principal stress at the nodes

     See also: EvaluateStress, EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
evaluate the first two principal stresses at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
EvaluatePrincipalStressAxi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 577
 -- function file[SIGMA_1,SIGMA_2]: =
          EvaluatePrincipalStressAxi(SIGMA_X,SIGMA_Z,TAU_XZ)

     evaluate two principal stresses at the nodes

     parameters:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Z values of normal stress in z direction at the nodes
        • TAU_XZ values of shearing strain at the nodes

     return values:
        • SIGMA_1 first principal stress at the nodes
        • SIGMA_2 second principal stress at the nodes

     See also: EvaluateStress, EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
evaluate two principal stresses at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
EvaluateStrain


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 625
 -- function file[EPS_XX,EPS_YY,EPS_XY]: = EvaluateStrain(MESH,U1,U2)

     evaluate the normal and shearing strains at the nodes

     parameters:
        • MESH is the mesh describing the domain
        • U1 vector with the values of the x-displacement at the nodes
        • U2 vector with the values of the x-displacement's at the nodes

     return values:
        • EPS_XX values of normal strain in x direction at the nodes
        • EPS_YY values of normal strain in y direction at the nodes
        • EPS_XY values of shearing strain at the nodes

     See also: EvaluateStress, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
evaluate the normal and shearing strains at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
EvaluateStrainAxi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 716
 -- function file[EPS_XX,EPS_YY,EPS_ZZ,EPS_XZ]: =
          EvaluateStrainAxi(MESH,UR,UZ)

     evaluate the normal and shearing strains at the nodes

     parameters:
        • MESH is the mesh describing the domain
        • UR vector with the values of the r-displacements at the nodes
        • UZ vector with the values of the z-displacements at the nodes

     return values:
        • EPS_XX values of normal strain in x direction at the nodes
        • EPS_YY values of normal strain in y direction at the nodes
        • EPS_ZZ values of normal strain in z direction at the nodes
        • EPS_XZ values of shearing strain at the nodes

     See also: EvaluateStress, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
evaluate the normal and shearing strains at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
EvaluateStress


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1342
 -- function file[SIGMA_X,SIGMA_Y,TAU_XY,SIGMA_Z]: =
          EvaluateStress(MESH,U1,U2,E,NU)

     evaluate the normal and shearing stresses at the nodes, using
     Hooke's law for plane stress or plane strain setups

        • [SIGMA_X,SIGMA_Y,TAU_XY] = EvaluateStress(MESH,U1,U2,E,NU)
          with three return arguments assumes a plane stress situation
        • [SIGMA_X,SIGMA_Y,TAU_XY,SIGMA_Z] =
          EvaluateStress(MESH,U1,U2,E,NU)
          with four return arguments assumes a plane strain situation

     parameters:
        • MESH is the mesh describing the domain
        • U1 vector with the values of the x-displacements at the nodes
        • U2 vector with the values of the y-displacements at the nodes
        • E Young's modulus of elasticity, either as constant or as
          string with the function name
        • NU Poisson's ratio, either as constant or as string with the
          function name

     return values:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • TAU_XY values of shearing strain at the nodes
        • SIGMA_Z values of normal stress in y direction at the nodes,
          only for plane strain situations

     See also: EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
evaluate the normal and shearing stresses at the nodes, using Hooke's
law for...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
EvaluateStressAxi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 973
 -- function file[SIGMA_X,SIGMA_Y,SIGMA_Z,TAU_XZ]: =
          EvaluateStressAxi(MESH,UR,UZ,E,NU)

     evaluate the normal and shearing stresses at the nodes, using
     Hooke's law

     parameters:
        • MESH is the mesh describing the domain
        • UR vector with the values of the r-displacements at the nodes
        • UZ vector with the values of the z-displacements at the nodes
        • E Young's modulus of elasticity, either as constant or as
          string with the function name
        • NU Young's modulus of elasticity, either as constant or as
          string with the function name

     return values:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • SIGMA_Z values of normal stress in z direction at the nodes
        • TAU_XZ values of shearing strain at the nodes

     See also: EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
evaluate the normal and shearing stresses at the nodes, using Hooke's
law



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
EvaluateTresca


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 874
 -- function fileTRESCA: =
          EvaluateTresca(SIGMA_X,SIGMA_Y,TAU_XY,SIGMA_Z)

     evaluate the Tresca stress at the nodes

        • TRESCA = EvaluateTresca(SIGMA_X,SIGMA_Y,TAU_XY)
          with three input arguments assumes a plane stress situation
        • TRESCA = EvaluateTresca(SIGMA_X,SIGMA_Y,TAU_XY,SIGMA_Z)
          with four input arguments assumes a plane strain situation

     parameters:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • TAU_XY values of shearing strain at the nodes
        • SIGMA_Z values of normal stress in z direction at the nodes,
          only for plane strain situations

     return values:
        • TRESCA Tresca stress at the nodes

     See also: EvaluateStress, EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
evaluate the Tresca stress at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
EvaluateTrescaAxi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 565
 -- function fileTRESCA: =
          EvaluateTrescaAxi(SIGMA_X,SIGMA_Y,SIGMA_Z,TAU_XZ)

     evaluate the Tresca stress at the nodes

     parameters:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • SIGMA_Z values of normal stress in z direction at the nodes
        • TAU_XZ values of shearing strain at the nodes

     return values:
        • TRESCA Tresca stress at the nodes

     See also: EvaluateStress, EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
evaluate the Tresca stress at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
EvaluateVonMises


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 907
 -- function fileVONMISES: =
          EvaluateVonMises(SIGMA_X,SIGMA_Y,TAU_XY,SIGMA_Z)

     evaluate the von Mises stress at the nodes

        • VONMISES = EvaluateVonMises(SIGMA_X,SIGMA_Y,TAU_XY)
          with three input arguments assumes a plane stress situation
        • VONMISES = EvaluateVonMises(SIGMA_X,SIGMA_Y,TAU_XY,SIGMA_Z)
          with four input arguments assumes a plane strain situation
     parameters:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • TAU_XY values of shearing strain at the nodes
        • SIGMA_Z values of normal stress in z direction at the nodes,
          only for plane strain situations

     return values:
        • VONMISES values of the von Mises stress at the nodes

     See also: EvaluateStress, EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
evaluate the von Mises stress at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
EvaluateVonMisesAxi


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 591
 -- function fileVONMISES: =
          EvaluateVonMisesAxi(SIGMA_X,SIGMA_Y,SIGMA_Z,TAU_XZ)

     evaluate the von Mises stress at the nodes

     parameters:
        • SIGMA_X values of normal stress in x direction at the nodes
        • SIGMA_Y values of normal stress in y direction at the nodes
        • SIGMA_Z values of normal stress in z direction at the nodes
        • TAU_XZ values of shearing strain at the nodes

     return values:
        • VONMISES values of the von Mises stress at the nodes

     See also: EvaluateStress, EvaluateStrain, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 42
evaluate the von Mises stress at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
FEM1DEvaluateDu


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 376
 -- function file[DU,DDU]: = FEM1DEvaluateDu(X,U)

     evaluate the first and second derivatives at the nodes x

     parameters:
        • X coordinates of the nodes, generated by BVP1D()
        • U values of the function at the nodes

     return values
        • DU the values of the derivative at the nodes
        • DDU the values of the derivative at the nodes


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
evaluate the first and second derivatives at the nodes x



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
FEM1DGaussPoints


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 453
 -- function file[XGAUSS,NODES2GAUSSU,NODES2GAUSSDU]: =
          FEM1DGaussPoints(X)

     determine the coordinates of the Gauss points and interpolation
     matrices

     parameters:
        • X coordinates of the nodes, generated by BVP1D()

     return values
        • XGAUSS coordinates of the Gauss points
        • NODES2GAUSSU matrix to evaluate u at the Gauss points
        • NODES2GAUSSDU matrix to evaluate u' at the Gauss points


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 72
determine the coordinates of the Gauss points and interpolation matrices



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
FEM1DIntegrate


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
 Result = FEM1DIntegrate(x,u)
 numerical integration of FEM expression, using Simpson's rule
 the grid x requires the shape of FEMoctave 1D grids



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 Result = FEM1DIntegrate(x,u)
 numerical integration of FEM expression, using...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
FEMEquation


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1050
[...] = FEMEquation (...)
  sets up the system of linear equations for a numerical solution of a PDE

  [A,b,n2d] = FEMEquation(Mesh,'a','b0','bx','by','f','gD','gN1','gN2')
    Mesh is the mesh describing the domain\n\
         see ReadMesh() for the description of the format
   'a','b0','bx','by','f','gD','gN1','gN2' are the functions and coefficients 
         for the boundary value problem. They can be given as a scalar value
         or as a string with the function name 
         The coefficient 'a' can also be a symmetric matrix a=[axx,axy;axy,ayy]
         given by the row vector [axx,ayy,axy].
         It can be given as row vector or as string with the function name or
         as nx3 matrix with the values at the Gauss points.


  -div(a*grad u-u*(bx,by)) + b0*u = f    in domain
                          u = gD         on Dirichlet section of the boundary
         (a*du-u*(bx,by))*n = gN1+gN2*u  on Neumann section of the boundary 


 A   is the matrix of the system to be solved.
 b   is the RHS of the system to be solved.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMEquation (...)
  sets up the system of linear equations for a nume...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
FEMEquationCubic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1055
[...] = FEMEquationCubic (...)
  sets up the system of linear equations for a numerical solution of a PDE

  [A,b] = FEMEquationCubicM(Mesh,'a','b0','bx','by','f','gD','gN1','gN2')
    Mesh is the mesh describing the domain\n\
         see ReadMesh() for the description of the format
   'a','b0','bx',by','f','gD','gN1','gN2' are the functions and coefficients 
         for the boundary value problem. They can be given as a scalar value
         or as a string with the function name 
         The coefficient 'a' can also be a symmetric matrix a=[axx,axy;axy,ayy]
         given by the row vector [axx,ayy,axy].
         It can be given as row vector or as string with the function name or
         as nx3 matrix with the values at the Gauss points.

  -div(a*grad u-u*(bx,by)) + b0*u = f    in domain%
                          u = gD         on Dirichlet section of the boundary
         (a*du-u*(bx,by))*n = gN1+gN2*u  on Neumann section of the boundary 

 A   is the matrix of the system to be solved.
 b   is the RHS of the system to be solved.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMEquationCubic (...)
  sets up the system of linear equations for a...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
FEMEquationCubicM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1104
[...] = FEMEquationCubicM (...)
  sets up the system of linear equations for a numerical solution of a PDE
  using a triangular mesh with elements of order 3

  [A,b] = FEMEquationCubicM(Mesh,'a','b0','bx','by','f','gD','gN1','gN2')
    Mesh is the mesh describing the domain\n\
         see ReadMesh() for the description of the format
   'a','b0','bx',by','f','gD','gN1','gN2' are the functions and coefficients
         for the boundary value problem. They can be given as a scalar value
         or as a string with the function name
         The coefficient 'a' can also be a symmetric matrix a=[axx,axy;axy,ayy]
         given by the row vector [axx,ayy,axy].
         It can be given as row vector or as string with the function name or
         as nx3 matrix with the values at the Gauss points.

  -div(a*grad u-u*(bx,by)) + b0*u = f    in domain%
                          u = gD         on Dirichlet section of the boundary
         (a*du-u*(bx,by))*n = gN1+gN2*u  on Neumann section of the boundary

 A   is the matrix of the system to be solved.
 b   is the RHS of the system to be solved.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMEquationCubicM (...)
  sets up the system of linear equations for ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
FEMEquationM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1099
[...] = FEMEquationM (...)
  sets up the system of linear equations for a numerical solution of a PDE
  using a triangular mesh with elements of order 1

  [A,b] = FEMEquationM(Mesh,'a','b0','bx','by','f','gD','gN1','gN2')
    Mesh is the mesh describing the domain\n\
         see ReadMesh() for the description of the format
   'a','b0','bx','by','f','gD','gN1','gN2' are the functions and coefficients 
         for the boundary value problem. They can be given as a scalar value
         or as a string with the function name 
         The coefficient 'a' can also be a symmetric matrix a=[axx,axy;axy,ayy]
         given by the row vector [axx,ayy,axy].
         It can be given as row vector or as string with the function name or
         as nx3 matrix with the values at the Gauss points.


  -div(a*grad u-u*(bx,by)) + b0*u = f    in domain
                          u = gD         on Dirichlet section of the boundary
         (a*du-u*(bx,by))*n = gN1+gN2*u  on Neumann section of the boundary 


 A   is the matrix of the system to be solved.
 b   is the RHS of the system to be solved.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMEquationM (...)
  sets up the system of linear equations for a num...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
FEMEquationQuad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1058
[...] = FEMEquationQuad (...)
  sets up the system of linear equations for a numerical solution of a PDE

  [A,b,n2d] = FEMEquationQuad(Mesh,'a','b0','bx',by','f','gD','gN1','gN2')
    Mesh is the mesh describing the domain\n\
         see ReadMesh() for the description of the format
   'a','b0', 'bx','by','f','gD','gN1','gN2' are the functions and coefficients 
         for the boundary value problem. They can be given as a scalar value
         or as a string with the function name 
         The coefficient 'a' can also be a symmetric matrix a=[axx,axy;axy,ayy]
         given by the row vector [axx,ayy,axy].
         It can be given as row vector or as string with the function name or
         as nx3 matrix with the values at the Gauss points.

  -div(a*grad u-u*(bx,by)) + b0*u = f    in domain%
                          u = gD         on Dirichlet section of the boundary
         (a*du-u*(bx,by))*n = gN1+gN2*u  on Neumann section of the boundary 


 A   is the matrix of the system to be solved.
 b   is the RHS of the system to be solved.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMEquationQuad (...)
  sets up the system of linear equations for a ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
FEMEquationQuadM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1103
[...] = FEMEquationQuadM (...)
  sets up the system of linear equations for a numerical solution of a PDE
  using a triangular mesh with elements of order 2

  [A,b] = FEMEquationQuadM(Mesh,'a','b0','bx',by','f','gD','gN1','gN2')
    Mesh is the mesh describing the domain\n\
         see ReadMesh() for the description of the format
   'a','b0', 'bx','by','f','gD','gN1','gN2' are the functions and coefficients
         for the boundary value problem. They can be given as a scalar value
         or as a string with the function name
         The coefficient 'a' can also be a symmetric matrix a=[axx,axy;axy,ayy]
         given by the row vector [axx,ayy,axy].
         It can be given as row vector or as string with the function name or
         as nx3 matrix with the values at the Gauss points.

  -div(a*grad u-u*(bx,by)) + b0*u = f    in domain
                          u = gD         on Dirichlet section of the boundary
         (a*du-u*(bx,by))*n = gN1+gN2*u  on Neumann section of the boundary


 A   is the matrix of the system to be solved.
 b   is the RHS of the system to be solved.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMEquationQuadM (...)
  sets up the system of linear equations for a...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
FEMEvaluateGP


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 515
 -- function file[UGP,GRADUGP]: = FEMEvaluateGP(MESH,U)

     evaluate the function and gradient at the Gauss points

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • U vector with the values of at the nodes

     return values
        • UGP values of u at the Gauss points
        • GRADUGP matrix with the values of the gradient in the columns

     See also: FEMEvaluateGradient, BVP2D, BVP2Dsym, BVP2eig, IBVP2D,
     CreateMeshRect, CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
evaluate the function and gradient at the Gauss points



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
FEMEvaluateGradient


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 646
 -- function file[UX,UY]: = FEMEvaluateGradient(MESH,U)

     evaluate the gradient of the function u at the nodes

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • U vector with the values of the function at the nodes

     return value
        • UX x component of the gradient of u
        • UY y component of the gradient of u

     the values of the gradient are determined on each element
     at the nodes the average of the gradients of the neighboring
     elements is used

     See also: FEMEvalutateGP, BVP2D, BVP2Dsym, BVP2eig, IBVP2D,
     CreateMeshRect, CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
evaluate the gradient of the function u at the nodes



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
FEMIntegrate


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 599
 -- function fileNUMINTEGRAL: = FEMIntegrate(MESH,U)

     integrate a function u over the domain given in Mesh

     parameters:
        • MESH is the mesh describing the domain
        • U the function to be integrated
          can be given as function name to be evaluated or as scalar
          value, or as a vector with the values at the nodes or the
          Gauss points.

     return value
        • NUMINTGERAL the numerical approximation of the integral

     See also: FEMEvaluateGradient, FEMEvaluateGP, BVP2D, BVP2Dsym,
     BVP2eig, IBVP2D, CreateMeshRect, CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
integrate a function u over the domain given in Mesh



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
FEMInterpolBoundaryWeight


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 759
 -- function fileWGD: = FEMInterpolBoundaryWeight(FEMMESH,A,B0)

     create the matrix to determine the contribution of gD to a IBVP or
     BVP
     the contribution of gD is the determined by WgD*gD, where gD is the
     vector with the values at the Dirichlet nodes

         -div(a*grad u)+ b0*u = f         in domain
                            u = gD        on Dirichlet boundary
                 n*(a*grad u) = gN1+gN2*u on Neumann boundary

     parameters:
        • FEMMESH is the mesh describing the domain and the boundary
          types.
        • A,B0 are the coefficients and functions describing the PDE.

     return value:
        • WGD is the sparse weight matrix

     See also: FEMInterpolWeight, IBVP2D, BVP2D, BVP2Dsym, BVP2eig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80

create the matrix to determine the contribution of gD to a IBVP or BVP
the c...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
FEMInterpolWeight


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 811
 -- function fileWMAT: = FEMInterpolWeight(FEMMESH,WFUNC)

     create the matrix to determine the contribution of w*f to a IBVP or
     BVP
     the contribution of w*f is the determined by wMat*f, where f is the
     vector with the values at the "free" nodes

         -div(a*grad u)+ b0*u = w*f       in domain
                            u = gD        on Dirichlet boundary
                 n*(a*grad u) = gN1+gN2*u on Neumann boundary

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • WFUNC is the weight function w
          It may be given as a function name, a vector with the values
          at the Gauss points or as a scalar value

     return value
        • WMAT is the sparse weight matrix

     See also: IBVP2D, BVP2D, BVP2Dsym, BVP2eig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80

create the matrix to determine the contribution of w*f to a IBVP or BVP
the ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
FEMSolve


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 545
[...] = FEMSolve (...)
  solves the system of linear equations for a numerical solution of a PDE

  u = FEMSolve(FEMmesh,A,b,gD)

 nodes contains information about the mesh
         see ReadMesh() for the description of the format
 A    is the matrix of the system to be solved.
      It is stored as a full matrix
 b    is the RHS of the system to be solved.
 'gD' is the function describing the Dirichlet boundary condition

 u    is the vector with the values of the solution

see also ReadMesh, ShowMesh, FEMEquation, ShowSolution, FEMValue



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
[...] = FEMSolve (...)
  solves the system of linear equations for a numerica...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
FEMgriddata


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1134
 -- function file[UI,UXI,UYI]: = FEMgriddata(MESH,U,XI,YI)

     evaluate the function (and gradient) at given points by
     interpolation

     parameters:
        • MESH is the mesh describing the domain
          If MESH consists of linear elements, piecewise linear
          interpolation is used.
          If MESH consists of quadratic elements, piecewise quadratic
          interpolation is used.
          If MESH consists of cubic elements, piecewise cubic
          interpolation is used.
        • U vector with the values of the function at the nodes
        • XI, YI coordinates of the points where the function is
          evaluated

     return values:
        • UI values of the interpolated function u
        • UXI x component of the gradient of u
        • UYI y component of the gradient of u

     The values of the function and the gradient are determined on each
     element by a piecewise linear, quadratic or cubic interpolation.
     If a point is not inside the mesh NaN is returned.

     See also: FEMEvalutateGP, BVP2D, BVP2Dsym, BVP2eig, IBVP2D,
     CreateMeshRect, CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
evaluate the function (and gradient) at given points by interpolation



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
FEMtricontour


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 401
 -- FEMtricontour (MESH, U, V)

     display contours of a function U on a triangular MESH

     parameters:
        • MESH is the mesh
        • U values of the function to be displayed
        • V contours to be used, default value is 21
          if V is scalar, it is the number of contours
          if V is a vector, it is the levels of the contours

     See also: FEMtrimesh, FEMtrisurf.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
display contours of a function U on a triangular MESH



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
FEMtrimesh


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 277
 -- FEMtrimesh (MESH, U)

     display a solution U on a triangular MESH

     parameters:
        • MESH is the mesh
        • U values of the function to be displayed
          if U is not given, then the mesh is displayed in 2D

     See also: FEMtrisurf, FEMtricontour.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
display a solution U on a triangular MESH



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
FEMtrisurf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 226
 -- FEMtrisurf (MESH, U)

     display a solution U as surface on a triangular MESH

     parameters:
        • MESH is the mesh
        • U values of the function to be displayed

     See also: FEMtrimesh, FEMtricontour.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
display a solution U as surface on a triangular MESH



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
GenerateFEM1D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 773
 -- function file[A,M,XNEW]: = GenerateFEM1D(X,A,B,C,D)

     generate the matrices A and M to discretize the expression

     -d/dx (a(x) d/dx u(x)) + b(x)*d/dx u(x) + c(x)*u(x) + d(x)*f(x)

     by A*u - M*f

     parameters:
        • A function handle to evaluate the coefficient a(x), vectorized
        • B function handle to evaluate the coefficient b(x), vectorized
        • C function handle to evaluate the coefficient c(x), vectorized
        • D function handle to evaluate the coefficient d(x), vectorized

     return values
        • A matrix discretizing the expressions involving u(x)
        • M matrix discretizing the evalaution of d(x)*f(x)
        • XNEW vector with the grid points

     for an elementary demo use "demo GenerateFEM1D"


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
generate the matrices A and M to discretize the expression



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
GenerateWeight1D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 530
 -- function file[XNEW,W1MAT,W2MAT]: = GenerateWeight1D(X,W1,W2)

     generate the weight matrices W1MAT and W2MAT

     parameters:
        • W1 constant, vector or function handle to evaluate the
          coefficient w1(x), vectorized
        • W2 (optional) constant, vector or function handle to evaluate
          the coefficient w2(x), vectorized

     return values
        • XNEW vector with the grid points
        • W1MAT weight matrix discretizing W1
        • W2MAT (optional) weight matrix discretizing W2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
generate the weight matrices W1MAT and W2MAT



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
I2BVP1D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2411
 -- function file[X,U,T]: =
          I2BVP1D(INTERVAL,W1,A,B,C,D,F,BCLEFT,BCRIGHT,U0,U1,T0,TEND,STEPS,OPTIONS)

     solve a second order 1D initial boundary value problem (IBVP)

     w2(x)*d^2/dt^2 u(x,t) + w1(x)*d/dt u(x,t) - (a(x)*u'(x,t))' +
     b(x)*u'(x,t) + c(x)*u(x,t) = d(x)*f(x,t)

     with initial condition u(x,t0) = u0(x) and d/dt u(x,t0) = u1 and
     boundary conditions at the two endpoints
        • Dirichlet: u(x,t) = g_D
        • Neumann: a(x)*u'(x,t) = g_N1 + g_N2*u(x)

     parameters:
        • INTERVAL the discretized interval for the BVP
        • W2 constant, vector or function handle to evaluate w2(x)
        • W1 constant, vector or function handle to evaluate w1(x)
        • A constant, vector or function handle to evaluate a(x)
        • B constant, vector or function handle to evaluate b(x)
        • C constant, vector or function handle to evaluate c(x)
        • D constant, vector or function handle to evaluate d(x)
        • F constant, vector or function handle to evaluate the f(x,t)
        • BCLEFT and BCRIGHT the two boundary conditions
             • for a Dirichlet condition specify a single value G_D
             • for a Neumann condition specify the values [G_N1,G_N2]
        • U0 constant, vector with the initial values at the nodes or a
          function handle to evaluate u(t0)
        • U1 constant, vector with the initial velocities at the nodes
          or a function handle to evaluate u(t0)
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n steps are taken and the n+1 results
               returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
          Currently only the stepping algorithm can be selected as
          "SOLVER" and the possible values
             • "IMPLICIT" the standard implicit solver (default)
             • "EXPLICIT" the standard explicit solver

     return values
        • X the nodes in the given interval
        • U is a matrix with n+1 columns with the values of the solution
          at the nodes at different times T
        • T is the vector with the values of the times at which the
          solutions are returned.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
solve a second order 1D initial boundary value problem (IBVP)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
I2BVP2D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2595
 -- function file[U,T]: =
          I2BVP2D(MESH,M,D,A,B0,BX,BY,F,GD,GN1,GN2,U0,V0,T0,TEND,STEPS,OPTIONS)

     Solve a second order initial boundary value problem

     m*d^2/dt^2 u + 2*d*d/dt u - div(a*grad u-u*(bx,by)) + b0*u = f  in domain
                            u = gD        on Dirichlet boundary
      n*(a*grad u -u*(bx,by)) = gN1+gN2*u on Neumann boundary
                        u(t0) = u0        initial value
                   d/dt u(t0) = v0        initial velocity

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • M,D,A,B0,BX,BY,F,GD,GN1,GN2 are the coefficients and functions
          describing the PDE.
          Any constant function can be given by its scalar value.
          The functions M,D,A,B0,BX,BY and F may also be given as
          vectors with the values of the function at the Gauss points.
        • F may be given as a string for a function depending on (x,y)
          and time t or a a vector with the values at nodes or as
          scalar.  If F is given by a scalar or vector it is independent
          on time.
        • U0,V0 are the initial value and velocity, can be given as a
          constant, function name or as vector with the values at the
          nodes
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n steps are taken and the n+1 results
               returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
             • The stepping algorithm can be selected as "SOLVER".  The
               possible values
                  • "IMPLICIT" the standard implicit solver (default)
                  • "EXPLICIT" the standard explicit solver
             • Complex coefficients can be selected by TYPE.  The
               possible values are
                  • "REAL": all coefficients are real (default)
                  • "COMPLEX": some coefficients might be complex
               If only the coefficients M and D are complex, there is no
               need to ask for complex coefficients.

     return values
        • U is a matrix with n+1 columns with the values of the solution
          at the nodes at different times T
        • T is the vector with the values of the times at which the
          solutions are returned.

     See also: IBVP2D, BVP2Dsym, BVP2eig, CreateMeshRect,
     CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
Solve a second order initial boundary value problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
IBVP1D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2266
 -- function file[X,U,T]: =
          IBVP1D(INTERVAL,W,A,B,C,D,F,BCLEFT,BCRIGHT,U0,T0,TEND,STEPS,OPTIONS)

     solve a 1D initial boundary value problem (IBVP)

     w(x)*d/dt u(x,t) - (a(x)*u'(x,t))' + b(x)*u'(x,t) + c(x)*u(x,t) =
     d(x)*f(x,t)

     with initial condition u(x,t0) = u0(x) and boundary conditions at
     the two endpoints
        • Dirichlet: u(x,t) = g_D
        • Neumann: a(x)*u'(x,t) = g_N1 + g_N2*u(x)

     parameters:
        • INTERVAL the discretized interval for the BVP
        • W constant, vector or function handle to evaluate w(x)
        • A constant, vector or function handle to evaluate a(x)
        • B constant, vector or function handle to evaluate b(x)
        • C constant, vector or function handle to evaluate c(x)
        • D constant, vector or function handle to evaluate d(x)
        • F constant, vector or function handle to evaluate the f(x,t)
        • BCLEFT and BCRIGHT the two boundary conditions
             • for a Dirichlet condition specify a single value G_D
             • for a Neumann condition specify the values [G_N1,G_N2]
        • U0 constant, vector with the initial values at the nodes or a
          function handle to evaluate u(t0)
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n steps are taken and the n+1 results
               returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
          Currently only the stepping algorithm can be selected as
          "SOLVER" and the possible values
             • "CN" the standard Crank-Nicolson (default)
             • "IMPLICIT" the standard implicit solver
             • "EXPLICIT" the standard explicit solver
             • "RK" an L-stable, implicit Runge-Kutta solver

     return values
        • X the nodes in the given interval
        • U is a matrix with n+1 columns with the values of the solution
          at the nodes at different times T
        • T is the vector with the values of the times at which the
          solutions are returned.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
solve a 1D initial boundary value problem (IBVP)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
IBVP1DNL


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2607
 -- function file[X,U,T]: =
          IBVP1DNL(INTERVAL,W,A,B,C,D,F,BCLEFT,BCRIGHT,U0,T0,TEND,STEPS,OPTIONS)

     solve a 1D nonlinear initial boundary value problem (IBVP)

     w(x)*d/dt u(x,t) - (a(x)*u'(x,t))' + b(x)*u'(x,t) + c(x)*u(x,t) =
     d(x)*f(x,t,u(x,t))

     with initial condition u(x,t0) = u0(x) and boundary conditions at
     the two endpoints
        • Dirichlet: u(x,t) = g_D
        • Neumann: a(x)*u'(x,t) = g_N1 + g_N2*u(x)

     parameters:
        • INTERVAL the discretized interval for the BVP
        • W constant, vector or function handle to evaluate w(x)
        • A constant, vector or function handle to evaluate a(x)
        • B constant, vector or function handle to evaluate b(x)
        • C constant, vector or function handle to evaluate c(x)
        • D constant, vector or function handle to evaluate d(x)
        • F a structure F = {@(X,T,U), @(X,T,U)}.  The two function
          handles evaluate f(x,t,u) and the partial derivative
          f_u(x,t,u).
        • BCLEFT and BCRIGHT the two boundary conditions
             • for a Dirichlet condition specify a single value G_D
             • for a Neumann condition specify the values [G_N1,G_N2]
        • U0 constant or vector with the initial values at the nodes or
          a function handle to evaluate u(x,t0)
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n steps are taken and the n+1 results
               returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
             • "TOL" the tolerance for the iteration at each time step
               to stop, given as pair [TOLREL,TOLABS] for the relative
               and absolute tolerance.  The iteration stops if the
               absolute or relative error is smaller than the specified
               tolerance.  RMS (root means square) values are used.  If
               only TOLREL is specified TOLABS=TOLREL is used.  The
               default values are TOLREL = TOLABS = 1E-5.
             • "MAXITER" the maximal number of iterations to be used.
               The default value is 10.

     return values
        • X the nodes in the given interval
        • U is a matrix with n+1 columns with the values of the solution
          at the nodes at times T
        • T is the vector with the values of the times at which the
          solutions are returned.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
solve a 1D nonlinear initial boundary value problem (IBVP)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
IBVP2D


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2667
 -- function file[U,T]: =
          IBVP2D(MESH,M,A,B0,BX,BY,F,GD,GN1,GN2,U0,T0,TEND,STEPS,OPTIONS)

     Solve an initial boundary value problem

     m*d/dt u - div(a*grad u-u*(bx,by)) + b0*u = f         in domain
                                             u = gD        on Dirichlet boundary
                       n*(a*grad u -u*(bx,by)) = gN1+gN2*u on Neumann boundary
                                         u(t0) = u0        initial value

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • M,A,B0,BX,BY,F,GD,GN1,GN2 are the coefficients and functions
          describing the PDE.
          Any constant function can be given by its scalar value.
          The functions M,A,B0,BX,BY and F may also be given as vectors
          with the values of the function at the Gauss points.
        • F may be given as a string for a function depending on (x,y)
          and time t or as a vector with the values at nodes or as
          scalar.  If F is given by a scalar or vector it is independent
          on time.
        • U0 is the initial value, can be given as a constant, function
          name or as vector with the values at the nodes
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n Crank Nicolson steps are taken and
               the n+1 results returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
             • The stepping algorithm can be selected as "SOLVER".  The
               possible values
                  • "CN" the standard Crank-Nicolson (default)
                  • "IMPLICIT" the standard implicit solver
                  • "EXPLICIT" the standard explicit solver
                  • "RK" an L-stable, implicit Runge-Kutta solver
             • Complex coefficients can be selected by TYPE.  The
               possible values are
                  • "REAL": all coefficients are real (default)
                  • "COMPLEX": some coefficients might be complex
               If only the coefficient M is complex, there is no need to
               ask for complex coefficients.

     return values
        • U is a matrix with n+1 columns with the values of the solution
          at the nodes at different times T
        • T is the vector with the values of the times at which the
          solutions are returned.

     See also: I2BVP2D, BVP2D, BVP2Dsym, BVP2eig, CreateMeshRect,
     CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Solve an initial boundary value problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
IBVP2Dsym


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2607
 -- function file[U,T]: =
          IBVP2Dsym(MESH,M,A,B0,F,GD,GN1,GN2,U0,T0,TEND,STEPS,OPTIONS)

     Solve a symmetric initial boundary value problem

     m*d/dt u - div(a*grad u) + b0*u = f         in domain
                                   u = gD        on Dirichlet boundary
                        n*(a*grad u) = gN1+gN2*u on Neumann boundary
                               u(t0) = u0        initial value

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • M,A,B0,F,GD,GN1,GN2 are the coefficients and functions
          describing the PDE.
          Any constant function can be given by its scalar value.
          The functions M,A,B0 and F may also be given as vectors with
          the values of the function at the Gauss points.
        • F may be given as a string for a function depending on (x,y)
          and time t or a a vector with the values at nodes or as
          scalar.  If F is given by a scalar or vector it is independent
          on time.
        • U0 is the initial value, can be given as a constant, function
          name or as vector with the values at the nodes
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
          If STEPS = n, then n Crank Nicolson steps are taken and the
          results returned.
          If STEPS = [n,nint], then n*nint Crank Nicolson steps are
          taken and (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
             • The stepping algorithm can be selected as "SOLVER".  The
               possible values
                  • "CN" the standard Crank-Nicolson (default)
                  • "IMPLICIT" the standard implicit solver
                  • "EXPLICIT" the standard explicit solver
                  • "RK" an L-stable, implicit Runge-Kutta solver
             • Complex coefficients can be selected by TYPE.  The
               possible values are
                  • "REAL": all coefficients are real (default)
                  • "COMPLEX": some coefficients might be complex
               If only the coefficient M is complex, there is no need to
               ask for complex coefficients.

     return values
        • U is a matrix with n+1 columns with the values of the solution
          at the nodes at different times T
        • T is the vector with the values of the times at which the
          solutions are returned.

     See also: I2BVP2D, BVP2D, BVP2Dsym, BVP2eig, CreateMeshRect,
     CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Solve a symmetric initial boundary value problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
MeshAddConstraint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 722
 -- function fileMESH: = MeshAddConstraint(MESH,POSITION,MODE)

     apply an additional constraint

     parameters:
        • MESH is the mesh describing the domain
        • POSITION coordinates of the node, may be approximate
        • MODE mode of the node with the additional constraint
             • MODE = -1: fixed value for scalar problems
             • MODE = [-1,-1]: fixed x and y displacements for
               elasticity
             • MODE = [-1,-2]: fixed x-displacement for elasticity
             • MODE = [-2,-1]: fixed y-displacement for elasticity

     return values:
        • MESH the new mesh with the additional constraints

     See also: CreateMeshRect, CreateMeshTriangle.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 30
apply an additional constraint



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
MeshCubic2Linear


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 321
 -- function fileMESHLIN: = MeshCubic2Linear(MESHCUBIC)

     convert a mesh MESHCUBIC of order 3 to a mesh MESHLIN of order 1

     parameter: MESHCUBIC the input mesh of order 3

     return value: MESHLIN the output mesh of order 1

     See also: MeshUpgrade, CreateMeshTriangle, CreateMeshRect,
     MeshQuad2Linear.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
convert a mesh MESHCUBIC of order 3 to a mesh MESHLIN of order 1



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
MeshDeform


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 920
 -- function fileMeshDeformed: = MeshDeform(MESH,DEFORM)

     Deform the nodes of MESH by the transformation DEFORM

     parameters:
        • MESH the initial mesh with linear elements
          this has to be a mesh with linear elements
        • DEFORM the transformation formula
          the function DEFORM takes one argument XY, a n by 2 matrix
          with the x and y components in columns and returns the result
          in a n by 2 matrix.

     return value:
        • DEFORMEDMESH the deformed mesh consistes of linear elements
          use MESHUPGRADE to generate quadratic or cubic elements

     Sample call:
     to generate a mesh in polar coordinates:
     
     function xy_new = Deform(xy)
      xy_new = [xy(:,1).*cos(xy(:,2)), xy(:,1).*sin(xy(:,2))];
     endfunction
     
     meshDeformed = MeshDeform(mesh,'Deform');

     See also: CreateMeshRect, CreateMeshTriangle, MeshUpgrade.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
Deform the nodes of MESH by the transformation DEFORM



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
MeshQuad2Linear


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 318
 -- function fileMESHLIN: = MeshQuad2Linear(MESHQUAD)

     convert a mesh MESHQUAD of order 2 to a mesh MESHLIN of order 1

     parameter: MESHQUAD the input mesh of order 2

     return value: MESHLIN the output mesh of order 1

     See also: MeshUpgrade, CreateMeshTriangle, CreateMeshRect,
     MeshCubic2Linear.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
convert a mesh MESHQUAD of order 2 to a mesh MESHLIN of order 1



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
MeshUpgrade


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 412
 -- function fileMESHNEW: = MeshUpgrade(MESHLIN,TYPE)

     convert a mesh MESHLIN of order 1 to a mesh MESHNEW of order 2 or 3

     parameters:
        • MESHLIN the input mesh of order 1
        • TYPE is a string, either 'quadratic' or 'cubic'
          the default is 'quadratic'

     return value: MESHNEW the output mesh of order 2 or 3

     See also: CreateMeshTriangle, CreateMeshRect, MeshDeform.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
convert a mesh MESHLIN of order 1 to a mesh MESHNEW of order 2 or 3



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
PStressEquationCubicM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 146
  [gMat,gVec] = PStressEquationCubicM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)

  setup the equation for a plane stress problem with cubic elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
  [gMat,gVec] = PStressEquationCubicM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
PStressEquationCubicWM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 140
  [gMat,wMat,OneMat] = PStressEquationCubicWM(Mesh,EFunc,nuFunc,wFunc)

  setup the equation for a plane stress problem with cubic elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
  [gMat,wMat,OneMat] = PStressEquationCubicWM(Mesh,EFunc,nuFunc,wFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
PStressEquationM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 142
  [gMat,gVec] = PStressEquationM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)

  setup the equation for a plane stress problem with linear elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
  [gMat,gVec] = PStressEquationM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
PStressEquationQuadM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 149
  [gMat,gVec] = PStressEquationQuadM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)

  setup the equation for a plane stress problem with quadratic elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
  [gMat,gVec] = PStressEquationQuadM(Mesh,EFunc,nuFunc,fFunc,gDFunc,gNFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
PStressEquationQuadWM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 143
  [gMat,wMat,OneMat] = PStressEquationQuadWM(Mesh,EFunc,nuFunc,wFunc)

  setup the equation for a plane stress problem with quadratic elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
  [gMat,wMat,OneMat] = PStressEquationQuadWM(Mesh,EFunc,nuFunc,wFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
PStressEquationWM


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 136
  [gMat,wMat,OneMat] = PStressEquationWM(Mesh,EFunc,nuFunc,wFunc)

  setup the equation for a plane stress problem with linear elements



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
  [gMat,wMat,OneMat] = PStressEquationWM(Mesh,EFunc,nuFunc,wFunc)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
PlaneStrain


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1261
 -- function file[U1,U2]: = PlaneStrain(MESH,E,NU,F,GD,GN)

     solve an plane strain problem

        plane strain equation    in domain
                       u = gD    on Gamma_1
           force density = gN    on Gamma_2 
           force density = 0     on Gamma_3 

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • F = {F1,F2} a cell array with the two components of the volume
          forces
        • GD = {GD1,GD2} a cell array with the two components of the
          prescribed displacements on the boundary section Gamma_1
        • GN = {GN1,GN2} a cell array with the two components of the
          surface forces on the boundary section Gamma_2
        • Any constant function can be given by its scalar value
        • Any function can be given by a string with the function name
        • The functions E, NU, F1 and F2 may also be given as vectors
          with the values of the function at the Gauss points

     return values
        • U1 vector with the values of the x-displacement at the nodes
        • U2 vector with the values of the y-displacement at the nodes

     See also: PlaneStress.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
solve an plane strain problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
PlaneStrainDynamic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2377
 -- function file[U1,U2,T]: =
          PlaneStrainDynamic(MESH,E,NU,RHO,F,GD,GN,U0,V0,T0,TEND,STEPS,OPTIONS)

     solve a dynamic plane strain problem

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • RHO,the density of the material
        • F = {F1,F2} a cell array with the two components of the volume
          forces.  The functions take two arguments, coordinates xy and
          time t, i.e.  of the form F1(XY,T).
        • GD = {GD1,GD2} a cell array with the two components of the
          prescribed displacements on the boundary section Gamma_1
        • GN = {GN1,GN2} a cell array with the two components of the
          surface forces on the boundary section Gamma_2
        • U0, V0 the initial displacement and initial velocity.
             • Any constant function can be given by its scalar value
             • Any function can be given by a string with the function
               name
             • The functions E, NU and RHO may also be given as vectors
               with the values of the function at the Gauss points
             • The functions F1, F2, U0 and V0 may also be given as
               vectors with the values of the function at the nodes
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n steps are taken and the n+1 results
               returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
          Currently only the time stepping algorithm can be selected as
          "SOLVER" and the possible values
             • "IMPLICIT" an implicit solver (default)
             • "EXPLICIT" the standard explicit solver

     return values
        • U1, U2 matrices with the values of the x- and y-displacements
          at the nodes.  Matrices with n+1 columns with the values of
          the solution at the nodes at different times T
        • T is the vector with the n+1 values of the times at which the
          solutions are returned.

     See also: PlaneStressDynamic, PlaneStress, PlaneStrain,
     PlaneStressEig, PlaneStrainEig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
solve a dynamic plane strain problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
PlaneStrainEig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1241
 -- function file[LA,U1,U2]: = PlaneStrainEig(MESH,E,NU,W,NVEC,TOL)

     solve a plane stress eigenvalue problem

                     A*u = la*w*u   in domain, plane strain equation
                       u = 0        on Gamma_1
           force density = 0        on Gamma_2
           force density = 0        on Gamma_3

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • W the material density
             • Any constant function can be given by its scalar value
             • Any function can be given by a string with the function
               name
             • The functions E, NU and W may also be given as vectors
               with the values of the function at the Gauss points
        • NVEC the number of smallest eigenvalues to be determined
        • TOL optional tolerance for for the eigenvalue iteration,
          default 1e-5

     return values
        • LA the eigenvalues
        • U1 matrix with the values of the x-displacement at the nodes
        • U2 matrix with the values of the y-displacement at the nodes

     See also: PlaneStressEig, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
solve a plane stress eigenvalue problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
PlaneStress


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1259
 -- function file[U1,U2]: = PlaneStress(MESH,E,NU,F,GD,GN)

     solve an plane stress problem

        plane stress equation    in domain
                       u = gD    on Gamma_1
           force density = gN    on Gamma_2
           force density = 0     on Gamma_3

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • F = {F1,F2} a cell array with the two components of the volume
          forces
        • GD = {GD1,GD2} a cell array with the two components of the
          prescribed displacements on the boundary section Gamma_1
        • GN = {GN1,GN2} a cell array with the two components of the
          surface forces on the boundary section Gamma_2
        • Any constant function can be given by its scalar value
        • Any function can be given by a string with the function name
        • The functions E, NU, F1 and F2 may also be given as vectors
          with the values of the function at the Gauss points

     return values
        • U1 vector with the values of the x-displacement at the nodes
        • U2 vector with the values of the y-displacement at the nodes

     See also: PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
solve an plane stress problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
PlaneStressDynamic


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2377
 -- function file[U1,U2,T]: =
          PlaneStressDynamic(MESH,E,NU,RHO,F,GD,GN,U0,V0,T0,TEND,STEPS,OPTIONS)

     solve a dynamic plane stress problem

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • RHO,the density of the material
        • F = {F1,F2} a cell array with the two components of the volume
          forces.  The functions take two arguments, coordinates xy and
          time t, i.e.  of the form F1(XY,T).
        • GD = {GD1,GD2} a cell array with the two components of the
          prescribed displacements on the boundary section Gamma_1
        • GN = {GN1,GN2} a cell array with the two components of the
          surface forces on the boundary section Gamma_2
        • U0, V0 the initial displacement and initial velocity.
             • Any constant function can be given by its scalar value
             • Any function can be given by a string with the function
               name
             • The functions E, NU and RHO may also be given as vectors
               with the values of the function at the Gauss points
             • The functions F1, F2, U0 and V0 may also be given as
               vectors with the values of the function at the nodes
        • T0, TEND are the initial and final times
        • STEPS is a vector with one or two positive integers.
             • If STEPS = n, then n steps are taken and the n+1 results
               returned.
             • If STEPS = [n,nint], then n*nint steps are taken and
               (n+1) results returned.
        • OPTIONS additional options, given as pairs name/value.
          Currently only the time stepping algorithm can be selected as
          "SOLVER" and the possible values
             • "IMPLICIT" an implicit solver (default)
             • "EXPLICIT" the standard explicit solver

     return values
        • U1, U2 matrices with the values of the x- and y-displacements
          at the nodes.  Matrices with n+1 columns with the values of
          the solution at the nodes at different times T
        • T is the vector with the n+1 values of the times at which the
          solutions are returned.

     See also: PlaneStrainDynamic, PlaneStress, PlaneStrain,
     PlaneStressEig, PlaneStrainEig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
solve a dynamic plane stress problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
PlaneStressEig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1241
 -- function file[LA,U1,U2]: = PlaneStressEig(MESH,E,NU,W,NVEC,TOL)

     solve a plane stress eigenvalue problem

                     A*u = la*w*u   in domain, plane stress equation
                       u = 0        on Gamma_1
           force density = 0        on Gamma_2
           force density = 0        on Gamma_3

     parameters:
        • MESH is the mesh describing the domain and the boundary types
        • E,NU Young's modulus and Poisson's ratio for the material
        • W the material density
             • Any constant function can be given by its scalar value
             • Any function can be given by a string with the function
               name
             • The functions E, NU and W may also be given as vectors
               with the values of the function at the Gauss points
        • NVEC the number of smallest eigenvalues to be determined
        • TOL optional tolerance for for the eigenvalue iteration,
          default 1e-5

     return values
        • LA the eigenvalues
        • U1 matrix with the values of the x-displacement at the nodes
        • U2 matrix with the values of the y-displacement at the nodes

     See also: PlaneStrainEig, PlaneStress, PlaneStrain.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
solve a plane stress eigenvalue problem



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
ReadMeshTriangle


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 479
 -- function fileFEMMESH: = ReadMeshTriangle(NAME.1)

     read a mesh generated by CreateMeshTriangle(NAME)

     parameter: NAME.1 the filename

     return value: FEMMESH the mesh stored in NAME

     Sample call:
     CreateMeshTriangle('Test',[0,-1,-1;1,-1,-2;1,2,-1;0,2,-2],0.01)
     Mesh = ReadMeshTriangle('Test.1');
       will create a mesh with 0<=x<=1, -1<=y<=+2
       and a typical area of 0.01 for each triangle

     See also: CreateMeshTriangle, CreateMeshRect.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
read a mesh generated by CreateMeshTriangle(NAME)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
ShowDeformation


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 394
 -- function file: ShowDeformation(MESH,U1,U2,FACTOR)

     display the original domain and the deformed domain

     parameters:
        • MESH is the mesh describing the domain
        • U1 vector with the values of the x-displacements at the nodes
        • U2 vector with the values of the y-displacements at the nodes
        • FACTOR scaling factor for the displacements U1 and U2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
display the original domain and the deformed domain



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
eigSmall


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 715
  [Lambda,{Ev,err}] = eigSmall(A,V,tol)
        solve A*Ev = Ev*diag(Lambda) standard eigenvalue problem

  [Lambda,{Ev,err}] = eigSmall(A,B,V,tol)
        solve A*Ev = B*Ev*diag(Lambda) generalized eigenvalue problem

   A   is a (sparse) mxm matrix
   B   is a (sparse) mxm matrix
   V   is a mxn matrix, where n is the number of eigenvalues desired
       it contains the initial eigenvectors for the iteration
   tol is the relative error, used as the stopping criterion

   X   is a column vector with the eigenvalues
   EV  is a matrix whose columns represent normalized eigenvectors
   err is a vector with the aposteriori error estimates for the eigenvalues

   this implementation is based on using eigs()



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
  [Lambda,{Ev,err}] = eigSmall(A,V,tol)
        solve A*Ev = Ev*diag(Lambda) ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
pwquadinterp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 548
 yi = pwquadinterp(xdata,ydata,xi)                 % to evaluate the values of the function
 [yi, yi_x, yi_xx] = pwquadinterp(xdata,ydata,xi)  % to evaluate first and second derivatives too

 Use the data (xdata,ydata) to determine a piecewise quadratic function
 and then evaluate this function at the points xi.
 With multiple return arguments derivatives are evaluated.
 The function requires that:
    there are an odd number of data points,
    xdata and xi are both in increasing order,
    the xi values lie between xdata(1) and xdata(end).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
 yi = pwquadinterp(xdata,ydata,xi)                 % to evaluate the values o...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
tricontour


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 760
 -- Function File: H = tricontour (TRI, X, Y, Z, LEVELS, LINESTYLE)
     Plot level curves for the values of ‘Z’ on a triangular mesh in 2D.

     parameters:
        • TRI is the triangular meshing of the points
        • X, Y are the coordinates of the points, e.g.  as generated by
          ‘delaunay’.
        • LEVELS is a vector with the values of the countour levels.
          If LEVELS is a scalar, then it corresponds to the number of
          level curves to be drawn.  If exactly one level curve is
          desired, list the level twice in the vector LEVELS.
        • LINESTYLE is an optional argument to modify the line style.

     output:
     H is the graphic handle to the plot.

     See also: trimesh, trisurf, delaunay.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Plot level curves for the values of ‘Z’ on a triangular mesh in 2D.





