/[escript]/trunk/esys2/finley/src/finleyC/Mesh_saveDX.c
ViewVC logotype

Diff of /trunk/esys2/finley/src/finleyC/Mesh_saveDX.c

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

revision 152 by jgs, Thu Sep 15 03:44:45 2005 UTC revision 153 by jgs, Tue Oct 25 01:51:20 2005 UTC
# Line 28  Line 28 
28    
29  /**************************************************************/  /**************************************************************/
30    
31  void Finley_Mesh_saveDX(const char * filename_p, Finley_Mesh *mesh_p, escriptDataC* data_p) {  void Finley_Mesh_saveDX(const char * filename_p, Finley_Mesh *mesh_p, const dim_t num_data,char* *names_p,escriptDataC* *data_pp) {
32    char error_msg[LenErrorMsg_MAX];    char error_msg[LenErrorMsg_MAX];
33    /* if there is no mesh we just return */    /* if there is no mesh we just return */
34    if (mesh_p==NULL) return;    if (mesh_p==NULL) return;
35    
36    /* some tables needed for reordering */    /* some tables needed for reordering */
37    int resort[6][9]={    int resort[6][9]={
38                      {0,1},   /* line */                      {0,1},   /* line */
# Line 40  void Finley_Mesh_saveDX(const char * fil Line 41  void Finley_Mesh_saveDX(const char * fil
41                      {0,3,1,2}, /* quadrilateral */                      {0,3,1,2}, /* quadrilateral */
42                      {3,0,7,4,2,1,6,5}, /* hexahedron */                      {3,0,7,4,2,1,6,5}, /* hexahedron */
43                     };                     };
44    Finley_ElementFile* elements=NULL;    int i,j,k,i_data;
   char elemTypeStr[32];  
   int i,j,k,numDXNodesPerElement,*resortIndex,isCellCentered=TRUE,nodetype=FINLEY_DEGREES_OF_FREEDOM;  
   double* values,rtmp;  
   int nDim = mesh_p->Nodes->numDim;  
45    /* open the file  and check handel */    /* open the file  and check handel */
46    
47    FILE * fileHandle_p = fopen(filename_p, "w");    FILE * fileHandle_p = fopen(filename_p, "w");
48    if (fileHandle_p==NULL) {    if (fileHandle_p==NULL) {
49           sprintf(error_msg,"File %s could not be opened for writing.",filename_p);      sprintf(error_msg,"File %s could not be opened for writing.",filename_p);
50           Finley_setError(IO_ERROR,error_msg);      Finley_setError(IO_ERROR,error_msg);
51           return;      return;
52      }
53      /* find the mesh type to be written */
54      int nodetype=FINLEY_DEGREES_OF_FREEDOM;
55      int elementtype=FINLEY_UNKNOWN;
56      bool_t isCellCentered[num_data];
57      for (i_data=0;i_data<num_data;++i_data) {
58         if (! isEmpty(data_pp[i_data])) {
59            switch(getFunctionSpaceType(data_pp[i_data])) {
60               case FINLEY_DEGREES_OF_FREEDOM:
61                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
62                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
63                     elementtype=FINLEY_ELEMENTS;
64                 } else {
65                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
66                     return;
67                 }
68                 isCellCentered[i_data]=FALSE;
69                 break;
70               case FINLEY_REDUCED_DEGREES_OF_FREEDOM:
71                 nodetype = FINLEY_REDUCED_DEGREES_OF_FREEDOM;
72                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
73                     elementtype=FINLEY_ELEMENTS;
74                 } else {
75                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
76                     return;
77                 }
78                 isCellCentered[i_data]=FALSE;
79                 break;
80               case FINLEY_NODES:
81                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
82                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
83                     elementtype=FINLEY_ELEMENTS;
84                 } else {
85                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
86                     return;
87                 }
88                 isCellCentered[i_data]=FALSE;
89                 break;
90               case FINLEY_ELEMENTS:
91                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
92                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
93                     elementtype=FINLEY_ELEMENTS;
94                 } else {
95                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
96                     return;
97                 }
98                 isCellCentered[i_data]=TRUE;
99                 break;
100               case FINLEY_FACE_ELEMENTS:
101                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
102                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_FACE_ELEMENTS) {
103                     elementtype=FINLEY_FACE_ELEMENTS;
104                 } else {
105                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
106                     return;
107                 }
108                 isCellCentered[i_data]=TRUE;
109                 break;
110               case FINLEY_POINTS:
111                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
112                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_POINTS) {
113                     elementtype=FINLEY_POINTS;
114                 } else {
115                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
116                     return;
117                 }
118                 isCellCentered[i_data]=TRUE;
119                 break;
120               case FINLEY_CONTACT_ELEMENTS_1:
121                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
122                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
123                     elementtype=FINLEY_CONTACT_ELEMENTS_1;
124                 } else {
125                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
126                     return;
127                 }
128                 isCellCentered[i_data]=TRUE;
129                 break;
130               case FINLEY_CONTACT_ELEMENTS_2:
131                 nodetype = (nodetype == FINLEY_REDUCED_DEGREES_OF_FREEDOM) ? FINLEY_REDUCED_DEGREES_OF_FREEDOM : FINLEY_DEGREES_OF_FREEDOM;
132                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
133                     elementtype=FINLEY_CONTACT_ELEMENTS_1;
134                 } else {
135                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
136                     return;
137                 }
138                 isCellCentered[i_data]=TRUE;
139                 break;
140               default:
141                 sprintf(error_msg,"saveDX: Finley does not know anything about function space type %d",getFunctionSpaceType(data_pp[i_data]));
142                 Finley_setError(TYPE_ERROR,error_msg);
143                 return;
144            }
145         }
146      }
147      /* select number of points and the mesh component */
148      int numPoints = mesh_p->Nodes->numNodes;
149      int nDim = mesh_p->Nodes->numDim;
150      if (nodetype==FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
151           numPoints = mesh_p->Nodes->reducedNumNodes;
152      } else {
153           numPoints = mesh_p->Nodes->numNodes;
154      }
155      if (elementtype==FINLEY_UNKNOWN) elementtype=FINLEY_ELEMENTS;
156      Finley_ElementFile* elements=NULL;
157      switch(elementtype) {
158        case FINLEY_ELEMENTS:
159          elements=mesh_p->Elements;
160          break;
161        case FINLEY_FACE_ELEMENTS:
162          elements=mesh_p->FaceElements;
163          break;
164        case FINLEY_POINTS:
165          elements=mesh_p->Points;
166          break;
167        case FINLEY_CONTACT_ELEMENTS_1:
168          elements=mesh_p->ContactElements;
169          break;
170    }    }
171      if (elements==NULL) {
172         Finley_setError(SYSTEM_ERROR,"saveDX: undefined element file");
173         return;
174      }
175    
176      /* map finley element type to DX element type */
177      ElementTypeId TypeId = elements->ReferenceElement->Type->TypeId;
178      int *resortIndex=NULL;
179      int numDXNodesPerElement=0;
180      int numCells = elements->numElements;
181      char elemTypeStr[32];
182      if (TypeId==Line2 || TypeId==Line3 || TypeId==Line4 ) {
183         numDXNodesPerElement=2;
184         resortIndex=resort[0];
185         strcpy(elemTypeStr, "lines");
186       } else if (TypeId==Tri3 || TypeId==Tri6 || TypeId==Tri9 || TypeId==Tri10 ) {
187         numDXNodesPerElement = 3;
188         resortIndex=resort[1];
189         strcpy(elemTypeStr, "triangles");
190       } else if (TypeId==Rec4 || TypeId==Rec8 || TypeId==Rec9 || TypeId==Rec12 || TypeId==Rec16 ) {
191         numDXNodesPerElement = 4;
192         resortIndex=resort[3];
193         strcpy(elemTypeStr, "quads");
194       } else if (TypeId==Tet4 || TypeId==Tet10 || TypeId==Tet16 ) {
195         numDXNodesPerElement = 4;
196         resortIndex=resort[2];
197         strcpy(elemTypeStr, "tetrahedra");
198       } else if (TypeId==Hex8 || TypeId==Hex20 || TypeId==Hex32 ) {
199         numDXNodesPerElement = 8;
200         resortIndex=resort[4];
201         strcpy(elemTypeStr, "cubes");
202       } else {
203         sprintf(error_msg,"saveDX: Element type %s is not supported by DX",elements->ReferenceElement->Type->Name);
204         Finley_setError(VALUE_ERROR,error_msg);
205         return;
206       }
207    
208    /* positions */    /* positions */
209    fprintf(fileHandle_p, "object 1 class array type float rank 1 shape %d items %d data follows\n",    fprintf(fileHandle_p, "object 1 class array type float rank 1 shape %d items %d data follows\n",nDim, mesh_p->Nodes->reducedNumNodes);
                                                                    nDim, mesh_p->Nodes->reducedNumNodes);  
