IFEM/ASMbase_8h_source.html

 // $Id$

 //==============================================================================

 //==============================================================================


 #ifndef _ASM_BASE_H

 #define _ASM_BASE_H


 #include "ASMenums.h"

 #include "MatVec.h"

 #include "MPCLess.h"

 #include <map>

 #include <set>

 #include <array>

 #include <string>


 using IntVec = std::vector<int>;

 using IntMat = std::vector<IntVec>;


 using MPCMap  = std::map<MPC*,int,MPCLess>;

 using MPCSet  = std::set<MPC*,MPCLess>;

 using MPCIter = MPCSet::const_iterator;


 struct TimeDomain;

 class ElementBlock;

 class Field;

 class Fields;

 class GlobalIntegral;

 class IntegrandBase;

 class Integrand;

 class L2Integrand;

 class ASMbase;

 class SystemMatrix;

 class SystemVector;

 class FunctionBase;

 class RealFunc;

 class VecFunc;

 class Vec3;

 class Tensor;

 class SAM;


 namespace ASM { class InterfaceChecker; }

 namespace utl { template<class Arg, class Result> class Function; }


 using ASMVec  = std::vector<ASMbase*>;

 using IntFunc = utl::Function<int,double>;


 class ASMbase

 {

 public:

   struct BC

   {

     int node;

     char CX;

     char CY;

     char CZ;

     char RX;

     char RY;

     char RZ;


     explicit BC(int n) : node(n), CX(1), CY(1), CZ(1), RX(1), RY(1), RZ(1) {}


     int fix(int dof);

     int free(int dof);

   };


   using BCVec = std::vector<BC>;


 protected:

   ASMbase(unsigned char n_p, unsigned char n_s, unsigned char n_f);

   ASMbase(const ASMbase& patch, unsigned char n_f);

   ASMbase(const ASMbase& patch);


 public:

   virtual ~ASMbase();


   ASMbase* cloneUnShared() const;


   virtual bool empty() const = 0;


   virtual bool read(std::istream& is) = 0;

   virtual bool readBasis(std::istream&, size_t) { return false; }

   virtual bool write(std::ostream& os, int basis = 0) const = 0;


   virtual void addHole(double, double, double) {}

   virtual void addHole(double, double, double, double, double) {}

   virtual bool setGeometry(RealFunc*, double, double) { return false; }


   virtual bool generateFEMTopology() = 0;


   virtual void clear(bool retainGeometry = false);


   virtual bool addXElms(short int dim, short int item, size_t nXn,

                         IntVec& nodes);


   bool addLagrangeMultipliers(size_t iel, const IntVec& mGLag,

                               unsigned char nnLag = 1);


   bool addGlobalLagrangeMultipliers(const IntVec& mGLag,

                                     unsigned char nnLag = 1);


   virtual void setGauss(int ng) { nGauss = ng; }


   void setNoFields(unsigned char n) { nf = n; }


   void setElementActivator(IntFunc* efunc) { myElActive = efunc; }

   const IntFunc* getElementActivator() const { return myElActive; }


   virtual void setMinimumSize(double) {}

   virtual double getMinimumSize(int = 0) const { return 0.0; }

   virtual bool checkElementSize(int, bool = true) const { return false; }


   static void resetNumbering(int n = 0);


   // Service methods for query of various model data

   // ===============================================


   unsigned char getNoSpaceDim() const { return nsd; }

   unsigned char getNoParamDim() const { return ndim; }

   virtual unsigned char getNoFields(int b = 0) const { return b > 1 ? 0 : nf; }

   unsigned char getNoLagPerNode() const { return nLag; }


   virtual bool getOrder(int&, int&, int&) const { return false; }


   virtual size_t getNodeIndex(int globalNum, bool = false) const;

   virtual int getNodeID(size_t inod, bool = false) const;

   size_t getElmIndex(int globalNum) const;

   int getElmID(size_t iel) const;

   virtual unsigned char getNodalDOFs(size_t inod) const;

   virtual char getNodeType(size_t inod) const;

   bool isLMn(size_t n) const { return myLMs.find(n) != myLMs.end(); }

   bool isRMn(size_t n) const { return myRmaster.find(n) != myRmaster.end(); }

   char getLMType(size_t inod) const;

   virtual Vec3 getCoord(size_t inod) const = 0;

   virtual void getNodalCoordinates(Matrix& X, bool geo = false) const = 0;

   virtual bool getElementCoordinates(Matrix& X, int iel,

                                      bool forceItg = false) const = 0;

   virtual Vec3 getElementCenter(int) const = 0;


   virtual void getBoundaryNodes(int lIndex, IntVec& nodes,

                                 int basis = 0, int thick = 1,

                                 int orient = -1, bool local = false) const = 0;


   virtual void getBoundary1Nodes(int lIndex, IntVec& nodes,

                                  int basis = 0, int orient = -1,

                                  bool local = false, bool open = false) const {}


   void getBoundaryElms(int lIndex, IntVec& elms,

                        int orient = -1, bool local = false) const;


   virtual int getNodeSetIdx(const std::string&) const { return 0; }

   virtual const IntVec& getNodeSet(int) const { return Empty; }

   virtual bool isInNodeSet(int, int) const { return false; }

   virtual int parseNodeSet(const std::string&, const char*) { return 0; }

   virtual int parseNodeBox(const std::string&, const char*) { return 0; }


   virtual int getElementSetIdx(const std::string&) const { return 0; }

   virtual const IntVec& getElementSet(int) const { return Empty; }

   virtual bool getElementSet(int, std::string&) const { return false; }

   virtual bool isInElementSet(int, int) const { return false; }

   virtual int parseElemSet(const std::string&, const char*) { return 0; }

   virtual int parseElemBox(const std::string&, const std::string&,

                            const char*) { return 0; }


   virtual std::pair<size_t,double> findClosestNode(const Vec3&) const

   { return { 0, -1 }; }


   void printNodes(std::ostream& os) const;

   void printElements(std::ostream& os) const;

   virtual void printElmInfo(int, const IntegrandBase*) const {}


   virtual void shiftGlobalNodeNums(int nshift);

   void setGlobalNodeNums(const IntVec& nodes) { myMLGN = nodes; }

   const IntVec& getMyNodeNums() const { return myMLGN; }

   const IntVec& getGlobalNodeNums() const { return MLGN; }


   virtual void shiftGlobalElmNums(int eshift);

   const IntVec& getGlobalElementNums() const { return MLGE; }


   void setActiveElements(IntVec* active) { myActiveEls = active; }

   bool isElementActive(int iel, double time = -1.0) const;

   bool inActive(double time) const;

   double getAge(int iel, double time) const;

   bool isElementInPartition(int iel) const;


   const IntVec& getElementNodes(int iel) const;

   virtual size_t getNoBasis() const { return 1; }

   virtual size_t getNoNodes(int basis = 0) const;

   size_t getNoElms(bool includeZeroVolElms = false,

                    bool includeXElms = false) const;

   int getMaxElmNo() const;

   virtual size_t getNoBoundaryElms(char, char) const { return 0; }

   size_t getNoMPCs() const { return mpcs.size(); }


   virtual void getNoIntPoints(size_t& nPt, size_t& nIPt);

   virtual void getNoBouPoints(size_t& nPt, char ldim, char lindx);


   BCVec::const_iterator begin_BC() const { return BCode.begin(); }

   BCVec::const_iterator end_BC() const { return BCode.end(); }


   IntMat::const_iterator begin_elm() const { return MNPC.begin(); }

   IntMat::const_iterator end_elm() const { return MNPC.end(); }


   MPCIter begin_MPC() const { return mpcs.begin(); }

   MPCIter end_MPC() const { return mpcs.end(); }

   MPC* findMPC(int node, int dof) const;


   bool isShared() const { return shareFE == 'F'; }

   bool hasXNodes() const { return MLGN.size() > nnod; }


   virtual bool getParameterDomain(Real2DMat& u,

                                   IntVec* corners = nullptr) const = 0;


   virtual void getElmConnectivities(IntMat& neighs,

                                     int basis = ASM::INTEGRATION_BASIS) const = 0;


   virtual IntMat getElmNodes(int) const { return MNPC; }


   // Various preprocessing methods

   // =============================


   virtual void copyParameterDomain(const ASMbase*) {}


   virtual void closeBoundaries(int dir = 1, int basis = 0, int master = 1) {}


   bool mergeNodes(size_t inod, int globalNum, bool verbose = true);


   static int renumberNodes(const ASMVec& model, std::map<int,int>& old2new);


   int renumberNodes(std::map<int,int>& old2new, int& nNod);


   bool renumberNodes(const std::map<int,int>& old2new,

                      const std::vector<int>& new2old = {}, int renumGN = 0,

                      std::map<int,int>* degenElm = nullptr);


   static void mergeAndGetAllMPCs(const ASMVec& model, MPCSet& allMPCs);


   static void resolveMPCchains(const MPCSet& allMPCs,

                                const ASMVec& model, bool setPtrOnly = false);


   virtual bool initConstraints() { return true; }


   virtual void setNodeNumbers(const IntVec& nodes);


   bool hasTimeDependentDirichlet(const std::map<int,RealFunc*>& func,

                                  const std::map<int,VecFunc*>& vfunc);


   virtual bool updateDirichlet(const std::map<int,RealFunc*>& func,

                                const std::map<int,VecFunc*>& vfunc,

                                double time = 0.0,

                                const std::map<int,int>* g2l = nullptr);


   virtual bool updateCoords(const Vector& displ) = 0;


   virtual bool transform(const Matrix&) { return true; }


   virtual void initMADOF(const int*) {}


   virtual void generateThreadGroups(const Integrand&, bool, bool) {}

   virtual void generateThreadGroups(char, bool, bool) {}

   virtual void generateThreadGroupsFromElms(const IntVec&) {}

   virtual void generateProjThreadGroupsFromElms(const IntVec&) {}

   virtual bool validateThreadGroups(const SAM*) const { return true; }


   virtual void changeNumThreads() {}


   // Methods for integration of finite element quantities.

   // These are the main computational methods of the ASM class hierarchy.

   // ====================================================================


   virtual bool integrate(Integrand& integrand,

                          GlobalIntegral& glbInt, const TimeDomain& time) = 0;


   virtual bool integrate(Integrand& integrand, int lIndex,

                          GlobalIntegral& glbInt, const TimeDomain& time) = 0;


   virtual bool integrateEdge(Integrand& integrand, int lEdge,

                              GlobalIntegral& glbInt,

                              const TimeDomain& time) { return false; }


   virtual bool integrate(Integrand& integrand, GlobalIntegral& glbInt,

                          const TimeDomain& time,

                          const ASM::InterfaceChecker& iChk) { return false; }


   virtual bool diracPoint(Integrand& integrand, GlobalIntegral& glbInt,

                           const double* u, const Vec3& p) { return false; }


   // Post-processing methods

   // =======================


   virtual int evalPoint(const double* xi, double* param, Vec3& X) const = 0;

   virtual int findElementContaining(const double* param) const = 0;

   virtual double findPoint(Vec3& X, double* param) const = 0;


   virtual bool tesselate(ElementBlock& grid, const int* npe) const = 0;

   virtual ElementBlock* immersedGeometry(char*) const { return nullptr; }

   virtual ElementBlock* extraGeometry(char*) const { return nullptr; }

   virtual void filterResults(Matrix&, const ElementBlock*) const {}


   virtual bool getSolution(Matrix& sField, const Vector& locSol,

                            const IntVec& nodes) const;


   virtual bool evalSolution(Matrix& sField, const Vector& locSol,

                             const int* npe, int n_f = 0,

                             bool piola = false) const;


   virtual bool immersedSolution(Matrix&, const Vector&) const { return false; }

   virtual bool extraSolution(Matrix&, const Vector&) const { return false; }


   virtual bool evalProjSolution(Matrix& sField, const Vector& locSol,

                                 const int* npe, int n_f = 0) const

   { return this->evalSolution(sField, locSol, npe, n_f); }


   virtual bool evalSolution(Matrix& sField, const Vector& locSol,

                             const RealArray* gpar, bool regular = true,

                             int deriv = 0, int n_f = 0) const;


   virtual bool evalSolutionPiola(Matrix& sField, const Vector& locSol,

                                  const RealArray* gpar, bool regular) const;


   virtual bool evaluate(const ASMbase* basis, const Vector& locVec,

                         RealArray& vec, int basisNum = 1) const;


   virtual bool evaluate(const Field* f, RealArray& vec, int basisNum = 1) const;


   virtual bool evaluate(const FunctionBase* f, RealArray& vec,

                         int basisNum = 1, double time = 0.0) const;


   virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,

                             const int* npe = nullptr, char project = 0) const;


   virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,

                             const RealArray* gpar, bool regular = true) const;


   virtual bool evalSolution(Matrix& sField, const IntegrandBase& integrand,

                             const IntVec& elements) const;


   bool globalL2projection(Matrix& sField,

                           const L2Integrand& integrand,

                           bool continuous = false,

                           bool enforceEnds = false) const;


   bool L2projection(Matrix& sField, IntegrandBase* integrand,

                     const TimeDomain& time);


   bool L2projection(Matrix& fVals, FunctionBase* function, double t = 0.0);

   bool L2projection(const std::vector<Matrix*>& fVals,

                     const std::vector<FunctionBase*>& function, double t = 0.0);


   virtual size_t getNoProjectionNodes() const { return this->getNoNodes(1); }


   virtual size_t getNoRefineNodes() const { return this->getNoNodes(1); }


   virtual size_t getNoRefineElms() const { return this->getNoElms(); }


   virtual Field* getProjectedField(const Vector&) const

   { return nullptr; }


   virtual Fields* getProjectedFields(const Vector&, size_t) const

   { return nullptr; }


   virtual bool createProjectionBasis(bool) { return false; }

   virtual bool separateProjectionBasis() const { return false; }

   virtual void swapProjectionBasis() {}


   // Methods for result extraction

   // =============================


   virtual void extractElmRes(const Vector& globRes, Vector& elmRes,

                              size_t internalFirst = 0) const;

   virtual void extractElmRes(const Matrix& globRes, Matrix& elmRes,

                              size_t internalFirst = 0) const;


   bool extractNodalVec(const RealArray& globVec, RealArray& nodeVec,

                        const int* madof, int ngnod = -1) const;


   virtual void extractNodeVec(const RealArray& globVec, RealArray& nodeVec,

                               unsigned char nndof = 0, int basis = 0) const;


   virtual bool injectNodeVec(const RealArray& nodeVec, RealArray& globVec,

                              unsigned char nndof = 0, int basis = 0) const;


   bool injectNodalVec(const RealArray& nodeVec, RealArray& globVec,

                       const IntVec& madof, int basis = 0) const;


   bool add2PC(int slave, int dir, int master, int code = 0);


   bool addMPC(MPC*& mpc, int code = 0,

               bool verbose = false, bool overrideD = false);


   virtual bool addRigidCpl(int lindx, int ldim, int basis,

                            int& gMaster, const Vec3& Xmaster,

                            bool extraPt = true);


   void addRigidCouplings(int gMaster, const Vec3& Xmaster,

                          const IntVec& slaveNodes);


 protected:


   // Internal methods for preprocessing of boundary conditions

   // =========================================================


   void addLocal2GlobalCpl(int iSlave, int master, const Tensor& Tlg);

   bool add3PC(int slave, int dir, int master1, int master2, int code = 0);

   bool addPeriodicity(size_t master, size_t slave, int dir);

   void makePeriodic(size_t master, size_t slave, int dirs = 123);

   void addNeighbor(ASMbase* pch);

   bool createRgdMasterNode(int& gMaster, const Vec3& Xmaster);

   void addRigidMPC(int gSlave, int gMaster, const Vec3& dX);


   int getNoGaussPt(int p, bool neumann = false) const;


   // Miscellaneous methods for internal use

   // ======================================


   int searchCtrlPt(RealArray::const_iterator cit, RealArray::const_iterator end,

                    const Vec3& X, int dimension, double tol = 0.001) const;


   virtual void findBoundaryElms(IntVec& elms, int lIndex, int orient) const = 0;


   virtual bool assembleL2matrices(SystemMatrix& A, SystemVector& B,

                                   const L2Integrand& obj,

                                   bool continuous) const { return false; }


 public:


   // More methods for preprocessing of Dirichlet boundary conditions

   // ===============================================================


   void constrainPatch(int dof, int code = 0);

   void constrainNodes(const IntVec& nodes, int dof, int code = 0,

                       bool overrideD = false);

   bool constrainXnode(int node, int dof, int code = 0);

   int prescribe(size_t inod, int dirs, int code, bool overrideD = false);

   int fix(size_t inod, int dirs = 123);

   bool isFixed(int node, int dof, bool all = false) const;


 protected:

   bool allDofs(int dirs) const;


   static bool deformedConfig(const Matrix& Xnod, Vectors& eVec,

                              bool force2nd = false);


   static bool collapseNodes(ASMbase& pch1, int node1, ASMbase& pch2, int node2);


   bool writeLagBasis(std::ostream& os, const char* type) const;


 public:

   static bool fixHomogeneousDirichlet;


   static int dbgElm;


   static double modelSize;


   size_t idx;


 protected:

   // Standard finite element data structures

   unsigned char ndim;

   unsigned char nsd;

   unsigned char nf;

   unsigned char nLag;

   size_t        nel;

   size_t        nnod;


   const IntVec& MLGE;

   const IntVec& MLGN;

   const IntMat& MNPC;


   const char shareFE;


   BCVec  BCode;

   MPCMap dCode;

   MPCSet mpcs;


   IntVec myMLGE;

   IntVec myMLGN;

   IntMat myMNPC;

   IntVec myElms;


   int nGauss;


   size_t firstEl;

   size_t firstIp;


   std::map<char,size_t> firstBp;


   ASMVec neighbors;


   static std::map<int,int> xNode;


   static int gEl;

   static int gNod;


 private:

   std::vector<char> myLMTypes;

   std::set<size_t>  myLMs;


   IntFunc* myElActive;

   IntVec* myActiveEls;

   static IntVec Empty;


 protected:

   using XYZ = std::array<double,3>;

   std::map<size_t,XYZ>   myRmaster;

 };


 #endif

