/[escript]/branches/split/weipa/src/DataVar.cpp
ViewVC logotype

Diff of /branches/split/weipa/src/DataVar.cpp

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

trunk/dataexporter/src/DataVar.cpp revision 2810 by caltinay, Mon Dec 7 04:13:49 2009 UTC trunk/weipa/src/DataVar.cpp revision 3357 by caltinay, Wed Nov 17 06:21:37 2010 UTC
# Line 1  Line 1 
1    
2  /*******************************************************  /*******************************************************
3  *  *
4  * Copyright (c) 2003-2009 by University of Queensland  * Copyright (c) 2003-2010 by University of Queensland
5  * Earth Systems Science Computational Center (ESSCC)  * Earth Systems Science Computational Center (ESSCC)
6  * http://www.uq.edu.au/esscc  * http://www.uq.edu.au/esscc
7  *  *
# Line 11  Line 11 
11  *  *
12  *******************************************************/  *******************************************************/
13    
14  #include <escriptexport/DataVar.h>  #include <weipa/DataVar.h>
15  #include <escriptexport/ElementData.h>  #include <weipa/DomainChunk.h>
16  #include <escriptexport/FinleyMesh.h>  #include <weipa/ElementData.h>
17  #include <escriptexport/NodeData.h>  #include <weipa/NodeData.h>
18    #ifndef VISIT_PLUGIN
19  #include <escript/Data.h>  #include <escript/Data.h>
20    #endif
21    
22  #if USE_NETCDF  #if USE_NETCDF
23  #include <netcdf.hh>  #include <netcdfcpp.h>
24  #endif  #endif
25    
26  #if USE_SILO  #if USE_SILO
27  #include <silo.h>  #include <silo.h>
28  #endif  #endif
29    
30    #include <numeric> // for accumulate
31    #include <iostream> // for cerr
32    #include <stdio.h>
33    
34  using namespace std;  using namespace std;
35    
36  namespace escriptexport {  namespace weipa {
37            
 enum {  
     NODE_CENTERED = 1,  
     ZONE_CENTERED = 2  
 };  
   
38  //  //
39  // Constructor  // Constructor
40  //  //
41  DataVar::DataVar(const string& name) :  DataVar::DataVar(const string& name) :
42      initialized(false), varName(name),      initialized(false), varName(name),
43      numSamples(0), rank(0), ptsPerSample(0), centering(0)      numSamples(0), rank(0), ptsPerSample(0)
44  {  {
45  }  }
46    
# Line 47  DataVar::DataVar(const string& name) : Line 48  DataVar::DataVar(const string& name) :
48  // Copy constructor  // Copy constructor
49  //  //
50  DataVar::DataVar(const DataVar& d) :  DataVar::DataVar(const DataVar& d) :
51        initialized(d.initialized), domain(d.domain),
52      varName(d.varName), numSamples(d.numSamples),      varName(d.varName), numSamples(d.numSamples),
53      rank(d.rank), ptsPerSample(d.ptsPerSample), centering(d.centering),      rank(d.rank), ptsPerSample(d.ptsPerSample), funcSpace(d.funcSpace),
54      funcSpace(d.funcSpace), shape(d.shape), sampleID(d.sampleID)      centering(d.centering), shape(d.shape), sampleID(d.sampleID)
55  {  {
56      if (numSamples > 0) {      if (numSamples > 0) {
57          CoordArray::const_iterator it;          CoordArray::const_iterator it;
# Line 59  DataVar::DataVar(const DataVar& d) : Line 61  DataVar::DataVar(const DataVar& d) :
61              dataArray.push_back(c);              dataArray.push_back(c);
62          }          }
63      }      }
     initialized = d.initialized;  
64  }  }
65    
66  //  //
# Line 88  void DataVar::cleanup() Line 89  void DataVar::cleanup()
89  //  //
90  //  //
91  //  //
92  bool DataVar::initFromEscript(escript::Data& escriptData, FinleyMesh_ptr mesh)  bool DataVar::initFromEscript(escript::Data& escriptData, const_DomainChunk_ptr dom)
93  {  {
94    #ifndef VISIT_PLUGIN
95      cleanup();      cleanup();
96    
97      if (!escriptData.actsExpanded()) {      if (!escriptData.isConstant() && !escriptData.actsExpanded()) {
98          cerr << "WARNING: Only expanded data supported!" << endl;          cerr << "WARNING: Weipa only supports constant & expanded data, "
99                << "not initializing " << varName << endl;
100          return false;          return false;
101      }      }
102    
103        domain = dom;
104      rank = escriptData.getDataPointRank();      rank = escriptData.getDataPointRank();
105      ptsPerSample = escriptData.getNumDataPointsPerSample();      ptsPerSample = escriptData.getNumDataPointsPerSample();
106      shape = escriptData.getDataPointShape();      shape = escriptData.getDataPointShape();
107      funcSpace = escriptData.getFunctionSpace().getTypeCode();      funcSpace = escriptData.getFunctionSpace().getTypeCode();
108      numSamples = escriptData.getNumSamples();      numSamples = escriptData.getNumSamples();
109        centering = domain->getCenteringForFunctionSpace(funcSpace);
     if (funcSpace == FINLEY_REDUCED_NODES || funcSpace == FINLEY_NODES) {  
         centering = NODE_CENTERED;  
     } else {  
         centering = ZONE_CENTERED;  
     }  
110    
111  #ifdef _DEBUG  #ifdef _DEBUG
112      cout << varName << ":\t" << numSamples << " samples,  "      cout << varName << ":\t" << numSamples << " samples,  "
113          << ptsPerSample << " pts/s,  rank: " << rank << endl;          << ptsPerSample << " pts/s,  rank: " << rank << endl;
114  #endif  #endif
115    
116        NodeData_ptr nodes = domain->getMeshForFunctionSpace(funcSpace);
117        if (nodes == NULL)
118            return false;
119    
120        meshName = nodes->getName();
121        siloMeshName = nodes->getFullSiloName();
122      initialized = true;      initialized = true;
123    
124        // no samples? Nothing more to do.
125      if (numSamples == 0)      if (numSamples == 0)
126          return true;          return true;
127    
# Line 137  bool DataVar::initFromEscript(escript::D Line 143  bool DataVar::initFromEscript(escript::D
143          size_t dataSize = dimSize * ptsPerSample;          size_t dataSize = dimSize * ptsPerSample;
144          float* tempData = new float[dataSize*numSamples];          float* tempData = new float[dataSize*numSamples];
145          float* destPtr = tempData;          float* destPtr = tempData;
146          for (int sampleNo=0; sampleNo<numSamples; sampleNo++) {          if (escriptData.isConstant()) {
147              const escript::DataAbstract::ValueType::value_type* values =              const escript::DataAbstract::ValueType::value_type* values =
148                  escriptData.getSampleDataRO(sampleNo);                  escriptData.getSampleDataRO(0);
149              copy(values, values+dataSize, destPtr);              for (int pointNo=0; pointNo<numSamples*ptsPerSample; pointNo++) {
150              destPtr += dataSize;                  copy(values, values+dimSize, destPtr);
151                    destPtr += dimSize;
152                }
153            } else {
154                for (int sampleNo=0; sampleNo<numSamples; sampleNo++) {
155                    const escript::DataAbstract::ValueType::value_type* values =
156                        escriptData.getSampleDataRO(sampleNo);
157                    copy(values, values+dataSize, destPtr);
158                    destPtr += dataSize;
159                }
160          }          }
161    
162          const float* srcPtr = tempData;          const float* srcPtr = tempData;
# Line 151  bool DataVar::initFromEscript(escript::D Line 166  bool DataVar::initFromEscript(escript::D
166          }          }
167          delete[] tempData;          delete[] tempData;
168    
169          initialized = filterSamples(mesh);          initialized = reorderSamples();
170      }      }
171    
172      return initialized;      return initialized;
173    
174    #else // VISIT_PLUGIN
175        return false;
176    #endif
177  }  }
178    
179  //  //
180  // Initialise with mesh data  // Initialise with domain data
181  //  //
182  bool DataVar::initFromMesh(FinleyMesh_ptr mesh)  bool DataVar::initFromMeshData(const_DomainChunk_ptr dom, const IntVec& data,
183            int fsCode, Centering c, NodeData_ptr nodes, const IntVec& id)
184  {  {
185      cleanup();      cleanup();
186            
187      const IntVec& data = mesh->getVarDataByName(varName);      domain = dom;
188      rank = 0;      rank = 0;
189      ptsPerSample = 1;      ptsPerSample = 1;
190        centering = c;
191        sampleID = id;
192        meshName = nodes->getName();
193        siloMeshName = nodes->getFullSiloName();
194      numSamples = data.size();      numSamples = data.size();
195    
196      if (numSamples > 0) {      if (numSamples > 0) {
# Line 175  bool DataVar::initFromMesh(FinleyMesh_pt Line 199  bool DataVar::initFromMesh(FinleyMesh_pt
199          IntVec::const_iterator it;          IntVec::const_iterator it;
200          for (it=data.begin(); it != data.end(); it++)          for (it=data.begin(); it != data.end(); it++)
201              *c++ = static_cast<float>(*it);              *c++ = static_cast<float>(*it);
   
         if (varName.compare(0, 6, "Nodes_") == 0) {  
             funcSpace = FINLEY_NODES;  
             centering = NODE_CENTERED;  
             sampleID.insert(sampleID.end(),  
                     mesh->getNodes()->getNodeIDs().begin(),  
                     mesh->getNodes()->getNodeIDs().end());  
         } else if (varName.compare(0, 9, "Elements_") == 0) {  
             funcSpace = FINLEY_ELEMENTS;  
             centering = ZONE_CENTERED;  
             sampleID.insert(sampleID.end(),  
                     mesh->getElements()->getIDs().begin(),  
                     mesh->getElements()->getIDs().end());  
         } else if (varName.compare(0, 13, "FaceElements_") == 0) {  
             funcSpace = FINLEY_FACE_ELEMENTS;  
             centering = ZONE_CENTERED;  
             sampleID.insert(sampleID.end(),  
                     mesh->getFaceElements()->getIDs().begin(),  
                     mesh->getFaceElements()->getIDs().end());  
         } else if (varName.compare(0, 16, "ContactElements_") == 0) {  
             funcSpace = FINLEY_CONTACT_ELEMENTS_1;  
             centering = ZONE_CENTERED;  
             sampleID.insert(sampleID.end(),  
                     mesh->getContactElements()->getIDs().begin(),  
                     mesh->getContactElements()->getIDs().end());  
         } else {  
             return false;  
         }  
   
         NodeData_ptr nodes = mesh->getMeshForFinleyFS(funcSpace);  
         meshName = nodes->getName();  
         siloMeshName = nodes->getFullSiloName();  
202      }      }
203      initialized = true;      initialized = true;
204    
# Line 214  bool DataVar::initFromMesh(FinleyMesh_pt Line 206  bool DataVar::initFromMesh(FinleyMesh_pt
206  }  }
207    
208  //  //
209  // Reads variable data from NetCDF file  // Reads variable data from dump file
210  //  //
211  bool DataVar::initFromNetCDF(const string& filename, FinleyMesh_ptr mesh)  bool DataVar::initFromFile(const string& filename, const_DomainChunk_ptr dom)
212  {  {
213      cleanup();      cleanup();
214            
# Line 249  bool DataVar::initFromNetCDF(const strin Line 241  bool DataVar::initFromNetCDF(const strin
241      att = input->get_att("function_space_type");      att = input->get_att("function_space_type");
242      funcSpace = att->as_int(0);      funcSpace = att->as_int(0);
243    
244      if (funcSpace == FINLEY_REDUCED_NODES || funcSpace == FINLEY_NODES) {      centering = dom->getCenteringForFunctionSpace(funcSpace);
         centering = NODE_CENTERED;  
     } else {  
         centering = ZONE_CENTERED;  
     }  
245    
246      dim = input->get_dim("num_samples");      dim = input->get_dim("num_samples");
247      numSamples = dim->size();      numSamples = dim->size();
# Line 263  bool DataVar::initFromNetCDF(const strin Line 251  bool DataVar::initFromNetCDF(const strin
251          << ptsPerSample << " pts/s,  rank: " << rank << endl;          << ptsPerSample << " pts/s,  rank: " << rank << endl;
252  #endif  #endif
253    
254      initialized = true;      domain = dom;
255        NodeData_ptr nodes = domain->getMeshForFunctionSpace(funcSpace);
256      // if there are no data samples we're done      if (nodes == NULL) {
     if (numSamples == 0) {  
257          delete input;          delete input;
258          return true;          return false;
259      }      }
260    
261      sampleID.insert(sampleID.end(), numSamples, 0);      meshName = nodes->getName();
262      NcVar* var = input->get_var("id");      siloMeshName = nodes->getFullSiloName();
263      var->get(&sampleID[0], numSamples);      initialized = true;
264    
265      size_t dimSize = 1;      size_t dimSize = 1;
266      vector<long> counts;      vector<long> counts;
# Line 297  bool DataVar::initFromNetCDF(const strin Line 284  bool DataVar::initFromNetCDF(const strin
284          initialized = false;          initialized = false;
285      }      }
286    
287      if (initialized) {      if (initialized && numSamples > 0) {
288            sampleID.insert(sampleID.end(), numSamples, 0);
289            NcVar* var = input->get_var("id");
290            var->get(&sampleID[0], numSamples);
291    
292          size_t dataSize = dimSize*numSamples*ptsPerSample;          size_t dataSize = dimSize*numSamples*ptsPerSample;
293          counts.push_back(ptsPerSample);          counts.push_back(ptsPerSample);
294          counts.push_back(numSamples);          counts.push_back(numSamples);
295          float* tempData = new float[dataSize];          float* tempData = new float[dataSize];
296          NcVar* var = input->get_var("data");          var = input->get_var("data");
297          var->get(tempData, &counts[0]);          var->get(tempData, &counts[0]);
298    
299          const float* srcPtr = tempData;          const float* srcPtr = tempData;
# Line 312  bool DataVar::initFromNetCDF(const strin Line 303  bool DataVar::initFromNetCDF(const strin
303          }          }
304          delete[] tempData;          delete[] tempData;
305    
306          initialized = filterSamples(mesh);          initialized = reorderSamples();
307      }      }
308    
309      delete input;      delete input;
# Line 337  bool DataVar::isNodeCentered() const Line 328  bool DataVar::isNodeCentered() const
328  //  //
329  float* DataVar::averageData(const float* src, size_t stride)  float* DataVar::averageData(const float* src, size_t stride)
330  {  {
331      float* res = new float[numSamples];      float* res;
332    
333      if (ptsPerSample == 1) {      if (ptsPerSample == 1) {
334            res = new float[numSamples];
335          float* dest = res;          float* dest = res;
336          for (int i=0; i<numSamples; i++, src+=stride)          for (int i=0; i<numSamples; i++, src+=stride)
337              *dest++ = *src;              *dest++ = *src;
338      } else {      } else {
339            ElementData_ptr cells = domain->getElementsForFunctionSpace(funcSpace);
340            int cellFactor = cells->getElementFactor();
341            res = new float[cellFactor * numSamples];
342          float* dest = res;          float* dest = res;
343          for (int i=0; i<numSamples; i++) {          QuadMaskInfo qmi = cells->getQuadMask(funcSpace);
344              double tmpVal = 0.0;          if (!qmi.mask.empty()) {
345              for (int j=0; j<ptsPerSample; j++, src+=stride)              const float* tmpSrc = src;
346                  tmpVal += *src;              for (int i=0; i<numSamples; i++, tmpSrc+=stride*ptsPerSample) {
347              *dest++ = (float)(tmpVal / ptsPerSample);                  for (int l=0; l<cellFactor; l++) {
348                        double tmpVal = 0.0;
349                        for (int j=0; j<ptsPerSample; j++) {
350                            if (qmi.mask[l][j] != 0) {
351                                tmpVal += *(tmpSrc+stride*j);
352                            }
353                        }
354                        *dest++ = (float)(tmpVal / qmi.factor[l]);
355                    }
356                }
357            } else {
358                for (int i=0; i<numSamples; i++) {
359                    double tmpVal = 0.0;
360                    for (int j=0; j<ptsPerSample; j++, src+=stride) {
361                        tmpVal += *src;
362                    }
363                    tmpVal /= ptsPerSample;
364                    for (int l=0; l<cellFactor; l++) {
365                        *dest++ = static_cast<float>(tmpVal);
366                    }
367                }
368          }          }
369      }      }
370      return res;      return res;
371  }  }
372    
373  //  //
374  // Filters and reorders the raw sample values according to the IDs provided  // Filters and reorders the raw sample values according to the node/element
375  // in 'requiredIDs'. This is used to have data arrays ordered according to  // IDs. This is used to have data arrays ordered according to the underlying
376  // the underlying mesh (i.e. DataID[i]==MeshNodeID[i])  // mesh (i.e. DataID[i]==MeshNodeID[i])
377  //  //
378  bool DataVar::filterSamples(FinleyMesh_ptr finleyMesh)  bool DataVar::reorderSamples()
379  {  {
380      if (numSamples == 0)      if (numSamples == 0)
381          return true;          return true;
382    
     IndexMap id2idxMap;  
383      const IntVec* requiredIDs = NULL;      const IntVec* requiredIDs = NULL;
   
     NodeData_ptr nodes = finleyMesh->getMeshForFinleyFS(funcSpace);  
     if (nodes == NULL)  
         return false;  
   
384      int requiredNumSamples = 0;      int requiredNumSamples = 0;
385        int cellFactor = 1;
386    
387      if (centering == NODE_CENTERED) {      if (centering == NODE_CENTERED) {
388          id2idxMap = nodes->getIndexMap();          NodeData_ptr nodes = domain->getMeshForFunctionSpace(funcSpace);
389          requiredIDs = &nodes->getNodeIDs();          requiredIDs = &nodes->getNodeIDs();
390          requiredNumSamples = nodes->getNumNodes();          requiredNumSamples = nodes->getNumNodes();
391      } else {      } else {
392          ElementData_ptr cells = finleyMesh->getElementsForFinleyFS(funcSpace);          ElementData_ptr cells = domain->getElementsForFunctionSpace(funcSpace);
393          if (cells == NULL)          if (cells == NULL)
394              return false;              return false;
395    
         id2idxMap = cells->getIndexMap();  
396          requiredIDs = &cells->getIDs();          requiredIDs = &cells->getIDs();
397          if (cells->getReducedNumElements() > 0) {          requiredNumSamples = cells->getNumElements();
398              requiredNumSamples = cells->getReducedNumElements();          cellFactor = cells->getElementFactor();
399          } else {          if (cellFactor > 1) {
400              requiredNumSamples = cells->getNumElements();              numSamples *= cellFactor;
401                // update sample IDs
402                IntVec newSampleID(numSamples);
403                IntVec::const_iterator idIt = sampleID.begin();
404                IntVec::iterator newIDit = newSampleID.begin();
405                for (; idIt != sampleID.end(); idIt++, newIDit+=cellFactor) {
406                    fill(newIDit, newIDit+cellFactor, *idIt);
407                }
408                sampleID.swap(newSampleID);
409          }          }
410      }      }
411    
# Line 398  bool DataVar::filterSamples(FinleyMesh_p Line 415  bool DataVar::filterSamples(FinleyMesh_p
415          return false;          return false;
416      }      }
417    
     meshName = nodes->getName();  
     siloMeshName = nodes->getFullSiloName();  
   