210    for (i = 0; i < mesh_p->Nodes->numNodes; i++) {    for (i = 0; i < mesh_p->Nodes->numNodes; i++) {
211      if (mesh_p->Nodes->toReduced[i]>=0) {      if (mesh_p->Nodes->toReduced[i]>=0) {
212         fprintf(fileHandle_p, "%g", mesh_p->Nodes->Coordinates[INDEX2(0, i, nDim)]);         for (j = 0; j < nDim; j++) fprintf(fileHandle_p, " %g",mesh_p->Nodes->Coordinates[INDEX2(j, i, nDim)]);
        for (j = 1; j < nDim; j++) fprintf(fileHandle_p, " %g",mesh_p->Nodes->Coordinates[INDEX2(j, i, nDim)]);  
213         fprintf(fileHandle_p, "\n");         fprintf(fileHandle_p, "\n");
214      }      }
215    }    }
216    /* connections */    /* connection table */
217    /* get a pointer to the relevant mesh component */    int NN=elements->ReferenceElement->Type->numNodes;
218    if (isEmpty(data_p)) {    fprintf(fileHandle_p, "object 2 class array type int rank 1 shape %d items %d data follows\n",numDXNodesPerElement, numCells);
219        elements=mesh_p->Elements;    for (i = 0; i < numCells; i++) {
220    } else {        for (j = 0; j < numDXNodesPerElement; j++) fprintf(fileHandle_p," %d",mesh_p->Nodes->toReduced[elements->Nodes[INDEX2(resortIndex[j], i, NN)]]);
221        switch(getFunctionSpaceType(data_p)) {        fprintf(fileHandle_p, "\n");
222         case(FINLEY_DEGREES_OF_FREEDOM):    }
223            nodetype=FINLEY_DEGREES_OF_FREEDOM;    fprintf(fileHandle_p, "attribute \"element type\" string \"%s\"\n",elemTypeStr);
224            isCellCentered=FALSE;    fprintf(fileHandle_p, "attribute \"ref\" string \"positions\"\n");
           elements=mesh_p->Elements;  
           break;  
        case(FINLEY_REDUCED_DEGREES_OF_FREEDOM):  
           nodetype=FINLEY_REDUCED_DEGREES_OF_FREEDOM;  
           isCellCentered=FALSE;  
           elements=mesh_p->Elements;  
           break;  
        case(FINLEY_NODES):  
           nodetype=FINLEY_NODES;  
           isCellCentered=FALSE;  
           elements=mesh_p->Elements;  
           break;  
        case(FINLEY_ELEMENTS):  
           isCellCentered=TRUE;  
           elements=mesh_p->Elements;  
           break;  
        case(FINLEY_FACE_ELEMENTS):  
           isCellCentered=TRUE;  
           elements=mesh_p->FaceElements;  
           break;  
        case(FINLEY_POINTS):  
           isCellCentered=TRUE;  
           elements=mesh_p->Points;  
           break;  
        case(FINLEY_CONTACT_ELEMENTS_1):  
        case(FINLEY_CONTACT_ELEMENTS_2):  
           isCellCentered=TRUE;  
           elements=mesh_p->ContactElements;  
           break;  
        default:  
           sprintf(error_msg,"saveDX:Finley does not know anything about function space type %d",getFunctionSpaceType(data_p));  
           Finley_setError(TYPE_ERROR,error_msg);  
           return;  
      }  
   }  
   /* if no element table is present jump over the connection table */  
   if (elements!=NULL) {  
        ElementTypeId TypeId = elements->ReferenceElement->Type->TypeId;  
        if (TypeId==Line2 || TypeId==Line3 || TypeId==Line4 ) {  
           numDXNodesPerElement=2;  
           resortIndex=resort[0];  
           strcpy(elemTypeStr, "lines");  
        } else if (TypeId==Tri3 || TypeId==Tri6 || TypeId==Tri9 || TypeId==Tri10 ) {  
           numDXNodesPerElement = 3;  
           resortIndex=resort[1];  
           strcpy(elemTypeStr, "triangles");  
        } else if (TypeId==Rec4 || TypeId==Rec8 || TypeId==Rec9 || TypeId==Rec12 || TypeId==Rec16 ) {  
           numDXNodesPerElement = 4;  
           resortIndex=resort[3];  
           strcpy(elemTypeStr, "quads");  
         } else if (TypeId==Tet4 || TypeId==Tet10 || TypeId==Tet16 ) {  
           numDXNodesPerElement = 4;  
           resortIndex=resort[2];  
           strcpy(elemTypeStr, "tetrahedra");  
         } else if (TypeId==Hex8 || TypeId==Hex20 || TypeId==Hex32 ) {  
           numDXNodesPerElement = 8;  
           resortIndex=resort[4];  
           strcpy(elemTypeStr, "cubes");  
         } else {  
           sprintf(error_msg,"saveDX: Element type %s is not supported by DX",elements->ReferenceElement->Type->Name);  
           Finley_setError(VALUE_ERROR,error_msg);  
           return;  
         }  
         int NN=elements->ReferenceElement->Type->numNodes;  
         fprintf(fileHandle_p, "object 2 class array type int rank 1 shape %d items %d data follows\n",numDXNodesPerElement, elements->numElements);  
         for (i = 0; i < elements->numElements; i++) {  
           fprintf(fileHandle_p,"%d",mesh_p->Nodes->toReduced[elements->Nodes[INDEX2(resortIndex[0], i, NN)]]);  
           for (j = 1; j < numDXNodesPerElement; j++) {  
              fprintf(fileHandle_p," %d",mesh_p->Nodes->toReduced[elements->Nodes[INDEX2(resortIndex[j], i, NN)]]);  
           }  
           fprintf(fileHandle_p, "\n");  
         }  
         fprintf(fileHandle_p, "attribute \"element type\" string \"%s\"\n",elemTypeStr);  
         fprintf(fileHandle_p, "attribute \"ref\" string \"positions\"\n");  
225    
   }  
