← Back to branch summary

~vcs-imports/escript-finley/trunk

« back to all changes in this revision

Viewing changes to finley/src/Mesh_read.c

  • Committer: jfenwick
  • Date: 2010-10-11 01:48:14 UTC
  • Revision ID: svn-v4:77569008-7704-0410-b7a0-a92fef0b09fd:trunk:3259
Merging dudley and scons updates from branches

Show diffs side-by-side

added added

removed removed

Lines of Context:
finley/src/Mesh_read.c
26
26
 
27
27
Finley_Mesh* Finley_Mesh_read(char* fname,index_t order, index_t reduced_order,  bool_t optimize)
28
28
{
29
 
    Paso_MPIInfo *mpi_info = NULL;
 
29
    Esys_MPIInfo *mpi_info = NULL;
30
30
    dim_t numNodes, numDim, numEle, i0, i1;
31
31
    Finley_Mesh *mesh_p=NULL;
32
32
    Finley_ReferenceElementSet *refPoints=NULL, *refContactElements=NULL, *refFaceElements=NULL, *refElements=NULL;
33
33
    char name[LenString_MAX],element_type[LenString_MAX],frm[20];
34
34
    char error_msg[LenErrorMsg_MAX];
35
35
    FILE *fileHandle_p = NULL;
36
 
    ElementTypeId typeID=NoRef;
 
36
    Finley_ElementTypeId typeID=Finley_NoRef;
37
37
    int scan_ret;
38
38
 
39
39
    Finley_resetError();
40
 
    mpi_info = Paso_MPIInfo_alloc( MPI_COMM_WORLD );
 
40
    mpi_info = Esys_MPIInfo_alloc( MPI_COMM_WORLD );
41
41
 
42
42
    if (mpi_info->rank == 0) {
43
43
        /* get file handle */
45
45
        if (fileHandle_p==NULL) {
46
46
            sprintf(error_msg,"Finley_Mesh_read: Opening file %s for reading failed.",fname);
47
47
            Finley_setError(IO_ERROR,error_msg);
48
 
            Paso_MPIInfo_free( mpi_info );
 
48
            Esys_MPIInfo_free( mpi_info );
49
49
            return NULL;
50
50
        }
51
51
 
59
59
        FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
60
60
    }
61
61
 
62
 
    #ifdef PASO_MPI
 
62
    #ifdef ESYS_MPI
63
63
        /* MPI Broadcast numDim, numNodes, name if there are multiple MPI procs*/
64
64
        if (mpi_info->size > 1) {
65
65
            int temp1[3];
129
129
                                        chunkNodes++; /* How many nodes do we actually have in this chunk? It may be smaller than chunkSize. */
130
130
                                }
131
131
                                if (chunkNodes > chunkSize) {
132
 
                                        Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: error reading chunks of mesh, data too large for message size");
 
132
                                        Finley_setError(ESYS_MPI_ERROR, "Finley_Mesh_read: error reading chunks of mesh, data too large for message size");
133
133
                                        return NULL;
134
134
                                }
135
 
                                #ifdef PASO_MPI
 
135
                                #ifdef ESYS_MPI
136
136
                                        /* Eventually we'll send chunkSize nodes to each CPU numbered 1 ... mpi_info->size-1, here goes one of them */
137
137
                                        if (nextCPU < mpi_info->size) {
138
138
                                                tempInts[chunkSize*3] = chunkNodes;   /* The message has one more int to send chunkNodes */
146
146
                        } /* Infinite loop */
147
147
                }   /* End master */
148
148
                else {  /* Worker */
149
 
                        #ifdef PASO_MPI
 
149
                        #ifdef ESYS_MPI
150
150
                                /* Each worker receives two messages */
151
151
                                MPI_Status status;
152
152
                                MPI_Recv(tempInts, chunkSize*3+1, MPI_INT, 0, 81720, mpi_info->comm, &status);
182
182
                        FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
183
183
            typeID=Finley_ReferenceElement_getTypeId(element_type);
184
184
                }
185
 
                #ifdef PASO_MPI
 
185
                #ifdef ESYS_MPI