418      IndexMap sampleID2idx = buildIndexMap();      IndexMap sampleID2idx = buildIndexMap();
419      numSamples = requiredNumSamples;      numSamples = requiredNumSamples;
420    
# Line 409  bool DataVar::filterSamples(FinleyMesh_p Line 423  bool DataVar::filterSamples(FinleyMesh_p
423          float* c = new float[numSamples];          float* c = new float[numSamples];
424          const float* src = dataArray[i];          const float* src = dataArray[i];
425          IntVec::const_iterator idIt = requiredIDs->begin();          IntVec::const_iterator idIt = requiredIDs->begin();
426          for (; idIt != requiredIDs->end(); idIt++) {          size_t destIdx = 0;
427            for (; idIt != requiredIDs->end(); idIt+=cellFactor, destIdx+=cellFactor) {
428              size_t srcIdx = sampleID2idx.find(*idIt)->second;              size_t srcIdx = sampleID2idx.find(*idIt)->second;
429              size_t destIdx = id2idxMap.find(*idIt)->second;              copy(&src[srcIdx], &src[srcIdx+cellFactor], &c[destIdx]);
             c[destIdx] = src[srcIdx];  
430          }          }
431          delete[] dataArray[i];          delete[] dataArray[i];
432          dataArray[i] = c;          dataArray[i] = c;
433      }      }
434    
435        // sample IDs now = mesh node/element IDs
436        sampleID = *requiredIDs;
437    
438      return true;      return true;
439  }  }
440    
441    //
442    //
443    //
444    int DataVar::getNumberOfComponents() const
445    {
446        return (rank == 0 ? 1 : accumulate(shape.begin(), shape.end(), 0));
447    }
448    
449    //
450    //
451    //
452    float* DataVar::getDataFlat() const
453    {
454        int totalSize = numSamples * getNumberOfComponents();
455        float* res = new float[totalSize];
456        if (rank == 0) {
457            copy(dataArray[0], dataArray[0]+numSamples, res);
458        } else if (rank == 1) {
459            float *dest = res;
460            for (size_t c=0; c<numSamples; c++) {
461                for (size_t i=0; i<shape[0]; i++) {
462                    *dest++ = dataArray[i][c];
463                }
464            }
465        } else if (rank == 2) {
466            float *dest = res;
467            for (size_t c=0; c<numSamples; c++) {
468                for (int i=0; i<shape[1]; i++) {
469                    for (int j=0; j<shape[0]; j++) {
470                        *dest++ = dataArray[i*shape[0]+j][c];
471                    }
472                }
473            }
474        }
475    
476        return res;
477    }
478    
479    //
480    //
481    //
482    void DataVar::sampleToStream(ostream& os, int index)
483    {
484        if (rank == 0) {
485            os << dataArray[0][index];
486        } else if (rank == 1) {
487            if (shape[0] < 3)
488                os << dataArray[0][index] << " " << dataArray[1][index]
489                    << " " << 0.;
490            else
491                os << dataArray[0][index] << " " << dataArray[1][index]
492                    << " " << dataArray[2][index];
493        } else if (rank == 2) {
494            if (shape[1] < 3) {
495                os << dataArray[0][index] << " " << dataArray[1][index]
496                    << " " << 0. << " ";
497                os << dataArray[2][index] << " " << dataArray[3][index]
498                    << " " << 0. << " ";
499                os << 0. << " " << 0. << " " << 0.;
500            } else {
501                os << dataArray[0][index] << " " << dataArray[1][index]
502                    << " " << dataArray[2][index] << " ";
503                os << dataArray[3][index] << " " << dataArray[4][index]
504                    << " " << dataArray[5][index] << " ";
505                os << dataArray[6][index] << " " << dataArray[7][index]
506                    << " " << dataArray[8][index];
507            }
508        }
509        os << endl;
510    }
511    
512    //
513    //
514    //
515    void DataVar::writeToVTK(ostream& os, int ownIndex)
516    {
517        if (numSamples == 0)
518            return;
519    
520        if (isNodeCentered()) {
521            // data was reordered in reorderSamples() but for VTK we write the
522            // original node mesh and thus need the original ordering...
523            const IntVec& requiredIDs = domain->getNodes()->getNodeIDs();
524            const IntVec& nodeGNI = domain->getNodes()->getGlobalNodeIndices();
525            const IntVec& nodeDist = domain->getNodes()->getNodeDistribution();
526            int firstId = nodeDist[ownIndex];
527            int lastId = nodeDist[ownIndex+1];
528            IndexMap sampleID2idx = buildIndexMap();
529            for (int i=0; i<nodeGNI.size(); i++) {
530                if (firstId <= nodeGNI[i] && nodeGNI[i] < lastId) {
531                    int idx = sampleID2idx[requiredIDs[i]];
532                    sampleToStream(os, idx);
533                }
534            }
535        } else {
536            // cell data: ghost cells have been removed so do not write ghost
537            // samples (which are the last elements in the arrays)
538            int toWrite = domain->getElementsByName(meshName)->getNumElements();
539            for (int i=0; i<toWrite; i++) {
540                sampleToStream(os, i);
541            }
542        }
543    }
544    
545  ///////////////////////////////  ///////////////////////////////
546  // SILO related methods follow  // SILO related methods follow
547  ///////////////////////////////  ///////////////////////////////
# Line 470  string DataVar::getTensorDef() const Line 592  string DataVar::getTensorDef() const
592    
593  //  //
594  // Writes the data to given Silo file under the virtual path provided.  // Writes the data to given Silo file under the virtual path provided.
595  // The corresponding mesh must have been written already and made known  // The corresponding mesh must have been written already.
 // to this variable by a call to setMesh().  