MPCIter
MPCSet::const_iterator MPCIter
Iterator over an MPC-equation set.
Definition: ASMbase.h:30

MPCSet
std::set< MPC *, MPCLess > MPCSet
Sorted set of MPC-equations.
Definition: ASMbase.h:29

ASMVec
std::vector< ASMbase * > ASMVec
Spline patch container type.
Definition: ASMbase.h:53

IntVec
std::vector< int > IntVec
General integer vector.
Definition: ASMbase.h:25

MPCMap
std::map< MPC *, int, MPCLess > MPCMap
MPC-to-function code mapping.
Definition: ASMbase.h:28

IntMat
std::vector< IntVec > IntMat
General 2D integer matrix.
Definition: ASMbase.h:26

ASMenums.h
Various enums for assembly scope.

Real2DMat
std::vector< RealArray > Real2DMat
A real-valued two-dimensional array without algebraic operations.
Definition: ImmersedBoundaries.h:34

RealArray
std::vector< Real > RealArray
A real-valued array without algebraic operations.
Definition: ImmersedBoundaries.h:29

MPCLess.h
Comparison of two MPC objects in a std::set<MPC*,MPCLess> object.

MatVec.h
Global algebraic operations on index 1-based matrices and vectors.

Vectors
std::vector< Vector > Vectors
An array of real-valued vectors with algebraic operations.
Definition: MatVec.h:37

