escript  Revision_
finley/src/FinleyDomain.h
Go to the documentation of this file.
1 
2 /*****************************************************************************
3 *
4 * Copyright (c) 2003-2020 by The University of Queensland
5 * http://www.uq.edu.au
6 *
7 * Primary Business: Queensland, Australia
8 * Licensed under the Apache License, version 2.0
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Development until 2012 by Earth Systems Science Computational Center (ESSCC)
12 * Development 2012-2013 by School of Earth Sciences
13 * Development from 2014-2017 by Centre for Geoscience Computing (GeoComp)
14 * Development from 2019 by School of Earth and Environmental Sciences
15 **
16 *****************************************************************************/
17 
18 #ifndef __FINLEY_DOMAIN_H__
19 #define __FINLEY_DOMAIN_H__
20 
21 /****************************************************************************
22 
23  Finley: Domain
24 
25  A mesh is built from nodes and elements which describe the domain, surface,
26  and point sources (the latter are needed to establish links with other
27  codes, in particular particle codes). The nodes are stored in a NodeFile
28  and elements in ElementFiles. Finley domains have four ElementFiles
29  containing the elements, surface, contact and point sources, respectively.
30  Notice that the surface elements do not necessarily cover the entire
31  surface of the domain.
32 
33  The element type is fixed by the reference element, see ReferenceElement.h.
34  The numbering of the nodes starts with 0.
35 
36  Important: it is assumed that every node appears in at least one element or
37  surface element and that any node used in an element, surface element or as
38  a point is specified in the NodeFile, see also resolveNodeIds.
39 
40  In some cases it is useful to refer to a mesh entirely built from
41  order 1 (=linear) elements. The linear version of the mesh can be
42  accessed by referring to the first few nodes of each element
43  (thanks to the way the nodes are ordered). As the numbering of
44  these nodes is not continuous a relabeling vector is introduced
45  in the NodeFile. This feature is not fully implemented yet.
46 
47  All nodes and elements are tagged. The tag allows to group nodes and
48  elements. A typical application is to mark surface elements on a
49  certain portion of the domain with the same tag. All these surface
50  elements can then be assigned the same value e.g. for the pressure.
51 
52  The spatial dimensionality is determined by the type of elements
53  used and can be queried using getDim(). Notice that the element type
54  also determines the type of surface elements to be used.
55 
56 *****************************************************************************/
57 
58 #include <finley/Finley.h>
59 #include <finley/ElementFile.h>
60 #include <finley/NodeFile.h>
61 #include <finley/Util.h>
62 
63 #include <escript/AbstractContinuousDomain.h>
64 #include <escript/FunctionSpace.h>
65 #include <escript/FunctionSpaceFactory.h>
66 
67 #ifdef ESYS_HAVE_PASO
68 #include <paso/SystemMatrixPattern.h>
69 #endif
70 #ifdef ESYS_HAVE_TRILINOS
71 #include <trilinoswrap/types.h>
72 #endif
73 
74 #include <map>
75 #include <string>
76 #include <vector>
77 
78 namespace finley {
79 
80 typedef std::map<std::string, int> TagMap;
81 
82 enum SystemMatrixType {
83  SMT_PASO = 1<<8,
84  SMT_TRILINOS = 1<<10,
85  SMT_COMPLEX = 1<<16,
86  SMT_UNROLL = 1<<17
87 };
88 
94 class FinleyDomain : public escript::AbstractContinuousDomain
95 {
96 public:
102  static escript::Domain_ptr load(const std::string& filename);
103 
116  static escript::Domain_ptr read(escript::JMPI mpiInfo,
117  const std::string& fileName,
118  int integrationOrder = -1,
119  int reducedIntegrationOrder = -1,
120  bool optimize = false);
121 
136  const std::string& filename,
137  int numDim, int integrationOrder = -1,
138  int reducedIntegrationOrder = -1,
139  bool optimize = false,
140  bool useMacroElements = false);
141 
159  static escript::Domain_ptr createRec4(dim_t NE0, dim_t NE1,
160  double L0, double L1,
161  bool periodic0, bool periodic1, int order,
162  int reducedOrder, bool useElementsOnFace,
163  bool optimize, escript::JMPI jmpi);
164 
185  static escript::Domain_ptr createRec8(dim_t NE0, dim_t NE1,
186  double l0, double l1,
187  bool periodic0, bool periodic1, int order,
188  int reducedOrder, bool useElementsOnFace,
189  bool useFullElementOrder,
190  bool useMacroElements, bool optimize,
191  escript::JMPI jmpi);
192 
213  static escript::Domain_ptr createHex8(dim_t NE0, dim_t NE1, dim_t NE2,
214  double l0, double l1, double l2,
215  bool periodic0, bool periodic1, bool periodic2,
216  int order, int reducedOrder,
217  bool useElementsOnFace,
218  bool optimize, escript::JMPI jmpi);
219 
242  static escript::Domain_ptr createHex20(dim_t NE0, dim_t NE1, dim_t NE2,
243  double l0, double l1, double l2,
244  bool periodic0, bool periodic1, bool periodic2,
245  int order, int reducedOrder,
246  bool useElementsOnFace,
247  bool useFullElementOrder,
248  bool useMacroElements, bool optimize,
249  escript::JMPI jmpi);
250 
259  FinleyDomain(const std::string& name, int numDim, escript::JMPI jmpi);
260 
265  FinleyDomain(const FinleyDomain& in);
266 
271  ~FinleyDomain();
272 
278  void addDiracPoints(const std::vector<double>& points,
279  const std::vector<int>& tags);
280 
285  NodeFile* getNodes() const { return m_nodes; }
286 
291  void setElements(ElementFile* elements);
292 
297  ElementFile* getElements() const { return m_elements; }
298 
303  void setFaceElements(ElementFile* elements);
304 
309  ElementFile* getFaceElements() const { return m_faceElements; }
310 
315  void setContactElements(ElementFile* elements);
316 
321  ElementFile* getContactElements() const { return m_contactElements; }
322 
327  void setPoints(ElementFile* elements);
328 
333  ElementFile* getPoints() const { return m_points; }
334 
339  virtual escript::JMPI getMPI() const { return m_mpiInfo; }
340 
345  virtual int getMPISize() const { return m_mpiInfo->size; }
346 
351  virtual int getMPIRank() const { return m_mpiInfo->rank; }
352 
357  virtual void MPIBarrier() const;
358 
363  virtual bool onMasterProcessor() const { return getMPIRank() == 0; }
364 
365  MPI_Comm getMPIComm() const { return m_mpiInfo->comm; }
366 
373  void write(const std::string& fileName) const;
374 
379  void Print_Mesh_Info(bool full=false) const;
380 
386  void dump(const std::string& fileName) const;
387 
394  int getTagFromSampleNo(int functionSpaceType, index_t sampleNo) const;
395 
401  const index_t* borrowSampleReferenceIDs(int functionSpaceType) const;
402 
408  virtual bool isValidFunctionSpaceType(int functionSpaceType) const;
409 
414  virtual std::string getDescription() const;
415 
420  virtual std::string functionSpaceTypeAsString(int functionSpaceType) const;
421 
427 
432  virtual int getContinuousFunctionCode() const;
433 
438  virtual int getReducedContinuousFunctionCode() const;
439 
444  virtual int getFunctionCode() const;
445 
450  virtual int getReducedFunctionCode() const;
451 
456  virtual int getFunctionOnBoundaryCode() const;
457 
462  virtual int getReducedFunctionOnBoundaryCode() const;
463 
468  virtual int getFunctionOnContactZeroCode() const;
469 
474  virtual int getReducedFunctionOnContactZeroCode() const;
475 
480  virtual int getFunctionOnContactOneCode() const;
481 
486  virtual int getReducedFunctionOnContactOneCode() const;
487 
492  virtual int getSolutionCode() const;
493 
498  virtual int getReducedSolutionCode() const;
499 
504  virtual int getDiracDeltaFunctionsCode() const;
505 
509  typedef std::map<int, std::string> FunctionSpaceNamesMapType;
510 
514  virtual int getDim() const { return m_nodes->numDim; }
515 
522  virtual StatusType getStatus() const;
523 
528  virtual dim_t getNumDataPointsGlobal() const;
529 
535  virtual std::pair<int,dim_t> getDataShape(int functionSpaceCode) const;
536 
542  virtual void setToX(escript::Data& arg) const;
543 
550  virtual void setTagMap(const std::string& name, int tag);
551 
557  virtual int getTag(const std::string& name) const;
558 
564  virtual bool isValidTagName(const std::string& name) const;
565 
570  virtual std::string showTagNames() const;
571 
576  virtual void setNewX(const escript::Data& arg);
577 
582  virtual void interpolateOnDomain(escript::Data& target,
583  const escript::Data& source) const;
584 
585  virtual bool probeInterpolationOnDomain(int functionSpaceType_source,
586  int functionSpaceType_target) const;
587 
588  virtual signed char preferredInterpolationOnDomain(int functionSpaceType_source, int functionSpaceType_target) const;
589 
594  bool commonFunctionSpace(const std::vector<int>& fs, int& resultcode) const;
595 
600  virtual void interpolateAcross(escript::Data& target, const escript::Data& source) const;
601 
605  virtual bool probeInterpolationAcross(int functionSpaceType_source,
606  const escript::AbstractDomain& targetDomain,
607  int functionSpaceType_target) const;
608 
614  virtual void setToNormal(escript::Data& out) const;
615 
621  virtual void setToSize(escript::Data& out) const;
622 
628  virtual void setToGradient(escript::Data& grad, const escript::Data& arg) const;
629 
635  virtual void setToIntegrals(std::vector<escript::DataTypes::real_t>& integrals,
636  const escript::Data& arg) const;
637  virtual void setToIntegrals(std::vector<escript::DataTypes::cplx_t>& integrals,
638  const escript::Data& arg) const;
639 
648  virtual int getSystemMatrixTypeId(const boost::python::object& options) const;
649 
659  virtual int getTransportTypeId(int solver, int preconditioner, int package,
660  bool symmetry) const;
661 
667  virtual bool isCellOriented(int functionSpaceCode) const;
668 
669  virtual bool ownSample(int fsCode, index_t id) const;
670 
675  virtual void addPDEToSystem(
677  const escript::Data& A, const escript::Data& B,
678  const escript::Data& C, const escript::Data& D,
679  const escript::Data& X, const escript::Data& Y,
680  const escript::Data& d, const escript::Data& y,
681  const escript::Data& d_contact,
682  const escript::Data& y_contact,
683  const escript::Data& d_dirac,
684  const escript::Data& y_dirac) const;
685 
690  virtual void addPDEToLumpedSystem(escript::Data& mat,
691  const escript::Data& D,
692  const escript::Data& d,
693  const escript::Data& d_dirac,
694  bool useHRZ) const;
695 
700  virtual void addPDEToRHS(escript::Data& rhs, const escript::Data& X,
701  const escript::Data& Y, const escript::Data& y,
702  const escript::Data& y_contact,
703  const escript::Data& y_dirac) const;
704 
709  virtual void addPDEToTransportProblem(
711  escript::Data& source, const escript::Data& M,
712  const escript::Data& A, const escript::Data& B,
713  const escript::Data& C, const escript::Data& D,
714  const escript::Data& X, const escript::Data& Y,
715  const escript::Data& d, const escript::Data& y,
716  const escript::Data& d_contact,
717  const escript::Data& y_contact,
718  const escript::Data& d_dirac,
719  const escript::Data& y_dirac) const;
720 
726  int row_blocksize,
727  const escript::FunctionSpace& row_functionspace,
728  int column_blocksize,
729  const escript::FunctionSpace& column_functionspace,
730  int type) const;
731 
737  const escript::FunctionSpace& functionspace,
738  int type) const;
739 
743  virtual escript::Data getX() const;
744 
745 #ifdef ESYS_HAVE_BOOST_NUMPY
746 
749  virtual boost::python::numpy::ndarray getNumpyX() const;
750 
754  virtual boost::python::numpy::ndarray getConnectivityInfo() const;
755 #endif
756 
760  virtual int getVTKElementType() const;
761 
766  virtual escript::Data getNormal() const;
767 
771  virtual escript::Data getSize() const;
772 
776  virtual bool operator==(const escript::AbstractDomain& other) const;
777  virtual bool operator!=(const escript::AbstractDomain& other) const;
778 
783  virtual void setTags(int functionSpaceType, int newTag,
784  const escript::Data& mask) const;
785 
791  virtual int getNumberOfTagsInUse(int functionSpaceCode) const;
792 
793  virtual const int* borrowListOfTagsInUse(int functionSpaceCode) const;
794 
799  virtual bool canTag(int functionSpaceCode) const;
800 
804  virtual int getApproximationOrder(int functionSpaceCode) const;
805 
806  virtual bool supportsContactElements() const { return true; }
807 
809  const escript::FunctionSpace& what, long seed,
810  const boost::python::tuple& filter) const;
811 
816  const TagMap& getTagMap() const { return m_tagMap; }
817 
818  void createMappings(const IndexVector& dofDistribution,
819  const IndexVector& nodeDistribution);
820 
821 #ifdef ESYS_HAVE_PASO
822  paso::SystemMatrixPattern_ptr getPasoPattern(bool reducedRowOrder,
824  bool reducedColOrder) const;
825 #endif
826 
827 #ifdef ESYS_HAVE_TRILINOS
828  esys_trilinos::const_TrilinosGraph_ptr getTrilinosGraph(bool reducedOrder) const;
830 #endif
831 
832  void glueFaces(double safetyFactor, double tolerance, bool optimize);
833 
834  void joinFaces(double safetyFactor, double tolerance, bool optimize);
835 
838  static FinleyDomain* merge(const std::vector<const FinleyDomain*>& meshes);
839 
840 private:
841  void prepare(bool optimize);
842 
843  void setOrders();
844 
852  void resolveNodeIds();
853 
856  void relabelElementNodes(const IndexVector& newNode, index_t offset);
857 
858  template<typename Scalar>
859  void setToIntegralsWorker(std::vector<Scalar>& integrals,
860  const escript::Data& arg) const;
861 
862 #ifdef ESYS_HAVE_PASO
863  paso::SystemMatrixPattern_ptr makePasoPattern(bool reducedRowOrder,
864  bool reducedColOrder) const;
865 #endif
866 #ifdef ESYS_HAVE_TRILINOS
867  esys_trilinos::GraphType* createTrilinosGraph(bool reducedOrder) const;
868 #endif
869  void createColoring(const IndexVector& dofMap);
870  void distributeByRankOfDOF(const IndexVector& distribution);
871  void markNodes(std::vector<short>& mask, index_t offset, bool useLinear) const;
872  void optimizeDOFDistribution(IndexVector& distribution);
873  void optimizeDOFLabeling(const IndexVector& distribution);
875  void findMatchingFaces(double safetyFactor, double tolerance, int* numPairs,
876  int* elem0, int* elem1, int* matchingNodes) const;
877  void updateTagList();
878  void printElementInfo(const ElementFile* e, const std::string& title,
879  const std::string& defaultType, bool full) const;
880 
881  void writeElementInfo(std::ostream& stream, const ElementFile* e,
882  const std::string& defaultType) const;
883 
887  std::string m_name;
888  int approximationOrder;
890  int integrationOrder;
893  NodeFile* m_nodes;
904 #ifdef ESYS_HAVE_PASO
905  // pointer to the sparse matrix patterns
906  mutable paso::SystemMatrixPattern_ptr FullFullPattern;
907  mutable paso::SystemMatrixPattern_ptr FullReducedPattern;
908  mutable paso::SystemMatrixPattern_ptr ReducedFullPattern;
909  mutable paso::SystemMatrixPattern_ptr ReducedReducedPattern;
910 #endif
911 #ifdef ESYS_HAVE_TRILINOS
912  mutable esys_trilinos::TrilinosGraph_ptr m_fullGraph;
913  mutable esys_trilinos::TrilinosGraph_ptr m_reducedGraph;
914 #endif
915 
917 };
918 
919 } // end of namespace
920 
921 #endif // __FINLEY_DOMAIN_H__
922 
finley::FinleyDomain::optimizeDOFLabeling
void optimizeDOFLabeling(const IndexVector &distribution)
optimizes the labeling of the DOFs on each processor
Definition: finley/src/FinleyDomain.cpp:2889
finley::FinleyDomain::getNumDataPointsGlobal
virtual dim_t getNumDataPointsGlobal() const
Return the number of data points summed across all MPI processes.
Definition: finley/src/FinleyDomain.cpp:1048
finley::NodeFile::updateTagList
void updateTagList()
Definition: finley/src/NodeFile.h:325
finley::FinleyDomain::setContactElements
void setContactElements(ElementFile *elements)
replaces the contact element file by elements
Definition: finley/src/FinleyDomain.cpp:134
dudley::DudleyDomain::getFaceElements
ElementFile * getFaceElements() const
returns a pointer to this domain's face element file
Definition: DudleyDomain.h:236
finley::brick_driver
Domain_ptr brick_driver(const bp::list &args)
Definition: finley/src/DomainFactory.cpp:1104
escript::SolverOptions
SolverOptions
Definition: SolverOptions.h:92
MPI_Status
int MPI_Status
Definition: EsysMPI.h:44
escript::SolverBuddy
Definition: SolverOptions.h:170
finley::FinleyDomain::randomFill
virtual escript::Data randomFill(const escript::DataTypes::ShapeType &shape, const escript::FunctionSpace &what, long seed, const boost::python::tuple &filter) const
Fills the data object with filtered random values.
Definition: finley/src/FinleyDomain.cpp:2768
escript::Data::isComplex
bool isComplex() const
True if components of this data are stored as complex.
Definition: Data.cpp:1164
finley::FinleyDomain::addPDEToLumpedSystem
virtual void addPDEToLumpedSystem(escript::Data &mat, const escript::Data &D, const escript::Data &d, const escript::Data &d_dirac, bool useHRZ) const
adds a PDE onto the lumped stiffness matrix matrix
Definition: finley/src/FinleyDomain.cpp:1172
finley::FinleyDomain::setToX
virtual void setToX(escript::Data &arg) const
copies the location of data points into arg. The domain of arg has to match this. has to be implement...
Definition: finley/src/FinleyDomain.cpp:1646
escript::FunctionSpace::getSize
escript::Data getSize() const
Returns the sample size (e.g. the diameter of elements, radius of particles).
Definition: FunctionSpace.cpp:294
finley::FinleyDomain::joinFaces
void joinFaces(double safetyFactor, double tolerance, bool optimize)
Definition: Mesh_joinFaces.cpp:49
finley::FinleyDomain
FinleyDomain implements the AbstractContinuousDomain interface for the Finley library.
Definition: finley/src/FinleyDomain.h:139
finley::FinleyDomain::relabelElementNodes
void relabelElementNodes(const IndexVector &newNode, index_t offset)
Definition: finley/src/FinleyDomain.cpp:203
finley::Assemble_NodeCoordinates
void Assemble_NodeCoordinates(const NodeFile *nodes, escript::Data &x)
copies node coordinates into expanded Data object x
Definition: finley/src/Assemble_NodeCoordinates.cpp:48
finley::SMT_COMPLEX
Definition: finley/src/FinleyDomain.h:130
finley::FaceElements
Definition: Finley.h:82
finley::NodeFile::globalReducedNodesIndex
index_t * globalReducedNodesIndex
Definition: finley/src/NodeFile.h:180
escript::DataTypes::real_t
double real_t
type of all real-valued scalars in escript
Definition: DataTypes.h:76
finley::FinleyDomain::approximationOrder
int approximationOrder
Definition: finley/src/FinleyDomain.h:933
REGISTER_ESCRIPT_EXCEPTION_TRANSLATORS
#define REGISTER_ESCRIPT_EXCEPTION_TRANSLATORS
Definition: ExceptionTranslators.h:25
finley::FinleyDomain::createRec8
static escript::Domain_ptr createRec8(dim_t NE0, dim_t NE1, double l0, double l1, bool periodic0, bool periodic1, int order, int reducedOrder, bool useElementsOnFace, bool useFullElementOrder, bool useMacroElements, bool optimize, escript::JMPI jmpi)
Creates a 2-dimensional rectangular domain with second order (Rec8 or Rec9) elements in the rectangle...
Definition: Mesh_rec8.cpp:25
finley::FinleyDomain::m_mpiInfo
escript::JMPI m_mpiInfo
MPI information.
Definition: finley/src/FinleyDomain.h:930
finley::FinleyDomain::functionSpaceTypeAsString
virtual std::string functionSpaceTypeAsString(int functionSpaceType) const
Return a description for the given function space type code.
Definition: finley/src/FinleyDomain.cpp:932
weipa::FinleyDomain::writeToSilo
virtual bool writeToSilo(DBfile *dbfile, const std::string &pathInSilo, const StringVec &labels, const StringVec &units, bool writeMeshData)
Writes the domain to a Silo file.
Definition: weipa/src/FinleyDomain.cpp:506
escript::reducedContinuousFunction
FunctionSpace reducedContinuousFunction(const AbstractDomain &domain)
Return a continuous with reduced order FunctionSpace (overlapped node values on reduced element order...
Definition: FunctionSpaceFactory.cpp:49
finley::Rec9
Definition: ReferenceElements.h:48
weipa::FinleyDomain::~FinleyDomain
virtual ~FinleyDomain()
Definition: weipa/src/FinleyDomain.cpp:78
finley::FinleyDomain::m_tagMap
TagMap m_tagMap
the tag map mapping names to tag keys
Definition: finley/src/FinleyDomain.h:948
FINLEY_REDUCED_FACE_ELEMENTS
#define FINLEY_REDUCED_FACE_ELEMENTS
Definition: Finley.h:71
finley::FinleyDomain::setTags
virtual void setTags(int functionSpaceType, int newTag, const escript::Data &mask) const
assigns new tag newTag to all samples of functionspace with a positive value of mask for any its samp...
Definition: finley/src/FinleyDomain.cpp:2569
finley::FinleyDomain::updateTagList
void updateTagList()
regenerates list of tags in use for node file and element files
Definition: finley/src/FinleyDomain.cpp:3070
finley::NodeFile::createDenseDOFLabeling
dim_t createDenseDOFLabeling()
Definition: finley/src/NodeFile.cpp:537
finley::FinleyDomain::getSolutionCode
virtual int getSolutionCode() const
Return a Solution code.
Definition: finley/src/FinleyDomain.cpp:1030
paso::SystemMatrix
this class holds a (distributed) stiffness matrix
Definition: SystemMatrix.h:60
finley::FinleyDomain::borrowListOfTagsInUse
virtual const int * borrowListOfTagsInUse(int functionSpaceCode) const
Definition: finley/src/FinleyDomain.cpp:2671
finley::Assemble_integrate
void Assemble_integrate(const NodeFile *nodes, const ElementFile *elements, const escript::Data &data, Scalar *integrals)
integrates data on quadrature points
Definition: finley/src/Assemble_integrate.cpp:48
paso::Pattern::fromIndexListArray
static Pattern_ptr fromIndexListArray(dim_t n0, dim_t n, const escript::IndexList *index_list_array, index_t range_min, index_t range_max, index_t index_offset)
Definition: Pattern.cpp:101
finley::NodeFile::globalDegreesOfFreedom
index_t * globalDegreesOfFreedom
Definition: finley/src/NodeFile.h:172
weipa::FinleyDomain::removeGhostZones
virtual void removeGhostZones(int ownIndex)
Removes 'ghost' elements and nodes.
Definition: weipa/src/FinleyDomain.cpp:487
escript::SO_METHOD_DIRECT
Definition: SolverOptions.h:125
finley::FinleyDomain::getTransportTypeId
virtual int getTransportTypeId(int solver, int preconditioner, int package, bool symmetry) const
return the identifier of the transport problem type to be used when a particular solver,...
Definition: finley/src/FinleyDomain.cpp:2360
FINLEY_REDUCED_ELEMENTS
#define FINLEY_REDUCED_ELEMENTS
Definition: Finley.h:70
finley::FinleyDomain::glueFaces
void glueFaces(double safetyFactor, double tolerance, bool optimize)
Definition: Mesh_glueFaces.cpp:49
finley::FinleyDomain::borrowSampleReferenceIDs
const index_t * borrowSampleReferenceIDs(int functionSpaceType) const
Return the reference number of the given sample number.
Definition: finley/src/FinleyDomain.cpp:2488
finley::FinleyDomain::getFunctionOnContactZeroCode
virtual int getFunctionOnContactZeroCode() const
Return a FunctionOnContactZero code.
Definition: finley/src/FinleyDomain.cpp:1010
finley::NodeFile::getNumReducedNodes
dim_t getNumReducedNodes() const
returns the number of reduced order FEM nodes (on this rank)
Definition: finley/src/NodeFile.h:260
FINLEY_REDUCED_CONTACT_ELEMENTS_1
#define FINLEY_REDUCED_CONTACT_ELEMENTS_1
Definition: Finley.h:72
finley::FinleyDomain::getReducedFunctionOnContactOneCode
virtual int getReducedFunctionOnContactOneCode() const
Return a FunctionOnContactOne code with reduced integration order.
Definition: finley/src/FinleyDomain.cpp:1025
weipa::FinleyDomain::getElementsForFunctionSpace
virtual ElementData_ptr getElementsForFunctionSpace(int fsCode) const
Returns the element data for given function space code.
Definition: weipa/src/FinleyDomain.cpp:252
finley::FinleyDomain::setToIntegrals
virtual void setToIntegrals(std::vector< escript::DataTypes::real_t > &integrals, const escript::Data &arg) const
copies the integrals of the function defined by arg into integrals. arg has to be defined on this.
finley::FinleyDomain::operator==
virtual bool operator==(const escript::AbstractDomain &other) const
comparison operators
Definition: finley/src/FinleyDomain.cpp:2282
finley::const_ReferenceElementSet_ptr
boost::shared_ptr< const ReferenceElementSet > const_ReferenceElementSet_ptr
Definition: ReferenceElementSets.h:92
finley::FinleyDomain::canTag
virtual bool canTag(int functionSpaceCode) const
Checks if this domain allows tags for the specified functionSpace code.
Definition: finley/src/FinleyDomain.cpp:2717
weipa::FinleyDomain::faces
FinleyElements_ptr faces
Definition: weipa/src/FinleyDomain.h:72
finley::NodeFile::assignMPIRankToDOFs
void assignMPIRankToDOFs(std::vector< int > &mpiRankOfDOF, const IndexVector &distribution)
Definition: finley/src/NodeFile.cpp:450
weipa::FinleyDomain::getMeshNames
virtual StringVec getMeshNames() const
Returns the names of all meshes within this domain.
Definition: weipa/src/FinleyDomain.cpp:333
finley::NodeFile::Tag
int * Tag
Tag[i] is the tag of node i.
Definition: finley/src/NodeFile.h:165
finley::FinleyDomain::getSystemMatrixTypeId
virtual int getSystemMatrixTypeId(const boost::python::object &options) const
return the identifier of the matrix type to be used for the global stiffness matrix when a particular...
Definition: finley/src/FinleyDomain.cpp:2300
weipa::VisItControl::initialized
bool initialized
Definition: VisItControl.cpp:63
finley::ReducedContactElementsOne
Definition: Finley.h:88
escript::SolverBuddy::getPackage
SolverOptions getPackage() const
Definition: SolverOptions.cpp:471
finley::NodeFile::getFirstNode
index_t getFirstNode() const
Definition: finley/src/NodeFile.h:215
weipa::FinleyDomain::nodes
FinleyNodes_ptr nodes
Definition: weipa/src/FinleyDomain.h:70
finley::Tet10
Definition: ReferenceElements.h:52
escript::continuousFunction
FunctionSpace continuousFunction(const AbstractDomain &domain)
Create function space objects.
Definition: FunctionSpaceFactory.cpp:43
finley::ElementFile::Tag
int * Tag
Tag[i] is the tag of element i.
Definition: finley/src/ElementFile.h:141
weipa::FinleyDomain::getDataVarByName
virtual DataVar_ptr getDataVarByName(const std::string &name) const
Creates and returns a variable with domain data.
Definition: weipa/src/FinleyDomain.cpp:371
finley::FinleyDomain::getTagFromSampleNo
int getTagFromSampleNo(int functionSpaceType, index_t sampleNo) const
Return the tag key for the given sample number.
Definition: finley/src/FinleyDomain.cpp:2529
escript::NotImplementedError
An exception class for features which are not (yet) implemented.
Definition: EsysException.h:91
finley::FinleyException
Definition: FinleyException.h:38
finley::FinleyDomain::addPDEToSystem
virtual void addPDEToSystem(escript::AbstractSystemMatrix &mat, escript::Data &rhs, const escript::Data &A, const escript::Data &B, const escript::Data &C, const escript::Data &D, const escript::Data &X, const escript::Data &Y, const escript::Data &d, const escript::Data &y, const escript::Data &d_contact, const escript::Data &y_contact, const escript::Data &d_dirac, const escript::Data &y_dirac) const
adds a PDE onto the stiffness matrix mat and a rhs
Definition: finley/src/FinleyDomain.cpp:1139
FINLEY_NODES
#define FINLEY_NODES
Definition: Finley.h:62
finley::Tet10Macro
Definition: ReferenceElements.h:112
dudley::DudleyDomain::getElements
ElementFile * getElements() const
returns a pointer to this domain's element file
Definition: DudleyDomain.h:224
weipa::FinleyDomain::reorderGhostZones
virtual void reorderGhostZones(int ownIndex)
Reorders elements so that 'ghost' elements (i.e. those that do not belong to ownIndex) appear last.
Definition: weipa/src/FinleyDomain.cpp:469
finley::NodeFile::nodesDistribution
escript::Distribution_ptr nodesDistribution
MPI distribution of nodes.
Definition: finley/src/NodeFile.h:185
paso::SystemMatrix_ptr
boost::shared_ptr< SystemMatrix > SystemMatrix_ptr
Definition: SystemMatrix.h:53
finley::FinleyDomain::integrationOrder
int integrationOrder
Definition: finley/src/FinleyDomain.h:935
paso::TransportProblem::borrowMassMatrix
SystemMatrix_ptr borrowMassMatrix() const
Definition: Transport.h:69
escript::DataTypes::DataVectorAlt< real_t >
escript::SolverBuddy::getSolverMethod
SolverOptions getSolverMethod() const
Definition: SolverOptions.cpp:408
escript::randomFillArray
void randomFillArray(long seed, double *array, size_t n)
Definition: Random.cpp:74
finley::FinleyDomain::m_faceElements
ElementFile * m_faceElements
the table of face elements
Definition: finley/src/FinleyDomain.h:942
escript::AbstractDomain::StatusType
int StatusType
Definition: AbstractDomain.h:65
paso::SystemMatrixPattern_ptr
boost::shared_ptr< SystemMatrixPattern > SystemMatrixPattern_ptr
Definition: SystemMatrixPattern.h:52
finley::NodeFile::reducedNodesId
index_t * reducedNodesId
Definition: finley/src/NodeFile.h:202
finley::NodeFile::globalReducedDOFIndex
index_t * globalReducedDOFIndex
Definition: finley/src/NodeFile.h:177
finley::FinleyDomain::probeInterpolationOnDomain
virtual bool probeInterpolationOnDomain(int functionSpaceType_source, int functionSpaceType_target) const
True if interpolation is possible from source to target.
Definition: finley/src/FinleyDomain.cpp:2138
finley::FinleyDomain::showTagNames
virtual std::string showTagNames() const
Returns all tag names in a single string sperated by commas.
Definition: finley/src/FinleyDomain.cpp:2627
finley::ElementFile::createColoring
void createColoring(const IndexVector &dofMap)
Tries to reduce the number of colours used to colour the elements.
Definition: finley/src/ElementFile.cpp:261
DUDLEY_NODES
#define DUDLEY_NODES
Definition: Dudley.h:54
finley::const_ReferenceElement_ptr
boost::shared_ptr< const ReferenceElement > const_ReferenceElement_ptr
Definition: ReferenceElements.h:212
finley::FinleyDomain::getMPISize
virtual int getMPISize() const
returns the number of processors used for this domain
Definition: finley/src/FinleyDomain.h:390
finley::ElementFile::relabelNodes
void relabelNodes(const IndexVector &newNode, index_t offset)
finley::FinleyDomain::getNumberOfTagsInUse
virtual int getNumberOfTagsInUse(int functionSpaceCode) const
returns the number of tags in use and a pointer to an array with the number of tags in use
Definition: finley/src/FinleyDomain.cpp:2640
escript::Domain_ptr
boost::shared_ptr< AbstractDomain > Domain_ptr
Definition: AbstractDomain.h:53
escript::AbstractTransportProblem
Give a short description of what AbstractTransportProblem does.
Definition: AbstractTransportProblem.h:56
finley::ReducedNodes
Definition: Finley.h:79
finley::FinleyDomain::readGmsh
static escript::Domain_ptr readGmsh(escript::JMPI mpiInfo, const std::string &filename, int numDim, int integrationOrder=-1, int reducedIntegrationOrder=-1, bool optimize=false, bool useMacroElements=false)
reads a gmsh mesh file.
Definition: finley/src/Mesh_readGmsh.cpp:1571
escript::SO_PRECONDITIONER_ILUT
Definition: SolverOptions.h:145
finley::FinleyDomain::getSize
virtual escript::Data getSize() const
returns the element size
Definition: finley/src/FinleyDomain.cpp:2483
escript::SolverBuddy::isComplex
bool isComplex() const
Definition: SolverOptions.cpp:637
finley::ElementFile::setTags
void setTags(const int newTag, const escript::Data &mask)
Definition: finley/src/ElementFile.cpp:228
finley::FinleyDomain::getApproximationOrder
virtual int getApproximationOrder(int functionSpaceCode) const
returns the approximation order used for a function space functionSpaceCode
Definition: finley/src/FinleyDomain.cpp:2741
finley::ElementFile::Nodes
index_t * Nodes
Definition: finley/src/ElementFile.h:156
escript::FunctionSpace
Definition: FunctionSpace.h:47
finley::FinleyDomain::createHex20
static escript::Domain_ptr createHex20(dim_t NE0, dim_t NE1, dim_t NE2, double l0, double l1, double l2, bool periodic0, bool periodic1, bool periodic2, int order, int reducedOrder, bool useElementsOnFace, bool useFullElementOrder, bool useMacroElements, bool optimize, escript::JMPI jmpi)
Creates a 3-dimensional rectangular domain with second order (Hex20 or Hex27) elements.
Definition: Mesh_hex20.cpp:37
finley::ElementFile::getNodeRange
std::pair< index_t, index_t > getNodeRange() const
Definition: finley/src/ElementFile.h:186
finley::FinleyDomain::m_nodes
NodeFile * m_nodes
the table of the nodes
Definition: finley/src/FinleyDomain.h:938
finley::Points
Definition: Finley.h:84
finley::ElementFile::distributeByRankOfDOF
void distributeByRankOfDOF(const std::vector< int > &mpiRankOfDOF, index_t *nodesId)
redistributes the elements including overlap by rank
Definition: finley/src/ElementFile.cpp:342
finley::SystemMatrixType
SystemMatrixType
Definition: finley/src/FinleyDomain.h:127
finley::FinleyDomain::resolveNodeIds
void resolveNodeIds()
Definition: finley/src/FinleyDomain.cpp:2970
escript::Data::getFunctionSpace
const FunctionSpace & getFunctionSpace() const
Return the function space.
Definition: Data.h:462
FINLEY_REDUCED_DEGREES_OF_FREEDOM
#define FINLEY_REDUCED_DEGREES_OF_FREEDOM
Definition: Finley.h:68
finley::NodeFile::getNumReducedDegreesOfFreedom
dim_t getNumReducedDegreesOfFreedom() const
returns the number of reduced order degrees of freedom (on this rank)
Definition: finley/src/NodeFile.h:270
weipa::DataVar_ptr
boost::shared_ptr< DataVar > DataVar_ptr
Definition: weipa.h:64
weipa
Definition: DataVar.cpp:50
finley::FinleyDomain::getElements
ElementFile * getElements() const
returns a pointer to this domain's element file
Definition: finley/src/FinleyDomain.h:342
finley::Rec9Macro
Definition: ReferenceElements.h:111
finley::FinleyDomain::getDiracDeltaFunctionsCode
virtual int getDiracDeltaFunctionsCode() const
Return a DiracDeltaFunctions code.
Definition: finley/src/FinleyDomain.cpp:1040
escript::FunctionSpace::getDomain
const_Domain_ptr getDomain() const
Returns the function space domain.
Definition: FunctionSpace.cpp:102
MPI_INT
#define MPI_INT
Definition: EsysMPI.h:45
escript::DataTypes::index_t_max
index_t index_t_max()
Returns the maximum finite value for the index_t type.
Definition: DataTypes.h:105
finley::Hex27
Definition: ReferenceElements.h:56
weipa::VisItControl::initialize
bool initialize(const std::string &simFile, const std::string &comment)
Definition: VisItControl.cpp:203
finley::FinleyDomain::getDescription
virtual std::string getDescription() const
Return a description for this domain.
Definition: finley/src/FinleyDomain.cpp:927
finley::FinleyDomain::findMatchingFaces
void findMatchingFaces(double safetyFactor, double tolerance, int *numPairs, int *elem0, int *elem1, int *matchingNodes) const
Definition: Mesh_findMatchingFaces.cpp:86
finley::FinleyDomain::setToSize
virtual void setToSize(escript::Data &out) const
copies the size of samples into out. The actual function space to be considered is defined by out....
Definition: finley/src/FinleyDomain.cpp:1820
finley::SMT_UNROLL
Definition: finley/src/FinleyDomain.h:131
MPI_MAX
#define MPI_MAX
Definition: EsysMPI.h:53
weipa::FinleyDomain::siloPath
std::string siloPath
Definition: weipa/src/FinleyDomain.h:74
finley::FinleyDomain::m_points
ElementFile * m_points
the table of points (treated as elements of dimension 0)
Definition: finley/src/FinleyDomain.h:946
finley::FinleyDomain::addPDEToTransportProblem
virtual void addPDEToTransportProblem(escript::AbstractTransportProblem &tp, escript::Data &source, const escript::Data &M, const escript::Data &A, const escript::Data &B, const escript::Data &C, const escript::Data &D, const escript::Data &X, const escript::Data &Y, const escript::Data &d, const escript::Data &y, const escript::Data &d_contact, const escript::Data &y_contact, const escript::Data &d_dirac, const escript::Data &y_dirac) const
adds a PDE onto a transport problem
Definition: finley/src/FinleyDomain.cpp:1210
finley::NodeFile::getNumNodes
dim_t getNumNodes() const
returns the number of FEM nodes (on this rank)
Definition: finley/src/NodeFile.h:255
finley::FinleyDomain::getReducedFunctionOnContactZeroCode
virtual int getReducedFunctionOnContactZeroCode() const
Return a FunctionOnContactZero code with reduced integration order.
Definition: finley/src/FinleyDomain.cpp:1015
weipa::FinleyDomain::contacts
FinleyElements_ptr contacts
Definition: weipa/src/FinleyDomain.h:73
weipa::ZONE_CENTERED
Definition: DomainChunk.h:32
finley::NodeFile::createNodeMappings
void createNodeMappings(const IndexVector &indexReducedNodes, const IndexVector &dofDistribution, const IndexVector &nodeDistribution)
Definition: finley/src/NodeFile.cpp:1016
finley::FinleyDomain::getReducedFunctionCode
virtual int getReducedFunctionCode() const
Return a function with reduced integration order FunctionSpace code.
Definition: finley/src/FinleyDomain.cpp:995
escript::FunctionSpace::getNormal
escript::Data getNormal() const
Returns the surface normal field.
Definition: FunctionSpace.cpp:285
finley::NodeFile::Coordinates
double * Coordinates
Coordinates[INDEX2(k,i,numDim)] is the k-th coordinate of node i.
Definition: finley/src/NodeFile.h:174
finley::FinleyDomain::getReducedFunctionOnBoundaryCode
virtual int getReducedFunctionOnBoundaryCode() const
Return a function on boundary with reduced integration order FunctionSpace code.
Definition: finley/src/FinleyDomain.cpp:1005
finley::FinleyDomain::probeInterpolationAcross
virtual bool probeInterpolationAcross(int functionSpaceType_source, const escript::AbstractDomain &targetDomain, int functionSpaceType_target) const
determines whether interpolation from source to target is possible.
Definition: finley/src/FinleyDomain.cpp:2276
finley::ElementFile::numElements
dim_t numElements
number of elements
Definition: finley/src/ElementFile.h:134
finley::FinleyDomain::getFunctionCode
virtual int getFunctionCode() const
Return a function FunctionSpace code.
Definition: finley/src/FinleyDomain.cpp:990
finley::ElementFile::Owner
int * Owner
Owner[i] contains the rank that owns element i.
Definition: finley/src/ElementFile.h:144
escript::Data
Data represents a collection of datapoints.
Definition: Data.h:63
paso::TransportProblem_ptr
boost::shared_ptr< TransportProblem > TransportProblem_ptr
Definition: Transport.h:31
paso::util::l2
double l2(dim_t n, const double *x, escript::JMPI mpiinfo)
returns the global L2 norm of x
Definition: PasoUtil.cpp:527
paso::TransportProblem::borrowTransportMatrix
SystemMatrix_ptr borrowTransportMatrix() const
Definition: Transport.h:64
finley::NodeFile::getLastNode
index_t getLastNode() const
Definition: finley/src/NodeFile.h:220
weipa::FinleyElements_ptr
boost::shared_ptr< FinleyElements > FinleyElements_ptr
Definition: FinleyElements.h:63
finley::FinleyDomain::getStatus
virtual StatusType getStatus() const
Returns a status indicator of the domain. The status identifier should be unique over the live time i...
Definition: finley/src/FinleyDomain.cpp:2736
finley::FinleyDomain::getFunctionOnBoundaryCode
virtual int getFunctionOnBoundaryCode() const
Return a function on boundary FunctionSpace code.
Definition: finley/src/FinleyDomain.cpp:1000
escript::AbstractSystemMatrix::getPtr
ASM_ptr getPtr()
Returns smart pointer which is managing this object. If one does not exist yet it creates one.
Definition: AbstractSystemMatrix.cpp:54
finley::FinleyDomain::Print_Mesh_Info
void Print_Mesh_Info(bool full=false) const
Definition: finley/src/Mesh_write.cpp:147
escript::FunctionSpace::getX
escript::Data getX() const
Returns the spatial locations of the data points.
Definition: FunctionSpace.cpp:228
escript::DataTypes::dim_t
index_t dim_t
Definition: DataTypes.h:90
escript::DataTypes::ShapeType
std::vector< int > ShapeType
The shape of a single datapoint.
Definition: DataTypes.h:68
weipa::FinleyDomain::initFromFile
virtual bool initFromFile(const std::string &filename)
Reads the domain from a dump file.
Definition: weipa/src/FinleyDomain.cpp:183
finley::ContactElementsZero
Definition: Finley.h:85
escript::JMPI
boost::shared_ptr< JMPI_ > JMPI
Definition: EsysMPI.h:71
FINLEY_FACE_ELEMENTS
#define FINLEY_FACE_ELEMENTS
Definition: Finley.h:64
finley::FinleyDomain::isCellOriented
virtual bool isCellOriented(int functionSpaceCode) const
returns true if data on this domain and a function space of type functionSpaceCode has to considered ...
Definition: finley/src/FinleyDomain.cpp:1992
finley::ReducedDegreesOfFreedom
Definition: Finley.h:77
escript::ATP_ptr
boost::shared_ptr< AbstractTransportProblem > ATP_ptr
Definition: AbstractTransportProblem.h:173
escript::AbstractSystemMatrix
Base class for escript system matrices.
Definition: AbstractSystemMatrix.h:55
finley::FinleyDomain::getFaceElements
ElementFile * getFaceElements() const
returns a pointer to this domain's face element file
Definition: finley/src/FinleyDomain.h:354
weipa::FinleyDomain::cells
FinleyElements_ptr cells
Definition: weipa/src/FinleyDomain.h:71
finley::DegreesOfFreedom
Definition: Finley.h:76
finley::NodeFile::borrowGlobalNodesIndex
const index_t * borrowGlobalNodesIndex() const
Definition: finley/src/NodeFile.h:230
finley::FinleyDomain::getDataShape
virtual std::pair< int, dim_t > getDataShape(int functionSpaceCode) const
Return the number of data points per sample, and the number of samples as a pair.
Definition: finley/src/FinleyDomain.cpp:1057
finley::NodeFile::createDenseReducedLabeling
dim_t createDenseReducedLabeling(const std::vector< short > &reducedMask, bool useNodes)
Definition: finley/src/NodeFile.cpp:714
finley::Tri6Macro
Definition: ReferenceElements.h:110
finley::FinleyDomain::createColoring
void createColoring(const IndexVector &dofMap)
tries to reduce the number of colours for all element files
Definition: finley/src/FinleyDomain.cpp:3052
finley::Hex27Macro
Definition: ReferenceElements.h:113
IndexList.h
finley::FinleyDomain::setToIntegralsWorker
void setToIntegralsWorker(std::vector< Scalar > &integrals, const escript::Data &arg) const
Definition: finley/src/FinleyDomain.cpp:1712
finley::FinleyDomain::addDiracPoints
void addDiracPoints(const std::vector< double > &points, const std::vector< int > &tags)
adds Dirac delta points. Do NOT call this at any time other than construction! Using them later creat...
Definition: Mesh_addPoints.cpp:47
finley::FinleyDomain::interpolateOnDomain
virtual void interpolateOnDomain(escript::Data &target, const escript::Data &source) const
interpolates data given on source onto target where source and target have to be given on the same do...
Definition: finley/src/FinleyDomain.cpp:1251
weipa::ElementData_ptr
boost::shared_ptr< ElementData > ElementData_ptr
Definition: weipa.h:66
FINLEY_DEGREES_OF_FREEDOM
#define FINLEY_DEGREES_OF_FREEDOM
Definition: Finley.h:61
finley::ElementFile::Color
index_t * Color
Definition: finley/src/ElementFile.h:162
finley::FinleyDomain::m_name
std::string m_name
domain description
Definition: finley/src/FinleyDomain.h:932
finley::FinleyDomain::setToGradient
virtual void setToGradient(escript::Data &grad, const escript::Data &arg) const
copies the gradient of arg into grad. The actual function space to be considered for the gradient is ...
Definition: finley/src/FinleyDomain.cpp:1754
finley::FinleyDomain::getNodes
NodeFile * getNodes() const
returns a pointer to this domain's node file
Definition: finley/src/FinleyDomain.h:330
weipa::NODE_CENTERED
Definition: DomainChunk.h:31
finley::readGmsh_driver
Domain_ptr readGmsh_driver(const bp::list &args)
Definition: finley/src/DomainFactory.cpp:984
finley::FinleyDomain::getDim
virtual int getDim() const
returns the dimensionality of this domain
Definition: finley/src/FinleyDomain.h:559
finley::FinleyDomain::setToNormal
virtual void setToNormal(escript::Data &out) const
copies the surface normals at data points into out. The actual function space to be considered is def...
Definition: finley/src/FinleyDomain.cpp:1665
finley::FinleyDomain::optimizeElementOrdering
void optimizeElementOrdering()
redistributes elements to minimize communication during assemblage
Definition: finley/src/FinleyDomain.cpp:3061
FINLEY_ELEMENTS
#define FINLEY_ELEMENTS
Definition: Finley.h:63
finley::FinleyDomain::reducedApproximationOrder
int reducedApproximationOrder
Definition: finley/src/FinleyDomain.h:934
finley::NodeFile::Id
index_t * Id
Id[i] is the unique ID number of FEM node i.
Definition: finley/src/NodeFile.h:163
finley::FinleyDomain::commonFunctionSpace
bool commonFunctionSpace(const std::vector< int > &fs, int &resultcode) const
given a vector of FunctionSpace typecodes, pass back a code which then can all be interpolated to.
Definition: finley/src/FinleyDomain.cpp:2017
finley::FinleyDomain::getFunctionOnContactOneCode
virtual int getFunctionOnContactOneCode() const
Return a FunctionOnContactOne code.
Definition: finley/src/FinleyDomain.cpp:1020
DUDLEY_REDUCED_ELEMENTS
#define DUDLEY_REDUCED_ELEMENTS
Definition: Dudley.h:58
finley::ElementFile::Id
index_t * Id
Definition: finley/src/ElementFile.h:138
weipa::FinleyDomain::FinleyDomain
FinleyDomain()
Definition: weipa/src/FinleyDomain.cpp:57
finley::NodeFile::createDenseNodeLabeling
dim_t createDenseNodeLabeling(IndexVector &nodeDistribution, const IndexVector &dofDistribution)
Definition: finley/src/NodeFile.cpp:600
finley::ReferenceElementInfo
this struct holds the definition of the reference element
Definition: ReferenceElements.h:119
finley::FinleyDomain::FunctionSpaceNamesMapType
std::map< int, std::string > FunctionSpaceNamesMapType
Definition: finley/src/FinleyDomain.h:554
finley::FinleyDomain::FinleyDomain
FinleyDomain(const std::string &name, int numDim, escript::JMPI jmpi)
Constructor for FinleyDomain.
Definition: finley/src/FinleyDomain.cpp:73
finley::FinleyDomain::getReducedContinuousFunctionCode
virtual int getReducedContinuousFunctionCode() const
Return a continuous on reduced order nodes FunctionSpace code.
Definition: finley/src/FinleyDomain.cpp:985
finley::FinleyDomain::addPDEToRHS
virtual void addPDEToRHS(escript::Data &rhs, const escript::Data &X, const escript::Data &Y, const escript::Data &y, const escript::Data &y_contact, const escript::Data &y_dirac) const
adds a PDE onto the stiffness matrix mat and a rhs
Definition: finley/src/FinleyDomain.cpp:1186
dudley::DudleyDomain::getNodes
NodeFile * getNodes() const
returns a pointer to this domain's node file
Definition: DudleyDomain.h:212
finley::NodeFile::status
int status
Definition: finley/src/NodeFile.h:208
weipa::FinleyDomain::cleanup
void cleanup()
Definition: weipa/src/FinleyDomain.cpp:86
finley::NodeFile::setCoordinates
void setCoordinates(const escript::Data &newX)
copies the array newX into this->coordinates
Definition: finley/src/NodeFile.cpp:254
finley::FinleyDomain::m_functionSpaceTypeNames
static FunctionSpaceNamesMapType m_functionSpaceTypeNames
Definition: finley/src/FinleyDomain.h:961
escript::SO_PRECONDITIONER_AMG
Definition: SolverOptions.h:142
DUDLEY_ELEMENTS
#define DUDLEY_ELEMENTS
Definition: Dudley.h:55
finley::joinFaces
Domain_ptr joinFaces(const bp::list &meshList, double safetyFactor, double tolerance, bool optimize)
Definition: finley/src/DomainFactory.cpp:1299
finley::FinleyDomain::reducedIntegrationOrder
int reducedIntegrationOrder
Definition: finley/src/FinleyDomain.h:936
finley::FinleyDomain::operator!=
virtual bool operator!=(const escript::AbstractDomain &other) const
Return true if given domains are not equal.
Definition: finley/src/FinleyDomain.cpp:2295
paso::TransportProblem
Definition: Transport.h:35
finley::SMT_TRILINOS
Definition: finley/src/FinleyDomain.h:129
paso::TransportProblem::getTypeId
static int getTypeId(int solver, int preconditioner, int package, bool symmetry, const escript::JMPI &mpi_info)
Definition: Transport.h:94
finley::FinleyDomain::getTagMap
const TagMap & getTagMap() const
returns a reference to the tag name->value map
Definition: finley/src/FinleyDomain.h:861
finley::Assemble_getSize
void Assemble_getSize(const NodeFile *nodes, const ElementFile *elements, escript::Data &size)
Definition: finley/src/Assemble_getSize.cpp:48
finley::SMT_PASO
Definition: finley/src/FinleyDomain.h:128
escript::SolverBuddy::isSymmetric
bool isSymmetric() const
Definition: SolverOptions.cpp:647
DUDLEY_REDUCED_FACE_ELEMENTS
#define DUDLEY_REDUCED_FACE_ELEMENTS
Definition: Dudley.h:59
finley::ReducedFaceElements
Definition: Finley.h:83
finley::FinleyDomain::m_contactElements
ElementFile * m_contactElements
the table of contact elements
Definition: finley/src/FinleyDomain.h:944
finley::FinleyDomain::getMPI
virtual escript::JMPI getMPI() const
returns a reference to the MPI information wrapper for this domain
Definition: finley/src/FinleyDomain.h:384
escript::SolverBuddy::getPreconditioner
SolverOptions getPreconditioner() const
Definition: SolverOptions.cpp:352
finley::FinleyDomain::preferredInterpolationOnDomain
virtual signed char preferredInterpolationOnDomain(int functionSpaceType_source, int functionSpaceType_target) const
Preferred direction of interpolation. If you really need to test for a particular direction,...
Definition: finley/src/FinleyDomain.cpp:2265
finley::FinleyDomain::getContactElements
ElementFile * getContactElements() const
returns a pointer to this domain's contact element file
Definition: finley/src/FinleyDomain.h:366
finley::Tri6
Definition: ReferenceElements.h:43
weipa::FinleyDomain::getElementsByName
virtual ElementData_ptr getElementsByName(const std::string &name) const
Returns element data with given name.
Definition: weipa/src/FinleyDomain.cpp:432
MPI_MIN
#define MPI_MIN
Definition: EsysMPI.h:52
escript::isDirectSolver
bool isDirectSolver(const SolverOptions &method)
returns true if the passed solver method refers to a direct solver type
Definition: SolverOptions.h:155
finley::FinleyDomain::interpolateAcross
virtual void interpolateAcross(escript::Data &target, const escript::Data &source) const
interpolates data given on source onto target where source and target are given on different domains.
Definition: finley/src/FinleyDomain.cpp:1689
finley::FinleyDomain::getNormal
virtual escript::Data getNormal() const
returns boundary normals at the quadrature point on the face elements
Definition: finley/src/FinleyDomain.cpp:2478
finley::FinleyDomain::read
static escript::Domain_ptr read(escript::JMPI mpiInfo, const std::string &fileName, int integrationOrder=-1, int reducedIntegrationOrder=-1, bool optimize=false)
reads a mesh from a fly file. For MPI parallel runs fans out the mesh to multiple processes.
Definition: finley/src/Mesh_read.cpp:152
finley::FinleyDomain::onMasterProcessor
virtual bool onMasterProcessor() const
returns true if on MPI processor 0, else false
Definition: finley/src/FinleyDomain.h:408
finley::NodeFile::degreesOfFreedomDistribution
escript::Distribution_ptr degreesOfFreedomDistribution
Definition: finley/src/NodeFile.h:187
finley::FinleyDomain::getContinuousFunctionCode
virtual int getContinuousFunctionCode() const
Return a continuous FunctionSpace code.
Definition: finley/src/FinleyDomain.cpp:980
finley::FinleyDomain::ownSample
virtual bool ownSample(int fsCode, index_t id) const
Definition: finley/src/FinleyDomain.cpp:1871
finley::NodeFile::getDOFRange
std::pair< index_t, index_t > getDOFRange() const
Definition: finley/src/NodeFile.cpp:227
finley::FinleyDomain::dump
void dump(const std::string &fileName) const
dumps the mesh to a file with the given name.
Definition: finley/src/FinleyDomain.cpp:564
finley::Assemble_LumpedSystem
void Assemble_LumpedSystem(const NodeFile *nodes, const ElementFile *elements, escript::Data &lumpedMat, const escript::Data &D, bool useHRZ)
Definition: finley/src/Assemble_LumpedSystem.cpp:54
escript::RuntimeErrorTranslator
void RuntimeErrorTranslator(const EsysException &e)
Function which translates an EsysException into a python RuntimeError.
Definition: ExceptionTranslators.cpp:49
escript::DataTypes::index_t
int index_t
type for array/matrix indices used both globally and on each rank
Definition: DataTypes.h:85
finley::FinleyDomain::load
static escript::Domain_ptr load(const std::string &filename)
recovers domain from a dump file
Definition: finley/src/DomainFactory.cpp:490
finley::Line3Macro
Definition: ReferenceElements.h:109
finley::NodeFile::getGlobalNumNodes
dim_t getGlobalNumNodes() const
Definition: finley/src/NodeFile.h:225
finley::glueFaces
Domain_ptr glueFaces(const bp::list &meshList, double safetyFactor, double tolerance, bool optimize)
Definition: finley/src/DomainFactory.cpp:1287
finley::FinleyDomain::setElements
void setElements(ElementFile *elements)
replaces the element file by elements
Definition: finley/src/FinleyDomain.cpp:122
finley::NodeFile
Definition: finley/src/NodeFile.h:40
finley::FinleyDomain::getPoints
ElementFile * getPoints() const
returns a pointer to this domain's point (nodal) element file
Definition: finley/src/FinleyDomain.h:378
finley::FinleyDomain::isValidTagName
virtual bool isValidTagName(const std::string &name) const
Returns true if name is a defined tag name.
Definition: finley/src/FinleyDomain.cpp:2622
finley::FinleyDomain::getMPIRank
virtual int getMPIRank() const
returns the number MPI rank of this processor
Definition: finley/src/FinleyDomain.h:396
finley::ElementFile::markNodes
void markNodes(std::vector< short > &mask, int offset, bool useLinear)
Definition: finley/src/ElementFile.cpp:317
finley::NodeFile::reducedDegreesOfFreedomId
index_t * reducedDegreesOfFreedomId
Definition: finley/src/NodeFile.h:204
finley::FinleyDomain::newTransportProblem
escript::ATP_ptr newTransportProblem(int blocksize, const escript::FunctionSpace &functionspace, int type) const
creates a TransportProblem
Definition: finley/src/FinleyDomain.cpp:1960
finley::Nodes
Definition: Finley.h:78
weipa::FinleyDomain::initialized
bool initialized
Definition: weipa/src/FinleyDomain.h:69
weipa::NodeData_ptr
boost::shared_ptr< NodeData > NodeData_ptr
Definition: weipa.h:68
finley::Assemble_PDE
void Assemble_PDE(const NodeFile *nodes, const ElementFile *elements, escript::ASM_ptr S, escript::Data &F, const escript::Data &A, const escript::Data &B, const escript::Data &C, const escript::Data &D, const escript::Data &X, const escript::Data &Y)
Definition: finley/src/Assemble_PDE.cpp:124
FINLEY_REDUCED_CONTACT_ELEMENTS_2
#define FINLEY_REDUCED_CONTACT_ELEMENTS_2
Definition: Finley.h:73
escript::SO_DEFAULT
Definition: SolverOptions.h:107
finley::FinleyDomain::setOrders
void setOrders()
Definition: finley/src/FinleyDomain.cpp:146
weipa::StringVec
std::vector< std::string > StringVec
Definition: weipa.h:60
finley::FinleyDomain::setPoints
void setPoints(ElementFile *elements)
replaces the point element file by elements
Definition: finley/src/FinleyDomain.cpp:140
BOOST_PYTHON_MODULE
BOOST_PYTHON_MODULE(finleycpp)
Definition: finleycpp.cpp:31
escript::FunctionSpace::getTypeCode
int getTypeCode() const
Returns the function space type code.
Definition: FunctionSpace.cpp:94
finley::NodeFile::globalNodesIndex
index_t * globalNodesIndex
assigns each local node a global unique ID in a dense labeling
Definition: finley/src/NodeFile.h:182
finley::ReducedElements
Definition: Finley.h:81
finley::IndexList_insertElementsWithRowRangeNoMainDiagonal
void IndexList_insertElementsWithRowRangeNoMainDiagonal(IndexList *index_list, index_t firstRow, index_t lastRow, ElementFile *elements, index_t *row_map, index_t *col_map)
Definition: finley/src/IndexList.cpp:103
FinleyException.h
dudley::DudleyDomain
DudleyDomain implements the AbstractContinuousDomain interface for the Dudley library.
Definition: DudleyDomain.h:121
escript::function
FunctionSpace function(const AbstractDomain &domain)
Return a function FunctionSpace.
Definition: FunctionSpaceFactory.cpp:55
escript::Vector
Data Vector(double value, const FunctionSpace &what, bool expanded)
Return a Data object containing vector data-points. ie: rank 1 data-points.
Definition: DataFactory.cpp:138
finley::ElementFile::tagsInUse
std::vector< int > tagsInUse
array of tags which are actually used
Definition: finley/src/ElementFile.h:147
finley::FinleyDomain::newSystemMatrix
escript::ASM_ptr newSystemMatrix(int row_blocksize, const escript::FunctionSpace &row_functionspace, int column_blocksize, const escript::FunctionSpace &column_functionspace, int type) const
creates a stiffness matrix and initializes it with zeros
Definition: finley/src/FinleyDomain.cpp:1897
paso::M
static dim_t M
Definition: SparseMatrix_saveHB.cpp:50
finley::ElementFile
Definition: finley/src/ElementFile.h:74
FinleyDomain.h
finley::FinleyDomain::distributeByRankOfDOF
void distributeByRankOfDOF(const IndexVector &distribution)
Definition: finley/src/FinleyDomain.cpp:2839
weipa::FinleyDomain::getVarNames
virtual StringVec getVarNames() const
Returns the names of all 'special' domain variables.
Definition: weipa/src/FinleyDomain.cpp:351
escript::functionOnBoundary
FunctionSpace functionOnBoundary(const AbstractDomain &domain)
Return a function on boundary FunctionSpace.
Definition: FunctionSpaceFactory.cpp:67
finley::FinleyDomain::createMappings
void createMappings(const IndexVector &dofDistribution, const IndexVector &nodeDistribution)
Definition: finley/src/FinleyDomain.cpp:185
finley::FinleyDomain::getMPIComm
MPI_Comm getMPIComm() const
get the communicator for this domain. Returns an integer on non-MPI builds Routine must be implemente...
Definition: finley/src/FinleyDomain.h:410
MPI_Comm
int MPI_Comm
Definition: EsysMPI.h:41
finley::FinleyDomain::optimizeDOFDistribution
void optimizeDOFDistribution(IndexVector &distribution)
Definition: finley/src/Mesh_optimizeDOFDistribution.cpp:78
FINLEY_REDUCED_NODES
#define FINLEY_REDUCED_NODES
Definition: Finley.h:69
paso::Pattern_ptr
boost::shared_ptr< Pattern > Pattern_ptr
Definition: Pattern.h:50
finley::FinleyDomain::setTagMap
virtual void setTagMap(const std::string &name, int tag)
sets a map from a clear tag name to a tag key
Definition: finley/src/FinleyDomain.cpp:2606
finley::Assemble_getNormal
void Assemble_getNormal(const NodeFile *nodes, const ElementFile *elements, escript::Data &normals)
calculates the normal vector at quadrature points on face elements
Definition: finley/src/Assemble_getNormal.cpp:48
weipa::FinleyDomain::getNodes
virtual NodeData_ptr getNodes() const
Returns a pointer to the full nodes.
Definition: weipa/src/FinleyDomain.h:62
finley::NodeFile::getNumDegreesOfFreedom
dim_t getNumDegreesOfFreedom() const
returns the number of degrees of freedom (on this rank)
Definition: finley/src/NodeFile.h:265
finley::FinleyDomain::getTag
virtual int getTag(const std::string &name) const
Return the tag key for tag name.
Definition: finley/src/FinleyDomain.cpp:2611
finley::TagMap
std::map< std::string, int > TagMap
Definition: finley/src/FinleyDomain.h:125
escript::AbstractDomain
Base class for all escript domains.
Definition: AbstractDomain.h:62
finley::FinleyDomain::printElementInfo
void printElementInfo(const ElementFile *e, const std::string &title, const std::string &defaultType, bool full) const
Definition: finley/src/Mesh_write.cpp:52
weipa::FinleyNodes
Stores and manipulates finley mesh nodes.
Definition: FinleyNodes.h:50
weipa::FinleyDomain::getMeshByName
virtual NodeData_ptr getMeshByName(const std::string &name) const
Returns the node mesh with given name.
Definition: weipa/src/FinleyDomain.cpp:454
weipa::FinleyNodes_ptr
boost::shared_ptr< FinleyNodes > FinleyNodes_ptr
Definition: FinleyNodes.h:42
paso::SystemMatrix::getSystemMatrixTypeId
static int getSystemMatrixTypeId(int solver, int preconditioner, int package, bool symmetry, const escript::JMPI &mpi_info)
Definition: SystemMatrix.cpp:545
finley::FinleyDomain::setFaceElements
void setFaceElements(ElementFile *elements)
replaces the face element file by elements
Definition: finley/src/FinleyDomain.cpp:128
finley::NodeFile::degreesOfFreedomId
index_t * degreesOfFreedomId
Definition: finley/src/NodeFile.h:203
weipa::FinleyDomain::getMeshForFunctionSpace
virtual NodeData_ptr getMeshForFunctionSpace(int fsCode) const
Returns the node mesh for given function space code.
Definition: weipa/src/FinleyDomain.cpp:235
escript::IndexList
Definition: escriptcore/src/IndexList.h:28
finley::ElementFile::referenceElementSet
const_ReferenceElementSet_ptr referenceElementSet
the reference element to be used
Definition: finley/src/ElementFile.h:132
escript::Data::getExpandedVectorReference
DataTypes::RealVectorType & getExpandedVectorReference(DataTypes::real_t dummy=0)
Ensures that the Data is expanded and returns its underlying vector Does not check for exclusive writ...
Definition: Data.cpp:5845
finley::ContactElementsOne
Definition: Finley.h:87
escript::SO_PACKAGE_TRILINOS
Definition: SolverOptions.h:116
escript::ASM_ptr
boost::shared_ptr< AbstractSystemMatrix > ASM_ptr
Definition: AbstractSystemMatrix.h:45
finley::NodeFile::gather_global
void gather_global(const index_t *index, const NodeFile *in)
Definition: finley/src/NodeFile.cpp:341
escript::DataTypes::cplx_t
std::complex< real_t > cplx_t
complex data type
Definition: DataTypes.h:79
finley::rectangle_driver
Domain_ptr rectangle_driver(const bp::list &args)
Definition: finley/src/DomainFactory.cpp:1206
ReferenceElements.h
weipa::Centering
Centering
Definition: DomainChunk.h:30
finley::NodeFile::tagsInUse
std::vector< int > tagsInUse
vector of tags which are actually used
Definition: finley/src/NodeFile.h:167
finley::ElementFile::optimizeOrdering
void optimizeOrdering()
reorders the elements so that they are stored close to the nodes
Definition: finley/src/ElementFile.cpp:186
finley::ElementFile::updateTagList
void updateTagList()
Definition: finley/src/ElementFile.h:191
escript::Data::expand
void expand()
Whatever the current Data type make this into a DataExpanded.
Definition: Data.cpp:1184
weipa::IntVec
std::vector< int > IntVec
Definition: weipa.h:59
weipa::FinleyElements
Stores and manipulates one type of finley mesh elements (cells, faces or contacts).
Definition: FinleyElements.h:75
finley::ReducedContactElementsZero
Definition: Finley.h:86
finley::FinleyDomain::write
void write(const std::string &fileName) const
writes the current mesh to a file with the given name in the fly file format.
Definition: finley/src/Mesh_write.cpp:87
finley
A suite of factory methods for creating various finley domains.
Definition: finley/src/Assemble.h:32
finley::NodeFile::setTags
void setTags(int newTag, const escript::Data &mask)
set tags to newTag where mask > 0
Definition: finley/src/NodeFile.cpp:279
finley::NodeFile::numDim
int numDim
number of spatial dimensions
Definition: finley/src/NodeFile.h:161
ESYS_ASSERT
#define ESYS_ASSERT(a, b)
EsysAssert is a MACRO that will throw an exception if the boolean condition specified is false.
Definition: Assert.h:78
finley::FinleyDomain::supportsContactElements
virtual bool supportsContactElements() const
Definition: finley/src/FinleyDomain.h:851
finley::util::packMask
std::vector< index_t > packMask(const std::vector< short > &mask)
Definition: finley/src/Util.cpp:357
finley::FinleyDomain::setFunctionSpaceTypeNames
void setFunctionSpaceTypeNames()
Build the table of function space type names.
Definition: finley/src/FinleyDomain.cpp:950
finley::NodeFile::allocTable
void allocTable(dim_t numNodes)
allocates the node table within this node file to hold numNodes nodes.
Definition: finley/src/NodeFile.cpp:139
finley::FinleyDomain::getVTKElementType
virtual int getVTKElementType() const
returns the VTK element type
Definition: finley/src/FinleyDomain.cpp:2421
escript::ValueError
An exception class that signals an invalid argument value.
Definition: EsysException.h:101
DUDLEY_FACE_ELEMENTS
#define DUDLEY_FACE_ELEMENTS
Definition: Dudley.h:56
finley::FinleyDomain::prepare
void prepare(bool optimize)
prepares the mesh for further use
Definition: finley/src/FinleyDomain.cpp:2782
finley::FinleyDomain::MPIBarrier
virtual void MPIBarrier() const
If compiled for MPI then execute an MPI_Barrier, else do nothing.
Definition: finley/src/FinleyDomain.cpp:115
finley::FinleyDomain::m_elements
ElementFile * m_elements
the table of the elements
Definition: finley/src/FinleyDomain.h:940
weipa::DataVar
A class that provides functionality to read an escript data object from a dump file or an escript::Da...
Definition: DataVar.h:35
finley::FinleyDomain::setNewX
virtual void setNewX(const escript::Data &arg)
assigns new location to the domain
Definition: finley/src/FinleyDomain.cpp:1858
finley::Elements
Definition: Finley.h:80
escript::AbstractContinuousDomain
AbstractContinuousDomain, base class for continuous domains.
Definition: AbstractContinuousDomain.h:58
finley::FinleyDomain::getX
virtual escript::Data getX() const
returns locations in the FEM nodes
Definition: finley/src/FinleyDomain.cpp:2372
finley::FinleyDomain::isValidFunctionSpaceType
virtual bool isValidFunctionSpaceType(int functionSpaceType) const
Returns true if the given integer is a valid function space type for this domain.
Definition: finley/src/FinleyDomain.cpp:943
FINLEY_CONTACT_ELEMENTS_2
#define FINLEY_CONTACT_ELEMENTS_2
Definition: Finley.h:67
weipa::FinleyDomain::initFromEscript
virtual bool initFromEscript(const escript::AbstractDomain *domain)
Initialises the domain using an escript domain instance.
Definition: weipa/src/FinleyDomain.cpp:98
finley::FinleyDomain::getReducedSolutionCode
virtual int getReducedSolutionCode() const
Return a ReducedSolution code.
Definition: finley/src/FinleyDomain.cpp:1035
Assemble.h
finley::FinleyDomain::createHex8
static escript::Domain_ptr createHex8(dim_t NE0, dim_t NE1, dim_t NE2, double l0, double l1, double l2, bool periodic0, bool periodic1, bool periodic2, int order, int reducedOrder, bool useElementsOnFace, bool optimize, escript::JMPI jmpi)
Creates a 3-dimensional rectangular domain with first order (Hex8) elements.
Definition: Mesh_hex8.cpp:38
finley::FinleyDomain::markNodes
void markNodes(std::vector< short > &mask, index_t offset, bool useLinear) const
Definition: finley/src/FinleyDomain.cpp:194
finley::readMesh_driver
Domain_ptr readMesh_driver(const bp::list &args)
Definition: finley/src/DomainFactory.cpp:903
FINLEY_CONTACT_ELEMENTS_1
#define FINLEY_CONTACT_ELEMENTS_1
Definition: Finley.h:66
finley::meshMerge
Domain_ptr meshMerge(const bp::list &meshList)
Definition: finley/src/DomainFactory.cpp:1271
finley::FinleyDomain::merge
static FinleyDomain * merge(const std::vector< const FinleyDomain * > &meshes)
Definition: Mesh_merge.cpp:24
escript::DataTypes::IndexVector
std::vector< index_t > IndexVector
Definition: DataTypes.h:88
weipa::FinleyDomain::getCenteringForFunctionSpace
virtual Centering getCenteringForFunctionSpace(int fsCode) const
Returns whether data on given function space is node or cell centered.
Definition: weipa/src/FinleyDomain.cpp:218
finley::ElementFile::numNodes
int numNodes
number of nodes per element
Definition: finley/src/ElementFile.h:150
finley::ReferenceElementInfo::Name
const char * Name
the name in text form e.g. "Line1", "Rec12", ...
Definition: ReferenceElements.h:123
finley::FinleyDomain::~FinleyDomain
~FinleyDomain()
Destructor for FinleyDomain.
Definition: finley/src/FinleyDomain.cpp:106
finley::FinleyDomain::writeElementInfo
void writeElementInfo(std::ostream &stream, const ElementFile *e, const std::string &defaultType) const
Definition: finley/src/Mesh_write.cpp:33
weipa::FinleyDomain
Represents a full Finley or Dudley domain including nodes and elements.
Definition: weipa/src/FinleyDomain.h:41
finley::FinleyDomain::createRec4
static escript::Domain_ptr createRec4(dim_t NE0, dim_t NE1, double L0, double L1, bool periodic0, bool periodic1, int order, int reducedOrder, bool useElementsOnFace, bool optimize, escript::JMPI jmpi)
Creates a 2-dimensional rectangular domain with first order (Rec4) elements in the rectangle [0,...
Definition: Mesh_rec4.cpp:25