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

Diff of /trunk/finley/src/ElementFile.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/finley/src/finleyC/ElementFile.c revision 123 by jgs, Fri Jul 8 04:08:13 2005 UTC temp/finley/src/ElementFile.c revision 1387 by trankine, Fri Jan 11 07:45:26 2008 UTC
# Line 1  Line 1 
1    
2  /* $Id$ */  /* $Id$ */
3    
4    /*******************************************************
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  /**************************************************************/  /**************************************************************/
17    
18  /*   Finley: ElementFile */  /*   Finley: ElementFile */
19    
20  /*   allocates an element file to hold elements of type id and with integration order order. */  /*   allocates an element file to hold elements of type id and with integration order order. */
21  /*   use Finley_Mesh_allocElementTable to allocate the element table (Id,Nodes,Tag). */  /*   use Finley_Mesh_allocElementTable to allocate the element table (Id,Nodes,Tag,Owner). */
   
 /**************************************************************/  
   
 /*   Copyrights by ACcESS Australia 2003/04 */  
 /*   Author: gross@access.edu.au */  
 /*   Version: $Id$ */  
22    
23  /**************************************************************/  /**************************************************************/
24    
 #include "Finley.h"  
25  #include "ElementFile.h"  #include "ElementFile.h"
26    
27  /**************************************************************/  /**************************************************************/
28    
29  Finley_ElementFile* Finley_ElementFile_alloc(ElementTypeId id,index_t order){  Finley_ElementFile* Finley_ElementFile_alloc(ElementTypeId id, index_t order, index_t reduced_order, Paso_MPIInfo *MPIInfo)
30    {
31    extern Finley_RefElementInfo Finley_RefElement_InfoList[];    extern Finley_RefElementInfo Finley_RefElement_InfoList[];
32    dim_t NQ;    dim_t NQ, reduced_NQ;
33    Finley_ElementFile *out;    Finley_ElementFile *out;
34        
35    /*   get the number of quadrature nodes needed to achieve integration order order: */    /*   get the number of quadrature nodes needed to achieve integration order order: */
36        
37    if (order<0) order=2*Finley_RefElement_InfoList[id].numOrder;    if (order<0) order=MAX(2*Finley_RefElement_InfoList[id].numOrder,0);
38      if (reduced_order<0) reduced_order=MAX(2*(Finley_RefElement_InfoList[id].numOrder-1),0);
39    NQ= Finley_RefElement_InfoList[id].getNumQuadNodes(order);    NQ= Finley_RefElement_InfoList[id].getNumQuadNodes(order);
40    if (Finley_ErrorCode!=NO_ERROR) return NULL;    reduced_NQ= Finley_RefElement_InfoList[id].getNumQuadNodes(reduced_order);
41      if (! Finley_noError()) return NULL;
42        
43    /*  allocate the return value */    /*  allocate the return value */
44        
45    out=MEMALLOC(1,Finley_ElementFile);    out=MEMALLOC(1,Finley_ElementFile);
46    if (Finley_checkPtr(out)) return NULL;    if (Finley_checkPtr(out)) return NULL;
47      out->order = order;
48      out->reduced_order = reduced_order;
49    out->ReferenceElement=NULL;    out->ReferenceElement=NULL;
50    out->LinearReferenceElement=NULL;    out->LinearReferenceElement=NULL;
51      out->ReferenceElementReducedOrder=NULL;
52      out->LinearReferenceElementReducedOrder=NULL;
53    out->numElements=0;    out->numElements=0;
54    out->Id=NULL;    out->Id=NULL;
55    out->Nodes=NULL;    out->Nodes=NULL;
# Line 43  Finley_ElementFile* Finley_ElementFile_a Line 57  Finley_ElementFile* Finley_ElementFile_a
57    out->Color=NULL;    out->Color=NULL;
58    out->minColor=0;    out->minColor=0;
59    out->maxColor=-1;    out->maxColor=-1;
60    out->order = order;    out->jacobeans=NULL;
61      out->jacobeans_reducedQ=NULL;
62      out->jacobeans_reducedS=NULL;
63      out->jacobeans_reducedS_reducedQ=NULL;
64    
65      out->Owner=NULL;                
66      out->MPIInfo = Paso_MPIInfo_getReference( MPIInfo );
67    
68    /*  allocate the reference element: */    /*  allocate the reference element: */
69        
70    out->ReferenceElement=Finley_RefElement_alloc(id,NQ);    out->ReferenceElement=Finley_RefElement_alloc(id,NQ);
71    if (Finley_ErrorCode!=NO_ERROR) {    out->jacobeans=Finley_ElementFile_Jacobeans_alloc(out->ReferenceElement);
72       Finley_ElementFile_dealloc(out);    out->ReferenceElementReducedOrder=Finley_RefElement_alloc(id,reduced_NQ);
73       return NULL;    out->jacobeans_reducedQ=Finley_ElementFile_Jacobeans_alloc(out->ReferenceElementReducedOrder);
74    }  
75    out->LinearReferenceElement=Finley_RefElement_alloc(Finley_RefElement_InfoList[id].LinearTypeId,NQ);    out->LinearReferenceElement=Finley_RefElement_alloc(Finley_RefElement_InfoList[id].LinearTypeId,NQ);
76    if (Finley_ErrorCode!=NO_ERROR) {    out->jacobeans_reducedS=Finley_ElementFile_Jacobeans_alloc(out->LinearReferenceElement);
77       Finley_ElementFile_dealloc(out);    out->LinearReferenceElementReducedOrder=Finley_RefElement_alloc(Finley_RefElement_InfoList[id].LinearTypeId,reduced_NQ);
78      out->jacobeans_reducedS_reducedQ=Finley_ElementFile_Jacobeans_alloc(out->LinearReferenceElementReducedOrder);
79    
80      out->numNodes=out->ReferenceElement->Type->numNodes;
81    
82      if (! Finley_noError()) {
83         Finley_ElementFile_free(out);
84       return NULL;       return NULL;
85    }    }
86    return out;    return out;
# Line 62  Finley_ElementFile* Finley_ElementFile_a Line 88  Finley_ElementFile* Finley_ElementFile_a
88    
89  /*  deallocates an element file: */  /*  deallocates an element file: */
90    
91  void Finley_ElementFile_dealloc(Finley_ElementFile* in) {  void Finley_ElementFile_free(Finley_ElementFile* in) {
92    if (in!=NULL) {    if (in!=NULL) {
93       #ifdef Finley_TRACE       #ifdef Finley_TRACE
94       if (in->ReferenceElement!=NULL) printf("element file for %s is deallocated.\n",in->ReferenceElement->Type->Name);       if (in->ReferenceElement!=NULL) printf("element file for %s is deallocated.\n",in->ReferenceElement->Type->Name);
95       #endif       #endif
96         Finley_ElementFile_freeTable(in);  
97       Finley_RefElement_dealloc(in->ReferenceElement);       Finley_RefElement_dealloc(in->ReferenceElement);
98         Finley_RefElement_dealloc(in->ReferenceElementReducedOrder);
99       Finley_RefElement_dealloc(in->LinearReferenceElement);       Finley_RefElement_dealloc(in->LinearReferenceElement);
100       Finley_ElementFile_deallocTable(in);         Finley_RefElement_dealloc(in->LinearReferenceElementReducedOrder);
101         Finley_ElementFile_Jacobeans_dealloc(in->jacobeans);
102         Finley_ElementFile_Jacobeans_dealloc(in->jacobeans_reducedS);
103         Finley_ElementFile_Jacobeans_dealloc(in->jacobeans_reducedQ);
104         Finley_ElementFile_Jacobeans_dealloc(in->jacobeans_reducedS_reducedQ);
105         Paso_MPIInfo_free( in->MPIInfo );
106       MEMFREE(in);             MEMFREE(in);      
107    }    }
108  }  }
109  /*  void Finley_ElementFile_setElementDistribution(Finley_ElementFile* in, dim_t* distribution) {
110  * $Log$    dim_t local_num_elements,e,out,num_elements=0, size;
111  * Revision 1.5  2005/07/08 04:07:48  jgs    Paso_MPI_rank myRank;
112  * Merge of development branch back to main trunk on 2005-07-08    if (in == NULL) {
113  *        distribution[0]=num_elements;
114  * Revision 1.4  2004/12/15 07:08:32  jgs    } else {
115  * *** empty log message ***        if (in->MPIInfo->size>1) {
116  * Revision 1.1.1.1.2.2  2005/06/29 02:34:49  gross           num_elements=0;
117  * some changes towards 64 integers in finley           myRank=in->MPIInfo->rank;
118  *           size=in->MPIInfo->size;
119  * Revision 1.1.1.1.2.1  2004/11/24 01:37:13  gross           #pragma omp parallel private(local_num_elements)
120  * some changes dealing with the integer overflow in memory allocation. Finley solves 4M unknowns now           {
121  *              local_num_elements=0;
122  *              #pragma omp for private(e)
123  *              for (e=0;e<in->numElements;e++) {
124  */                 if (in->Owner[e] == myRank) local_num_elements++;
125                }
126                #pragma omp critical
127                num_elements+=local_num_elements;
128             }
129             #ifdef PASO_MPI
130               MPI_Allgather(&num_elements,1,MPI_INT,distribution,1,MPI_INT,in->MPIInfo->comm);
131             #else
132               distribution[0]=num_elements;
133             #endif
134          } else {
135            distribution[0]=in->numElements;
136          }
137      }
138    }
139    
140    dim_t Finley_ElementFile_getGlobalNumElements(Finley_ElementFile* in) {
141      dim_t size, *distribution=NULL, out, p;
142      if (in == NULL) {
143          return 0;
144      } else {
145        size=in->MPIInfo->size;
146        distribution=TMPMEMALLOC(size,dim_t);
147        Finley_ElementFile_setElementDistribution(in,distribution);
148        out=0;
149        for (p=0;p<size;++p) out+=distribution[p];
150        TMPMEMFREE(distribution);
151        return out;
152      }
153    }
154    dim_t Finley_ElementFile_getMyNumElements(Finley_ElementFile* in) {
155      dim_t size, *distribution=NULL, out, p;
156      if (in == NULL) {
157          return 0;
158      } else {
159        size=in->MPIInfo->size;
160        distribution=TMPMEMALLOC(size,dim_t);
161        Finley_ElementFile_setElementDistribution(in,distribution);
162        out=distribution[in->MPIInfo->rank];
163        TMPMEMFREE(distribution);
164        return out;
165      }
166    
167    }
168    index_t Finley_ElementFile_getFirstElement(Finley_ElementFile* in){
169      dim_t size, *distribution=NULL, out, p;
170      if (in == NULL) {
171          return 0;
172      } else {
173        size=in->MPIInfo->size;
174        distribution=TMPMEMALLOC(size,dim_t);
175        Finley_ElementFile_setElementDistribution(in,distribution);
176        out=0;
177        for (p=0;p<in->MPIInfo->rank;++p) out+=distribution[p];
178        TMPMEMFREE(distribution);
179        return out;
180      }
181    }

Legend:
Removed from v.123  
changed lines
  Added in v.1387

  ViewVC Help
Powered by ViewVC 1.1.26