finley/src/ElementFile.h


/*******************************************************
*
* Copyright (c) 2003-2008 by University of Queensland
* Earth Systems Science Computational Center (ESSCC)
* http://www.uq.edu.au/esscc
*
* Primary Business: Queensland, Australia
* Licensed under the Open Software License version 3.0
* http://www.opensource.org/licenses/osl-3.0.php
*
*******************************************************/


#ifndef INC_FINLEY_ELEMENTFILE
#define INC_FINLEY_ELEMENTFILE

#include "Finley.h"
#include "NodeFile.h"
#include "ReferenceElements.h"
#include "escript/DataC.h"

#ifdef PASO_MPI
#include "paso/Paso_MPI.h"
#endif

struct Finley_ElementFile_Jacobeans {
  Finley_Status_t status;               /* status of mesh when jacobeans where updated last time */
  dim_t numDim;                         /* spatial dimension */
  Finley_RefElement* ReferenceElement;  /* reference elemnt used to calculate jacobeans (this is a borrowd reference) */
  double* volume;                       /* local volume */
  double* DSDX;                         /* derivatives of shape functions in global coordinates at quadrature points*/
};

typedef struct Finley_ElementFile_Jacobeans Finley_ElementFile_Jacobeans;

struct Finley_ElementFile {
  Paso_MPIInfo *MPIInfo;
  Paso_MPI_rank *Owner;

  Finley_RefElement* ReferenceElement;           /* the reference element, see Reference element.c */
  Finley_RefElement* ReferenceElementReducedOrder;    /* the reference element with reduced integration order, see Reference element.c */
  Finley_RefElement* LinearReferenceElement;     /* the reference element for the linear mesh. it is vital that it is using the same quadrature scheme like ReferenceElement*/
  Finley_RefElement* LinearReferenceElementReducedOrder;  /* the reference element for the linear mesh. it is vital that it is using the same quadrature 
\                                                                scheme like LinearReferenceElementReducedIntegration*/

  dim_t numElements;                             /* number of elements. */
  
  index_t *Id;                                 /* Id[i] is the id nmber of
                            node i. this number is not
                            used but useful when
                            elements are resorted. in
                            the entire code the term
                            'element id' refers to i
                            but nor to Id[i] if not
                            explicitly stated
                            otherwise. */

  index_t *Tag;                                /* Tag[i] is the tag of
                            element i. */

  index_t *tagsInUse;                  /* array of tags which are actually used */
  dim_t     numTagsInUse;               /* number of tags used */


  dim_t numNodes;                              /* number of nodes per element = ReferenceElement.Type.numNodes */
  index_t *Nodes;                              /* Nodes[INDEX(k, i, numNodes)]
                            is the k-the node in the
                            i-the element. note that
                            in the way the nodes are
                            ordered Nodes[INDEX(k, i,
                            LinearReferenceElement.Type.numNodes)
                            is k-the node of element i
                            when refering to the
                            linear version of the
                            mesh. */
  index_t minColor;                           /* minimum color */
  index_t maxColor;                           /* maximum color */
  index_t *Color;                             /* assigns each element a color. elements with the same color     */
                              /* are don't share a node so they can be processed simultaneously */
                                              /* at anytime Color must provide a valid value. In any case one can set  */
                                              /* Color[e]=e  for all e */
  index_t order;                   /* order of the element integration scheme*/
  index_t reduced_order;                   /* order of the reduced element integration scheme*/

  Finley_ElementFile_Jacobeans* jacobeans;           /* element jacobeans */
  Finley_ElementFile_Jacobeans* jacobeans_reducedS;  /* element jacobeans for reduced order of shape function*/
  Finley_ElementFile_Jacobeans* jacobeans_reducedQ;  /* element jacobeans for reduced integration order*/
  Finley_ElementFile_Jacobeans* jacobeans_reducedS_reducedQ;  /* element jacobeans for reduced integration order and  reduced order of shape function*/

};

typedef struct Finley_ElementFile Finley_ElementFile;
Finley_ElementFile* Finley_ElementFile_alloc( ElementTypeId, index_t, index_t, Paso_MPIInfo* );
void Finley_ElementFile_free(Finley_ElementFile*);
void Finley_ElementFile_allocTable(Finley_ElementFile*,dim_t);
void Finley_ElementFile_freeTable(Finley_ElementFile*);
void Finley_ElementFile_setElementDistribution(Finley_ElementFile* in, dim_t* distribution);
dim_t Finley_ElementFile_getGlobalNumElements(Finley_ElementFile* in);
dim_t Finley_ElementFile_getMyNumElements(Finley_ElementFile* in);
index_t Finley_ElementFile_getFirstElement(Finley_ElementFile* in); 
void Finley_ElementFile_distributeByRankOfDOF(Finley_ElementFile* self, Paso_MPI_rank* mpiRankOfDOF, index_t *Id);