226    /* data */    /* data */
227    if (!isEmpty(data_p)) {    int object_count=2;
228        int rank=getDataPointRank(data_p);    for (i_data =0 ;i_data<num_data;++i_data) {
229        int nComp=getDataPointSize(data_p);        if (! isEmpty(data_pp[i_data])) {
230        fprintf(fileHandle_p, "object 3 class array type float rank %d ", rank);           object_count++;
231        if (0 < rank) {           int rank=getDataPointRank(data_pp[i_data]);
232           fprintf(fileHandle_p, "shape ");           int nComp=getDataPointSize(data_pp[i_data]);
233           for (i = 0; i < rank; i++) fprintf(fileHandle_p, "%d ", getDataPointShape(data_p,i));           double* values,rtmp;
234        }           fprintf(fileHandle_p, "object %d class array type float rank %d ",object_count,rank);
235        if (isCellCentered) {           if (0 < rank) {
236            int numPointsPerSample=elements->ReferenceElement->numQuadNodes;              fprintf(fileHandle_p, "shape ");
237            if (numPointsPerSample>0) {              for (i = 0; i < rank; i++) fprintf(fileHandle_p, "%d ", getDataPointShape(data_pp[i_data],i));
238               fprintf(fileHandle_p, "items %d data follows\n", elements->numElements);           }
239               for (i=0;i<elements->numElements;i++) {           if (isCellCentered[i_data]) {
240                   values=getSampleData(data_p,i);               int numPointsPerSample=elements->ReferenceElement->numQuadNodes;
241                   for (k=0;k<nComp;k++) {               if (numPointsPerSample>0) {
242                       rtmp=0.;                  fprintf(fileHandle_p, "items %d data follows\n", numCells);
243                       for (j=0;j<numPointsPerSample;j++) rtmp+=values[INDEX2(k,j,nComp)];                  for (i=0;i<elements->numElements;i++) {
244                       fprintf(fileHandle_p, " %g", rtmp/numPointsPerSample);                      values=getSampleData(data_pp[i_data],i);
245                        for (k=0;k<nComp;k++) {
246                            rtmp=0.;
247                            for (j=0;j<numPointsPerSample;j++) rtmp+=values[INDEX2(k,j,nComp)];
248                            fprintf(fileHandle_p, " %g", rtmp/numPointsPerSample);
249                        }
250                    fprintf(fileHandle_p, "\n");
251                    }
252                    fprintf(fileHandle_p, "attribute \"dep\" string \"connections\"\n");
253                }
254             } else {
255                 fprintf(fileHandle_p, "items %d data follows\n", mesh_p->Nodes->reducedNumNodes);
256                 for (i=0;i<mesh_p->Nodes->numNodes;i++) {
257                     if (mesh_p->Nodes->toReduced[i]>=0) {
258                        switch (getFunctionSpaceType(data_pp[i_data])) {
259                           case FINLEY_DEGREES_OF_FREEDOM:
260                              values=getSampleData(data_pp[i_data],mesh_p->Nodes->degreeOfFreedom[i]);
261                              break;
262                           case FINLEY_REDUCED_DEGREES_OF_FREEDOM:
263                              values=getSampleData(data_pp[i_data],mesh_p->Nodes->reducedDegreeOfFreedom[i]);
264                              break;
265                           case FINLEY_NODES:
266                              values=getSampleData(data_pp[i_data],i);
267                              break;
268                        }
269                        for (k=0;k<nComp;k++) fprintf(fileHandle_p, " %g", values[k]);
270                    fprintf(fileHandle_p, "\n");
271                   }                   }
              fprintf(fileHandle_p, "\n");  
272               }               }
273               fprintf(fileHandle_p, "attribute \"dep\" string \"connections\"\n");               fprintf(fileHandle_p, "attribute \"dep\" string \"positions\"\n");
274           }           }
275        } else {       }
           fprintf(fileHandle_p, "items %d data follows\n", mesh_p->Nodes->reducedNumNodes);  
           for (i=0;i<mesh_p->Nodes->numNodes;i++) {  
               if (mesh_p->Nodes->toReduced[i]>=0) {  
                  switch (nodetype) {  
                     case(FINLEY_DEGREES_OF_FREEDOM):  
                        values=getSampleData(data_p,mesh_p->Nodes->degreeOfFreedom[i]);  
                        break;  
                     case(FINLEY_REDUCED_DEGREES_OF_FREEDOM):  
                        values=getSampleData(data_p,mesh_p->Nodes->reducedDegreeOfFreedom[i]);  
                        break;  
                     case(FINLEY_NODES):  
                        values=getSampleData(data_p,i);  
                        break;  
                  }  
                  for (k=0;k<nComp;k++) fprintf(fileHandle_p, " %g", values[k]);  
              fprintf(fileHandle_p, "\n");  
               }  
           }  
           fprintf(fileHandle_p, "attribute \"dep\" string \"positions\"\n");  
       }  
276    }    }
277    
278    /* and finish it up */    /* and finish it up */
279    fprintf(fileHandle_p, "object 4 class field\n");    if (num_data==0) {
280    fprintf(fileHandle_p, "component \"positions\" value 1\n");       fprintf(fileHandle_p, "object %d class field\n",object_count+1);
281    if (elements!=NULL) fprintf(fileHandle_p, "component \"connections\" value 2\n");       fprintf(fileHandle_p, "component \"positions\" value 1\n");
282    if (!isEmpty(data_p)) fprintf(fileHandle_p, "component \"data\" value 3\n");       fprintf(fileHandle_p, "component \"connections\" value 2\n");
283      } else {
284         object_count=2;
285         for (i_data=0; i_data<num_data;++i_data) {
286             if (! isEmpty(data_pp[i_data])) {
287                object_count++;
288                fprintf(fileHandle_p, "object \"%s\" class field\n",names_p[i_data]);
289                fprintf(fileHandle_p, "component \"positions\" value 1\n");
290                fprintf(fileHandle_p, "component \"connections\" value 2\n");
291                fprintf(fileHandle_p, "component \"data\" value %d\n",object_count);
292             }
293         }
294      }
295    fprintf(fileHandle_p, "end\n");    fprintf(fileHandle_p, "end\n");
296    /* close the file */    /* close the file */
297    fclose(fileHandle_p);    fclose(fileHandle_p);
298    return;    return;
299  }  }
   
 /*  
  * $Log$  
  * Revision 1.5  2005/09/15 03:44:23  jgs  
  * Merge of development branch dev-02 back to main trunk on 2005-09-15  
  *  
  * Revision 1.4.2.3  2005/09/09 08:15:17  gross  
  * bugs in vtk and dx writer fixed  
  *  
  * Revision 1.4.2.2  2005/09/08 08:28:39  gross  
  * some cleanup in savevtk  
  *  
  * Revision 1.4.2.1  2005/09/07 06:26:20  gross  
  * the solver from finley are put into the standalone package paso now  
  *  
  * Revision 1.4  2005/07/08 04:07:55  jgs  
  * Merge of development branch back to main trunk on 2005-07-08  
  *  
  * Revision 1.1.1.1.2.5  2005/06/29 02:34:53  gross  
  * some changes towards 64 integers in finley  
  *  
  * Revision 1.1.1.1.2.4  2005/03/03 05:01:12  gross  
  * bug in saveDX fixed  
  *  
  * Revision 1.1.1.1.2.3  2005/02/17 23:43:06  cochrane  
  * Fixed error throwing bug.  Default case of switch statement should have ended  
  * with return instead of break, hence errors weren't being thrown (but they now  
  * should be).  
  *  
  * Revision 1.1.1.1.2.2  2005/02/17 05:53:26  gross  
  * some bug in saveDX fixed: in fact the bug was in  
  * DataC/getDataPointShape  
  *  
  * Revision 1.1.1.1.2.1  2005/02/17 03:23:01  gross  
  * some performance improvements in MVM  
  *  
  * Revision 1.1.1.1  2004/10/26 06:53:57  jgs  
  * initial import of project esys2  
  *  
  * Revision 1.1  2004/07/27 08:27:11  gross  
  * Finley: saveDX added: now it is possible to write data on boundary and contact elements  
  *  
  */  

Legend:
Removed from v.152  
changed lines
  Added in v.153

  ViewVC Help
Powered by ViewVC 1.1.26