ASM::InterfaceChecker
Base class to check for internal boundary integrand contributions.
Definition: Interface.h:40

ASMbase
Base class for spline-based finite element (FE) assembly drivers.
Definition: ASMbase.h:70

ASMbase::immersedGeometry
virtual ElementBlock * immersedGeometry(char *) const
Returns an additional geometry to visualize (immersed boundaries).
Definition: ASMbase.h:601

ASMbase::getElementSetIdx
virtual int getElementSetIdx(const std::string &) const
Returns (1-based) index of a predefined element set in the patch.
Definition: ASMbase.h:300

ASMbase::nel
size_t nel
Number of regular elements in this patch.
Definition: ASMbase.h:1035

ASMbase::globalL2projection
bool globalL2projection(Matrix &sField, const L2Integrand &integrand, bool continuous=false, bool enforceEnds=false) const
Projects the secondary solution using a (discrete) global L2-fit.
Definition: GlbL2projector.C:513

ASMbase::begin_MPC
MPCIter begin_MPC() const
Returns the beginning of the mpcs set.
Definition: ASMbase.h:387

ASMbase::getNodeID
virtual int getNodeID(size_t inod, bool=false) const
Returns the global node number for the given node.
Definition: ASMbase.C:274

ASMbase::injectNodeVec
virtual bool injectNodeVec(const RealArray &nodeVec, RealArray &globVec, unsigned char nndof=0, int basis=0) const
Injects nodal results for this patch into the global vector.
Definition: ASMbase.C:1586

ASMbase::setGeometry
virtual bool setGeometry(RealFunc *, double, double)
Defines the immersed geometry from a scalar function.
Definition: ASMbase.h:141

ASMbase::integrate
virtual bool integrate(Integrand &integrand, GlobalIntegral &glbInt, const TimeDomain &time)=0
Evaluates an integral over the interior patch domain.

ASMbase::writeLagBasis
bool writeLagBasis(std::ostream &os, const char *type) const
Writes a Lagrangian basis to the given stream.
Definition: ASMbase.C:1797

