/[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 782 - (show annotations)
Tue Jul 18 00:47:47 2006 UTC (12 years, 9 months ago) by bcumming
File MIME type: text/plain
File size: 18362 byte(s)
Large number of changes to Finley for meshing in MPI.

- optimisation and neatening up of rectcanglular mesh generation code
- first and second order 1D, 2D and 3D rectangular meshes are now
  available in finley and escript using MPI.
- reduced meshes now generated in MPI, and interpolation to and from 
  reduced data types now supported.  

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 #else
168 out=Finley_Mesh_alloc(name,1,order);
169 if (! Finley_noError()) return NULL;
170
171 out->Elements=Finley_ElementFile_alloc(Line2,out->order);
172 if (useElementsOnFace) {
173 out->FaceElements=Finley_ElementFile_alloc(Line2Face,out->order);
174 out->ContactElements=Finley_ElementFile_alloc(Line2Face_Contact,out->order);
175 } else {
176 out->FaceElements=Finley_ElementFile_alloc(Point1,out->order);
177 out->ContactElements=Finley_ElementFile_alloc(Point1_Contact,out->order);
178 }
179 out->Points=Finley_ElementFile_alloc(Point1,out->order);
180 if (! Finley_noError()) {
181 Finley_Mesh_dealloc(out);
182 return NULL;
183 }
184
185 /* allocate tables: */
186
187 Finley_NodeFile_allocTable(out->Nodes,N0);
188 Finley_ElementFile_allocTable(out->Elements,NE0);
189 Finley_ElementFile_allocTable(out->FaceElements,NFaceElements);
190 #endif
191 if (! Finley_noError()) {
192 Finley_Mesh_dealloc(out);
193 return NULL;
194 }
195
196 /* set nodes: */
197
198 #pragma omp parallel for private(i0,k)
199 for (i0=0;i0<N0;i0++) {
200 k=i0;
201 out->Nodes->Coordinates[INDEX2(0,k,1)]=DBLE(i0)/DBLE(N0-1)*Length[0];
202 out->Nodes->Id[k]=k;
203 out->Nodes->Tag[k]=0;
204 out->Nodes->degreeOfFreedom[k]=(i0%NDOF0);
205 #ifdef PASO_MPI
206 out->Nodes->Dom[k] = NODE_INTERNAL;
207 #endif
208 }
209 if (!periodic[0]) {
210 out->Nodes->Tag[0]=1;
211 out->Nodes->Tag[N0-1]=2;
212 }
213
214 /* set the elements: */
215
216 #pragma omp parallel for private(i0,k)
217 for (i0=0;i0<NE0;i0++) {
218 k=i0;
219 out->Elements->Id[k]=k;
220 out->Elements->Tag[k]=0;
221 out->Elements->Color[k]=COLOR_MOD(i0);
222 #ifdef PASO_MPI
223 out->Elements->Dom[k] = ELEMENT_INTERNAL;
224 #endif
225
226 out->Elements->Nodes[INDEX2(0,k,2)]=i0;
227 out->Elements->Nodes[INDEX2(1,k,2)]=i0+1;
228 }
229 out->Elements->minColor=0;
230 out->Elements->maxColor=COLOR_MOD(0);
231
232 /* face elements: */
233 if (useElementsOnFace) {
234 NUMNODES=2;
235 } else {
236 NUMNODES=1;
237 }
238 if (!periodic[0]) {
239 out->FaceElements->Id[0]=NE0;
240 out->FaceElements->Tag[0]=1;
241 out->FaceElements->Color[0]=0;
242 #ifdef PASO_MPI
243 out->FaceElements->Dom[0] = ELEMENT_INTERNAL;
244 #endif
245 if (useElementsOnFace) {
246 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
247 out->FaceElements->Nodes[INDEX2(1,0,NUMNODES)]=1;
248 } else {
249 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
250 }
251
252 out->FaceElements->Id[1]=NE0+1;
253 out->FaceElements->Tag[1]=2;
254 out->FaceElements->Color[1]=1;
255 #ifdef PASO_MPI
256 out->FaceElements->Dom[1] = ELEMENT_INTERNAL;
257 #endif
258 if (useElementsOnFace) {
259 out->FaceElements->Nodes[INDEX2(0,1,NUMNODES)]=N0-1;
260 out->FaceElements->Nodes[INDEX2(1,1,NUMNODES)]=N0-2;
261 } else {
262 out->FaceElements->Nodes[INDEX2(0,1,NUMNODES)]=N0-1;
263 }
264 }
265 out->FaceElements->maxColor=1;
266 out->FaceElements->minColor=0;
267
268 #ifdef PASO_MPI
269 Finley_ElementFile_setDomainFlags( out->Elements );
270 Finley_ElementFile_setDomainFlags( out->FaceElements );
271 Finley_ElementFile_setDomainFlags( out->ContactElements );
272 Finley_ElementFile_setDomainFlags( out->Points );
273
274 /* reorder the degrees of freedom */
275 Finley_Mesh_resolveDegreeOfFreedomOrder( out, TRUE );
276 #endif
277
278 /* condense the nodes: */
279 Finley_Mesh_resolveNodeIds(out);
280
281 /* prepare mesh for further calculatuions:*/
282 Finley_Mesh_prepare(out) ;
283
284 #ifdef Finley_TRACE
285 printf("timing: mesh generation: %.4e sec\n",Finley_timer()-time0);
286 #endif
287
288 if (! Finley_noError()) {
289 Finley_Mesh_dealloc(out);
290 return NULL;
291 }
292
293 return out;
294 }
295 #ifdef PASO_MPI
296 Finley_Mesh* Finley_RectangularMesh_Line2(dim_t* numElements,double* Length,bool_t* periodic, dim_t order,bool_t useElementsOnFace)
297 {
298 /* MPI version */
299 dim_t N0, NE0, NE0_local, i0, NDOF0, NFaceElements, numNodesLocal, numDOFLocal, numElementsLocal, numElementsInternal, nodesExternal[2], DOFExternal[2], numNodesExternal, N0t, NDOF0t;
300 index_t NUMNODES,k,firstNode=0, firstNodeConstruct, DOFcount=0, forwardDOF[2], backwardDOF[2];
301 index_t targetDomain=-1, node0;
302 bool_t periodicLocal[2], domLeft=FALSE, domRight=FALSE, domInternal=FALSE, boundaryRight, boundaryLeft;
303 Finley_Mesh* out=NULL;
304 char name[50];
305 double time0=Finley_timer();
306 Paso_MPIInfo *mpi_info = NULL;
307
308 /* dimensions the global domain */
309 NE0=MAX(1,numElements[0]);
310 N0=NE0+1;
311 NDOF0=N0;
312 if( periodic[0] )
313 NDOF0--;
314
315 /* get MPI information */
316 mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );
317 if (! Finley_noError()) {
318 Finley_Mesh_dealloc(out);
319 return NULL;
320 }
321
322 /* use the serial code to generate the mesh in the 1-CPU case */
323 if( mpi_info->size==1 ){
324 out = Finley_RectangularMesh_Line2_singleCPU(numElements,Length,periodic,order,useElementsOnFace,mpi_info);
325 return out;
326 }
327
328 if( mpi_info->rank==0 )
329 domLeft = TRUE;
330 if( mpi_info->rank==mpi_info->size-1 )
331 domRight = TRUE;
332 if( mpi_info->rank>0 && mpi_info->rank<mpi_info->size-1 )
333 domInternal = TRUE;
334
335 /* dimensions of the local subdomain */
336 domain_calculateDimension( mpi_info->rank, mpi_info->size, NE0, periodic[0], &numNodesLocal, &numDOFLocal, &numElementsLocal, &numElementsInternal, &firstNode, nodesExternal, DOFExternal, &numNodesExternal, periodicLocal );
337
338 /* form face element if the local domain contains a periodic boundary */
339 NFaceElements = 0;
340 if( !periodic[0] )
341 {
342 if(domLeft)
343 NFaceElements++;
344 if(domRight)
345 NFaceElements++;
346 }
347
348 boundaryLeft = !domLeft || periodicLocal[0];
349 boundaryRight = !domRight || periodicLocal[1];
350 N0t = numNodesLocal + boundaryRight + boundaryLeft;
351 NDOF0t = numDOFLocal + boundaryRight + boundaryLeft;
352 firstNodeConstruct = firstNode - boundaryLeft;
353 firstNodeConstruct = firstNodeConstruct<0 ? N0-2 : firstNodeConstruct;
354
355 /* allocate mesh: */
356 sprintf(name,"Rectangular mesh with %d nodes",N0);
357 out=Finley_Mesh_alloc(name,1,order,mpi_info);
358 if (! Finley_noError()) return NULL;
359
360 out->Elements=Finley_ElementFile_alloc(Line2,out->order,mpi_info);
361 if (useElementsOnFace) {
362 out->FaceElements=Finley_ElementFile_alloc(Line2Face,out->order,mpi_info);
363 out->ContactElements=Finley_ElementFile_alloc(Line2Face_Contact,out->order,mpi_info);
364 } else {
365 out->FaceElements=Finley_ElementFile_alloc(Point1,out->order,mpi_info);
366 out->ContactElements=Finley_ElementFile_alloc(Point1_Contact,out->order,mpi_info);
367 }
368 out->Points=Finley_ElementFile_alloc(Point1,out->order,mpi_info);
369 if (! Finley_noError()) {
370 Finley_Mesh_dealloc(out);
371 return NULL;
372 }
373
374 /* allocate tables: */
375
376 Finley_NodeFile_allocTable(out->Nodes,numNodesLocal+numNodesExternal);
377 Finley_NodeDistribution_allocTable( out->Nodes->degreeOfFreedomDistribution, numNodesLocal, numNodesExternal, 0);
378 Finley_ElementFile_allocTable(out->Elements,numElementsLocal);
379 if( NFaceElements )
380 Finley_ElementFile_allocTable(out->FaceElements,NFaceElements);
381 if (! Finley_noError()) {
382 Finley_Mesh_dealloc(out);
383 return NULL;
384 }
385
386 /* set nodes: */
387 #pragma omp parallel for private(i0,k)
388 /* local nodes */
389 for (i0=0;i0<N0t;i0++) {
390 k=i0;
391 out->Nodes->Coordinates[INDEX2(0,k,1)]=DBLE((i0+firstNodeConstruct) % N0)/DBLE(N0-1)*Length[0];
392 out->Nodes->Id[k]=k;
393 out->Nodes->Tag[k]=0;
394 out->Nodes->degreeOfFreedom[k]=k;
395 out->Nodes->Dom[k]=NODE_INTERNAL;
396 }
397
398 /* setup boundary DOF data */
399 if( boundaryLeft ){
400 out->Nodes->Dom[0] = NODE_EXTERNAL;
401 out->Nodes->Dom[1] = NODE_BOUNDARY;
402 }
403 else
404 out->Nodes->Tag[0] += 1;
405 if( boundaryRight ){
406 out->Nodes->Dom[N0t-1] = NODE_EXTERNAL;
407 out->Nodes->Dom[N0t-2] = NODE_BOUNDARY;
408 }
409 else
410 out->Nodes->Tag[N0t-1] += 2;
411 if( periodicLocal[0] ){
412 out->Nodes->degreeOfFreedom[2] = out->Nodes->degreeOfFreedom[1];
413 out->Nodes->Dom[2] = out->Nodes->Dom[1];
414 }
415
416 if( !(mpi_info->size==2 && periodicLocal[0])){
417 if( boundaryLeft ) {
418 targetDomain = mpi_info->rank-1 < 0 ? mpi_info->size-1 : mpi_info->rank-1;
419 forwardDOF[0] = out->Nodes->degreeOfFreedom[1];
420 backwardDOF[0] = out->Nodes->degreeOfFreedom[0];
421 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
422 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
423 }
424 if( boundaryRight ) {
425 targetDomain = mpi_info->rank+1 > mpi_info->size-1 ? 0 : mpi_info->rank+1;
426 forwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-2];
427 backwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-1];
428 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
429 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
430 }
431 } else{
432 /* periodic boundary conditions with 2 domains, need to change the order in which domain 0 passes boundary data */
433 targetDomain = 1;
434
435 forwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-2];
436 backwardDOF[0] = out->Nodes->degreeOfFreedom[N0t-1];
437 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
438 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
439
440 forwardDOF[0] = out->Nodes->degreeOfFreedom[1];
441 backwardDOF[0] = out->Nodes->degreeOfFreedom[0];
442 Finley_NodeDistribution_addForward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, forwardDOF );
443 Finley_NodeDistribution_addBackward( out->Nodes->degreeOfFreedomDistribution, targetDomain, 1, backwardDOF );
444 }
445
446 if (! Finley_MPI_noError(mpi_info)) {
447 Finley_Mesh_dealloc(out);
448 return NULL;
449 }
450
451 /* set the elements: */
452 /* form internal elements */
453 #pragma omp parallel for private(i0,k)
454 for (i0=0;i0<numElementsLocal;i0++)
455 {
456 k=i0;
457 node0 = (periodicLocal[0] && !i0) ? 0 : i0 + periodicLocal[0];
458
459 out->Elements->Id[k]=k;
460 out->Elements->Tag[k]=0;
461 out->Elements->Color[k]=COLOR_MOD(i0);
462 out->Elements->Dom[k]=ELEMENT_INTERNAL;
463
464 out->Elements->Nodes[INDEX2(0,k,2)]=node0;
465 out->Elements->Nodes[INDEX2(1,k,2)]=node0+1;
466 }
467 if( boundaryLeft )
468 out->Elements->Dom[0] = ELEMENT_BOUNDARY;
469 if( boundaryRight )
470 out->Elements->Dom[numElementsLocal-1] = ELEMENT_BOUNDARY;
471
472 out->Elements->minColor=0;
473 out->Elements->maxColor=COLOR_MOD(0);
474
475 Finley_ElementFile_setDomainFlags( out->Elements );
476
477 /* face elements: */
478 if (useElementsOnFace) {
479 NUMNODES=2;
480 } else {
481 NUMNODES=1;
482 }
483 i0 = numElementsLocal;
484 if ( domLeft && !periodicLocal[0] )
485 {
486 out->FaceElements->Id[0]=i0;
487 out->FaceElements->Tag[0]=1;
488 out->FaceElements->Color[0]=0;
489 out->FaceElements->Dom[0]=ELEMENT_INTERNAL;
490 if (useElementsOnFace) {
491 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
492 out->FaceElements->Nodes[INDEX2(1,0,NUMNODES)]=1;
493 } else {
494 out->FaceElements->Nodes[INDEX2(0,0,NUMNODES)]=0;
495 }
496 i0++;
497 }
498 if( domRight && !periodicLocal[1])
499 {
500 out->FaceElements->Id[domLeft]=i0;
501 out->FaceElements->Tag[domLeft]=2;
502 out->FaceElements->Color[domLeft]=1;
503 out->FaceElements->Dom[domLeft]=ELEMENT_INTERNAL;
504 if (useElementsOnFace) {
505 out->FaceElements->Nodes[INDEX2(0,domLeft,NUMNODES)]=N0t-1;
506 out->FaceElements->Nodes[INDEX2(1,domLeft,NUMNODES)]=N0t-2;
507 } else {
508 out->FaceElements->Nodes[INDEX2(0,domLeft,NUMNODES)]=N0t-1;
509 }
510 }
511 out->FaceElements->numElements=NFaceElements;
512 out->FaceElements->maxColor=1;
513 out->FaceElements->minColor=0;
514
515 Finley_ElementFile_setDomainFlags( out->FaceElements );
516
517 /* setup distribution info for other elements */
518 Finley_ElementFile_setDomainFlags( out->ContactElements );
519 Finley_ElementFile_setDomainFlags( out->Points );
520
521 /* reorder the degrees of freedom */
522 Finley_Mesh_resolveDegreeOfFreedomOrder( out, TRUE );
523
524 /* condense the nodes: */
525 Finley_Mesh_resolveNodeIds(out);
526 if( !Finley_MPI_noError(mpi_info) )
527 {
528 Paso_MPIInfo_dealloc( mpi_info );
529 Finley_Mesh_dealloc(out);
530 return NULL;
531 }
532
533 /* prepare mesh for further calculatuions:*/
534 Finley_Mesh_prepare(out);
535 if( !Finley_MPI_noError(mpi_info) )
536 {
537 Paso_MPIInfo_dealloc( mpi_info );
538 Finley_Mesh_dealloc(out);
539 return NULL;
540 }
541
542 /* free up memory */
543 Paso_MPIInfo_dealloc( mpi_info );
544
545 #ifdef Finley_TRACE
546 printf("timing: mesh generation: %.4e sec\n",Finley_timer()-time0);
547 #endif
548
549 return out;
550 }
551 #endif
552
553
554
555
556 /*
557 * Revision 1.3 2005/09/01 03:31:36 jgs
558 * Merge of development branch dev-02 back to main trunk on 2005-09-01
559 *
560 * Revision 1.2.2.2 2005/09/07 06:26:19 gross
561 * the solver from finley are put into the standalone package paso now
562 *
563 * Revision 1.2.2.1 2005/08/24 02:02:18 gross
564 * timing output switched off. solver output can be swiched through getSolution(verbose=True) now.
565 *
566 * Revision 1.2 2005/07/08 04:07:52 jgs
567 * Merge of development branch back to main trunk on 2005-07-08
568 *
569 * Revision 1.1.1.1.2.2 2005/06/30 01:53:56 gross
570 * a bug in coloring fixed
571 *
572 * Revision 1.1.1.1.2.1 2005/06/29 02:34:52 gross
573 * some changes towards 64 integers in finley
574 *
575 * Revision 1.1.1.1 2004/10/26 06:53:57 jgs
576 * initial import of project esys2
577 *
578 * Revision 1.1.1.1 2004/06/24 04:00:40 johng
579 * Initial version of eys using boost-python.
580 *
581 *
582 */
583

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26