/[escript]/trunk/finley/src/Mesh.h
ViewVC logotype

Annotation of /trunk/finley/src/Mesh.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1360 - (hide annotations)
Thu Dec 13 05:05:00 2007 UTC (12 years, 9 months ago) by ksteube
File MIME type: text/plain
File size: 7689 byte(s)
Partial implementation of ReadMeshMPI.
Will eventually replace ReadMesh but for now has a different name.

1 jgs 82
2 ksteube 1312 /* $Id$ */
3 jgs 150
4 ksteube 1312 /*******************************************************
5     *
6     * Copyright 2003-2007 by ACceSS MNRF
7     * Copyright 2007 by University of Queensland
8     *
9     * http://esscc.uq.edu.au
10     * Primary Business: Queensland, Australia
11     * Licensed under the Open Software License version 3.0
12     * http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16 jgs 82 #ifndef INC_FINLEY_MESH
17     #define INC_FINLEY_MESH
18    
19     /**************************************************************/
20    
21     /* Finley: Mesh */
22    
23     /* A mesh is built from nodes and elements which are describing the
24     domain, the surface and point sources. (the latter are needed to
25     establish links with other codes, in particular to particle
26     codes). The nodes are stored a Finley_NodeFile and elements in a
27     Finley_ElementFile. A Finley_NodeFile and three Finley_ElementFile
28     containing the elements describing the domain, surface and point
29     sources respectively. Notice that the surface elements do not
30     necessaryly cover the entire surface of the domain. */
31    
32     /* The element type is fixed by the reference element, see
33     ReferenceElement.h. The numbering of the nodes starts with 0. */
34    
35     /* Important: it is assumed that every node is appearing in at least
36     one element or surface element and that any node used in an
37     element, surface element or as a point is specified in the
38     Finley_Node, see also Finley_resolveNodeIds. */
39    
40     /* In some cases it is useful to refer to a mesh entirly built from
41     order 1 (=linear) elements. The linear version of the mesh can be
42     accessed by referning 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 vectors are introduced
45     in the Finley_NodeFile. This feature is not fully implemented
46     yet. */
47    
48     /* allnodes and elements are tagged. the tag allows to group nodes and
49     elements. A typical application is to mark surface elements on a
50     certain portion of the domain with the same tag. All these surface
51     elements can then assigned the same value eg. for the pressure. */
52    
53     /* Thespacial dimension is determined by the type of elements
54     used. The spacial dimension should be accessed by the function
55     Finley_Mesh_getDim. Notice that the element type also determines
56     the type of surface elements to be used. */
57    
58     /**************************************************************/
59    
60 jgs 150 #include "Finley.h"
61 jgs 82 #include "NodeFile.h"
62     #include "ElementFile.h"
63 gross 1044 #include "TagMap.h"
64 ksteube 1312 #include "Util.h"
65 robwdcock 682 #include "paso/SystemMatrixPattern.h"
66     #include "escript/DataC.h"
67 jgs 82
68 bcumming 730 #ifdef PASO_MPI
69     #include "paso/Paso_MPI.h"
70     #endif
71    
72 jgs 82 /**************************************************************/
73    
74     /* this struct holds a mesh: */
75    
76     struct Finley_Mesh {
77     char* Name; /* the name of the mesh */
78 gross 964 index_t order; /* integration order */
79 gross 1062 index_t reduced_order; /* reduced integration order */
80 jgs 123 dim_t reference_counter; /* counts the number of references to the mesh; */
81 jgs 82 Finley_NodeFile* Nodes; /* the table of the nodes */
82     Finley_ElementFile* Elements; /* the table of the elements */
83     Finley_ElementFile* FaceElements; /* the table of the face elements */
84     Finley_ElementFile* ContactElements; /* the table of the contact elements */
85     Finley_ElementFile* Points; /* the table of points (treated as elements of dimension 0) */
86 gross 1044 Finley_TagMap* TagMap; /* the tag map mapping names to tag keys */
87 jgs 102
88     /* pointer to the sparse matrix pattern */
89    
90 jgs 150 Paso_SystemMatrixPattern *FullFullPattern;
91     Paso_SystemMatrixPattern *FullReducedPattern;
92     Paso_SystemMatrixPattern *ReducedFullPattern;
93     Paso_SystemMatrixPattern *ReducedReducedPattern;
94 bcumming 730 Paso_MPIInfo *MPIInfo;
95 jgs 82 };
96    
97     typedef struct Finley_Mesh Finley_Mesh;
98    
99     /* these structures are used for matching surfaces elements: */
100    
101     struct Finley_Mesh_findMatchingFaces_center{
102 jgs 123 index_t refId;
103 jgs 82 double x[MAX_numDim];
104     };
105     typedef struct Finley_Mesh_findMatchingFaces_center Finley_Mesh_findMatchingFaces_center;
106    
107     /**************************************************************/
108    
109     /* interfaces: */
110 gross 1062 Finley_Mesh* Finley_Mesh_alloc(char* name,dim_t numDim, index_t order, index_t reduced_order, Paso_MPIInfo *mpi_info);
111 jgs 102 Finley_Mesh* Finley_Mesh_reference(Finley_Mesh*);
112 jgs 123 dim_t Finley_Mesh_getDim(Finley_Mesh*);
113 ksteube 1312 void Finley_Mesh_free(Finley_Mesh*);
114    
115     void Finley_Mesh_addTagMap(Finley_Mesh *mesh_p,const char* name, index_t tag_key);
116     index_t Finley_Mesh_getTag(Finley_Mesh *mesh_p,const char* name);
117     bool_t Finley_Mesh_isValidTagName(Finley_Mesh *mesh_p,const char* name);
118     void Finley_Mesh_distributeByRankOfDOF(Finley_Mesh* in, dim_t *distribution);
119 jgs 150 Paso_SystemMatrixPattern* Finley_getPattern(Finley_Mesh *mesh,bool_t reduce_row_order, bool_t reduce_col_order);
120     Paso_SystemMatrixPattern* Finley_makePattern(Finley_Mesh *mesh,bool_t reduce_row_order, bool_t reduce_col_order);
121 jgs 82 void Finley_Mesh_write(Finley_Mesh*,char*);
122 ksteube 1312 void Finley_Mesh_dump(Finley_Mesh *in,char* fname);
123 ksteube 1339 void Finley_PrintMesh_Info(Finley_Mesh *, bool_t);
124 ksteube 1312 Finley_Mesh* Finley_Mesh_load(char* fname);
125 gross 1062 Finley_Mesh* Finley_Mesh_read(char*,index_t, index_t, bool_t);
126 ksteube 1360 Finley_Mesh* Finley_Mesh_read_MPI(char*,index_t, index_t, bool_t);
127 gross 934 Finley_Mesh* Finley_Mesh_readGmsh(char*,index_t, index_t, index_t, bool_t);
128 gross 532 void Finley_Mesh_setCoordinates(Finley_Mesh*,escriptDataC*);
129 ksteube 1312 void Finley_Mesh_setElements(Finley_Mesh* self,Finley_ElementFile *elements);
130     void Finley_Mesh_setFaceElements(Finley_Mesh* self,Finley_ElementFile *elements);
131     void Finley_Mesh_setContactElements(Finley_Mesh* self,Finley_ElementFile *elements);
132     void Finley_Mesh_setPoints(Finley_Mesh* self,Finley_ElementFile *elements);
133     void Finley_Mesh_optimizeDOFDistribution(Finley_Mesh* in,dim_t *distribution);
134     void Finley_Mesh_prepare(Finley_Mesh* in, bool_t optimize);
135     void Finley_Mesh_createColoring(Finley_Mesh* in, index_t *node_localDOF_map);
136     void Finley_Mesh_optimizeElementOrdering(Finley_Mesh* in);
137     void Finley_Mesh_resolveNodeIds(Finley_Mesh*);
138     void Finley_Mesh_createMappings(Finley_Mesh* in, index_t *distribution);
139     void Finley_Mesh_createNodeFileMappings(Finley_Mesh* in, dim_t numReducedNodes, index_t* indexReducedNodes, index_t* dof_first_component);
140     void Finley_Mesh_markDOFsConnectedToRange(index_t* mask, index_t offset, index_t marker,index_t firstDOF,index_t lastDOF,Finley_Mesh* in, bool_t useLinear);
141 jgs 82
142 ksteube 1312 void Finley_Mesh_optimizeDOFLabeling(Finley_Mesh*,dim_t *);
143    
144    
145 jgs 123 Finley_Mesh* Finley_Mesh_merge(dim_t, Finley_Mesh**);
146 jgs 82
147     void Finley_Mesh_relableElementNodes(int*,int,Finley_Mesh*);
148     void Finley_Mesh_markNodes(int*,int,Finley_Mesh*,int);
149    
150 gross 1062 void Finley_Mesh_glueFaces(Finley_Mesh* self,double safety_factor,double tolerance, bool_t);
151     void Finley_Mesh_joinFaces(Finley_Mesh* self,double safety_factor,double tolerance, bool_t);
152 jgs 82
153     int Finley_Mesh_findMatchingFaces_compar(const void*,const void*);
154     void Finley_Mesh_findMatchingFaces(Finley_NodeFile*,Finley_ElementFile *,double,double, int*, int*,int*,int*);
155     void Finley_Mesh_print(Finley_Mesh *in);
156 jgs 153 void Finley_Mesh_saveDX(const char * filename_p, Finley_Mesh *mesh_p, const dim_t num_data,char* *names_p,escriptDataC* *data_pp);
157 gross 1156 void Finley_Mesh_optimizeNodeLabeling(Finley_Mesh* mesh_p);
158 gross 1171 dim_t Finley_Mesh_FindMinDegreeNode(Paso_SystemMatrixPattern* pattern_p,index_t* available,index_t indicator);
159     index_t Finley_Mesh_getDegree(Paso_SystemMatrixPattern* pattern_p, index_t *label);
160 jgs 82
161 dhawcroft 793
162 ksteube 1312 void Finley_Mesh_saveVTK(const char * filename_p, Finley_Mesh *mesh_p, const dim_t num_data,char* *names_p,escriptDataC* *data_pp);
163 dhawcroft 793
164 jgs 82 #endif /* #ifndef INC_FINLEY_MESH */
165 jgs 123

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26