186
186
                        if (mpi_info->size > 1) {
187
187
                                int temp1[2], mpi_error;
188
188
                                temp1[0] = (int) typeID;
189
189
                                temp1[1] = numEle;
190
190
                                mpi_error = MPI_Bcast (temp1, 2, MPI_INT,  0, mpi_info->comm);
191
191
                                if (mpi_error != MPI_SUCCESS) {
192
 
                                        Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of Element typeID failed");
 
192
                                        Finley_setError(ESYS_MPI_ERROR, "Finley_Mesh_read: broadcast of Element typeID failed");
193
193
                                        return NULL;
194
194
                                }
195
 
                                typeID = (ElementTypeId) temp1[0];
 
195
                                typeID = (Finley_ElementTypeId) temp1[0];
196
196
                                numEle = temp1[1];
197
197
                        }
198
198
                #endif
199
 
        if (typeID==NoRef) {
 
199
        if (typeID==Finley_NoRef) {
200
200
            sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type);
201
201
            Finley_setError(VALUE_ERROR, error_msg);
202
202
          }
234
234
                                        totalEle++;
235
235
                                        chunkEle++;
236
236
                                }
237
 
                                #ifdef PASO_MPI
 
237
                                #ifdef ESYS_MPI
238
238
                                        /* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */
239
239
                                        if (nextCPU < mpi_info->size) {
240
240
                                                tempInts[chunkSize*(2+numNodes)] = chunkEle;
247
247
                        } /* Infinite loop */
248
248
                }   /* End master */
249
249
                else {  /* Worker */
250
 
                        #ifdef PASO_MPI
 
250
                        #ifdef ESYS_MPI
251
251
                                /* Each worker receives one message */
252
252
                                MPI_Status status;
253
253
                                MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81722, mpi_info->comm, &status);
289
289
                         FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
290
290
                         typeID=Finley_ReferenceElement_getTypeId(element_type);
291
291
                }
292
 
                #ifdef PASO_MPI
 
292
                #ifdef ESYS_MPI
293
293
                        if (mpi_info->size > 1) {
294
294
                                int temp1[2];
295
295
                                temp1[0] = (int) typeID;
296
296
                                temp1[1] = numEle;
297
297
                                MPI_Bcast (temp1, 2, MPI_INT,  0, mpi_info->comm);
298
 
                                typeID = (ElementTypeId) temp1[0];
 
298
                                typeID = (Finley_ElementTypeId) temp1[0];
299
299
                                numEle = temp1[1];
300
300
                        }
301
301
                #endif
302
 
        if (typeID==NoRef) {
 
302
        if (typeID==Finley_NoRef) {
303
303
            sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type);
304
304
            Finley_setError(VALUE_ERROR, error_msg);
305
305
        }
337
337
                                        totalEle++;
338
338
                                        chunkEle++;
339
339
                                }
340
 
                                #ifdef PASO_MPI
 
340
                                #ifdef ESYS_MPI
341
341
                                        /* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */
342
342
                                        if (nextCPU < mpi_info->size) {
343
343
                                                tempInts[chunkSize*(2+numNodes)] = chunkEle;
350
350
                        } /* Infinite loop */
351
351
                }   /* End master */
352
352
                else {  /* Worker */
353
 
                        #ifdef PASO_MPI
 
353
                        #ifdef ESYS_MPI
354
354
                                /* Each worker receives one message */
355
355
                                MPI_Status status;
356
356
                                MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81723, mpi_info->comm, &status);
391
391
                        FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
392
392
            typeID=Finley_ReferenceElement_getTypeId(element_type);
393
393
                }
394
 
                #ifdef PASO_MPI
 
394
                #ifdef ESYS_MPI
395
395
                        if (mpi_info->size > 1) {
396
396
                                int temp1[2];
397
397
                                temp1[0] = (int) typeID;
398
398
                                temp1[1] = numEle;
399
399
                                MPI_Bcast (temp1, 2, MPI_INT,  0, mpi_info->comm);
400
 
                                typeID = (ElementTypeId) temp1[0];
 
400
                                typeID = (Finley_ElementTypeId) temp1[0];
401
401
                                numEle = temp1[1];
402
402
                        }
403
403
                #endif
404
 
        if (typeID==NoRef) {
 
404
        if (typeID==Finley_NoRef) {
405
405
                        sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type);
406
406
            Finley_setError(VALUE_ERROR, error_msg);
407
407
         }
437
437
                                        totalEle++;
438
438
                                        chunkEle++;