void Finley_ElementFile_createColoring(Finley_ElementFile* in,dim_t numNodes,dim_t* degreeOfFreedom);
void Finley_ElementFile_optimizeOrdering(Finley_ElementFile** in);
void Finley_ElementFile_setNodeRange(dim_t*,dim_t*,Finley_ElementFile*);
void Finley_ElementFile_relableNodes(dim_t*,dim_t,Finley_ElementFile*);
void Finley_ElementFile_markNodes(dim_t*,dim_t,dim_t,Finley_ElementFile*,dim_t);
void Finley_ElementFile_scatter(dim_t*,Finley_ElementFile*,Finley_ElementFile*);
void Finley_ElementFile_gather(dim_t*,Finley_ElementFile*,Finley_ElementFile*);
void Finley_ElementFile_copyTable(dim_t,Finley_ElementFile*,dim_t,dim_t,Finley_ElementFile*);
void Finley_ElementFile_markDOFsConnectedToRange(index_t* mask,index_t offset,index_t marker,index_t firstDOF,index_t lastDOF,index_t *dofIndex,Finley_ElementFile*in ,bool_t useLinear);

void Finley_ElementFile_setTags(Finley_ElementFile*,const int,escriptDataC*);
Finley_ElementFile_Jacobeans* Finley_ElementFile_Jacobeans_alloc(Finley_RefElement*);
void Finley_ElementFile_Jacobeans_dealloc(Finley_ElementFile_Jacobeans*);
Finley_ElementFile_Jacobeans* Finley_ElementFile_borrowJacobeans(Finley_ElementFile*, Finley_NodeFile*, bool_t, bool_t);
void Finley_ElementFile_setTagsInUse(Finley_ElementFile* in);


#endif /* #ifndef INC_FINLEY_ELEMENTFILE */