ASMbase::evalSolutionPiola
virtual bool evalSolutionPiola(Matrix &sField, const Vector &locSol, const RealArray *gpar, bool regular) const
Evaluates the primary solution field with Piola mapping.
Definition: ASMbase.C:1748

ASMbase::getNoElms
size_t getNoElms(bool includeZeroVolElms=false, bool includeXElms=false) const
Returns the total number of elements in this patch.
Definition: ASMbase.C:337

ASMbase::nLag
unsigned char nLag
Number of Lagrange multipliers per node.
Definition: ASMbase.h:1034

ASMbase::getElementActivator
const IntFunc * getElementActivator() const
Returns a pointer to the element activation function.
Definition: ASMbase.h:184

ASMbase::findElementContaining
virtual int findElementContaining(const double *param) const =0
Returns the element that contains a specified spatial point.

ASMbase::MNPC
const IntMat & MNPC
Matrix of Nodal Point Correspondance.
Definition: ASMbase.h:1040

ASMbase::myActiveEls
IntVec * myActiveEls
List of active elements during element assembly.
Definition: ASMbase.h:1085

ASMbase::MLGN
const IntVec & MLGN
Matrix of Local to Global Node numbers.
Definition: ASMbase.h:1039

ASMbase::getElmID
int getElmID(size_t iel) const
Returns the global element number for the given element.
Definition: ASMbase.C:293

ASMbase::addXElms
virtual bool addXElms(short int dim, short int item, size_t nXn, IntVec &nodes)
Adds extraordinary elements associated with a patch boundary.
Definition: ASMbase.C:192

ASMbase::assembleL2matrices
virtual bool assembleL2matrices(SystemMatrix &A, SystemVector &B, const L2Integrand &obj, bool continuous) const
Assembles L2-projection matrices for the secondary solution.
Definition: ASMbase.h:956

ASMbase::getNodeSet
virtual const IntVec & getNodeSet(int) const
Returns an indexed predefined node set.
Definition: ASMbase.h:291

ASMbase::dbgElm
static int dbgElm
One-based element index to print debugging info for.
Definition: ASMbase.h:1023

ASMbase::xNode
static std::map< int, int > xNode
Auxilliary node number map used when establishing Dirichlet constraints.
Definition: ASMbase.h:1075

ASMbase::closeBoundaries
virtual void closeBoundaries(int dir=1, int basis=0, int master=1)
Makes two opposite boundaries periodic.
Definition: ASMbase.h:426

ASMbase::findPoint
virtual double findPoint(Vec3 &X, double *param) const =0
Searches for the specified Cartesian point in the patch.

ASMbase::changeNumThreads
virtual void changeNumThreads()
Hook for changing number of threads.
Definition: ASMbase.h:527

ASMbase::parseElemSet
virtual int parseElemSet(const std::string &, const char *)
Defines an element set by parsing a list of element numbers.
Definition: ASMbase.h:308

ASMbase::addRigidMPC
void addRigidMPC(int gSlave, int gMaster, const Vec3 &dX)
Adds MPC-equations representing a rigid arm to a 6-DOF node.
Definition: ASMbase.C:646

ASMbase::getLMType
char getLMType(size_t inod) const
Returns the type of a Lagrange multiplier node.
Definition: ASMbase.C:280

ASMbase::separateProjectionBasis
virtual bool separateProjectionBasis() const
Checks if a separate projection basis is used for this patch.
Definition: ASMbase.h:795

ASMbase::getNodalCoordinates
virtual void getNodalCoordinates(Matrix &X, bool geo=false) const =0
Returns a matrix with all nodal coordinates within the patch.

ASMbase::mpcs
MPCSet mpcs
All multi-point constraints with the slave in this patch.
Definition: ASMbase.h:1049

ASMbase::myMLGN
IntVec myMLGN
The actual Matrix of Local to Global Node numbers.
Definition: ASMbase.h:1052

ASMbase::checkElementSize
virtual bool checkElementSize(int, bool=true) const
Checks if the specified element is larger than the minimum size.
Definition: ASMbase.h:191

ASMbase::generateThreadGroupsFromElms
virtual void generateThreadGroupsFromElms(const IntVec &)
Generates element groups for multi-threading based on a partition.
Definition: ASMbase.h:520

ASMbase::renumberNodes
static int renumberNodes(const ASMVec &model, std::map< int, int > &old2new)
Renumbers all global node numbers in the entire model.
Definition: ASMbase.C:1260

ASMbase::evalProjSolution
virtual bool evalProjSolution(Matrix &sField, const Vector &locSol, const int *npe, int n_f=0) const
Evaluates the projected solution field at all visualization points.
Definition: ASMbase.h:634

ASMbase::addHole
virtual void addHole(double, double, double)
Adds a circular immersed boundary in the physical geometry.
Definition: ASMbase.h:137

ASMbase::Empty
static IntVec Empty
Empty integer vector used when a reference is needed.
Definition: ASMbase.h:1086

ASMbase::getProjectedFields
virtual Fields * getProjectedFields(const Vector &, size_t) const
Returns a field using the projection basis.
Definition: ASMbase.h:789

ASMbase::initConstraints
virtual bool initConstraints()
Initializes the multi-point constraint coefficients.
Definition: ASMbase.h:483

ASMbase::collapseNodes
static bool collapseNodes(ASMbase &pch1, int node1, ASMbase &pch2, int node2)
Collapses the given two nodes into one.
Definition: ASMbase.C:1215

ASMbase::parseNodeSet
virtual int parseNodeSet(const std::string &, const char *)
Defines a node set by parsing a list of node numbers.
Definition: ASMbase.h:295

ASMbase::nf
unsigned char nf
Number of primary solution fields (1 or larger)
Definition: ASMbase.h:1033

ASMbase::getBoundary1Nodes
virtual void getBoundary1Nodes(int lIndex, IntVec &nodes, int basis=0, int orient=-1, bool local=false, bool open=false) const
Finds the global (or patch-local) node numbers on a patch boundary.
Definition: ASMbase.h:276

ASMbase::findClosestNode
virtual std::pair< size_t, double > findClosestNode(const Vec3 &) const
Finds the node that is closest to the given point.
Definition: ASMbase.h:314

ASMbase::setNoFields
void setNoFields(unsigned char n)
Defines the number of solution fields in the patch.
Definition: ASMbase.h:179

ASMbase::getNoBouPoints
virtual void getNoBouPoints(size_t &nPt, char ldim, char lindx)
Computes the number of boundary integration points in this patch.
Definition: ASMbase.C:385

ASMbase::getNoProjectionNodes
virtual size_t getNoProjectionNodes() const
Returns the number of projection nodes for this patch.
Definition: ASMbase.h:776

ASMbase::tesselate
virtual bool tesselate(ElementBlock &grid, const int *npe) const =0
Creates a standard FE model of this patch for visualization.

ASMbase::add2PC
bool add2PC(int slave, int dir, int master, int code=0)
Creates and adds a two-point constraint to this patch.
Definition: ASMbase.C:551

ASMbase::getNoSpaceDim
unsigned char getNoSpaceDim() const
Returns the number of spatial dimensions.
Definition: ASMbase.h:201

ASMbase::getSolution
virtual bool getSolution(Matrix &sField, const Vector &locSol, const IntVec &nodes) const
Extract the primary solution field at the specified nodes.
Definition: ASMbase.C:1620

ASMbase::constrainXnode
bool constrainXnode(int node, int dof, int code=0)
Constrains an extraordinary node in the patch.
Definition: ASMbase.C:801

ASMbase::getNodeIndex
virtual size_t getNodeIndex(int globalNum, bool=false) const
Returns local 1-based index of the node with given global number.
Definition: ASMbase.C:268

ASMbase::readBasis
virtual bool readBasis(std::istream &, size_t)
Reads a basis from the given input stream.
Definition: ASMbase.h:132

ASMbase::generateFEMTopology
virtual bool generateFEMTopology()=0
Generates the finite element topology data for this patch.

ASMbase::getNoParamDim
unsigned char getNoParamDim() const
Returns the number of parameter dimensions.
Definition: ASMbase.h:203

ASMbase::addLocal2GlobalCpl
void addLocal2GlobalCpl(int iSlave, int master, const Tensor &Tlg)
Creates constraint equations coupling global DOFs to local DOFs.
Definition: ASMbase.C:588

ASMbase::addNeighbor
void addNeighbor(ASMbase *pch)
Adds a patch to the list of neighbors of this patch.
Definition: ASMbase.C:1205

ASMbase::end_elm
IntMat::const_iterator end_elm() const
Returns the end of the MNPC array.
Definition: ASMbase.h:384

ASMbase::hasXNodes
bool hasXNodes() const
Returns true if this patch has additional (extraordinary) nodes.
Definition: ASMbase.h:398

ASMbase::isRMn
bool isRMn(size_t n) const
Returns true if node n is a master node of a rigid coupling.
Definition: ASMbase.h:235

ASMbase::getGlobalNodeNums
const IntVec & getGlobalNodeNums() const
Returns the global node numbers of this patch.
Definition: ASMbase.h:331

ASMbase::extractElmRes
virtual void extractElmRes(const Vector &globRes, Vector &elmRes, size_t internalFirst=0) const
Extracts element results for this patch from a global vector.
Definition: ASMbase.C:1417

ASMbase::diracPoint
virtual bool diracPoint(Integrand &integrand, GlobalIntegral &glbInt, const double *u, const Vec3 &p)
Integrates a spatial dirac-delta function over a patch.
Definition: ASMbase.h:572

ASMbase::allDofs
bool allDofs(int dirs) const
Returns true if dirs constains all local DOFs in the patch.
Definition: ASMbase.C:928

ASMbase::nnod
size_t nnod
Number of regular nodes in this patch.
Definition: ASMbase.h:1036

ASMbase::getGlobalElementNums
const IntVec & getGlobalElementNums() const
Returns the global element numbers of this patch.
Definition: ASMbase.h:336

ASMbase::createRgdMasterNode
bool createRgdMasterNode(int &gMaster, const Vec3 &Xmaster)
Creates an additional master node for a rigid coupling.
Definition: ASMbase.C:628

ASMbase::hasTimeDependentDirichlet
bool hasTimeDependentDirichlet(const std::map< int, RealFunc * > &func, const std::map< int, VecFunc * > &vfunc)
Checks for time-dependent in-homogeneous Dirichlet conditions.
Definition: ASMbase.C:1136

ASMbase::dCode
MPCMap dCode
Inhomogeneous Dirichlet condition codes for the MPCs.
Definition: ASMbase.h:1048

ASMbase::addPeriodicity
bool addPeriodicity(size_t master, size_t slave, int dir)
Creates and adds a periodicity constraint to this patch.
Definition: ASMbase.C:740

ASMbase::getElementNodes
const IntVec & getElementNodes(int iel) const
Returns the nodal point correspondance array for an element.
Definition: ASMbase.C:299

ASMbase::makePeriodic
void makePeriodic(size_t master, size_t slave, int dirs=123)
Creates periodicity constraints between two nodes in this patch.
Definition: ASMbase.C:762

ASMbase::getProjectedField
virtual Field * getProjectedField(const Vector &) const
Returns a field using the projection basis.
Definition: ASMbase.h:785

ASMbase::BCode
BCVec BCode
Array of Boundary Condition codes.
Definition: ASMbase.h:1047

ASMbase::constrainNodes
void constrainNodes(const IntVec &nodes, int dof, int code=0, bool overrideD=false)
Constrains a list of nodes in the patch.
Definition: ASMbase.C:786

ASMbase::gEl
static int gEl
Global element counter.
Definition: ASMbase.h:1077

ASMbase::addLagrangeMultipliers
bool addLagrangeMultipliers(size_t iel, const IntVec &mGLag, unsigned char nnLag=1)
Adds a set of Lagrange multipliers to the specified element.
Definition: ASMbase.C:198

ASMbase::firstBp
std::map< char, size_t > firstBp
Global indices to first integration point for the Neumann boundaries.
Definition: ASMbase.h:1070

ASMbase::printElmInfo
virtual void printElmInfo(int, const IntegrandBase *) const
Prints out additional app-dependent element information.
Definition: ASMbase.h:322

ASMbase::constrainPatch
void constrainPatch(int dof, int code=0)
Constrains all nodes in the patch.
Definition: ASMbase.C:773

ASMbase::isLMn
bool isLMn(size_t n) const
Returns true if node n is a Lagrange multiplier node.
Definition: ASMbase.h:233

ASMbase::~ASMbase
virtual ~ASMbase()
The destructor frees the dynamically allocated data objects.
Definition: ASMbase.C:135

ASMbase::setMinimumSize
virtual void setMinimumSize(double)
Sets the minimum element size for adaptive refinement.
Definition: ASMbase.h:187

ASMbase::printElements
void printElements(std::ostream &os) const
Prints out element connections of this patch to the given stream.
Definition: ASMbase.C:429

ASMbase::resetNumbering
static void resetNumbering(int n=0)
Resets the global element and node counters.
Definition: ASMbase.C:260

ASMbase::isFixed
bool isFixed(int node, int dof, bool all=false) const
Checks if the given DOFs are fixed.
Definition: ASMbase.C:483

ASMbase::add3PC
bool add3PC(int slave, int dir, int master1, int master2, int code=0)
Creates and adds a three-point constraint to this patch.
Definition: ASMbase.C:568

ASMbase::immersedSolution
virtual bool immersedSolution(Matrix &, const Vector &) const
Evaluates the primary solution at the immersed geometry points.
Definition: ASMbase.h:625

ASMbase::idx
size_t idx
Index of this patch in the multi-patch model.
Definition: ASMbase.h:1027

ASMbase::cloneUnShared
ASMbase * cloneUnShared() const
Returns a copy of this patch with identical FE discretization.
Definition: ASMbase.C:143

ASMbase::XYZ
std::array< double, 3 > XYZ
Convenience type definition.
Definition: ASMbase.h:1089

ASMbase::addGlobalLagrangeMultipliers
bool addGlobalLagrangeMultipliers(const IntVec &mGLag, unsigned char nnLag=1)
Adds global Lagrange multipliers to the system.
Definition: ASMbase.C:253

ASMbase::createProjectionBasis
virtual bool createProjectionBasis(bool)
Creates a separate projection basis for this patch.
Definition: ASMbase.h:793

ASMbase::end_MPC
MPCIter end_MPC() const
Returns the end of the mpcs set.
Definition: ASMbase.h:389

