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 | |
---|
10 | namespace 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 | for (std::list<StdString>::const_iterator it = dimList.begin(); it != dimList.end(); ++it) |
---|
187 | listDimSize.push_front(*dimSizeMap.find(*it)); |
---|
188 | |
---|
189 | // Now process domain and axis |
---|
190 | CArray<int,1> axisDomainOrder = grid->axis_domain_order; |
---|
191 | int numElement = domainP.size() + axisP.size() + scalarP.size(); |
---|
192 | int elementPosition = 0; |
---|
193 | int idxDomain = 0, idxAxis = 0, idxScalar = 0; |
---|
194 | |
---|
195 | std::pair<std::set<StdString>::iterator,bool> it; |
---|
196 | for (int i = 0; i < numElement; ++i) |
---|
197 | { |
---|
198 | if(2 == axisDomainOrder(i)) |
---|
199 | { |
---|
200 | if (readAttributeValues) |
---|
201 | { |
---|
202 | it = readValueDomains_.insert(domainP[idxDomain]->getId()); |
---|
203 | if (it.second) readDomainAttributeValueFromFile(domainP[idxDomain], listDimSize, elementPosition, fieldId); |
---|
204 | } |
---|
205 | else |
---|
206 | { |
---|
207 | it = readMetaDataDomains_.insert(domainP[idxDomain]->getId()); |
---|
208 | if (it.second) readDomainAttributesFromFile(domainP[idxDomain], listDimSize, elementPosition, fieldId); |
---|
209 | } |
---|
210 | ++idxDomain; |
---|
211 | if (isUnstructuredGrid) ++elementPosition; |
---|
212 | else elementPosition += 2; |
---|
213 | } |
---|
214 | else if (1 == axisDomainOrder(i)) |
---|
215 | { |
---|
216 | if (readAttributeValues) |
---|
217 | { |
---|
218 | it = readValueAxis_.insert(axisP[idxAxis]->getId()); |
---|
219 | if (it.second) readAxisAttributeValueFromFile(axisP[idxAxis], listDimSize, elementPosition, fieldId); |
---|
220 | } |
---|
221 | else |
---|
222 | { |
---|
223 | it = readMetaDataAxis_.insert(axisP[idxAxis]->getId()); |
---|
224 | if (it.second) readAxisAttributesFromFile(axisP[idxAxis], listDimSize, elementPosition, fieldId); |
---|
225 | } |
---|
226 | ++idxAxis; |
---|
227 | ++elementPosition; |
---|
228 | } |
---|
229 | else |
---|
230 | { |
---|
231 | if (readAttributeValues) |
---|
232 | { |
---|
233 | it = readValueScalar_.insert(scalarP[idxScalar]->getId()); |
---|
234 | if (it.second) readScalarAttributeValueFromFile(scalarP[idxScalar], listDimSize, elementPosition, fieldId); |
---|
235 | } |
---|
236 | else |
---|
237 | { |
---|
238 | it = readMetaDataScalar_.insert(scalarP[idxScalar]->getId()); |
---|
239 | if (it.second) readScalarAttributesFromFile(scalarP[idxScalar], listDimSize, elementPosition, fieldId); |
---|
240 | } |
---|
241 | ++idxScalar; |
---|
242 | ++elementPosition; |
---|
243 | } |
---|
244 | } |
---|
245 | } |
---|
246 | |
---|
247 | /*! |
---|
248 | Read attributes of a domain from a file |
---|
249 | \param [in] domain domain whose attributes are read from the file |
---|
250 | \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file |
---|
251 | \param [in] emelentPosition position of domain in grid |
---|
252 | \param [in] fieldId id (or name) associated with the grid |
---|
253 | */ |
---|
254 | void CNc4DataInput::readDomainAttributeValueFromFile(CDomain* domain, std::list<std::pair<StdString, StdSize> >& dimSizeMap, |
---|
255 | int elementPosition, const StdString& fieldId) |
---|
256 | { |
---|
257 | // There are some optional attributes of a domain to retrieve from file // + lon lat? |
---|
258 | std::list<std::pair<StdString, StdSize> >::const_iterator itMapNi = dimSizeMap.begin(), itMapNj, |
---|
259 | iteMap = dimSizeMap.end(); |
---|
260 | |
---|
261 | for (int i = 0; i < elementPosition; ++i, ++itMapNi) {} |
---|
262 | itMapNj = itMapNi; ++itMapNj; |
---|
263 | |
---|
264 | if ((CDomain::type_attr::rectilinear == domain->type)) |
---|
265 | { |
---|
266 | // Ok, try to read some attributes such as longitude and latitude |
---|
267 | bool hasLat = SuperClassWriter::hasVariable(itMapNj->first); |
---|
268 | if (hasLat) |
---|
269 | { |
---|
270 | domain->latvalue_rectilinear_read_from_file.resize(itMapNj->second); |
---|
271 | std::vector<StdSize> nBeginLat(1, 0), nSizeLat(1, itMapNj->second); |
---|
272 | readFieldVariableValue(domain->latvalue_rectilinear_read_from_file, itMapNj->first, nBeginLat, nSizeLat, true); |
---|
273 | } |
---|
274 | |
---|
275 | bool hasLon = SuperClassWriter::hasVariable(itMapNi->first); |
---|
276 | if (hasLon) |
---|
277 | { |
---|
278 | domain->lonvalue_rectilinear_read_from_file.resize(itMapNi->second); |
---|
279 | std::vector<StdSize> nBeginLon(1, 0), nSizeLon(1, itMapNi->second); |
---|
280 | readFieldVariableValue(domain->lonvalue_rectilinear_read_from_file, itMapNi->first, nBeginLon, nSizeLon, true); |
---|
281 | } |
---|
282 | } |
---|
283 | else if ((CDomain::type_attr::curvilinear == domain->type)) |
---|
284 | { |
---|
285 | // Make sure that if there is no local domain defined on a process, the process still reads just one value. |
---|
286 | int ni, nj, ibegin, jbegin; |
---|
287 | if (domain->ni == 0) |
---|
288 | { |
---|
289 | ni = 1; |
---|
290 | ibegin = 0; |
---|
291 | } |
---|
292 | else |
---|
293 | { |
---|
294 | ni = domain->ni; |
---|
295 | ibegin = domain->ibegin; |
---|
296 | } |
---|
297 | if (domain->nj == 0) |
---|
298 | { |
---|
299 | nj = 1; |
---|
300 | jbegin = 0; |
---|
301 | } |
---|
302 | else |
---|
303 | { |
---|
304 | nj = domain->nj; |
---|
305 | jbegin = domain->jbegin; |
---|
306 | } |
---|
307 | |
---|
308 | std::vector<StdSize> nBeginLatLon(2), nSizeLatLon(2); |
---|
309 | nBeginLatLon[0] = jbegin; nBeginLatLon[1] = ibegin; |
---|
310 | nSizeLatLon[0] = nj; nSizeLatLon[1] = ni; |
---|
311 | |
---|
312 | StdString latName = this->getLatCoordName(fieldId); |
---|
313 | if (SuperClassWriter::hasVariable(latName)) |
---|
314 | { |
---|
315 | domain->latvalue_curvilinear_read_from_file.resize(ni, nj); |
---|
316 | readFieldVariableValue(domain->latvalue_curvilinear_read_from_file, latName, nBeginLatLon, nSizeLatLon); |
---|
317 | } |
---|
318 | StdString lonName = this->getLonCoordName(fieldId); |
---|
319 | if (SuperClassWriter::hasVariable(lonName)) |
---|
320 | { |
---|
321 | domain->lonvalue_curvilinear_read_from_file.resize(ni, nj); |
---|
322 | readFieldVariableValue(domain->lonvalue_curvilinear_read_from_file, lonName, nBeginLatLon, nSizeLatLon); |
---|
323 | } |
---|
324 | |
---|
325 | StdString boundsLatName = this->getBoundsId(latName); |
---|
326 | StdString boundsLonName = this->getBoundsId(lonName); |
---|
327 | |
---|
328 | int nbVertex = this->getNbVertex(fieldId); |
---|
329 | if (!domain->nvertex.isEmpty() && (domain->nvertex != nbVertex)) |
---|
330 | { |
---|
331 | ERROR("void CNc4DataInput::readDomainAttributeValueFromFile(...)", |
---|
332 | << "The domain " << domain->getDomainOutputName() |
---|
333 | << " has nvertex read from file " << this->filename << " and nvertex provided from model" |
---|
334 | << " are not coherent. They should be the same." << std::endl |
---|
335 | << " nvertex read from file: "<< nbVertex |
---|
336 | << " nvertex from model: "<< domain->nvertex << std::endl); |
---|
337 | } |
---|
338 | |
---|
339 | if (SuperClassWriter::hasVariable(boundsLatName) || SuperClassWriter::hasVariable(boundsLonName)) |
---|
340 | domain->nvertex.setValue(nbVertex); |
---|
341 | |
---|
342 | std::vector<StdSize> nBeginBndsLatLon(3), nSizeBndsLatLon(3); |
---|
343 | nBeginBndsLatLon[0] = jbegin; nSizeBndsLatLon[0] = nj; |
---|
344 | nBeginBndsLatLon[1] = ibegin; nSizeBndsLatLon[1] = ni; |
---|
345 | nBeginBndsLatLon[2] = 0; nSizeBndsLatLon[2] = nbVertex; |
---|
346 | |
---|
347 | if (SuperClassWriter::hasVariable(boundsLatName)) |
---|
348 | { |
---|
349 | domain->bounds_latvalue_curvilinear_read_from_file.resize(nbVertex, ni, nj); |
---|
350 | readFieldVariableValue(domain->bounds_latvalue_curvilinear_read_from_file, boundsLatName, nBeginBndsLatLon, nSizeBndsLatLon); |
---|
351 | |
---|
352 | } |
---|
353 | if (SuperClassWriter::hasVariable(boundsLonName)) |
---|
354 | { |
---|
355 | domain->bounds_lonvalue_curvilinear_read_from_file.resize(nbVertex, ni, nj); |
---|
356 | readFieldVariableValue(domain->bounds_lonvalue_curvilinear_read_from_file, boundsLonName, nBeginBndsLatLon, nSizeBndsLatLon); |
---|
357 | } |
---|
358 | } |
---|
359 | else if ((CDomain::type_attr::unstructured == domain->type))// || (this->isUnstructured(fieldId))) |
---|
360 | { |
---|
361 | // Make sure that if there is no local domain defined on a process, the process still reads just one value. |
---|
362 | int ni, ibegin; |
---|
363 | if (domain->ni == 0) |
---|
364 | { |
---|
365 | ni = 1; |
---|
366 | ibegin = 0; |
---|
367 | } |
---|
368 | else |
---|
369 | { |
---|
370 | ni = domain->ni; |
---|
371 | ibegin = domain->ibegin; |
---|
372 | } |
---|
373 | |
---|
374 | std::vector<StdSize> nBeginLatLon(1,0), nSizeLatLon(1,0); |
---|
375 | nBeginLatLon[0] = ibegin; |
---|
376 | nSizeLatLon[0] = ni; |
---|
377 | |
---|
378 | StdString latName = this->getLatCoordName(fieldId); |
---|
379 | if (SuperClassWriter::hasVariable(latName)) |
---|
380 | { |
---|
381 | domain->latvalue_unstructured_read_from_file.resize(ni); |
---|
382 | readFieldVariableValue(domain->latvalue_unstructured_read_from_file, latName, nBeginLatLon, nSizeLatLon); |
---|
383 | } |
---|
384 | |
---|
385 | StdString lonName = this->getLonCoordName(fieldId); |
---|
386 | if (SuperClassWriter::hasVariable(lonName)) //(0 != lonName.compare("")) |
---|
387 | { |
---|
388 | domain->lonvalue_unstructured_read_from_file.resize(ni); |
---|
389 | readFieldVariableValue(domain->lonvalue_unstructured_read_from_file, lonName, nBeginLatLon, nSizeLatLon); |
---|
390 | } |
---|
391 | |
---|
392 | StdString boundsLatName = this->getBoundsId(latName); |
---|
393 | StdString boundsLonName = this->getBoundsId(lonName); |
---|
394 | |
---|
395 | int nbVertex = this->getNbVertex(fieldId); |
---|
396 | if (!domain->nvertex.isEmpty() && (domain->nvertex != nbVertex)) |
---|
397 | { |
---|
398 | ERROR("void CNc4DataInput::readDomainAttributeValueFromFile(...)", |
---|
399 | << "The domain " << domain->getDomainOutputName() |
---|
400 | << " has nvertex read from file " << this->filename << " and nvertex provided from model" |
---|
401 | << " are not coherent. They should be the same." << std::endl |
---|
402 | << " nvertex read from file: "<< nbVertex |
---|
403 | << " nvertex from model: "<< domain->nvertex << std::endl); |
---|
404 | } |
---|
405 | |
---|
406 | if (SuperClassWriter::hasVariable(boundsLatName) || SuperClassWriter::hasVariable(boundsLonName)) |
---|
407 | domain->nvertex.setValue(nbVertex); |
---|
408 | |
---|
409 | std::vector<StdSize> nBeginBndsLatLon(2), nSizeBndsLatLon(2); |
---|
410 | nBeginBndsLatLon[0] = ibegin; nSizeBndsLatLon[0] = ni; |
---|
411 | nBeginBndsLatLon[1] = 0; nSizeBndsLatLon[1] = nbVertex; |
---|
412 | |
---|
413 | if (SuperClassWriter::hasVariable(boundsLatName)) |
---|
414 | { |
---|
415 | domain->bounds_latvalue_unstructured_read_from_file.resize(nSizeBndsLatLon[1], nSizeBndsLatLon[0]); |
---|
416 | readFieldVariableValue(domain->bounds_latvalue_unstructured_read_from_file, boundsLatName, nBeginBndsLatLon, nSizeBndsLatLon); |
---|
417 | } |
---|
418 | |
---|
419 | if (SuperClassWriter::hasVariable(boundsLonName)) |
---|
420 | { |
---|
421 | domain->bounds_lonvalue_unstructured_read_from_file.resize(nSizeBndsLatLon[1], nSizeBndsLatLon[0]); |
---|
422 | readFieldVariableValue(domain->bounds_lonvalue_unstructured_read_from_file, boundsLonName, nBeginBndsLatLon, nSizeBndsLatLon); |
---|
423 | } |
---|
424 | } |
---|
425 | domain->fillInLonLat(); |
---|
426 | } |
---|
427 | |
---|
428 | /*! |
---|
429 | Read attribute value of a domain from a file |
---|
430 | \param [in] domain domain whose attributes are read from the file |
---|
431 | \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file |
---|
432 | \param [in] emelentPosition position of domain in grid |
---|
433 | \param [in] fieldId id (or name) associated with the grid |
---|
434 | */ |
---|
435 | void CNc4DataInput::readDomainAttributesFromFile(CDomain* domain, std::list<std::pair<StdString, StdSize> >& dimSizeMap, |
---|
436 | int elementPosition, const StdString& fieldId) |
---|
437 | { |
---|
438 | // There are some mandatory attributes of a domain to retrieve from file |
---|
439 | // + ni_glo, nj_glo |
---|
440 | std::list<std::pair<StdString, StdSize> >::const_iterator itMapNi = dimSizeMap.begin(), itMapNj, |
---|
441 | iteMap = dimSizeMap.end(); |
---|
442 | for (int i = 0; i < elementPosition; ++i, ++itMapNi) {} |
---|
443 | itMapNj = itMapNi; ++itMapNj; |
---|
444 | |
---|
445 | if (this->isRectilinear(fieldId) || this->isCurvilinear(fieldId)) |
---|
446 | { |
---|
447 | if (!domain->nj_glo.isEmpty() && (domain->nj_glo != itMapNj->second)) |
---|
448 | { |
---|
449 | ERROR("void CNc4DataInput::readDomainAttributesFromFile(...)", |
---|
450 | << "The domain " << domain->getDomainOutputName() |
---|
451 | << " has nj_glo read from file " << this->filename << " and nj_glo provided from model" |
---|
452 | << " are not coherent. They should be the same." << std::endl |
---|
453 | << " nj_glo read from file: "<< itMapNj->second |
---|
454 | << " nj_glo from model: "<< domain->nj_glo << std::endl); |
---|
455 | } |
---|
456 | domain->nj_glo.setValue(itMapNj->second); |
---|
457 | |
---|
458 | if (!domain->ni_glo.isEmpty() && (domain->ni_glo != itMapNi->second)) |
---|
459 | { |
---|
460 | ERROR("void CNc4DataInput::readDomainAttributesFromFile(...)", |
---|
461 | << "The domain " << domain->getDomainOutputName() |
---|
462 | << " has ni_glo read from file " << this->filename << " and ni_glo provided from model" |
---|
463 | << " are not coherent. They should be the same." << std::endl |
---|
464 | << " ni_glo read from file: "<< itMapNi->second |
---|
465 | << " ni_glo from model: "<< domain->ni_glo << std::endl); |
---|
466 | } |
---|
467 | domain->ni_glo.setValue(itMapNi->second); |
---|
468 | } |
---|
469 | else if (this->isUnstructured(fieldId)) |
---|
470 | { |
---|
471 | domain->nj_glo.setValue(1); |
---|
472 | |
---|
473 | if (!domain->ni_glo.isEmpty() && (domain->ni_glo != itMapNi->second)) |
---|
474 | { |
---|
475 | ERROR("void CNc4DataInput::readDomainAttributesFromFile(...)", |
---|
476 | << "The domain " << domain->getDomainOutputName() |
---|
477 | << " has ni_glo read from file " << this->filename << " and ni_glo provided from model" |
---|
478 | << " are not coherent. They should be the same." << std::endl |
---|
479 | << " ni_glo read from file: "<< itMapNi->second |
---|
480 | << " ni_glo from model: "<< domain->ni_glo << std::endl); |
---|
481 | } |
---|
482 | domain->ni_glo.setValue(itMapNi->second); |
---|
483 | } |
---|
484 | } |
---|
485 | |
---|
486 | /*! |
---|
487 | Read attributes of an axis from a file |
---|
488 | \param [in] axis axis whose attributes are read from the file |
---|
489 | \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file |
---|
490 | \param [in] emelentPosition position of axis in grid |
---|
491 | \param [in] fieldId id (or name) associated with the grid |
---|
492 | */ |
---|
493 | void CNc4DataInput::readAxisAttributesFromFile(CAxis* axis, std::list<std::pair<StdString, StdSize> >& dimSizeMap, |
---|
494 | int elementPosition, const StdString& fieldId) |
---|
495 | { |
---|
496 | std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(), |
---|
497 | iteMap = dimSizeMap.end(); |
---|
498 | for (int i = 0; i < elementPosition; ++i, ++itMapN) {} |
---|
499 | |
---|
500 | if (!axis->n_glo.isEmpty() && (axis->n_glo != itMapN->second)) |
---|
501 | { |
---|
502 | ERROR("void CNc4DataInput::readAxisAttributesFromFile(...)", |
---|
503 | << "The axis " << axis->getAxisOutputName() |
---|
504 | << " has n_glo read from file " << this->filename << " and n_glo provided from model" |
---|
505 | << " are not coherent. They should be the same." << std::endl |
---|
506 | << " n_glo read from file: "<< itMapN->second |
---|
507 | << " n_glo from model: "<< axis->n_glo << std::endl); |
---|
508 | } |
---|
509 | axis->n_glo.setValue(itMapN->second); |
---|
510 | } |
---|
511 | |
---|
512 | /*! |
---|
513 | Read attribute value 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::readAxisAttributeValueFromFile(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 | { // Read axis value |
---|
527 | bool hasValue = SuperClassWriter::hasVariable(itMapN->first); |
---|
528 | if (hasValue) |
---|
529 | { |
---|
530 | std::vector<StdSize> nBegin(1, 0), nSize(1, itMapN->second); |
---|
531 | CArray<double,1> readAxisValue(itMapN->second); |
---|
532 | readFieldVariableValue(readAxisValue, itMapN->first, nBegin, nSize, true); |
---|
533 | int begin = 0, n = itMapN->second; |
---|
534 | if (!axis->begin.isEmpty()) begin = axis->begin.getValue(); |
---|
535 | if (!axis->n.isEmpty()) n = axis->n.getValue(); |
---|
536 | axis->value.resize(n); |
---|
537 | for (int i = 0; i < n; ++i) axis->value(i) = readAxisValue(begin + i); |
---|
538 | } |
---|
539 | } |
---|
540 | } |
---|
541 | |
---|
542 | /*! |
---|
543 | Read attributes of a scalar from a file |
---|
544 | \param [in] scalar scalar whose attributes are read from the file |
---|
545 | \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file |
---|
546 | \param [in] emelentPosition position of scalar in grid |
---|
547 | \param [in] fieldId id (or name) associated with the grid |
---|
548 | */ |
---|
549 | void CNc4DataInput::readScalarAttributesFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap, |
---|
550 | int elementPosition, const StdString& fieldId) |
---|
551 | { |
---|
552 | /*Nothing to do */ |
---|
553 | } |
---|
554 | |
---|
555 | /*! |
---|
556 | Read attribute value of an axis from a file |
---|
557 | \param [in] axis axis whose attributes are read from the file |
---|
558 | \param [in] dimSizeMap Dimensions and and their corresponding names and size read from file |
---|
559 | \param [in] emelentPosition position of axis in grid |
---|
560 | \param [in] fieldId id (or name) associated with the grid |
---|
561 | */ |
---|
562 | void CNc4DataInput::readScalarAttributeValueFromFile(CScalar* scalar, std::list<std::pair<StdString, StdSize> >& dimSizeMap, |
---|
563 | int elementPosition, const StdString& fieldId) |
---|
564 | { |
---|
565 | /*Nothing to do */ |
---|
566 | } |
---|
567 | |
---|
568 | void CNc4DataInput::closeFile_(void) |
---|
569 | { |
---|
570 | SuperClassWriter::close(); |
---|
571 | } |
---|
572 | } // namespace xios |
---|