IFEM-2/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 Ipair  = std::pair<int,int>;


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 IntFunc;

class VecFunc;

class Vec3;

class Tensor;

class SAM;


namespace ASM {

  class InterfaceChecker;

  using NodeSet  = std::pair<std::string,IntVec>;

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

}


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;


  int getNodeSetIdx(const std::string& setName) const;

  const IntVec& getNodeSet(int iset) const;

  IntVec& getNodeSet(const std::string& setName, int& idx);


  bool isInNodeSet(int iset, int inod) const;

  int parseNodeSet(const std::string& setName, const char* cset,

                   bool assumeZeroBased = false);

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

  void convertNodeSets();


  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 = -1.0) 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 ASM::PatchVec& 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 ASM::PatchVec& model, MPCSet& allMPCs);


  static void resolveMPCchains(const MPCSet& allMPCs,

                               const ASM::PatchVec& 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,

                               bool tangent = false);


  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* func, 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* func, double t = 0.0);

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

                    const std::vector<FunctionBase*>& funcs, 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 const ASMbase* getOutputMaster() const { return this; }


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

                     size_t internalFirst = 0) const;

  void extractElmRes(const Matrix& globRes, Vector& elmRes, size_t irow) 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);


  void addNodalCouplings(int slave, const IntVec& masters,

                         const RealArray& weights);


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 xtol = 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;

  virtual bool selfInterconnect(const std::vector<Ipair>& nodes,

                                double xtol = 1.0e-8);


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;


  std::vector<ASM::NodeSet> nodeSets;


  IntVec myMLGE;

  IntVec myMLGN;

  IntMat myMNPC;

  IntVec myElms;


  int nGauss;


  size_t firstEl;

  size_t firstIp;


  std::map<char,size_t> firstBp;


  ASM::PatchVec 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;

  mutable bool active;

  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:31

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

Ipair
std::pair< int, int > Ipair
A pair of integers.
Definition ASMbase.h:27

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:29

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:32

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:72

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

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

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:589

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

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

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:1648

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

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

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:1859

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:1810

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

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

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:322

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:1064

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

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

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

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

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:195

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:975

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

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

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

ASMbase::nodeSets
std::vector< ASM::NodeSet > nodeSets
Node sets for explicit Dirichlet BCs.
Definition ASMbase.h:1075

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:539

ASMbase::active
bool active
If true, the patch is currently active.
Definition ASMbase.h:1112

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

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:654

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

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

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:1073

ASMbase::convertNodeSets
void convertNodeSets()
Converts node number sets to internal (1-based) node indices.
Definition ASMbase.C:2020

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

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

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

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:646

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

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

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

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

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

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:278

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

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:388

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

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

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:557

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

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

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:1682

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

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:271

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

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:205

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

ASMbase::parseNodeSet
int parseNodeSet(const std::string &setName, const char *cset, bool assumeZeroBased=false)
Defines a node set by parsing a list of node numbers.
Definition ASMbase.C:2001

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

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

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

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

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

ASMbase::extractElmRes
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:1481

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

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:584

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

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

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

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:1181

ASMbase::isInNodeSet
bool isInNodeSet(int iset, int inod) const
Checks if node inod is within predefined node set iset.
Definition ASMbase.C:1989

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

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

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

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:780

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

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:831

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

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:201

ASMbase::getOutputMaster
virtual const ASMbase * getOutputMaster() const
Returns the master patch to use for VTF- and HDF5-output.
Definition ASMbase.h:816

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

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

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

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

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

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

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

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

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

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

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:575

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

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

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

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

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

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

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

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

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::getGlobalElementNums
const IntVec & getGlobalElementNums() const
Returns the global element numbers of this patch.
Definition ASMbase.h:344

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

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

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

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

ASMbase::myElActive
IntFunc * myElActive
Function returning activation time of an element.
Definition ASMbase.h:1110

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

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

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

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:290

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

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:175

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:1616

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

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

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

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

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:502

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

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:1514

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:1080

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:566

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

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

ASMbase::getNodeSet
const IntVec & getNodeSet(int iset) const
Returns an indexed predefined node set.
Definition ASMbase.C:1959

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

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

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

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:1874

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

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

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

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

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

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

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

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

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

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, bool tangent=false)
Updates the time-dependent in-homogeneous Dirichlet coefficients.
Definition ASMbase.C:1202

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

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:683

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:1563

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

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

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

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

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

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

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

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

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

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:375

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

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

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:791

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

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

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

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

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:859

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:1885

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:191

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

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:703

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

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

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:404

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:385

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:750

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:1303

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

ASMbase::selfInterconnect
virtual bool selfInterconnect(const std::vector< Ipair > &nodes, double xtol=1.0e-8)
Connects a list of node pairs to each other.
Definition ASMbase.C:795

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

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

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

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

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:1841

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

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

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

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

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:575

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

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

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

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:1797

ASMbase::addNodalCouplings
void addNodalCouplings(int slave, const IntVec &masters, const RealArray &weights)
Adds MPC-equations for general nodal couplings in this patch.
Definition ASMbase.C:735

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

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

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

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:318

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

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

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

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

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

ASMbase::neighbors
ASM::PatchVec neighbors
Patches having nodes in common with this one.
Definition ASMbase.h:1098

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

IntFunc
A real-valued integer function.
Definition Functions.h:617

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:40

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::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

ASM::NodeSet
std::pair< std::string, IntVec > NodeSet
Named set container type.
Definition ASMbase.h:54

ASM::PatchVec
std::vector< ASMbase * > PatchVec
Spline patch container type.
Definition ASMbase.h:55

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

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

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

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

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

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

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

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

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

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

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

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