1
2	/*******************************************************
3	*
4	* Copyright (c) 2003-2008 by University of Queensland
5	* Earth Systems Science Computational Center (ESSCC)
6	* http://www.uq.edu.au/esscc
7	*
8	* Primary Business: Queensland, Australia
9	* Licensed under the Open Software License version 3.0
10	* http://www.opensource.org/licenses/osl-3.0.php
11	*
12	*******************************************************/
13
14
15	#ifndef INC_FINLEY_ELEMENTFILE
16	#define INC_FINLEY_ELEMENTFILE
17
18	#include "Finley.h"
19	#include "NodeFile.h"
20	#include "ReferenceElements.h"
21	#include "escript/DataC.h"
22
23	#ifdef PASO_MPI
24	#include "paso/Paso_MPI.h"
25	#endif
26
27	struct Finley_ElementFile_Jacobeans {
28	Finley_Status_t status; /* status of mesh when jacobeans where updated last time */
29	dim_t numDim; /* spatial dimension */
30	Finley_RefElement* ReferenceElement; /* reference elemnt used to calculate jacobeans (this is a borrowd reference) */
31	double* volume; /* local volume */
32	double* DSDX; /* derivatives of shape functions in global coordinates at quadrature points*/
33	};
34
35	typedef struct Finley_ElementFile_Jacobeans Finley_ElementFile_Jacobeans;
36
37	struct Finley_ElementFile {
38	Paso_MPIInfo *MPIInfo;
39	Paso_MPI_rank *Owner;
40
41	Finley_RefElement* ReferenceElement; /* the reference element, see Reference element.c */
42	Finley_RefElement* ReferenceElementReducedOrder; /* the reference element with reduced integration order, see Reference element.c */
43	Finley_RefElement* LinearReferenceElement; /* the reference element for the linear mesh. it is vital that it is using the same quadrature scheme like ReferenceElement*/
44	Finley_RefElement* LinearReferenceElementReducedOrder; /* the reference element for the linear mesh. it is vital that it is using the same quadrature
45	\ scheme like LinearReferenceElementReducedIntegration*/
46
47	dim_t numElements; /* number of elements. */
48
49	index_t Id; / Id[i] is the id nmber of
50	node i. this number is not
51	used but useful when
52	elements are resorted. in
53	the entire code the term
54	'element id' refers to i
55	but nor to Id[i] if not
56	explicitly stated
57	otherwise. */
58
59	index_t Tag; / Tag[i] is the tag of
60	element i. */
61
62	index_t tagsInUse; / array of tags which are actually used */
63	dim_t numTagsInUse; /* number of tags used */
64
65
66	dim_t numNodes; /* number of nodes per element = ReferenceElement.Type.numNodes */
67	index_t Nodes; / Nodes[INDEX(k, i, numNodes)]
68	is the k-the node in the
69	i-the element. note that
70	in the way the nodes are
71	ordered Nodes[INDEX(k, i,
72	LinearReferenceElement.Type.numNodes)
73	is k-the node of element i
74	when refering to the
75	linear version of the
76	mesh. */
77	index_t minColor; /* minimum color */
78	index_t maxColor; /* maximum color */
79	index_t Color; / assigns each element a color. elements with the same color */
80	/* are don't share a node so they can be processed simultaneously */
81	/* at anytime Color must provide a valid value. In any case one can set */
82	/* Color[e]=e for all e */
83	index_t order; /* order of the element integration scheme*/
84	index_t reduced_order; /* order of the reduced element integration scheme*/
85
86	Finley_ElementFile_Jacobeans* jacobeans; /* element jacobeans */
87	Finley_ElementFile_Jacobeans* jacobeans_reducedS; /* element jacobeans for reduced order of shape function*/
88	Finley_ElementFile_Jacobeans* jacobeans_reducedQ; /* element jacobeans for reduced integration order*/
89	Finley_ElementFile_Jacobeans* jacobeans_reducedS_reducedQ; /* element jacobeans for reduced integration order and reduced order of shape function*/
90
91	};
92
93	typedef struct Finley_ElementFile Finley_ElementFile;
94	Finley_ElementFile* Finley_ElementFile_alloc( ElementTypeId, index_t, index_t, Paso_MPIInfo* );
95	void Finley_ElementFile_free(Finley_ElementFile*);
96	void Finley_ElementFile_allocTable(Finley_ElementFile*,dim_t);
97	void Finley_ElementFile_freeTable(Finley_ElementFile*);
98	void Finley_ElementFile_setElementDistribution(Finley_ElementFile* in, dim_t* distribution);
99	dim_t Finley_ElementFile_getGlobalNumElements(Finley_ElementFile* in);
100	dim_t Finley_ElementFile_getMyNumElements(Finley_ElementFile* in);
101	index_t Finley_ElementFile_getFirstElement(Finley_ElementFile* in);
102	void Finley_ElementFile_distributeByRankOfDOF(Finley_ElementFile* self, Paso_MPI_rank* mpiRankOfDOF, index_t *Id);
103
104	void Finley_ElementFile_createColoring(Finley_ElementFile* in,dim_t numNodes,dim_t* degreeOfFreedom);
105	void Finley_ElementFile_optimizeOrdering(Finley_ElementFile** in);
106	void Finley_ElementFile_setNodeRange(dim_t,dim_t,Finley_ElementFile*);
107	void Finley_ElementFile_relableNodes(dim_t,dim_t,Finley_ElementFile);
108	void Finley_ElementFile_markNodes(dim_t,dim_t,dim_t,Finley_ElementFile,dim_t);
109	void Finley_ElementFile_scatter(dim_t,Finley_ElementFile,Finley_ElementFile*);
110	void Finley_ElementFile_gather(dim_t,Finley_ElementFile,Finley_ElementFile*);
111	void Finley_ElementFile_copyTable(dim_t,Finley_ElementFile,dim_t,dim_t,Finley_ElementFile);
112	void Finley_ElementFile_markDOFsConnectedToRange(index_t* mask,index_t offset,index_t marker,index_t firstDOF,index_t lastDOF,index_t dofIndex,Finley_ElementFilein ,bool_t useLinear);
113
114	void Finley_ElementFile_setTags(Finley_ElementFile,const int,escriptDataC);
115	Finley_ElementFile_Jacobeans* Finley_ElementFile_Jacobeans_alloc(Finley_RefElement*);
116	void Finley_ElementFile_Jacobeans_dealloc(Finley_ElementFile_Jacobeans*);
117	Finley_ElementFile_Jacobeans* Finley_ElementFile_borrowJacobeans(Finley_ElementFile, Finley_NodeFile, bool_t, bool_t);
118	void Finley_ElementFile_setTagsInUse(Finley_ElementFile* in);
119
120
121	#endif /* #ifndef INC_FINLEY_ELEMENTFILE */
122
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision