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

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

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

trunk/esys2/finley/src/finleyC/Mesh_saveDX.c revision 150 by jgs, Thu Sep 15 03:44:45 2005 UTC trunk/finley/src/Mesh_saveDX.c revision 1338 by gross, Mon Nov 5 06:32:29 2007 UTC
# Line 1  Line 1 
 /*  
  ******************************************************************************  
  *                                                                            *  
  *       COPYRIGHT  ACcESS 2003,2004,2005 -  All Rights Reserved              *  
  *                                                                            *  
  * This software is the property of ACcESS. No part of this code              *  
  * may be copied in any form or by any means without the expressed written    *  
  * consent of ACcESS.  Copying, use or modification of this software          *  
  * by any unauthorised person is illegal unless that person has a software    *  
  * license agreement with ACcESS.                                             *  
  *                                                                            *  
  ******************************************************************************  
 */  
1    
2    /* $Id$ */
3    
4  /**************************************************************/  /*******************************************************
5     *
6  /*   writes data and mesh in an opendx file */   *           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  /*   Author: Lutz Gross, gross@access.edu.au */  /*   writes data and mesh in an opendx file                      */
19  /*   Version: $Id$ */  /*   the input data needs to be cell centered or on reducedNodes */
20    
21  /**************************************************************/  /**************************************************************/
22    
23  #include "Mesh.h"  #include "Mesh.h"
24    #include "Assemble.h"
25    
26  /**************************************************************/  /**************************************************************/
27    
28  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) {
29    char error_msg[LenErrorMsg_MAX];    char error_msg[LenErrorMsg_MAX], elemTypeStr[32];
   /* if there is no mesh we just return */  
   if (mesh_p==NULL) return;  
30    /* some tables needed for reordering */    /* some tables needed for reordering */
31    int resort[6][9]={    int resort[6][9]={
32                      {0,1},   /* line */                      {0,1},   /* line */
# Line 40  void Finley_Mesh_saveDX(const char * fil Line 35  void Finley_Mesh_saveDX(const char * fil
35                      {0,3,1,2}, /* quadrilateral */                      {0,3,1,2}, /* quadrilateral */
36                      {3,0,7,4,2,1,6,5}, /* hexahedron */                      {3,0,7,4,2,1,6,5}, /* hexahedron */
37                     };                     };
38    Finley_ElementFile* elements=NULL;    FILE * fileHandle_p = NULL;
39    char elemTypeStr[32];    int i,j,k,i_data, elementtype, numPoints = 0, nDim, *resortIndex=NULL, p,
40    int i,j,k,numDXNodesPerElement,*resortIndex,isCellCentered=TRUE,nodetype=FINLEY_DEGREES_OF_FREEDOM;        numDXNodesPerElement=0, numCells, NN, object_count, rank, nComp, numPointsPerSample;
41    double* values,rtmp;    double* values,rtmp;
42    int nDim = mesh_p->Nodes->numDim;    bool_t *isCellCentered=NULL;
43      Finley_ElementFile* elements=NULL;
44      ElementTypeId TypeId;
45    /* open the file  and check handel */    /* open the file  and check handel */
46    FILE * fileHandle_p = fopen(filename_p, "w");  
47      /* if there is no mesh we just return */
48      if (mesh_p==NULL) return;
49      isCellCentered=MEMALLOC(num_data, bool_t);
50      if (Finley_checkPtr(isCellCentered)) return;
51    
52      fileHandle_p = fopen(filename_p, "w");
53    if (fileHandle_p==NULL) {    if (fileHandle_p==NULL) {
54           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);
55           Finley_setError(IO_ERROR,error_msg);      MEMFREE(isCellCentered);
56           return;      fclose(fileHandle_p);
57        Finley_setError(IO_ERROR,error_msg);
58        return;
59    }    }
60      /* find the mesh type to be written */
61      elementtype=FINLEY_UNKNOWN;
62      for (i_data=0;i_data<num_data;++i_data) {
63         if (! isEmpty(data_pp[i_data])) {
64            switch(getFunctionSpaceType(data_pp[i_data])) {
65               case FINLEY_REDUCED_NODES:
66                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
67                     elementtype=FINLEY_ELEMENTS;
68                 } else {
69                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
70                     MEMFREE(isCellCentered);
71                     fclose(fileHandle_p);
72                     return;
73                 }
74                 isCellCentered[i_data]=FALSE;
75                 break;
76               case FINLEY_ELEMENTS:
77               case FINLEY_REDUCED_ELEMENTS:
78                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_ELEMENTS) {
79                     elementtype=FINLEY_ELEMENTS;
80                 } else {
81                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
82                     MEMFREE(isCellCentered);
83                     fclose(fileHandle_p);
84                     return;
85                 }
86                 isCellCentered[i_data]=TRUE;
87                 break;
88               case FINLEY_FACE_ELEMENTS:
89               case FINLEY_REDUCED_FACE_ELEMENTS:
90                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_FACE_ELEMENTS) {
91                     elementtype=FINLEY_FACE_ELEMENTS;
92                 } else {
93                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
94                     MEMFREE(isCellCentered);
95                     fclose(fileHandle_p);
96                     return;
97                 }
98                 isCellCentered[i_data]=TRUE;
99                 break;
100               case FINLEY_POINTS:
101                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_POINTS) {
102                     elementtype=FINLEY_POINTS;
103                 } else {
104                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
105                     MEMFREE(isCellCentered);
106                     fclose(fileHandle_p);
107                     return;
108                 }
109                 isCellCentered[i_data]=TRUE;
110                 break;
111               case FINLEY_CONTACT_ELEMENTS_1:
112               case FINLEY_REDUCED_CONTACT_ELEMENTS_1:
113                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
114                     elementtype=FINLEY_CONTACT_ELEMENTS_1;
115                 } else {
116                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
117                     MEMFREE(isCellCentered);
118                     fclose(fileHandle_p);
119                     return;
120                 }
121                 isCellCentered[i_data]=TRUE;
122                 break;
123               case FINLEY_CONTACT_ELEMENTS_2:
124               case FINLEY_REDUCED_CONTACT_ELEMENTS_2:
125                 if (elementtype==FINLEY_UNKNOWN || elementtype==FINLEY_CONTACT_ELEMENTS_1) {
126                     elementtype=FINLEY_CONTACT_ELEMENTS_1;
127                 } else {
128                     Finley_setError(TYPE_ERROR,"saveDX: cannot write given data in single file.");
129                     MEMFREE(isCellCentered);
130                     fclose(fileHandle_p);
131                     return;
132                 }
133                 isCellCentered[i_data]=TRUE;
134                 break;
135               default:
136                 sprintf(error_msg,"saveDX: I don't know how to handel function space type %d",getFunctionSpaceType(data_pp[i_data]));
137                 Finley_setError(TYPE_ERROR,error_msg);
138                 MEMFREE(isCellCentered);
139                 fclose(fileHandle_p);
140                 return;
141            }
142         }
143      }
144      /* select number of points and the mesh component */
145      numPoints = mesh_p->Nodes->reducedNodesMapping->numTargets;
146      nDim = mesh_p->Nodes->numDim;
147      if (elementtype==FINLEY_UNKNOWN) elementtype=FINLEY_ELEMENTS;
148      switch(elementtype) {
149        case FINLEY_ELEMENTS:
150          elements=mesh_p->Elements;
151          break;
152        case FINLEY_FACE_ELEMENTS:
153          elements=mesh_p->FaceElements;
154          break;
155        case FINLEY_POINTS:
156          elements=mesh_p->Points;
157          break;
158        case FINLEY_CONTACT_ELEMENTS_2:
159          elements=mesh_p->ContactElements;
160          break;
161        case FINLEY_CONTACT_ELEMENTS_1:
162          elements=mesh_p->ContactElements;
163          break;
164      }
165      if (elements==NULL) {
166         Finley_setError(SYSTEM_ERROR,"saveDX: undefined element file");
167         MEMFREE(isCellCentered);
168         fclose(fileHandle_p);
169         return;
170      }
171    
172      /* map finley element type to DX element type */
173      TypeId = elements->ReferenceElement->Type->TypeId;
174      numDXNodesPerElement=0;
175      numCells = elements->numElements;
176      if (TypeId==Line2 || TypeId==Line3 || TypeId==Line4 ) {
177         numDXNodesPerElement=2;
178         resortIndex=resort[0];
179         strcpy(elemTypeStr, "lines");
180       } else if (TypeId==Tri3 || TypeId==Tri6 || TypeId==Tri9 || TypeId==Tri10 ) {
181         numDXNodesPerElement = 3;
182         resortIndex=resort[1];
183         strcpy(elemTypeStr, "triangles");
184       } else if (TypeId==Rec4 || TypeId==Rec8 || TypeId==Rec9 || TypeId==Rec12 || TypeId==Rec16 ) {
185         numDXNodesPerElement = 4;
186         resortIndex=resort[3];
187         strcpy(elemTypeStr, "quads");
188       } else if (TypeId==Tet4 || TypeId==Tet10 || TypeId==Tet16 ) {
189         numDXNodesPerElement = 4;
190         resortIndex=resort[2];
191         strcpy(elemTypeStr, "tetrahedra");
192       } else if (TypeId==Hex8 || TypeId==Hex20 || TypeId==Hex32 ) {
193         numDXNodesPerElement = 8;
194         resortIndex=resort[4];
195         strcpy(elemTypeStr, "cubes");
196       } else {
197         sprintf(error_msg,"saveDX: Element type %s is not supported by DX",elements->ReferenceElement->Type->Name);
198         Finley_setError(VALUE_ERROR,error_msg);
199         MEMFREE(isCellCentered);
200         fclose(fileHandle_p);
201         return;
202       }
203    
204    /* positions */    /* positions */
205    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, numPoints);
206                                                                     nDim, mesh_p->Nodes->reducedNumNodes);    for (i = 0; i < numPoints; i++) {
207    for (i = 0; i < mesh_p->Nodes->numNodes; i++) {         p=mesh_p->Nodes->reducedNodesMapping->map[i];
208      if (mesh_p->Nodes->toReduced[i]>=0) {         for (j = 0; j < nDim; j++) fprintf(fileHandle_p, " %g",mesh_p->Nodes->Coordinates[INDEX2(j, p, nDim)]);
        fprintf(fileHandle_p, "%g", mesh_p->Nodes->Coordinates[INDEX2(0, i, nDim)]);  
        for (j = 1; j < nDim; j++) fprintf(fileHandle_p, " %g",mesh_p->Nodes->Coordinates[INDEX2(j, i, nDim)]);  
209         fprintf(fileHandle_p, "\n");         fprintf(fileHandle_p, "\n");
     }  
210    }    }
211    /* connections */    /* connection table */
212    /* get a pointer to the relevant mesh component */    NN=elements->numNodes;
213    if (isEmpty(data_p)) {    fprintf(fileHandle_p, "object 2 class array type int rank 1 shape %d items %d data follows\n",numDXNodesPerElement, numCells);
214        elements=mesh_p->Elements;    for (i = 0; i < numCells; i++) {
215    } else {        for (j = 0; j < numDXNodesPerElement; j++)
216        switch(getFunctionSpaceType(data_p)) {              fprintf(fileHandle_p," %d",mesh_p->Nodes->reducedNodesMapping->target[elements->Nodes[INDEX2(resortIndex[j], i, NN)]]);
217         case(FINLEY_DEGREES_OF_FREEDOM):        fprintf(fileHandle_p, "\n");
218            nodetype=FINLEY_DEGREES_OF_FREEDOM;    }
219            isCellCentered=FALSE;    fprintf(fileHandle_p, "attribute \"element type\" string \"%s\"\n",elemTypeStr);
220            elements=mesh_p->Elements;    fprintf(fileHandle_p, "attribute \"ref\" string \"positions\"\n");
           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");  
221    
   }  
222    /* data */    /* data */
223    if (!isEmpty(data_p)) {    object_count=2;
224        int rank=getDataPointRank(data_p);    for (i_data =0 ;i_data<num_data;++i_data) {
225        int nComp=getDataPointSize(data_p);        if (! isEmpty(data_pp[i_data])) {
226        fprintf(fileHandle_p, "object 3 class array type float rank %d ", rank);           object_count++;
227        if (0 < rank) {           rank=getDataPointRank(data_pp[i_data]);
228           fprintf(fileHandle_p, "shape ");           nComp=getDataPointSize(data_pp[i_data]);
229           for (i = 0; i < rank; i++) fprintf(fileHandle_p, "%d ", getDataPointShape(data_p,i));           fprintf(fileHandle_p, "object %d class array type float rank %d ",object_count,rank);
230        }           if (0 < rank) {
231        if (isCellCentered) {              fprintf(fileHandle_p, "shape ");
232            int numPointsPerSample=elements->ReferenceElement->numQuadNodes;              for (i = 0; i < rank; i++) fprintf(fileHandle_p, "%d ", getDataPointShape(data_pp[i_data],i));
233            if (numPointsPerSample>0) {           }
234               fprintf(fileHandle_p, "items %d data follows\n", elements->numElements);           if (isCellCentered[i_data]) {
235               for (i=0;i<elements->numElements;i++) {               if (Finley_Assemble_reducedIntegrationOrder(data_pp[i_data])) {
236                   values=getSampleData(data_p,i);                  numPointsPerSample=elements->ReferenceElementReducedOrder->numQuadNodes;
237                   for (k=0;k<nComp;k++) {               } else {
238                       rtmp=0.;                  numPointsPerSample=elements->ReferenceElement->numQuadNodes;
                      for (j=0;j<numPointsPerSample;j++) rtmp+=values[INDEX2(k,j,nComp)];  
                      fprintf(fileHandle_p, " %g", rtmp/numPointsPerSample);  
                  }  
              fprintf(fileHandle_p, "\n");  
239               }               }
240               fprintf(fileHandle_p, "attribute \"dep\" string \"connections\"\n");               if (numPointsPerSample>0) {
241                    fprintf(fileHandle_p, "items %d data follows\n", numCells);
242                    for (i=0;i<elements->numElements;i++) {
243                        values=getSampleData(data_pp[i_data],i);
244                        for (k=0;k<nComp;k++) {
245                            if ( isExpanded(data_pp[i_data]) ) {
246                                rtmp=0.;
247                                for (j=0;j<numPointsPerSample;j++) rtmp+=values[INDEX2(k,j,nComp)];
248                                fprintf(fileHandle_p, " %g", rtmp/numPointsPerSample);
249                            } else {
250                                fprintf(fileHandle_p, " %g", values[k]);
251                            }
252                        }
253                    fprintf(fileHandle_p, "\n");
254                    }
255                    fprintf(fileHandle_p, "attribute \"dep\" string \"connections\"\n");
256                }
257             } else {
258                 fprintf(fileHandle_p, "items %d data follows\n", numPoints);
259                 for (i=0;i<numPoints;i++) {
260                       values=getSampleData(data_pp[i_data],i);
261                       for (k=0;k<nComp;k++) fprintf(fileHandle_p, " %g", values[k]);
262                   fprintf(fileHandle_p, "\n");
263                 }
264                 fprintf(fileHandle_p, "attribute \"dep\" string \"positions\"\n");
265           }           }
266        } 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");  
       }  
267    }    }
268    
269    /* and finish it up */    /* and finish it up */
270    fprintf(fileHandle_p, "object 4 class field\n");    if (num_data==0) {
271    fprintf(fileHandle_p, "component \"positions\" value 1\n");       fprintf(fileHandle_p, "object %d class field\n",object_count+1);
272    if (elements!=NULL) fprintf(fileHandle_p, "component \"connections\" value 2\n");       fprintf(fileHandle_p, "component \"positions\" value 1\n");
273    if (!isEmpty(data_p)) fprintf(fileHandle_p, "component \"data\" value 3\n");       fprintf(fileHandle_p, "component \"connections\" value 2\n");
274      } else {
275         object_count=2;
276         for (i_data=0; i_data<num_data;++i_data) {
277             if (! isEmpty(data_pp[i_data])) {
278                object_count++;
279                fprintf(fileHandle_p, "object \"%s\" class field\n",names_p[i_data]);
280                fprintf(fileHandle_p, "component \"positions\" value 1\n");
281                fprintf(fileHandle_p, "component \"connections\" value 2\n");
282                fprintf(fileHandle_p, "component \"data\" value %d\n",object_count);
283             }
284         }
285      }
286    fprintf(fileHandle_p, "end\n");    fprintf(fileHandle_p, "end\n");
287    /* close the file */    /* close the file */
288    fclose(fileHandle_p);    fclose(fileHandle_p);
289      MEMFREE(isCellCentered);
290    return;    return;
291  }  }
   
 /*  
  * $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.150  
changed lines
  Added in v.1338

  ViewVC Help
Powered by ViewVC 1.1.26