source: XIOS/dev/XIOS_DEV_CMIP6/src/io/nc4_data_input.cpp @ 1479

Last change on this file since 1479 was 1479, checked in by ymipsl, 3 years ago

Fix : when reading domain from a file, if the type of domain is given, it will be used instead guessing the type from metadata in the file.

YM

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