ASMbase::addHole
virtual void addHole(double, double, double, double, double)
Adds an oval immersed boundary in the physical geometry.
Definition: ASMbase.h:139

ASMbase::findBoundaryElms
virtual void findBoundaryElms(IntVec &elms, int lIndex, int orient) const =0
Finds the patch-local element numbers on a patch boundary.

ASMbase::getElementCoordinates
virtual bool getElementCoordinates(Matrix &X, int iel, bool forceItg=false) const =0
Returns a matrix with nodal coordinates for an element.

ASMbase::firstEl
size_t firstEl
Global index to first element within this patch.
Definition: ASMbase.h:1066

ASMbase::modelSize
static double modelSize
Characteristic model size.
Definition: ASMbase.h:1025

ASMbase::MLGE
const IntVec & MLGE
Matrix of Local to Global Element numbers.
Definition: ASMbase.h:1038

ASMbase::firstIp
size_t firstIp
Global index to first interior integration point.
Definition: ASMbase.h:1067

ASMbase::myElActive
IntFunc * myElActive
Function returning activatiation time of element.
Definition: ASMbase.h:1084

ASMbase::clear
virtual void clear(bool retainGeometry=false)
Clears the contents of this patch, making it empty.
Definition: ASMbase.C:155

ASMbase::myLMTypes
std::vector< char > myLMTypes
Type of Lagrange multiplier ('L' or 'G')
Definition: ASMbase.h:1081

ASMbase::ASMbase
ASMbase(unsigned char n_p, unsigned char n_s, unsigned char n_f)
The constructor sets the number of space dimensions and fields.
Definition: ASMbase.C:59

ASMbase::evalPoint
virtual int evalPoint(const double *xi, double *param, Vec3 &X) const =0
Evaluates the geometry at a specified point.

ASMbase::getElmIndex
size_t getElmIndex(int globalNum) const
Returns local 1-based index of element with given global number.
Definition: ASMbase.C:287

ASMbase::extraSolution
virtual bool extraSolution(Matrix &, const Vector &) const
Evaluates the primary solution at the extra geometry points.
Definition: ASMbase.h:627

ASMbase::getBoundaryNodes
virtual void getBoundaryNodes(int lIndex, IntVec &nodes, int basis=0, int thick=1, int orient=-1, bool local=false) const =0
Finds the global (or patch-local) node numbers on a patch boundary.

ASMbase::setGauss
virtual void setGauss(int ng)
Defines the numerical integration scheme nGauss in the patch.
Definition: ASMbase.h:173

ASMbase::extractNodeVec
virtual void extractNodeVec(const RealArray &globVec, RealArray &nodeVec, unsigned char nndof=0, int basis=0) const
Extracts nodal results for this patch from the global vector.
Definition: ASMbase.C:1554

ASMbase::getNoRefineElms
virtual size_t getNoRefineElms() const
Returns the number of elements on refinement basis for this patch.
Definition: ASMbase.h:782

ASMbase::setElementActivator
void setElementActivator(IntFunc *efunc)
Sets the element activation function.
Definition: ASMbase.h:182

ASMbase::getElmNodes
virtual IntMat getElmNodes(int) const
Returns the matrix of nodal point correspondance for given basis.
Definition: ASMbase.h:413

ASMbase::generateProjThreadGroupsFromElms
virtual void generateProjThreadGroupsFromElms(const IntVec &)
Generates element groups for multi-threading based on a partition.
Definition: ASMbase.h:522

ASMbase::addMPC
bool addMPC(MPC *&mpc, int code=0, bool verbose=false, bool overrideD=false)
Adds a general multi-point-constraint (MPC) equation to this patch.
Definition: ASMbase.C:496

ASMbase::shiftGlobalNodeNums
virtual void shiftGlobalNodeNums(int nshift)
Increase all global node numbers by nshift.
Definition: ASMbase.C:1397

ASMbase::extractNodalVec
bool extractNodalVec(const RealArray &globVec, RealArray &nodeVec, const int *madof, int ngnod=-1) const
Extracts nodal results for this patch from the global vector.
Definition: ASMbase.C:1452

ASMbase::searchCtrlPt
int searchCtrlPt(RealArray::const_iterator cit, RealArray::const_iterator end, const Vec3 &X, int dimension, double tol=0.001) const
Helper method used by evalPoint to search for a control point.
Definition: ASMbase.C:1693

ASMbase::integrate
virtual bool integrate(Integrand &integrand, int lIndex, GlobalIntegral &glbInt, const TimeDomain &time)=0
Evaluates a boundary integral over a patch face/edge.

ASMbase::myElms
IntVec myElms
Elements on patch - used with partitioning.
Definition: ASMbase.h:1054

ASMbase::integrateEdge
virtual bool integrateEdge(Integrand &integrand, int lEdge, GlobalIntegral &glbInt, const TimeDomain &time)
Evaluates a boundary integral over a patch edge.
Definition: ASMbase.h:554

ASMbase::fix
int fix(size_t inod, int dirs=123)
Constrains DOFs in the given node to zero.
Definition: ASMbase.C:893

ASMbase::getAge
double getAge(int iel, double time) const
Returns the age of the element with 0-based index iel.
Definition: ASMbase.C:1843

ASMbase::getNoBasis
virtual size_t getNoBasis() const
Returns number of bases of this patch.
Definition: ASMbase.h:354

ASMbase::getNoNodes
virtual size_t getNoNodes(int basis=0) const
Returns the total number of nodes in this patch.
Definition: ASMbase.C:326

ASMbase::getBoundaryElms
void getBoundaryElms(int lIndex, IntVec &elms, int orient=-1, bool local=false) const
Finds the global (or patch-local) element numbers on a boundary.
Definition: ASMbase.C:1812

ASMbase::ndim
unsigned char ndim
Number of parametric dimensions (1, 2 or 3)
Definition: ASMbase.h:1031

ASMbase::isInNodeSet
virtual bool isInNodeSet(int, int) const
Checks if a node is within a predefined node set.
Definition: ASMbase.h:293

ASMbase::transform
virtual bool transform(const Matrix &)
Applies a transformation matrix from local to global system.
Definition: ASMbase.h:510

ASMbase::filterResults
virtual void filterResults(Matrix &, const ElementBlock *) const
Filters out result point values that are outside physical domain.
Definition: ASMbase.h:605

ASMbase::updateCoords
virtual bool updateCoords(const Vector &displ)=0
Updates the nodal coordinates for this patch.

ASMbase::printNodes
void printNodes(std::ostream &os) const
Prints out the nodal coordinates of this patch to the given stream.
Definition: ASMbase.C:413

ASMbase::gNod
static int gNod
Global node counter.
Definition: ASMbase.h:1078

ASMbase::getElementSet
virtual bool getElementSet(int, std::string &) const
Returns the name of an indexed predefined element set.
Definition: ASMbase.h:304

ASMbase::deformedConfig
static bool deformedConfig(const Matrix &Xnod, Vectors &eVec, bool force2nd=false)
Calculates the deformed configuration for current element.
Definition: ASMbase.C:1654

ASMbase::addRigidCpl
virtual bool addRigidCpl(int lindx, int ldim, int basis, int &gMaster, const Vec3 &Xmaster, bool extraPt=true)
Adds MPC-equations representing a rigid coupling to this patch.
Definition: ASMbase.C:678

