source: XIOS/dev/branch_openmp/src/io/nc4_data_input.cpp @ 1460

Last change on this file since 1460 was 1460, checked in by yushan, 3 years ago

branch_openmp merged with XIOS_DEV_CMIP6@1459

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
File size: 24.2 KB
Line 
1#include "nc4_data_input.hpp"
2
3#include "context.hpp"
4#include "context_server.hpp"
5#include "context_client.hpp"
6#include "domain.hpp"
7#include "axis.hpp"
8#include "scalar.hpp"
9
10namespace xios
11{
12  CNc4DataInput::CNc4DataInput(const StdString& filename, ep_lib::MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/, const StdString& timeCounterName /*= "time_counter"*/)
13    : SuperClass()
14    , SuperClassWriter(filename, &comm_file, multifile, timeCounterName)
15    , comm_file(comm_file)
16    , filename(filename)
17    , isCollective(isCollective)
18    , readMetaDataDomains_(), readValueDomains_()
19    , readMetaDataAxis_(), readValueAxis_()
20    , readMetaDataScalar_(), readValueScalar_()
21  {
22    SuperClass::type = multifile ? MULTI_FILE : ONE_FILE;
23  }
24
25  CNc4DataInput::~CNc4DataInput(void)
26  { /* Nothing more to do */ }
27
28  StdSize CNc4DataInput::getFieldNbRecords_(CField* field)
29  {
30    StdString fieldId = field->getFieldOutputName();
31
32    if (SuperClassWriter::isTemporal(fieldId))
33    {
34//      return SuperClassWriter::getDimensions(&fieldId)[SuperClassWriter::getUnlimitedDimensionName()];
35      return SuperClassWriter::getDimensions(&fieldId)[SuperClassWriter::getTimeCounterName()];
36    }
37
38    return 1;
39  }
40
41  void CNc4DataInput::readFieldData_(CField* field)
42  {
43    CContext* context = CContext::getCurrent();
44    CContextServer* server = context->server;
45
46    CGrid* grid = field->grid;
47
48    if (!grid->doGridHaveDataToWrite())
49      if (SuperClass::type==MULTI_FILE || !isCollective) return;
50
51    StdString fieldId = field->getFieldOutputName();
52
53    CArray<double,1> fieldData(grid->getWrittenDataSize());
54    if (!field->default_value.isEmpty()) fieldData = field->default_value;
55    #ifdef _usingEP
56      SuperClass::type = ONE_FILE;
57      printf("SuperClass::type = %d\n", SuperClass::type);
58    #endif
59       
60    switch (SuperClass::type)
61    {
62      case MULTI_FILE:
63        SuperClassWriter::getData(fieldData, fieldId, isCollective, (field->getNStep() - 1)%field->nstepMax );
64        break;
65      case ONE_FILE:
66      {
67/*
68        std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
69        std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
70        std::vector<int> nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer();
71
72        int ssize = nZoomBeginGlobal.size();
73
74        std::vector<StdSize> start(ssize);
75        std::vector<StdSize> count(ssize);
76
77        for (int i = 0; i < ssize; ++i)
78        {
79          start[i] = nZoomBeginServer[ssize - i - 1] - nZoomBeginGlobal[ssize - i - 1];
80          count[i] = nZoomSizeServer[ssize - i - 1];
81        }
82*/
83
84        std::vector<int> nZoomBeginGlobal = grid->getDistributionServer()->getZoomBeginGlobal();
85        std::vector<int> nZoomBeginServer = grid->getDistributionServer()->getZoomBeginServer();
86        std::vector<int> nZoomSizeServer  = grid->getDistributionServer()->getZoomSizeServer();
87
88        std::vector<StdSize> start, count;
89
90        CArray<int,1> axisDomainOrder = grid->axis_domain_order;
91        std::vector<StdString> domainList = grid->getDomainList();
92        std::vector<StdString> axisList   = grid->getAxisList();
93        int numElement = axisDomainOrder.numElements();
94        int idxDomain = domainList.size() - 1, idxAxis = axisList.size() - 1;
95        int idx = nZoomBeginGlobal.size() - 1;
96
97        start.reserve(nZoomBeginGlobal.size());
98        count.reserve(nZoomBeginGlobal.size());
99
100        for (int i = numElement - 1; i >= 0; --i)
101        {
102          if (2 == axisDomainOrder(i))
103          {
104            CDomain* domain = CDomain::get(domainList[idxDomain]);
105            if ((domain->type) != CDomain::type_attr::unstructured)
106            {
107              start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
108              count.push_back(nZoomSizeServer[idx]);
109            }
110            --idx ;
111            start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
112            count.push_back(nZoomSizeServer[idx]);
113            --idx ;
114            --idxDomain;
115          }
116          else if (1 == axisDomainOrder(i))
117          {
118            start.push_back(nZoomBeginServer[idx] - nZoomBeginGlobal[idx]);
119            count.push_back(nZoomSizeServer[idx]);
120            --idx;
121          }
122          else
123          {
124            if (1 == axisDomainOrder.numElements())
125            {
126              start.push_back(0);
127              count.push_back(1);
128            }
129            --idx;
130          }
131        }
132
133        SuperClassWriter::getData(fieldData, fieldId, isCollective, (field->getNStep() - 1)%field->nstepMax, &start, &count);
134        break;
135      }
136    }
137
138    field->inputField(fieldData);
139
140    if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty())
141    {
142      double scaleFactor = 1.0, addOffset = 0.0;
143      if (!field->scale_factor.isEmpty()) scaleFactor = field->scale_factor;
144      if (!field->add_offset.isEmpty()) addOffset = field->add_offset;
145      field->invertScaleFactorAddOffset(scaleFactor, addOffset);
146    }
147  }
148
149  void CNc4DataInput::readFieldAttributes_(CField* field, bool readAttributeValues)
150  {
151    StdString fieldId = field->getFieldOutputName();
152
153    CGrid* grid = field->grid;
154
155    std::vector<CDomain*> domainP = grid->getDomains();
156    std::vector<CAxis*> axisP = grid->getAxis();
157    std::vector<CScalar*> scalarP = grid->getScalars();
158    int gridDim = domainP.size() * 2 + axisP.size();
159
160    // Nothing to do with scalar without timestep
161    if ((0 == gridDim) && (!SuperClassWriter::isTemporal(fieldId))) 
162      return;
163
164    // Verify the compatibility of dimension of declared grid and real grid in file
165    int realGridDim = 1;
166    bool isUnstructuredGrid = SuperClassWriter::isUnstructured(fieldId);
167    std::map<StdString, StdSize> dimSizeMap = SuperClassWriter::getDimensions(&fieldId);
168    std::list<StdString> dimList = SuperClassWriter::getDimensionsList(&fieldId);
169
170    realGridDim = SuperClassWriter::isTemporal(fieldId) ? dimSizeMap.size() - 1 : dimSizeMap.size();
171    if (isUnstructuredGrid) ++realGridDim;
172
173    if (gridDim != realGridDim)
174       ERROR("CNc4DataInput::readFieldAttributes_(CField* field, bool readAttributeValues)",
175        << "Field '" << fieldId << "' has incorrect dimension " << std::endl
176        << "Verify dimension of grid defined by 'grid_ref' or 'domain_ref'/'axis_ref' and dimension of grid in read file.");
177
178    // Remove unlimited dimension from the map, we dont need it anymore
179    if (SuperClassWriter::isTemporal(fieldId))
180    {
181      dimSizeMap.erase(SuperClassWriter::getUnlimitedDimensionName());
182      dimList.pop_front() ;  // assume time dimension is first
183    }
184
185    std::list<std::pair<StdString, StdSize> > listDimSize;
186/*
187    for (std::map<StdString, StdSize>::const_iterator itMap = dimSizeMap.begin(); itMap != dimSizeMap.end(); ++itMap)
188      listDimSize.push_front(*itMap);
189*/
190
191    if (!SuperClassWriter::isRectilinear(fieldId))
192    {
193      for (std::list<StdString>::const_iterator it = dimList.begin(); it != dimList.end(); ++it)
194        listDimSize.push_front(*dimSizeMap.find(*it));
195    }
196    else
197    {
198       std::list<StdString> coords = SuperClassWriter::getCoordinatesIdList(fieldId);
199       std::list<StdString>::const_iterator itCoord = coords.begin();
200       for (; itCoord != coords.end(); itCoord++)
201       {
202         const StdString& coord = *itCoord;
203         if (SuperClassWriter::hasVariable(coord) && !SuperClassWriter::isTemporal(coord))
204         {
205           std::map<StdString, StdSize> dimsTmp = SuperClassWriter::getDimensions(&coord);
206           StdString dimNameTmp = dimsTmp.begin()->first;
207           StdSize dimSizeTmp = dimsTmp.begin()->second;
208           listDimSize.push_front(make_pair(coord, dimSizeTmp));
209           dimSizeMap.erase(dimNameTmp);
210           dimList.remove(dimNameTmp);
211         }
212       }
213       for (std::list<StdString>::const_iterator it = dimList.begin(); it != dimList.end(); ++it)
214        listDimSize.push_front(*dimSizeMap.find(*it));
215    }
216
217    // Now process domain and axis
218    CArray<int,1> axisDomainOrder = grid->axis_domain_order;
219    int numElement = domainP.size() + axisP.size() + scalarP.size();
220    int elementPosition = 0;
221    int idxDomain = 0, idxAxis = 0, idxScalar = 0;
222
223    std::pair<std::set<StdString>::iterator,bool> it;
224    for (int i = 0; i < numElement; ++i)
225    {
226      if(2 == axisDomainOrder(i))
227      {
228        if (readAttributeValues)
229        {
230           it = readValueDomains_.insert(domainP[idxDomain]->getId());
231           if (it.second) readDomainAttributeValueFromFile(domainP[idxDomain], listDimSize, elementPosition, fieldId);
232        }
233        else
234        {
235          it = readMetaDataDomains_.insert(domainP[idxDomain]->getId());
236          if (it.second) readDomainAttributesFromFile(domainP[idxDomain], listDimSize, elementPosition, fieldId);
237        }
238        ++idxDomain;
239        if (isUnstructuredGrid) ++elementPosition;
240        else elementPosition += 2;
241      }
242      else if (1 == axisDomainOrder(i))
243      {
244        if (readAttributeValues)
245        {
246          it = readValueAxis_.insert(axisP[idxAxis]->getId());
247          if (it.second) readAxisAttributeValueFromFile(axisP[idxAxis], listDimSize, elementPosition, fieldId);
248        }
249        else
250        {
251          it = readMetaDataAxis_.insert(axisP[idxAxis]->getId());
252          if (it.second) readAxisAttributesFromFile(axisP[idxAxis], listDimSize, elementPosition, fieldId);
253        }
254        ++idxAxis;
255        ++elementPosition;
256      }
257      else
258      {
259        if (readAttributeValues)
260        {
261          it = readValueScalar_.insert(scalarP[idxScalar]->getId());
262          if (it.second) readScalarAttributeValueFromFile(scalarP[idxScalar], listDimSize, elementPosition, fieldId);
263        }
264        else
265        {
266          it = readMetaDataScalar_.insert(scalarP[idxScalar]->getId());
267          if (it.second) readScalarAttributesFromFile(scalarP[idxScalar], listDimSize, elementPosition, fieldId);
268        }
269        ++idxScalar;
270        ++elementPosition;
271      }
272    }
273  }
274
275  /*!
276    Read attributes of a domain from a file
277    \param [in] domain domain whose attributes are read from the file
278    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file
279    \param [in] emelentPosition position of domain in grid
280    \param [in] fieldId id (or name) associated with the grid
281  */
282  void CNc4DataInput::readDomainAttributeValueFromFile(CDomain* domain, std::list<std::pair<StdString, StdSize> >& dimSizeMap,
283                                                       int elementPosition, const StdString& fieldId)
284  {
285    // There are some optional attributes of a domain to retrieve from file    // + lon lat?
286    std::list<std::pair<StdString, StdSize> >::const_iterator itMapNi = dimSizeMap.begin(), itMapNj,
287                                                              iteMap  = dimSizeMap.end();
288
289    for (int i = 0; i < elementPosition; ++i, ++itMapNi) {}
290    itMapNj = itMapNi; ++itMapNj;
291
292    if ((CDomain::type_attr::rectilinear == domain->type))
293    {
294      // Ok, try to read some attributes such as longitude and latitude
295      bool hasLat = SuperClassWriter::hasVariable(itMapNj->first);
296      if (hasLat)
297      {
298        domain->latvalue_rectilinear_read_from_file.resize(itMapNj->second);
299        std::vector<StdSize> nBeginLat(1, 0), nSizeLat(1, itMapNj->second);
300        readFieldVariableValue(domain->latvalue_rectilinear_read_from_file, itMapNj->first, nBeginLat, nSizeLat, true);
301      }
302
303      bool hasLon = SuperClassWriter::hasVariable(itMapNi->first);
304      if (hasLon)
305      {
306        domain->lonvalue_rectilinear_read_from_file.resize(itMapNi->second);
307        std::vector<StdSize> nBeginLon(1, 0), nSizeLon(1, itMapNi->second);
308        readFieldVariableValue(domain->lonvalue_rectilinear_read_from_file, itMapNi->first, nBeginLon, nSizeLon, true);
309      }     
310    }
311    else if ((CDomain::type_attr::curvilinear == domain->type))
312    {
313      // Make sure that if there is no local domain defined on a process, the process still reads just one value.
314      int ni, nj, ibegin, jbegin;
315      if (domain->ni == 0)
316      {
317        ni = 1;
318        ibegin = 0;
319      }
320      else
321      {
322        ni = domain->ni;
323        ibegin = domain->ibegin;
324      }
325      if (domain->nj == 0)
326      {
327        nj = 1;
328        jbegin = 0;
329      }
330      else
331      {
332        nj = domain->nj;
333        jbegin = domain->jbegin;
334      }
335
336      std::vector<StdSize> nBeginLatLon(2), nSizeLatLon(2);
337      nBeginLatLon[0] = jbegin; nBeginLatLon[1] = ibegin;
338      nSizeLatLon[0]  = nj; nSizeLatLon[1] = ni;
339
340      StdString latName = this->getLatCoordName(fieldId);
341      if (SuperClassWriter::hasVariable(latName))
342      {
343        domain->latvalue_curvilinear_read_from_file.resize(ni, nj);
344        readFieldVariableValue(domain->latvalue_curvilinear_read_from_file, latName, nBeginLatLon, nSizeLatLon);
345      }
346      StdString lonName = this->getLonCoordName(fieldId);
347      if (SuperClassWriter::hasVariable(lonName))
348      {
349        domain->lonvalue_curvilinear_read_from_file.resize(ni, nj);
350        readFieldVariableValue(domain->lonvalue_curvilinear_read_from_file, lonName, nBeginLatLon, nSizeLatLon);
351      }
352
353      StdString boundsLatName = this->getBoundsId(latName);
354      StdString boundsLonName = this->getBoundsId(lonName);
355
356      int nbVertex = 4; //this->getNbVertex(fieldId);
357      if (!domain->nvertex.isEmpty() && (domain->nvertex != nbVertex))
358      {
359        ERROR("void CNc4DataInput::readDomainAttributeValueFromFile(...)",
360          << "The domain " << domain->getDomainOutputName()
361          << " has nvertex read from file " << this->filename << " and nvertex provided from model"
362          << " are not coherent. They should be the same." << std::endl
363          << " nvertex read from file: "<< nbVertex
364          << " nvertex from model: "<< domain->nvertex << std::endl);
365      } 
366
367      if (SuperClassWriter::hasVariable(boundsLatName) || SuperClassWriter::hasVariable(boundsLonName)) 
368        domain->nvertex.setValue(nbVertex);
369
370      std::vector<StdSize> nBeginBndsLatLon(3), nSizeBndsLatLon(3);
371      nBeginBndsLatLon[0] = jbegin; nSizeBndsLatLon[0] = nj;
372      nBeginBndsLatLon[1] = ibegin; nSizeBndsLatLon[1] = ni;
373      nBeginBndsLatLon[2] = 0; nSizeBndsLatLon[2] = nbVertex;
374
375      if (SuperClassWriter::hasVariable(boundsLatName))
376      {
377        domain->bounds_latvalue_curvilinear_read_from_file.resize(nbVertex, ni, nj);
378        readFieldVariableValue(domain->bounds_latvalue_curvilinear_read_from_file, boundsLatName, nBeginBndsLatLon, nSizeBndsLatLon);
379
380      }
381      if (SuperClassWriter::hasVariable(boundsLonName)) 
382      {
383        domain->bounds_lonvalue_curvilinear_read_from_file.resize(nbVertex, ni, nj);
384        readFieldVariableValue(domain->bounds_lonvalue_curvilinear_read_from_file, boundsLonName, nBeginBndsLatLon, nSizeBndsLatLon);
385      }     
386    }
387    else if ((CDomain::type_attr::unstructured == domain->type))// || (this->isUnstructured(fieldId)))
388    {
389      // Make sure that if there is no local domain defined on a process, the process still reads just one value.
390      int ni, ibegin;
391      if (domain->ni == 0)
392      {
393        ni = 1;
394        ibegin = 0;
395      }
396      else
397      {
398        ni = domain->ni;
399        ibegin = domain->ibegin;
400      }
401
402      std::vector<StdSize> nBeginLatLon(1,0), nSizeLatLon(1,0);
403      nBeginLatLon[0] = ibegin;
404      nSizeLatLon[0]  = ni;
405
406      StdString latName = this->getLatCoordName(fieldId);
407      if (SuperClassWriter::hasVariable(latName))
408      {
409        domain->latvalue_unstructured_read_from_file.resize(ni);
410        readFieldVariableValue(domain->latvalue_unstructured_read_from_file, latName, nBeginLatLon, nSizeLatLon); 
411      }
412
413      StdString lonName = this->getLonCoordName(fieldId);
414      if (SuperClassWriter::hasVariable(lonName)) //(0 != lonName.compare(""))
415      {
416        domain->lonvalue_unstructured_read_from_file.resize(ni);
417        readFieldVariableValue(domain->lonvalue_unstructured_read_from_file, lonName, nBeginLatLon, nSizeLatLon);
418      }
419
420      StdString boundsLatName = this->getBoundsId(latName);
421      StdString boundsLonName = this->getBoundsId(lonName);
422
423      int nbVertex = this->getNbVertex(fieldId);
424      if (!domain->nvertex.isEmpty() && (domain->nvertex != nbVertex))
425      {
426        ERROR("void CNc4DataInput::readDomainAttributeValueFromFile(...)",
427          << "The domain " << domain->getDomainOutputName()
428          << " has nvertex read from file " << this->filename << " and nvertex provided from model"
429          << " are not coherent. They should be the same." << std::endl
430          << " nvertex read from file: "<< nbVertex
431          << " nvertex from model: "<< domain->nvertex << std::endl);
432      } 
433     
434      if (SuperClassWriter::hasVariable(boundsLatName) || SuperClassWriter::hasVariable(boundsLonName)) 
435        domain->nvertex.setValue(nbVertex);
436
437      std::vector<StdSize> nBeginBndsLatLon(2), nSizeBndsLatLon(2);
438      nBeginBndsLatLon[0] = ibegin; nSizeBndsLatLon[0] = ni;
439      nBeginBndsLatLon[1] = 0; nSizeBndsLatLon[1] = nbVertex;
440
441      if (SuperClassWriter::hasVariable(boundsLatName)) 
442      {
443        domain->bounds_latvalue_unstructured_read_from_file.resize(nSizeBndsLatLon[1], nSizeBndsLatLon[0]);
444        readFieldVariableValue(domain->bounds_latvalue_unstructured_read_from_file, boundsLatName, nBeginBndsLatLon, nSizeBndsLatLon);
445      }
446
447      if (SuperClassWriter::hasVariable(boundsLonName)) 
448      {
449        domain->bounds_lonvalue_unstructured_read_from_file.resize(nSizeBndsLatLon[1], nSizeBndsLatLon[0]);
450        readFieldVariableValue(domain->bounds_lonvalue_unstructured_read_from_file, boundsLonName, nBeginBndsLatLon, nSizeBndsLatLon);
451      }     
452    }
453    domain->fillInLonLat();
454  }
455
456  /*!
457    Read attribute value of a domain from a file
458    \param [in] domain domain whose attributes are read from the file
459    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file
460    \param [in] emelentPosition position of domain in grid
461    \param [in] fieldId id (or name) associated with the grid
462  */
463  void CNc4DataInput::readDomainAttributesFromFile(CDomain* domain, std::list<std::pair<StdString, StdSize> >& dimSizeMap,
464                                                   int elementPosition, const StdString& fieldId)
465  {
466    // There are some mandatory attributes of a domain to retrieve from file
467    // + ni_glo, nj_glo
468    std::list<std::pair<StdString, StdSize> >::const_iterator itMapNi = dimSizeMap.begin(), itMapNj,
469                                                              iteMap  = dimSizeMap.end();
470    for (int i = 0; i < elementPosition; ++i, ++itMapNi) {}
471    itMapNj = itMapNi; ++itMapNj;
472
473    if (this->isRectilinear(fieldId) || this->isCurvilinear(fieldId))
474    {
475      if (!domain->nj_glo.isEmpty() && (domain->nj_glo != itMapNj->second))
476      {
477        ERROR("void CNc4DataInput::readDomainAttributesFromFile(...)",
478          << "The domain " << domain->getDomainOutputName()
479          << " has nj_glo read from file " << this->filename << " and nj_glo provided from model"
480          << " are not coherent. They should be the same." << std::endl
481          << " nj_glo read from file: "<< itMapNj->second
482          << " nj_glo from model: "<< domain->nj_glo << std::endl);
483      } 
484      domain->nj_glo.setValue(itMapNj->second);
485
486      if (!domain->ni_glo.isEmpty() && (domain->ni_glo != itMapNi->second))
487      {
488        ERROR("void CNc4DataInput::readDomainAttributesFromFile(...)",
489          << "The domain " << domain->getDomainOutputName()
490          << " has ni_glo read from file " << this->filename << " and ni_glo provided from model"
491          << " are not coherent. They should be the same." << std::endl
492          << " ni_glo read from file: "<< itMapNi->second
493          << " ni_glo from model: "<< domain->ni_glo << std::endl);
494      } 
495      domain->ni_glo.setValue(itMapNi->second);
496    }
497    else if (this->isUnstructured(fieldId))
498    {
499      domain->nj_glo.setValue(1);
500
501      if (!domain->ni_glo.isEmpty() && (domain->ni_glo != itMapNi->second))
502      {
503        ERROR("void CNc4DataInput::readDomainAttributesFromFile(...)",
504          << "The domain " << domain->getDomainOutputName()
505          << " has ni_glo read from file " << this->filename << " and ni_glo provided from model"
506          << " are not coherent. They should be the same." << std::endl
507          << " ni_glo read from file: "<< itMapNi->second
508          << " ni_glo from model: "<< domain->ni_glo << std::endl);
509      }       
510      domain->ni_glo.setValue(itMapNi->second);
511    }
512  }
513
514  /*!
515    Read attributes of an axis from a file
516    \param [in] axis axis whose attributes are read from the file
517    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file
518    \param [in] emelentPosition position of axis in grid
519    \param [in] fieldId id (or name) associated with the grid
520  */
521  void CNc4DataInput::readAxisAttributesFromFile(CAxis* axis, std::list<std::pair<StdString, StdSize> >& dimSizeMap,
522                                                 int elementPosition, const StdString& fieldId)
523  {
524    std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(),
525                                                              iteMap = dimSizeMap.end();
526    for (int i = 0; i < elementPosition; ++i, ++itMapN) {}
527
528    if (!axis->n_glo.isEmpty() && (axis->n_glo != itMapN->second))
529    {
530      ERROR("void CNc4DataInput::readAxisAttributesFromFile(...)",
531        << "The axis " << axis->getAxisOutputName()
532        << " has n_glo read from file " << this->filename << " and n_glo provided from model"
533        << " are not coherent. They should be the same." << std::endl
534        << " n_glo read from file: "<< itMapN->second
535        << " n_glo from model: "<< axis->n_glo << std::endl);
536    }   
537    axis->n_glo.setValue(itMapN->second);
538  }
539
540  /*!
541    Read attribute value of an axis from a file
542    \param [in] axis axis whose attributes are read from the file
543    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file
544    \param [in] emelentPosition position of axis in grid
545    \param [in] fieldId id (or name) associated with the grid
546  */
547  void CNc4DataInput::readAxisAttributeValueFromFile(CAxis* axis, std::list<std::pair<StdString, StdSize> >& dimSizeMap,
548                                                    int elementPosition, const StdString& fieldId)
549  {
550    std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(),
551                                                              iteMap = dimSizeMap.end();
552    for (int i = 0; i < elementPosition; ++i, ++itMapN) {}
553
554    { // Read axis value
555      bool hasValue = SuperClassWriter::hasVariable(itMapN->first);
556      if (hasValue)
557      {
558        std::vector<StdSize> nBegin(1, 0), nSize(1, itMapN->second);
559        CArray<double,1> readAxisValue(itMapN->second);
560        readFieldVariableValue(readAxisValue, itMapN->first, nBegin, nSize, true);
561        int begin = 0, n = itMapN->second;
562        if (!axis->begin.isEmpty()) begin = axis->begin.getValue();
563        if (!axis->n.isEmpty()) n = axis->n.getValue();
564        axis->value.resize(n);
565        for (int i = 0; i < n; ++i) axis->value(i) = readAxisValue(begin + i);
566      }
567    }
568  }
569
570  /*!
571    Read attributes of a scalar from a file
572    \param [in] scalar scalar whose attributes are read from the file
573    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file
574    \param [in] emelentPosition position of scalar in grid
575    \param [in] fieldId id (or name) associated with the grid
576  */
577  void CNc4DataInput::readScalarAttributesFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap,
578                                                  int elementPosition, const StdString& fieldId)
579  {
580    /*Nothing to do */
581  }
582
583  /*!
584    Read attribute value of an axis from a file
585    \param [in] axis axis whose attributes are read from the file
586    \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file
587    \param [in] emelentPosition position of axis in grid
588    \param [in] fieldId id (or name) associated with the grid
589  */
590  void CNc4DataInput::readScalarAttributeValueFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap,
591                                                      int elementPosition, const StdString& fieldId)
592  {
593    /*Nothing to do */
594  }
595
596  void CNc4DataInput::closeFile_(void)
597  {
598    SuperClassWriter::close();
599  }
600} // namespace xios
Note: See TracBrowser for help on using the repository browser.