439
439
                                }
440
 
                                #ifdef PASO_MPI
 
440
                                #ifdef ESYS_MPI
441
441
                                        /* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */
442
442
                                        if (nextCPU < mpi_info->size) {
443
443
                                                tempInts[chunkSize*(2+numNodes)] = chunkEle;
450
450
                        } /* Infinite loop */
451
451
                }   /* End master */
452
452
                else {  /* Worker */
453
 
                        #ifdef PASO_MPI
 
453
                        #ifdef ESYS_MPI
454
454
                                /* Each worker receives one message */
455
455
                                MPI_Status status;
456
456
                                MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81724, mpi_info->comm, &status);
488
488
                        FSCANF_CHECK(scan_ret, "Finley_Mesh_read")
489
489
            typeID=Finley_ReferenceElement_getTypeId(element_type);
490
490
                }
491
 
                #ifdef PASO_MPI
 
491
                #ifdef ESYS_MPI
492
492
                        if (mpi_info->size > 1) {
493
493
                                int temp1[2];
494
494
                                temp1[0] = (int) typeID;
495
495
                                temp1[1] = numEle;
496
496
                                MPI_Bcast (temp1, 2, MPI_INT,  0, mpi_info->comm);
497
 
                                typeID = (ElementTypeId) temp1[0];
 
497
                                typeID = (Finley_ElementTypeId) temp1[0];
498
498
                                numEle = temp1[1];
499
499
                        }
500
500
                #endif
501
 
        if (typeID==NoRef) {
 
501
        if (typeID==Finley_NoRef) {
502
502
                        sprintf(error_msg, "Finley_Mesh_read: Unidentified element type %s", element_type);
503
503
            Finley_setError(VALUE_ERROR, error_msg);
504
504
         }
535
535
                                        totalEle++;
536
536
                                        chunkEle++;
537
537
                                }
538
 
                                #ifdef PASO_MPI
 
538
                                #ifdef ESYS_MPI
539
539
                                        /* Eventually we'll send chunk of elements to each CPU except 0 itself, here goes one of them */
540
540
                                        if (nextCPU < mpi_info->size) {
541
541
                                                tempInts[chunkSize*(2+numNodes)] = chunkEle;
548
548
                        } /* Infinite loop */
549
549
                }   /* End master */
550
550
                else {  /* Worker */
551
 
                        #ifdef PASO_MPI
 
551
                        #ifdef ESYS_MPI
552
552
                                /* Each worker receives one message */
553
553
                                MPI_Status status;
554
554
                                MPI_Recv(tempInts, chunkSize*(2+numNodes)+1, MPI_INT, 0, 81725, mpi_info->comm, &status);
582
582
        if (Finley_noError()) {
583
583
        char *remainder=0, *ptr;
584
584
        size_t len=0;
585
 
                #ifdef PASO_MPI
 
585
                #ifdef ESYS_MPI
586
586
                int len_i;
587
587
                #endif
588
588
        int tag_key;
645
645
                        len = strlen(remainder);
646
646
                        TMPMEMREALLOC(remainder,remainder,len+1,char);
647
647
        } /* Master */
648
 
                #ifdef PASO_MPI
 
648
                #ifdef ESYS_MPI
649
649
 
650
650
                len_i=(int) len;
651
651
                        MPI_Bcast (&len_i, 1, MPI_INT,  0, mpi_info->comm);
656
656
                        }
657
657
                        if (MPI_Bcast (remainder, len+1, MPI_CHAR,  0, mpi_info->comm) !=
658
658
                                        MPI_SUCCESS)
659
 
                                Finley_setError(PASO_MPI_ERROR, "Finley_Mesh_read: broadcast of remainder failed");
 
659
                                Finley_setError(ESYS_MPI_ERROR, "Finley_Mesh_read: broadcast of remainder failed");
660
660
                #endif
661
661
 
662
662
                if (remainder[0]) {
688
688
        Finley_ReferenceElementSet_dealloc(refContactElements);
689
689
        Finley_ReferenceElementSet_dealloc(refFaceElements);
690
690
        Finley_ReferenceElementSet_dealloc(refElements);
691
 
        Paso_MPIInfo_free( mpi_info );
 
691
        Esys_MPIInfo_free( mpi_info );
692
692
        return mesh_p;
693
693
}
694
694