ASMbase::injectNodalVec
bool injectNodalVec(const RealArray &nodeVec, RealArray &globVec, const IntVec &madof, int basis=0) const
Injects nodal results for this patch into the global vector.
Definition: ASMbase.C:1501

ASMbase::L2projection
bool L2projection(Matrix &sField, IntegrandBase *integrand, const TimeDomain &time)
Projects the secondary solution using a continuous global L2-fit.
Definition: GlbL2projector.C:472

ASMbase::setGlobalNodeNums
void setGlobalNodeNums(const IntVec &nodes)
Sets the global node numbers for this patch.
Definition: ASMbase.h:327

ASMbase::getOrder
virtual bool getOrder(int &, int &, int &) const
Returns the polynomial order in each parameter direction.
Definition: ASMbase.h:210

ASMbase::getNoIntPoints
virtual void getNoIntPoints(size_t &nPt, size_t &nIPt)
Computes the total number of integration points in this patch.
Definition: ASMbase.C:357

ASMbase::nGauss
int nGauss
Numerical integration scheme for this patch.
Definition: ASMbase.h:1064

ASMbase::getNodalDOFs
virtual unsigned char getNodalDOFs(size_t inod) const
Returns the number of DOFs per node.
Definition: ASMbase.C:309

ASMbase::setActiveElements
void setActiveElements(IntVec *active)
Sets the list of active elements during assembly.
Definition: ASMbase.h:339

ASMbase::getNodeSetIdx
virtual int getNodeSetIdx(const std::string &) const
Returns (1-based) index of a predefined node set in the patch.
Definition: ASMbase.h:289

ASMbase::parseNodeBox
virtual int parseNodeBox(const std::string &, const char *)
Defines a node set by parsing a 3D bounding box.
Definition: ASMbase.h:297

ASMbase::begin_elm
IntMat::const_iterator begin_elm() const
Returns the beginning of the MNPC array.
Definition: ASMbase.h:382

ASMbase::getElmConnectivities
virtual void getElmConnectivities(IntMat &neighs, int basis=ASM::INTEGRATION_BASIS) const =0
Calculates the matrix of element neighbour connectivities.

ASMbase::getNoBoundaryElms
virtual size_t getNoBoundaryElms(char, char) const
Returns the number of elements on a boundary.
Definition: ASMbase.h:367

ASMbase::getNoLagPerNode
unsigned char getNoLagPerNode() const
Returns the number of Lagrange multipliers per node.
Definition: ASMbase.h:207

ASMbase::updateDirichlet
virtual bool updateDirichlet(const std::map< int, RealFunc * > &func, const std::map< int, VecFunc * > &vfunc, double time=0.0, const std::map< int, int > *g2l=nullptr)
Updates the time-dependent in-homogeneous Dirichlet coefficients.
Definition: ASMbase.C:1157

ASMbase::inActive
bool inActive(double time) const
Returns true if none of the elements in the patch are active.
Definition: ASMbase.C:1829

ASMbase::setNodeNumbers
virtual void setNodeNumbers(const IntVec &nodes)
Sets the global node numbers for this patch.
Definition: ASMbase.C:1129

ASMbase::getMyNodeNums
const IntVec & getMyNodeNums() const
Returns the actual global node numbers of this patch.
Definition: ASMbase.h:329

ASMbase::write
virtual bool write(std::ostream &os, int basis=0) const =0
Writes the geometry/basis of the patch to the given stream.

ASMbase::getNoRefineNodes
virtual size_t getNoRefineNodes() const
Returns the number of nodes on refinement basis for this patch.
Definition: ASMbase.h:779

ASMbase::getMaxElmNo
int getMaxElmNo() const
Returns the highest external element number in this patch.
Definition: ASMbase.C:351

ASMbase::isInElementSet
virtual bool isInElementSet(int, int) const
Checks if an element is within a predefined element set.
Definition: ASMbase.h:306

ASMbase::generateThreadGroups
virtual void generateThreadGroups(const Integrand &, bool, bool)
Generates element groups for multi-threading of interior integrals.
Definition: ASMbase.h:516

ASMbase::fixHomogeneousDirichlet
static bool fixHomogeneousDirichlet
If true, pre-eliminate fixed DOFs.
Definition: ASMbase.h:1021

ASMbase::prescribe
int prescribe(size_t inod, int dirs, int code, bool overrideD=false)
Constrains DOFs in the given node to the given value.
Definition: ASMbase.C:814

ASMbase::isElementActive
bool isElementActive(int iel, double time=-1.0) const
Returns true if element with 0-based index iel is active.
Definition: ASMbase.C:1823

ASMbase::read
virtual bool read(std::istream &is)=0
Creates an instance by reading the given input stream.

ASMbase::getMinimumSize
virtual double getMinimumSize(int=0) const
Defines the minimum element size for adaptive refinement.
Definition: ASMbase.h:189

ASMbase::validateThreadGroups
virtual bool validateThreadGroups(const SAM *) const
Validates the threading groups based on the assembly data in SAM.
Definition: ASMbase.h:524

ASMbase::addRigidCouplings
void addRigidCouplings(int gMaster, const Vec3 &Xmaster, const IntVec &slaveNodes)
Adds MPC-equations representing a rigid coupling to this patch.
Definition: ASMbase.C:698

ASMbase::end_BC
BCVec::const_iterator end_BC() const
Returns the end of the BCode array.
Definition: ASMbase.h:379

ASMbase::extraGeometry
virtual ElementBlock * extraGeometry(char *) const
Returns an additional geometry to visualize (spiders, etc.).
Definition: ASMbase.h:603

ASMbase::neighbors
ASMVec neighbors
Patches having nodes in common with this one.
Definition: ASMbase.h:1072

ASMbase::myMLGE
IntVec myMLGE
The actual Matrix of Local to Global Element numbers.
Definition: ASMbase.h:1051

ASMbase::getCoord
virtual Vec3 getCoord(size_t inod) const =0
Returns the global coordinates for the given node.

ASMbase::isShared
bool isShared() const
Returns true if this patch shares FE data with another patch.
Definition: ASMbase.h:396

ASMbase::getElementCenter
virtual Vec3 getElementCenter(int) const =0
Returns the coordinates of the element center.

ASMbase::begin_BC
BCVec::const_iterator begin_BC() const
Returns the beginning of the BCode array.
Definition: ASMbase.h:377

ASMbase::findMPC
MPC * findMPC(int node, int dof) const
Returns a pointer to the MPC object for a specified slave, if any.
Definition: ASMbase.C:732

ASMbase::mergeNodes
bool mergeNodes(size_t inod, int globalNum, bool verbose=true)
Merges a given node in this patch with a given global node.
Definition: ASMbase.C:1238

ASMbase::isElementInPartition
bool isElementInPartition(int iel) const
Returns true if element is in process partition.
Definition: ASMbase.C:1866

ASMbase::getElementSet
virtual const IntVec & getElementSet(int) const
Returns an indexed predefined element set.
Definition: ASMbase.h:302

ASMbase::BCVec
std::vector< BC > BCVec
Nodal boundary condition container.
Definition: ASMbase.h:92

ASMbase::nsd
unsigned char nsd
Number of space dimensions (ndim <= nsd <= 3)
Definition: ASMbase.h:1032