596  //  //
597  bool DataVar::writeToSilo(DBfile* dbfile, const string& siloPath)  bool DataVar::writeToSilo(DBfile* dbfile, const string& siloPath,
598                              const string& units)
599  {  {
600  #if USE_SILO  #if USE_SILO
601      if (!initialized)      if (!initialized)
# Line 492  bool DataVar::writeToSilo(DBfile* dbfile Line 614  bool DataVar::writeToSilo(DBfile* dbfile
614    
615      char* siloMesh = const_cast<char*>(siloMeshName.c_str());      char* siloMesh = const_cast<char*>(siloMeshName.c_str());
616      int dcenter = (centering == NODE_CENTERED ? DB_NODECENT : DB_ZONECENT);      int dcenter = (centering == NODE_CENTERED ? DB_NODECENT : DB_ZONECENT);
617        DBoptlist* optList = DBMakeOptlist(2);
618        if (units.length()>0) {
619            DBAddOption(optList, DBOPT_UNITS, (void*)units.c_str());
620        }
621    
622      if (rank == 0) {      if (rank == 0) {
623          ret = DBPutUcdvar1(dbfile, varName.c_str(), siloMesh, dataArray[0],          ret = DBPutUcdvar1(dbfile, varName.c_str(), siloMesh, dataArray[0],
624                  numSamples, NULL, 0, DB_FLOAT, dcenter, NULL);                  numSamples, NULL, 0, DB_FLOAT, dcenter, optList);
625      }      }
626      else if (rank == 1) {      else if (rank == 1) {
627          const string comps[3] = {          const string comps[3] = {
# Line 507  bool DataVar::writeToSilo(DBfile* dbfile Line 633  bool DataVar::writeToSilo(DBfile* dbfile
633    
634          ret = DBPutUcdvar(dbfile, varName.c_str(), siloMesh, shape[0],          ret = DBPutUcdvar(dbfile, varName.c_str(), siloMesh, shape[0],
635                  (char**)varnames, &dataArray[0], numSamples, NULL,                  (char**)varnames, &dataArray[0], numSamples, NULL,
636                  0, DB_FLOAT, dcenter, NULL);                  0, DB_FLOAT, dcenter, optList);
637      }      }
638      else {      else {
639          string tensorDir = varName+string("_comps/");          string tensorDir = varName+string("_comps/");
640          ret = DBMkdir(dbfile, tensorDir.c_str());          ret = DBMkdir(dbfile, tensorDir.c_str());
641          if (ret == 0) {          if (ret == 0) {
642              int one = 1;              int one = 1;
             DBoptlist* optList = DBMakeOptlist(1);  
643              DBAddOption(optList, DBOPT_HIDE_FROM_GUI, &one);              DBAddOption(optList, DBOPT_HIDE_FROM_GUI, &one);
644    
645              for (int i=0; i<shape[1]; i++) {              for (int i=0; i<shape[1]; i++) {
# Line 528  bool DataVar::writeToSilo(DBfile* dbfile Line 653  bool DataVar::writeToSilo(DBfile* dbfile
653                  }                  }
654                  if (ret != 0) break;                  if (ret != 0) break;
655              }              }
             DBFreeOptlist(optList);  
656          } // ret==0          } // ret==0
657      } // rank      } // rank
658    
659        DBFreeOptlist(optList);
660      DBSetDir(dbfile, "/");      DBSetDir(dbfile, "/");
661      return (ret == 0);      return (ret == 0);
662    
# Line 540  bool DataVar::writeToSilo(DBfile* dbfile Line 665  bool DataVar::writeToSilo(DBfile* dbfile
665  #endif  #endif
666  }  }
667    
668  } // namespace escriptexport  } // namespace weipa
669    

Legend:
Removed from v.2810  
changed lines
  Added in v.3357

  ViewVC Help
Powered by ViewVC 1.1.26