/[escript]/trunk/finley/src/Mesh_hex8.cpp
ViewVC logotype

Contents of /trunk/finley/src/Mesh_hex8.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4492 - (show annotations)
Tue Jul 2 01:44:11 2013 UTC (5 years, 9 months ago) by caltinay
File size: 20493 byte(s)
Finley changes that were held back while in release mode - moved more stuff
into finley namespace.

1
2 /*****************************************************************************
3 *
4 * Copyright (c) 2003-2013 by University of Queensland
5 * http://www.uq.edu.au
6 *
7 * Primary Business: Queensland, Australia
8 * Licensed under the Open Software License version 3.0
9 * http://www.opensource.org/licenses/osl-3.0.php
10 *
11 * Development until 2012 by Earth Systems Science Computational Center (ESSCC)
12 * Development since 2012 by School of Earth Sciences
13 *
14 *****************************************************************************/
15
16
17 /************************************************************************************/
18
19 /* Finley: generates rectangular meshes */
20
21 /* Generates a numElements[0] x numElements[1] x numElements[2] mesh with first order elements (Hex8) in the brick */
22 /* [0,Length[0]] x [0,Length[1]] x [0,Length[2]]. order is the desired accuracy of the */
23 /* integration scheme. */
24
25 /************************************************************************************/
26
27 #include "RectangularMesh.h"
28
29 Finley_Mesh* Finley_RectangularMesh_Hex8(dim_t* numElements,
30 double* Length,
31 bool_t* periodic,
32 index_t order,
33 index_t reduced_order,
34 bool_t useElementsOnFace,
35 bool_t useFullElementOrder,
36 bool_t optimize)
37 {
38 #define N_PER_E 1
39 #define DIM 3
40 dim_t N0,N1,N2,NE0,NE1,NE2,i0,i1,i2,k,Nstride0=0, Nstride1=0,Nstride2=0, local_NE0, local_NE1, local_NE2, local_N0=0, local_N1=0, local_N2=0;
41 dim_t totalNECount,faceNECount,NDOF0=0,NDOF1=0,NDOF2=0,NFaceElements=0, NN;
42 index_t node0, myRank, e_offset2, e_offset1, e_offset0=0, offset1=0, offset2=0, offset0=0, global_i0, global_i1, global_i2;
43 ReferenceElementSet *refPoints=NULL, *refContactElements=NULL, *refFaceElements=NULL, *refElements=NULL;
44 Finley_Mesh* out;
45 Esys_MPIInfo *mpi_info = NULL;
46 char name[50];
47 #ifdef Finley_TRACE
48 double time0=Finley_timer();
49 #endif
50
51 /* get MPI information */
52 mpi_info = Esys_MPIInfo_alloc( MPI_COMM_WORLD );
53 if (! Finley_noError()) {
54 return NULL;
55 }
56 myRank=mpi_info->rank;
57
58 /* set up the global dimensions of the mesh */
59
60 NE0=MAX(1,numElements[0]);
61 NE1=MAX(1,numElements[1]);
62 NE2=MAX(1,numElements[2]);
63 N0=N_PER_E*NE0+1;
64 N1=N_PER_E*NE1+1;
65 N2=N_PER_E*NE2+1;
66
67 /* allocate mesh: */
68 sprintf(name,"Rectangular %d x %d x %d mesh",N0,N1,N2);
69 out=Finley_Mesh_alloc(name,DIM, mpi_info);
70 if (! Finley_noError()) {
71 Esys_MPIInfo_free( mpi_info );
72 return NULL;
73 }
74 refElements= ReferenceElementSet_alloc(Hex8,order,reduced_order);
75 if (useElementsOnFace) {
76 refFaceElements=ReferenceElementSet_alloc(Hex8Face, order, reduced_order);
77 refContactElements=ReferenceElementSet_alloc(Hex8Face_Contact, order, reduced_order);
78 } else {
79 refFaceElements=ReferenceElementSet_alloc(Rec4, order, reduced_order);
80 refContactElements=ReferenceElementSet_alloc(Rec4_Contact, order, reduced_order);
81 }
82 refPoints=ReferenceElementSet_alloc(Point1, order, reduced_order);
83
84
85 if ( Finley_noError()) {
86
87 Finley_Mesh_setPoints(out, new ElementFile(refPoints, mpi_info));
88 Finley_Mesh_setContactElements(out, new ElementFile(refContactElements, mpi_info));
89 Finley_Mesh_setFaceElements(out, new ElementFile(refFaceElements, mpi_info));
90 Finley_Mesh_setElements(out, new ElementFile(refElements, mpi_info));
91
92 /* work out the largest dimension */
93 if (N2==MAX3(N0,N1,N2)) {
94 Nstride0=1;
95 Nstride1=N0;
96 Nstride2=N0*N1;
97 local_NE0=NE0;
98 e_offset0=0;
99 local_NE1=NE1;
100 e_offset1=0;
101 Esys_MPIInfo_Split(mpi_info,NE2,&local_NE2,&e_offset2);
102 } else if (N1==MAX3(N0,N1,N2)) {
103 Nstride0=N2;
104 Nstride1=N0*N2;
105 Nstride2=1;
106 local_NE0=NE0;
107 e_offset0=0;
108 Esys_MPIInfo_Split(mpi_info,NE1,&local_NE1,&e_offset1);
109 local_NE2=NE2;
110 e_offset2=0;
111 } else {
112 Nstride0=N1*N2;
113 Nstride1=1;
114 Nstride2=N1;
115 Esys_MPIInfo_Split(mpi_info,NE0,&local_NE0,&e_offset0);
116 local_NE1=NE1;
117 e_offset1=0;
118 local_NE2=NE2;
119 e_offset2=0;
120 }
121 offset0=e_offset0*N_PER_E;
122 offset1=e_offset1*N_PER_E;
123 offset2=e_offset2*N_PER_E;
124 local_N0=local_NE0>0 ? local_NE0*N_PER_E+1 : 0;
125 local_N1=local_NE1>0 ? local_NE1*N_PER_E+1 : 0;
126 local_N2=local_NE2>0 ? local_NE2*N_PER_E+1 : 0;
127
128 /* get the number of surface elements */
129
130 NFaceElements=0;
131 if (!periodic[2] && (local_NE2>0)) {
132 NDOF2=N2;
133 if (offset2==0) NFaceElements+=local_NE1*local_NE0;
134 if (local_NE2+e_offset2 == NE2) NFaceElements+=local_NE1*local_NE0;
135 } else {
136 NDOF2=N2-1;
137 }
138
139 if (!periodic[0] && (local_NE0>0)) {
140 NDOF0=N0;
141 if (e_offset0 == 0) NFaceElements+=local_NE1*local_NE2;
142 if (local_NE0+e_offset0 == NE0) NFaceElements+=local_NE1*local_NE2;
143 } else {
144 NDOF0=N0-1;
145 }
146 if (!periodic[1] && (local_NE1>0)) {
147 NDOF1=N1;
148 if (e_offset1 == 0) NFaceElements+=local_NE0*local_NE2;
149 if (local_NE1+e_offset1 == NE1) NFaceElements+=local_NE0*local_NE2;
150 } else {
151 NDOF1=N1-1;
152 }
153 }
154
155
156 /* allocate tables: */
157 if (Finley_noError()) {
158
159 out->Nodes->allocTable(local_N0*local_N1*local_N2);
160 out->Elements->allocTable(local_NE0*local_NE1*local_NE2);
161 out->FaceElements->allocTable(NFaceElements);
162 }
163
164 if (Finley_noError()) {
165 /* create nodes */
166
167 #pragma omp parallel for private(i0,i1,i2,k,global_i0,global_i1,global_i2)
168 for (i2=0;i2<local_N2;i2++) {
169 for (i1=0;i1<local_N1;i1++) {
170 for (i0=0;i0<local_N0;i0++) {
171 k=i0+local_N0*i1+local_N0*local_N1*i2;
172 global_i0=i0+offset0;
173 global_i1=i1+offset1;
174 global_i2=i2+offset2;
175 out->Nodes->Coordinates[INDEX2(0,k,DIM)]=DBLE(global_i0)/DBLE(N0-1)*Length[0];
176 out->Nodes->Coordinates[INDEX2(1,k,DIM)]=DBLE(global_i1)/DBLE(N1-1)*Length[1];
177 out->Nodes->Coordinates[INDEX2(2,k,DIM)]=DBLE(global_i2)/DBLE(N2-1)*Length[2];
178 out->Nodes->Id[k]=Nstride0*global_i0+Nstride1*global_i1+Nstride2*global_i2;
179 out->Nodes->Tag[k]=0;
180 out->Nodes->globalDegreesOfFreedom[k]=Nstride0*(global_i0%NDOF0)
181 +Nstride1*(global_i1%NDOF1)
182 +Nstride2*(global_i2%NDOF2);
183 }
184 }
185 }
186 /* set the elements: */
187 NN=out->Elements->numNodes;
188 #pragma omp parallel for private(i0,i1,i2,k,node0)
189 for (i2=0;i2<local_NE2;i2++) {
190 for (i1=0;i1<local_NE1;i1++) {
191 for (i0=0;i0<local_NE0;i0++) {
192
193 k=i0+local_NE0*i1+local_NE0*local_NE1*i2;
194 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(i2+e_offset2);
195
196 out->Elements->Id[k]=(i0+e_offset0)+NE0*(i1+e_offset1)+NE0*NE1*(i2+e_offset2);
197 out->Elements->Tag[k]=0;
198 out->Elements->Owner[k]=myRank;
199
200 out->Elements->Nodes[INDEX2(0,k,NN)] =node0 ;
201 out->Elements->Nodes[INDEX2(1,k,NN)] =node0+ Nstride0;
202 out->Elements->Nodes[INDEX2(2,k,NN)] =node0+ Nstride1+Nstride0;
203 out->Elements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride1;
204 out->Elements->Nodes[INDEX2(4,k,NN)] =node0+Nstride2 ;
205 out->Elements->Nodes[INDEX2(5,k,NN)] =node0+Nstride2 +Nstride0;
206 out->Elements->Nodes[INDEX2(6,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
207 out->Elements->Nodes[INDEX2(7,k,NN)] =node0+Nstride2+Nstride1 ;
208 }
209 }
210 }
211 /* face elements */
212 NN=out->FaceElements->numNodes;
213 totalNECount=NE0*NE1*NE2;
214 faceNECount=0;
215 /* these are the quadrilateral elements on boundary 1 (x3=0): */
216 if (!periodic[2] && (local_NE2>0)) {
217 /* ** elements on boundary 100 (x3=0): */
218 if (e_offset2==0) {
219 #pragma omp parallel for private(i0,i1,k,node0)
220 for (i1=0;i1<local_NE1;i1++) {
221 for (i0=0;i0<local_NE0;i0++) {
222
223 k=i0+local_NE0*i1+faceNECount;
224 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(i1+e_offset1);
225
226 out->FaceElements->Id[k]=(i0+e_offset0)+NE0*(i1+e_offset1)+totalNECount;
227 out->FaceElements->Tag[k]=100;
228 out->FaceElements->Owner[k]=myRank;
229
230 if (useElementsOnFace) {
231 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
232 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0 +Nstride1 ;
233 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0 +Nstride1+Nstride0;
234 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride0 ;
235 out->FaceElements->Nodes[INDEX2(4,k,NN)] =node0+Nstride2 ;
236 out->FaceElements->Nodes[INDEX2(5,k,NN)] =node0+Nstride2+Nstride1 ;
237 out->FaceElements->Nodes[INDEX2(6,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
238 out->FaceElements->Nodes[INDEX2(7,k,NN)] =node0+Nstride2 +Nstride0;
239 } else {
240 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
241 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+ Nstride1 ;
242 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+ Nstride1+Nstride0;
243 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride0;
244 }
245 }
246 }
247 faceNECount+=local_NE1*local_NE0;
248 }
249 totalNECount+=NE1*NE0;
250 /* ** elements on boundary 200 (x3=1) */
251 if (local_NE2+e_offset2 == NE2) {
252 #pragma omp parallel for private(i0,i1,k,node0)
253 for (i1=0;i1<local_NE1;i1++) {
254 for (i0=0;i0<local_NE0;i0++) {
255
256 k=i0+local_NE0*i1+faceNECount;
257 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(NE2-1);
258
259 out->FaceElements->Id[k]=(i0+e_offset0)+NE0*(i1+e_offset1)+totalNECount;
260 out->FaceElements->Tag[k]=200;
261 out->FaceElements->Owner[k]=myRank;
262 if (useElementsOnFace) {
263 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0+Nstride2 ;
264 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2+ Nstride0;
265 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
266 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+Nstride2+Nstride1 ;
267
268 out->FaceElements->Nodes[INDEX2(4,k,NN)] =node0 ;
269 out->FaceElements->Nodes[INDEX2(5,k,NN)] =node0+Nstride0 ;
270 out->FaceElements->Nodes[INDEX2(6,k,NN)] =node0+ Nstride1+Nstride0;
271 out->FaceElements->Nodes[INDEX2(7,k,NN)] =node0+ Nstride1;
272 } else {
273 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0+Nstride2 ;
274 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2 +Nstride0;
275 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
276 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+Nstride2+Nstride1 ;
277 }
278 }
279 }
280 faceNECount+=local_NE1*local_NE0;
281 }
282 totalNECount+=NE1*NE0;
283 }
284 if (!periodic[0] && (local_NE0>0)) {
285 /* ** elements on boundary 001 (x1=0): */
286
287 if (e_offset0 == 0) {
288 #pragma omp parallel for private(i1,i2,k,node0)
289 for (i2=0;i2<local_NE2;i2++) {
290 for (i1=0;i1<local_NE1;i1++) {
291
292 k=i1+local_NE1*i2+faceNECount;
293 node0=Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(i2+e_offset2);
294 out->FaceElements->Id[k]=(i1+e_offset1)+NE1*(i2+e_offset2)+totalNECount;
295 out->FaceElements->Tag[k]=1;
296 out->FaceElements->Owner[k]=myRank;
297
298 if (useElementsOnFace) {
299 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
300 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2 ;
301 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1 ;
302 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+Nstride1 ;
303 out->FaceElements->Nodes[INDEX2(4,k,NN)] =node0+Nstride0 ;
304 out->FaceElements->Nodes[INDEX2(5,k,NN)] =node0+Nstride2+Nstride0 ;
305 out->FaceElements->Nodes[INDEX2(6,k,NN)] =node0+Nstride2+Nstride1+Nstride0;
306 out->FaceElements->Nodes[INDEX2(7,k,NN)] =node0+Nstride1+Nstride0 ;
307 } else {
308 out->FaceElements->Nodes[INDEX2(0,k,NN)] =node0 ;
309 out->FaceElements->Nodes[INDEX2(1,k,NN)] =node0+Nstride2 ;
310 out->FaceElements->Nodes[INDEX2(2,k,NN)] =node0+Nstride2+Nstride1 ;
311 out->FaceElements->Nodes[INDEX2(3,k,NN)] =node0+ Nstride1 ;
312 }
313 }
314 }
315 faceNECount+=local_NE1*local_NE2;
316 }
317 totalNECount+=NE1*NE2;
318 /* ** elements on boundary 002 (x1=1): */
319 if (local_NE0+e_offset0 == NE0) {
320 #pragma omp parallel for private(i1,i2,k,node0)
321 for (i2=0;i2<local_NE2;i2++) {
322 for (i1=0;i1<local_NE1;i1++) {
323 k=i1+local_NE1*i2+faceNECount;
324 node0=Nstride0*N_PER_E*(NE0-1)+Nstride1*N_PER_E*(i1+e_offset1)+Nstride2*N_PER_E*(i2+e_offset2);
325 out->FaceElements->Id[k]=(i1+e_offset1)+NE1*(i2+e_offset2)+totalNECount;
326 out->FaceElements->Tag[k]=2;
327 out->FaceElements->Owner[k]=myRank;
328
329 if (useElementsOnFace) {
330 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0+ Nstride0;
331 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride1+Nstride0;
332 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
333 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2+ Nstride0;
334
335 out->FaceElements->Nodes[INDEX2(4,k,NN)]=node0 ;
336 out->FaceElements->Nodes[INDEX2(5,k,NN)]=node0+ Nstride1 ;
337 out->FaceElements->Nodes[INDEX2(6,k,NN)]=node0+Nstride2+Nstride1 ;
338 out->FaceElements->Nodes[INDEX2(7,k,NN)]=node0+Nstride2 ;
339
340 } else {
341 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0 +Nstride0;
342 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride1+Nstride0;
343 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
344 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2+ Nstride0;
345 }
346
347 }
348 }
349 faceNECount+=local_NE1*local_NE2;
350 }
351 totalNECount+=NE1*NE2;
352 }
353 if (!periodic[1] && (local_NE1>0)) {
354 /* ** elements on boundary 010 (x2=0): */
355 if (e_offset1 == 0) {
356 #pragma omp parallel for private(i0,i2,k,node0)
357 for (i2=0;i2<local_NE2;i2++) {
358 for (i0=0;i0<local_NE0;i0++) {
359 k=i0+local_NE0*i2+faceNECount;
360 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride2*N_PER_E*(i2+e_offset2);
361
362 out->FaceElements->Id[k]=(i2+e_offset2)+NE2*(e_offset0+i0)+totalNECount;
363 out->FaceElements->Tag[k]=10;
364 out->FaceElements->Owner[k]=myRank;
365 if (useElementsOnFace) {
366 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0 ;
367 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride0;
368 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2 +Nstride0;
369 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2 ;
370
371 out->FaceElements->Nodes[INDEX2(4,k,NN)]=node0+ Nstride1 ;
372 out->FaceElements->Nodes[INDEX2(5,k,NN)]=node0+Nstride1+ Nstride0;
373 out->FaceElements->Nodes[INDEX2(6,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
374 out->FaceElements->Nodes[INDEX2(7,k,NN)]=node0+Nstride2+Nstride1 ;
375 } else {
376 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0 ;
377 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+ Nstride0;
378 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+ Nstride0;
379 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride2 ;
380 }
381 }
382 }
383 faceNECount+=local_NE0*local_NE2;
384 }
385 totalNECount+=NE0*NE2;
386 /* ** elements on boundary 020 (x2=1): */
387 if (local_NE1+e_offset1 == NE1) {
388 #pragma omp parallel for private(i0,i2,k,node0)
389 for (i2=0;i2<local_NE2;i2++) {
390 for (i0=0;i0<local_NE0;i0++) {
391 k=i0+local_NE0*i2+faceNECount;
392 node0=Nstride0*N_PER_E*(i0+e_offset0)+Nstride1*N_PER_E*(NE1-1)+Nstride2*N_PER_E*(i2+e_offset2);
393
394 out->FaceElements->Id[k]=(i2+e_offset2)+NE2*(i0+e_offset0)+totalNECount;
395 out->FaceElements->Tag[k]=20;
396 out->FaceElements->Owner[k]=myRank;
397
398 if (useElementsOnFace) {
399 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0+ Nstride1 ;
400 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+Nstride2+Nstride1 ;
401 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
402 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+Nstride1+Nstride0 ;
403
404 out->FaceElements->Nodes[INDEX2(4,k,NN)]=node0 ;
405 out->FaceElements->Nodes[INDEX2(5,k,NN)]=node0+Nstride2 ;
406 out->FaceElements->Nodes[INDEX2(6,k,NN)]=node0+Nstride2+ Nstride0;
407 out->FaceElements->Nodes[INDEX2(7,k,NN)]=node0+ Nstride0;
408 } else {
409 out->FaceElements->Nodes[INDEX2(0,k,NN)]=node0+ Nstride1 ;
410 out->FaceElements->Nodes[INDEX2(1,k,NN)]=node0+Nstride2+Nstride1 ;
411 out->FaceElements->Nodes[INDEX2(2,k,NN)]=node0+Nstride2+Nstride1+Nstride0;
412 out->FaceElements->Nodes[INDEX2(3,k,NN)]=node0+ Nstride1+Nstride0;
413 }
414 }
415 }
416 faceNECount+=local_NE0*local_NE2;
417 }
418 totalNECount+=NE0*NE2;
419 }
420 }
421 if (Finley_noError()) {
422 /* add tag names */
423 Finley_Mesh_addTagMap(out,"top", 200);
424 Finley_Mesh_addTagMap(out,"bottom", 100);
425 Finley_Mesh_addTagMap(out,"left", 1);
426 Finley_Mesh_addTagMap(out,"right", 2);
427 Finley_Mesh_addTagMap(out,"front", 10);
428 Finley_Mesh_addTagMap(out,"back", 20);
429 }
430 /* prepare mesh for further calculations:*/
431 if (Finley_noError()) {
432 Finley_Mesh_resolveNodeIds(out);
433 }
434 if (Finley_noError()) {
435 Finley_Mesh_prepare(out, optimize);
436 }
437
438 if (!Finley_noError()) {
439 Finley_Mesh_free(out);
440 }
441 /* free up memory */
442 ReferenceElementSet_dealloc(refPoints);
443 ReferenceElementSet_dealloc(refContactElements);
444 ReferenceElementSet_dealloc(refFaceElements);
445 ReferenceElementSet_dealloc(refElements);
446 Esys_MPIInfo_free( mpi_info );
447
448 return out;
449 }

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision
svn:mergeinfo /branches/lapack2681/finley/src/Mesh_hex8.cpp:2682-2741 /branches/pasowrap/finley/src/Mesh_hex8.cpp:3661-3674 /branches/py3_attempt2/finley/src/Mesh_hex8.cpp:3871-3891 /branches/restext/finley/src/Mesh_hex8.cpp:2610-2624 /branches/ripleygmg_from_3668/finley/src/Mesh_hex8.cpp:3669-3791 /branches/stage3.0/finley/src/Mesh_hex8.cpp:2569-2590 /branches/symbolic_from_3470/finley/src/Mesh_hex8.cpp:3471-3974 /release/3.0/finley/src/Mesh_hex8.cpp:2591-2601 /trunk/finley/src/Mesh_hex8.cpp:4257-4344

  ViewVC Help
Powered by ViewVC 1.1.26