ASMbase::myRmaster
std::map< size_t, XYZ > myRmaster
Rigid master nodal points.
Definition: ASMbase.h:1090

ASMbase::getNodeType
virtual char getNodeType(size_t inod) const
Returns the classification of a node.
Definition: ASMbase.C:320

ASMbase::mergeAndGetAllMPCs
static void mergeAndGetAllMPCs(const ASMVec &model, MPCSet &allMPCs)
Computes the set of all MPC-equations over the whole model.
Definition: ASMbase.C:939

ASMbase::evaluate
virtual bool evaluate(const ASMbase *basis, const Vector &locVec, RealArray &vec, int basisNum=1) const
Evaluates and interpolates a field over a given geometry.
Definition: ASMbase.C:1779

ASMbase::initMADOF
virtual void initMADOF(const int *)
Initializes the patch level MADOF array for mixed problems.
Definition: ASMbase.h:513

ASMbase::myLMs
std::set< size_t > myLMs
Nodal indices of the Lagrange multipliers.
Definition: ASMbase.h:1082

ASMbase::empty
virtual bool empty() const =0
Checks if this patch is empty.

ASMbase::resolveMPCchains
static void resolveMPCchains(const MPCSet &allMPCs, const ASMVec &model, bool setPtrOnly=false)
Resolves (possibly multi-level) chaining in MPC-equations.
Definition: ASMbase.C:1025

ASMbase::swapProjectionBasis
virtual void swapProjectionBasis()
Swap between main and alternative projection basis.
Definition: ASMbase.h:797

ASMbase::integrate
virtual bool integrate(Integrand &integrand, GlobalIntegral &glbInt, const TimeDomain &time, const ASM::InterfaceChecker &iChk)
Evaluates an integral over element interfaces in the patch.
Definition: ASMbase.h:563

ASMbase::getNoGaussPt
int getNoGaussPt(int p, bool neumann=false) const
Returns the number of Gauss points to use in one direction.
Definition: ASMbase.C:1722

ASMbase::getParameterDomain
virtual bool getParameterDomain(Real2DMat &u, IntVec *corners=nullptr) const =0
Returns parameter values and node numbers of the domain corners.

ASMbase::evalSolution
virtual bool evalSolution(Matrix &sField, const Vector &locSol, const int *npe, int n_f=0, bool piola=false) const
Evaluates the primary solution field at all visualization points.
Definition: ASMbase.C:1735

ASMbase::getNoFields
virtual unsigned char getNoFields(int b=0) const
Returns the number of solution fields.
Definition: ASMbase.h:205

ASMbase::shiftGlobalElmNums
virtual void shiftGlobalElmNums(int eshift)
Increase all global element numbers by eshift.
Definition: ASMbase.C:1410

ASMbase::parseElemBox
virtual int parseElemBox(const std::string &, const std::string &, const char *)
Defines an element set by parsing a 3D bounding box.
Definition: ASMbase.h:310

ASMbase::myMNPC
IntMat myMNPC
The actual Matrix of Nodal Point Correspondance.
Definition: ASMbase.h:1053

ASMbase::copyParameterDomain
virtual void copyParameterDomain(const ASMbase *)
Copies the parameter domain from another patch.
Definition: ASMbase.h:420

ASMbase::getNoMPCs
size_t getNoMPCs() const
Returns the total number of multi-point constraint equations.
Definition: ASMbase.h:369

ASMbase::shareFE
const char shareFE
Flag telling whether this patch shares its data with another patch.
Definition: ASMbase.h:1045

ASMbase::generateThreadGroups
virtual void generateThreadGroups(char, bool, bool)
Generates element groups for multi-threading of boundary integrals.
Definition: ASMbase.h:518

ElementBlock
Class for storage of a standard FE grid block.
Definition: ElementBlock.h:27

Field
Interface class for scalar fields.
Definition: Field.h:30

Fields
Base class for vector fields.
Definition: Fields.h:35

FunctionBase
Base class for unary spatial functions of arbitrary result type.
Definition: Function.h:147

GlobalIntegral
Abstract base class representing a system level integrated quantity.
Definition: GlobalIntegral.h:29

IntegrandBase
Base class representing a system level integrated quantity.
Definition: IntegrandBase.h:42

Integrand
Abstract base class representing a system level integrated quantity.
Definition: Integrand.h:44

L2Integrand
Abstract class for evaluating integrand or function.
Definition: GlbL2projector.h:39

MPC
A class representing a general multi-point constraint equation.
Definition: MPC.h:52

RealFunc
Scalar-valued unary function of a spatial point.
Definition: Function.h:193

SAM
This class contains data and functions for the assembly of FE matrices.
Definition: SAM.h:39

SystemMatrix
Base class for representing a system matrix on different formats.
Definition: SystemMatrix.h:220

SystemVector
Base class for representing a system vector on different formats.
Definition: SystemMatrix.h:32

Tensor
Simple class for representing a non-symmetric second-order tensor.
Definition: Tensor.h:28

Vec3
Simple class for representing a point in 3D space.
Definition: Vec3.h:27

VecFunc
Vector-valued unary function of a spatial point.
Definition: Function.h:242

utl::Function
Base class for unary functions of arbitrary result and argument type.
Definition: Function.h:31

utl::matrix< Real >

utl::vector
A vector class with some added algebraic operations.
Definition: matrix.h:64

ASM
Assembly scope.
Definition: SIMdummy.h:24

ASM::INTEGRATION_BASIS
@ INTEGRATION_BASIS
Integration basis.
Definition: ASMenums.h:58

SplineUtils::project
Go::SplineCurve * project(const Go::SplineCurve *curve, const FunctionBase &f, int nComp=1, Real time=Real(0))
Projects a spatial function onto a spline curve.
Definition: SplineUtils.C:204

eig::verbose
bool verbose
If true, print out some Arnoldi iteration info.
Definition: EigSolver.C:100

utl
General utility classes and functions.
Definition: SIMoptions.h:22

ASMbase::BC
Struct for boundary condition codes.
Definition: ASMbase.h:74

ASMbase::BC::RX
char RX
Boundary condition code for X-rotation.
Definition: ASMbase.h:79

ASMbase::BC::BC
BC(int n)
Constructor initializing a BC instance.
Definition: ASMbase.h:84

ASMbase::BC::RZ
char RZ
Boundary condition code for Z-rotation.
Definition: ASMbase.h:81

ASMbase::BC::node
int node
Global node number of the constrained node.
Definition: ASMbase.h:75

ASMbase::BC::CZ
char CZ
Boundary condition code for Z-translation.
Definition: ASMbase.h:78

ASMbase::BC::RY
char RY
Boundary condition code for Y-rotation.
Definition: ASMbase.h:80

ASMbase::BC::CX
char CX
Boundary condition code for X-translation.
Definition: ASMbase.h:76

ASMbase::BC::CY
char CY
Boundary condition code for Y-translation.
Definition: ASMbase.h:77

ASMbase::BC::free
int free(int dof)
Removes the fixation in local dof dof.
Definition: ASMbase.C:863

ASMbase::BC::fix
int fix(int dof)
Fixes local dof dof.
Definition: ASMbase.C:878

TimeDomain
Struct representing the time domain.
Definition: TimeDomain.h:23