/[escript]/trunk/finley/src/Mesh_line2.c
ViewVC logotype

Contents of /trunk/finley/src/Mesh_line2.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 787 - (show annotations)
Wed Jul 26 01:46:45 2006 UTC (13 years, 2 months ago) by bcumming
File MIME type: text/plain
File size: 18779 byte(s)
MPI update
Each element (normal elements, faceElements, ContactElements and points)
are now assigned a unique global id to streamline per-element
calculations and file IO of element data.



1 /*
2 ************************************************************
3 * Copyright 2006 by ACcESS MNRF *
4 * *
5 * http://www.access.edu.au *
6 * Primary Business: Queensland, Australia *
7 * Licensed under the Open Software License version 3.0 *
8 * http://www.opensource.org/licenses/osl-3.0.php *
9 * *
10 ************************************************************
11 */
12
13 /**************************************************************/
14
15 /* Finley: generates rectangular meshes */
16
17 /* Generates numElements[0] mesh with first order elements (Line2) in
18 the interval [0,Length[0]]. order is the desired accuracy of the
19 integration scheme. */
20
21
22 /**************************************************************/
23
24 /* Author: gross@access.edu.au */
25 /* Version: $Id$ */
26
27 /**************************************************************/
28
29 #include "RectangularMesh.h"
30
31 /**************************************************************/
32
33 #ifdef PASO_MPI
34 /* get the number of nodes/elements for domain with rank=rank, of size processors
35 where n is the total number of nodes/elements in the global domain */
36 static index_t domain_MODdim( index_t rank, index_t size, index_t n )
37 {
38 rank = size-rank-1;
39
40 if( rank < n%size )
41 return (index_t)floor(n/size)+1;
42 return (index_t)floor(n/size);
43 }
44
45
46 /* Determines the number of nodes/elements etc along an axis which is numElementsGlobal long for domain rank */
47 /* A bit messy, but it only has to be done once... */
48 static void domain_calculateDimension( index_t rank, dim_t size, dim_t numElementsGlobal, bool_t periodic, dim_t *numNodesLocal, dim_t *numDOFLocal, dim_t *numElementsLocal, dim_t *numElementsInternal, dim_t *firstNode, dim_t *nodesExternal, dim_t *DOFExternal, dim_t *numNodesExternal, bool_t *periodicLocal )
49 {
50 index_t i0;
51 dim_t numNodesGlobal = numElementsGlobal+1;
52
53 (*numNodesLocal) = domain_MODdim( rank, size, numNodesGlobal );
54
55 numElementsLocal[0] = numNodesLocal[0]+1;
56 periodicLocal[0] = periodicLocal[1] = FALSE;
57 nodesExternal[0] = nodesExternal[1] = 1;
58 if( periodic )
59 {
60 if( size==1 )
61 {
62 numElementsLocal[0] = numElementsGlobal;
63 nodesExternal[0] = nodesExternal[1] = 0;
64 periodicLocal[0] = periodicLocal[1] = TRUE;
65 }
66 else
67 {
68 if( rank==0 )
69 {
70 periodicLocal[0] = TRUE;
71 numNodesLocal[0]++;
72 }
73 if( rank==(size-1) )
74 {
75 periodicLocal[1] = TRUE;
76 numNodesLocal[0]--;
77 numElementsLocal[0]--;
78 }
79 }
80 }
81 else if( !periodic )
82 {
83 if( rank==0 ){
84 nodesExternal[0]--;
85 numElementsLocal[0]--;
86 }
87 if( rank==(size-1) )
88 {
89 nodesExternal[1]--;
90 numElementsLocal[0]--;
91 }
92 }
93 numNodesExternal[0] = nodesExternal[0]+nodesExternal[1];
94
95 numElementsInternal[0] = numElementsLocal[0];
96 if( (rank==0) && (rank==size-1) );
97
98 else if( !periodic && ( (rank==0) ^ (rank==size-1) ) )
99 numElementsInternal[0] -= 1;
100 else
101 numElementsInternal[0] -= 2;
102
103 firstNode[0] = 0;
104 for( i0=0; i0<rank; i0++ )
105 firstNode[0] += domain_MODdim( i0, size, numNodesGlobal );
106
107 numDOFLocal[0] = numNodesLocal[0];
108 if( periodicLocal[0] )
109 {
110 numDOFLocal[0]--;
111 }
112 DOFExternal[0] = nodesExternal[0];
113 DOFExternal[1] = nodesExternal[1];
114 }
115
116 #endif
117
118 #ifdef PASO_MPI
119 Finley_Mesh* Finley_RectangularMesh_Line2_singleCPU(dim_t* numElements,double* Length,bool_t* periodic, dim_t order,bool_t useElementsOnFace, Paso_MPIInfo *mpi_info)
120 #else
121 Finley_Mesh* Finley_RectangularMesh_Line2(dim_t* numElements,double* Length,bool_t* periodic, dim_t order,bool_t useElementsOnFace)
122 #endif
123 {
124 /* Serial/OpenMP version */
125 dim_t N0,NE0,i0,NDOF0,NFaceElements;
126 index_t NUMNODES,k;
127 Finley_Mesh* out;
128 char name[50];
129 double time0=Finley_timer();
130 NE0=MAX(1,numElements[0]);
131 N0=NE0+1;
132
133 if (!periodic[0]) {
134 NDOF0=N0;
135 NFaceElements=2;
136 } else {
137 NDOF0=N0-1;
138 NFaceElements=0;
139 }
140
141 /* allocate mesh: */
142
143 sprintf(name,"Rectangular mesh with %d nodes",N0);
144 #ifdef PASO_MPI
145 out=Finley_Mesh_alloc(name,1,order,mpi_info);
146 if (! Finley_noError()) return NULL;
147
148 out->Elements=Finley_ElementFile_alloc(Line2,out->order,mpi_info);
149 if (useElementsOnFace) {
150 out->FaceElements=Finley_ElementFile_alloc(Line2Face,out->order,mpi_info);
151 out->ContactElements=Finley_ElementFile_alloc(Line2Face_Contact,out->order,mpi_info);
152 } else {
153 out->FaceElements=Finley_ElementFile_alloc(Point1,out->order,mpi_info);
154 out->ContactElements=Finley_ElementFile_alloc(Point1_Contact,out->order,mpi_info);
155 }
156 out->Points=Finley_ElementFile_alloc(Point1,out->order,mpi_info);
157 if (! Finley_noError()) {
158 Finley_Mesh_dealloc(out);
159 return NULL;
160 }
161
162 /* allocate tables: */
163 Finley_NodeFile_allocTable(out->Nodes,N0);
164 Finley_NodeDistribution_allocTable( out->Nodes->degreeOfFreedomDistribution, N0, 0, 0);
165 Finley_ElementFile_allocTable(out->Elements,NE0);
166 Finley_ElementFile_allocTable(out->FaceElements,NFaceElements);
167 Finley_ElementDistribution_allocTable( out->Elements->elementDistribution, NE0, 0);
168 Finley_ElementDistribution_allocTable( out->FaceElements->elementDistribution, NFaceElements, 0 );
169 #else
170 out=Finley_Mesh_alloc(name,1,order);
171 if (! Finley_noError()) return NULL;
172
173 out->Elements=Finley_ElementFile_alloc(Line2,out->order);
174 if (useElementsOnFace) {
175 out->FaceElements=Finley_ElementFile_alloc(Line2Face,out->order);
176 out->ContactElements=Finley_ElementFile_alloc(Line2Face_Contact,out->order);
177 } else {
178 out->FaceElements=Finley_ElementFile_alloc(Point1,out->order);
179 out->ContactElements=Finley_ElementFile_alloc(Point1_Contact,out->order);
180 }
181 out->Points=Finley_ElementFile_alloc(Point1,out->order);
182 if (! Finley_noError()) {
183 Finley_Mesh_dealloc(out);
184 return NULL;
185 }
186
187 /* allocate tables: */
188
189 Finley_NodeFile_allocTable(out->Nodes,N0);
190 Finley_ElementFile_allocTable(out->Elements,NE0);
191 Finley_ElementFile_allocTable(out->FaceElements,NFaceElements);
192 #endif
193 if (! Finley_noError()) {
194 Finley_Mesh_dealloc(out);
195 return NULL;
196 }
197
198 /* set nodes: */
199
200 #pragma omp parallel for private(i0,k)
201 for (i0=0;i0<N0;i0++) {
202 k=i0;
203 out->Nodes->Coordinates[INDEX2(0,k,1)]=DBLE(i0)/DBLE(N0-1)*Length[0];
204 out->Nodes->Id[k]=k;
205 out->Nodes->Tag[k]=0;
206 out->Nodes->degreeOfFreedom[k]=(i0%NDOF0);
207 #ifdef PASO_MPI
208 out->Nodes->Dom[k] = NODE_INTERNAL;
209 #endif
210 }
211 if (!periodic[0]) {
212 out->Nodes->Tag[0]=1;
213 out->Nodes->Tag[N0-1]=2;
214 }
215
216 /* set the elements: */
217
218 #pragma omp parallel for private(i0,k)
219 for (i0=0;i0<NE0;i0++) {
220 k=i0;
221 out->Elements->Id[k]=k;
222 out->Elements->Tag[k]=0;
223 out->Elements->Color[k]=COLOR_MOD(i0);
224 #ifdef PASO_MPI
225 out->Elements->Dom[k] = ELEMENT_INTERNAL;
226 #endif
227
228 out->Elements->Nodes[INDEX2(0,k,2)]=i0;
229 out->Elements->Nodes[INDEX2(1,k,2)]=i0+1;
230 }
231 out->Elements->minColor=0;
232 out->Elements->maxColor=COLOR_MOD(0);
233
234 /* face elements: */
235 if (useElementsOnFace) {
236 NUMNODES=2;
237 } else {
238 NUMNODES=1;
239 }
240 if (!periodic[0]) {
241 out->FaceElements->Id[0]=NE0;
242 out->FaceElements->Tag[0]=1;
243 out->FaceElements->Color[0]=0;
244 #ifdef PASO_MPI
245 out->FaceElements->Dom[0] = ELEMENT_INTERNAL;
246 #endif
247 if (useElementsOnFace) {
248 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
249 out->FaceElements->Nodes[INDEX2(1,0,NUMNODES)]=1;
250 } else {
251 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
252 }
253
254 out->FaceElements->Id[1]=NE0+1;
255 out->FaceElements->Tag[1]=2;
256 out->FaceElements->Color[1]=1;
257 #ifdef PASO_MPI
258 out->FaceElements->Dom[1] = ELEMENT_INTERNAL;
259 #endif
260 if (useElementsOnFace) {
261 out->FaceElements->Nodes[INDEX2(0,1,NUMNODES)]=N0-1;
262 out->FaceElements->Nodes[INDEX2(1,1,NUMNODES)]=N0-2;
263 } else {
264 out->FaceElements->Nodes[INDEX2(0,1,NUMNODES)]=N0-1;
265 }
266 }
267 out->FaceElements->maxColor=1;
268 out->FaceElements->minColor=0;
269
270 #ifdef PASO_MPI
271 Finley_ElementFile_setDomainFlags( out->Elements );
272 Finley_ElementFile_setDomainFlags( out->FaceElements );
273 Finley_ElementFile_setDomainFlags( out->ContactElements );
274 Finley_ElementFile_setDomainFlags( out->Points );
275
276 /* reorder the degrees of freedom */
277 Finley_Mesh_resolveDegreeOfFreedomOrder( out, TRUE );
278 #endif
279
280 /* condense the nodes: */
281 Finley_Mesh_resolveNodeIds(out);
282
283 /* prepare mesh for further calculatuions:*/
284 Finley_Mesh_prepare(out) ;
285
286 #ifdef Finley_TRACE
287 printf("timing: mesh generation: %.4e sec\n",Finley_timer()-time0);
288 #endif
289
290 if (! Finley_noError()) {
291 Finley_Mesh_dealloc(out);
292 return NULL;
293 }
294
295 return out;
296 }
297 #ifdef PASO_MPI
298 Finley_Mesh* Finley_RectangularMesh_Line2(dim_t* numElements,double* Length,bool_t* periodic, dim_t order,bool_t useElementsOnFace)
299 {
300 /* MPI version */
301 dim_t N0, NE0, NE0_local, i0, NDOF0, NFaceElements, numNodesLocal, numDOFLocal, numElementsLocal, numElementsInternal, nodesExternal[2], DOFExternal[2], numNodesExternal, N0t, NDOF0t;
302 index_t NUMNODES,k,firstNode=0, firstNodeConstruct, DOFcount=0, forwardDOF[2], backwardDOF[2];
303 index_t targetDomain=-1, node0;
304 bool_t periodicLocal[2], domLeft=FALSE, domRight=FALSE, domInternal=FALSE, boundaryRight, boundaryLeft;
305 Finley_Mesh* out=NULL;
306 char name[50];
307 double time0=Finley_timer();
308 Paso_MPIInfo *mpi_info = NULL;
309
310 /* dimensions the global domain */
311 NE0=MAX(1,numElements[0]);
312 N0=NE0+1;
313 NDOF0=N0;
314 if( periodic[0] )
315 NDOF0--;
316
317 /* get MPI information */
318 mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );
319 if (! Finley_noError()) {
320 Finley_Mesh_dealloc(out);
321 return NULL;
322 }
323
324 /* use the serial code to generate the mesh in the 1-CPU case */
325 if( mpi_info->size==1 ){
326 out = Finley_RectangularMesh_Line2_singleCPU(numElements,Length,periodic,order,useElementsOnFace,mpi_info);
327 return out;
328 }
329
330 if( mpi_info->rank==0 )
331 domLeft = TRUE;
332 if( mpi_info->rank==mpi_info->size-1 )
333 domRight = TRUE;
334 if( mpi_info->rank>0 && mpi_info->rank<mpi_info->size-1 )
335 domInternal = TRUE;
336
337 /* dimensions of the local subdomain */
338 domain_calculateDimension( mpi_info->rank, mpi_info->size, NE0, periodic[0], &numNodesLocal, &numDOFLocal, &numElementsLocal, &numElementsInternal, &firstNode, nodesExternal, DOFExternal, &numNodesExternal, periodicLocal );
339
340 /* form face element if the local domain contains a periodic boundary */
341 NFaceElements = 0;
342 if( !periodic[0] )
343 {
344 if(domLeft)
345 NFaceElements++;
346 if(domRight)
347 NFaceElements++;
348 }
349
350 boundaryLeft = !domLeft || periodicLocal[0];
351 boundaryRight = !domRight || periodicLocal[1];
352 N0t = numNodesLocal + boundaryRight + boundaryLeft;
353 NDOF0t = numDOFLocal + boundaryRight + boundaryLeft;
354 firstNodeConstruct = firstNode - boundaryLeft;
355 firstNodeConstruct = firstNodeConstruct<0 ? N0-2 : firstNodeConstruct;
356
357 /* allocate mesh: */
358 sprintf(name,"Rectangular mesh with %d nodes",N0);
359 out=Finley_Mesh_alloc(name,1,order,mpi_info);
360 if (! Finley_noError()) return NULL;
361
362 out->Elements=Finley_ElementFile_alloc(Line2,out->order,mpi_info);
363 if (useElementsOnFace) {
364 out->FaceElements=Finley_ElementFile_alloc(Line2Face,out->order,mpi_info);
365 out->ContactElements=Finley_ElementFile_alloc(Line2Face_Contact,out->order,mpi_info);
366 } else {
367 out->FaceElements=Finley_ElementFile_alloc(Point1,out->order,mpi_info);
368 out->ContactElements=Finley_ElementFile_alloc(Point1_Contact,out->order,mpi_info);
369 }
370 out->Points=Finley_ElementFile_alloc(Point1,out->order,mpi_info);
371 if (! Finley_noError()) {
372 Finley_Mesh_dealloc(out);
373 return NULL;
374 }
375
376 /* allocate tables: */
377
378 Finley_NodeFile_allocTable(out->Nodes,numNodesLocal+numNodesExternal);
379 Finley_NodeDistribution_allocTable( out->Nodes->degreeOfFreedomDistribution, numNodesLocal, numNodesExternal, 0);
380 Finley_ElementFile_allocTable(out->Elements,numElementsLocal);
381 Finley_ElementFile_allocTable(out->FaceElements,NFaceElements);
382 Finley_ElementDistribution_allocTable( out->Elements->elementDistribution, numElementsLocal, domRight);
383 Finley_ElementDistribution_allocTable( out->FaceElements->elementDistribution, NFaceElements, 0 );
384 if (! Finley_noError()) {
385 Finley_Mesh_dealloc(out);
386 return NULL;
387 }
388
389 /* set nodes: */
390 #pragma omp parallel for private(i0,k)
391 /* local nodes */
392 for (i0=0;i0<N0t;i0++) {
393 k=i0;
394 out->Nodes->Coordinates[INDEX2(0,k,1)]=DBLE((i0+firstNodeConstruct) % N0)/DBLE(N0-1)*Length[0];
395 out->Nodes->Id[k]=k;
396 out->Nodes->Tag[k]=0;
397 out->Nodes->degreeOfFreedom[k]=k;
398 out->Nodes->Dom[k]=NODE_INTERNAL;
399 }
400
401 /* setup boundary DOF data */
402 if( boundaryLeft ){
403 out->Nodes->Dom[0] = NODE_EXTERNAL;
404 out->Nodes->Dom[1] = NODE_BOUNDARY;
405 }
406 else
407 out->Nodes->Tag[0] += 1;
408 if( boundaryRight ){
409 out->Nodes->Dom[N0t-1] = NODE_EXTERNAL;
410 out->Nodes->Dom[N0t-2] = NODE_BOUNDARY;
411 }
412 else
413 out->Nodes->Tag[N0t-1] += 2;
414 if( periodicLocal[0] ){
415 out->Nodes->degreeOfFreedom[2] = out->Nodes->degreeOfFreedom[1];
416 out->Nodes->Dom[2] = out->Nodes->Dom[1];
417 }
418
419 if( !(mpi_info->size==2 && periodicLocal[0])){
420 if( boundaryLeft ) {
421 targetDomain = mpi_info->rank-1 < 0 ? mpi_info->size-1 : mpi_info->rank-1;
422 forwardDOF[0] = out->Nodes->degreeOfFreedom[1];
423 backwardDOF[0] = out->Nodes->degreeOfFreedom[0];
424 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
425 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
426 }
427 if( boundaryRight ) {
428 targetDomain = mpi_info->rank+1 > mpi_info->size-1 ? 0 : mpi_info->rank+1;
429 forwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-2];
430 backwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-1];
431 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
432 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
433 }
434 } else{
435 /* periodic boundary conditions with 2 domains, need to change the order in which domain 0 passes boundary data */
436 targetDomain = 1;
437
438 forwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-2];
439 backwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-1];
440 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
441 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
442
443 forwardDOF[0] = out->Nodes->degreeOfFreedom[1];
444 backwardDOF[0] = out->Nodes->degreeOfFreedom[0];
445 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
446 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
447 }
448
449 if (! Finley_MPI_noError(mpi_info)) {
450 Finley_Mesh_dealloc(out);
451 return NULL;
452 }
453
454 /* set the elements: */
455 /* form internal elements */
456 #pragma omp parallel for private(i0,k)
457 for (i0=0;i0<numElementsLocal;i0++)
458 {
459 k=i0;
460 node0 = (periodicLocal[0] && !i0) ? 0 : i0 + periodicLocal[0];
461
462 out->Elements->Id[k]=(i0+firstNodeConstruct) % NE0;
463 out->Elements->Tag[k]=0;
464 out->Elements->Color[k]=COLOR_MOD(i0);
465 out->Elements->Dom[k]=ELEMENT_INTERNAL;
466
467 out->Elements->Nodes[INDEX2(0,k,2)]=node0;
468 out->Elements->Nodes[INDEX2(1,k,2)]=node0+1;
469 }
470 if( boundaryLeft )
471 out->Elements->Dom[0] = ELEMENT_BOUNDARY;
472 if( boundaryRight )
473 out->Elements->Dom[numElementsLocal-1] = ELEMENT_BOUNDARY;
474
475 out->Elements->minColor=0;
476 out->Elements->maxColor=COLOR_MOD(0);
477
478 Finley_ElementFile_setDomainFlags( out->Elements );
479
480 /* face elements: */
481 if (useElementsOnFace) {
482 NUMNODES=2;
483 } else {
484 NUMNODES=1;
485 }
486 if ( domLeft && !periodicLocal[0] )
487 {
488 out->FaceElements->Id[0]=NE0;
489 out->FaceElements->Tag[0]=1;
490 out->FaceElements->Color[0]=0;
491 out->FaceElements->Dom[0]=ELEMENT_INTERNAL;
492 if (useElementsOnFace) {
493 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
494 out->FaceElements->Nodes[INDEX2(1,0,NUMNODES)]=1;
495 } else {
496 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
497 }
498 }
499 if( domRight && !periodicLocal[1])
500 {
501 out->FaceElements->Id[domLeft]=NE0+1;
502 out->FaceElements->Tag[domLeft]=2;
503 out->FaceElements->Color[domLeft]=1;
504 out->FaceElements->Dom[domLeft]=ELEMENT_INTERNAL;
505 if (useElementsOnFace) {
506 out->FaceElements->Nodes[INDEX2(0,domLeft,NUMNODES)]=N0t-1;
507 out->FaceElements->Nodes[INDEX2(1,domLeft,NUMNODES)]=N0t-2;
508 } else {
509 out->FaceElements->Nodes[INDEX2(0,domLeft,NUMNODES)]=N0t-1;
510 }
511 }
512 out->FaceElements->numElements=NFaceElements;
513 out->FaceElements->maxColor=1;
514 out->FaceElements->minColor=0;
515
516 Finley_ElementFile_setDomainFlags( out->FaceElements );
517
518 /* setup distribution info for other elements */
519 Finley_ElementFile_setDomainFlags( out->ContactElements );
520 Finley_ElementFile_setDomainFlags( out->Points );
521
522 Finley_Mesh_prepareElementDistribution( out );
523
524 /* reorder the degrees of freedom */
525 Finley_Mesh_resolveDegreeOfFreedomOrder( out, TRUE );
526
527 /* condense the nodes: */
528 Finley_Mesh_resolveNodeIds(out);
529 if( !Finley_MPI_noError(mpi_info) )
530 {
531 Paso_MPIInfo_dealloc( mpi_info );
532 Finley_Mesh_dealloc(out);
533 return NULL;
534 }
535
536 /* prepare mesh for further calculatuions:*/
537 Finley_Mesh_prepare(out);
538 if( !Finley_MPI_noError(mpi_info) )
539 {
540 Paso_MPIInfo_dealloc( mpi_info );
541 Finley_Mesh_dealloc(out);
542 return NULL;
543 }
544
545 /* free up memory */
546 Paso_MPIInfo_dealloc( mpi_info );
547
548 #ifdef Finley_TRACE
549 printf("timing: mesh generation: %.4e sec\n",Finley_timer()-time0);
550 #endif
551
552 return out;
553 }
554 #endif
555
556
557
558
559 /*
560 * Revision 1.3 2005/09/01 03:31:36 jgs
561 * Merge of development branch dev-02 back to main trunk on 2005-09-01
562 *
563 * Revision 1.2.2.2 2005/09/07 06:26:19 gross
564 * the solver from finley are put into the standalone package paso now
565 *
566 * Revision 1.2.2.1 2005/08/24 02:02:18 gross
567 * timing output switched off. solver output can be swiched through getSolution(verbose=True) now.
568 *
569 * Revision 1.2 2005/07/08 04:07:52 jgs
570 * Merge of development branch back to main trunk on 2005-07-08
571 *
572 * Revision 1.1.1.1.2.2 2005/06/30 01:53:56 gross
573 * a bug in coloring fixed
574 *
575 * Revision 1.1.1.1.2.1 2005/06/29 02:34:52 gross
576 * some changes towards 64 integers in finley
577 *
578 * Revision 1.1.1.1 2004/10/26 06:53:57 jgs
579 * initial import of project esys2
580 *
581 * Revision 1.1.1.1 2004/06/24 04:00:40 johng
582 * Initial version of eys using boost-python.
583 *
584 *
585 */
586

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26