source: XIOS/trunk/src/transformation/domain_algorithm_extract.cpp @ 1553

Last change on this file since 1553 was 1553, checked in by oabramkina, 2 years ago

The zoom is dead, long live the zoom.

Replacing domain_zoom transformation by copying it from domain_extract. From now on, only the zoomed part of a domain is sent to servers. On the user's side all definitions stay the same.

To do soon: axis_zoom.

File size: 9.4 KB
Line 
1#include "domain_algorithm_extract.hpp"
2#include "extract_domain.hpp"
3#include "domain.hpp"
4#include "grid.hpp"
5#include "grid_transformation_factory_impl.hpp"
6#include "attribute_template.hpp"
7
8namespace xios {
9CGenericAlgorithmTransformation* CDomainAlgorithmExtract::create(CGrid* gridDst, CGrid* gridSrc,
10                                                             CTransformation<CDomain>* transformation,
11                                                             int elementPositionInGrid,
12                                                             std::map<int, int>& elementPositionInGridSrc2ScalarPosition,
13                                                             std::map<int, int>& elementPositionInGridSrc2AxisPosition,
14                                                             std::map<int, int>& elementPositionInGridSrc2DomainPosition,
15                                                             std::map<int, int>& elementPositionInGridDst2ScalarPosition,
16                                                             std::map<int, int>& elementPositionInGridDst2AxisPosition,
17                                                             std::map<int, int>& elementPositionInGridDst2DomainPosition)
18{
19  std::vector<CDomain*> domainListDestP = gridDst->getDomains();
20  std::vector<CDomain*> domainListSrcP  = gridSrc->getDomains();
21
22  CExtractDomain* extractDomain = dynamic_cast<CExtractDomain*> (transformation);
23  int domainDstIndex = elementPositionInGridDst2DomainPosition[elementPositionInGrid];
24  int domainSrcIndex = elementPositionInGridSrc2DomainPosition[elementPositionInGrid];
25
26  return (new CDomainAlgorithmExtract(domainListDestP[domainDstIndex], domainListSrcP[domainSrcIndex], extractDomain));
27}
28
29bool CDomainAlgorithmExtract::registerTrans()
30{
31  CGridTransformationFactory<CDomain>::registerTransformation(TRANS_EXTRACT_DOMAIN, create);
32}
33
34CDomainAlgorithmExtract::CDomainAlgorithmExtract(CDomain* domainDestination, CDomain* domainSource, CExtractDomain* extractDomain)
35: CDomainAlgorithmTransformation(domainDestination, domainSource)
36{
37  extractDomain->checkValid(domainSource);
38  extractIBegin_ = extractDomain->ibegin.getValue();
39  extractJBegin_ = extractDomain->jbegin.getValue();
40
41  extractNi_  = extractDomain->ni.getValue();
42  extractNj_  = extractDomain->nj.getValue();
43
44  extractIEnd_ = extractIBegin_ + extractNi_ - 1;
45  extractJEnd_ = extractJBegin_ + extractNj_ - 1;
46
47  if (extractNi_ > domainSource->ni_glo.getValue())
48  {
49    ERROR("CDomainAlgorithmExtract::CDomainAlgorithmExtract(CDomain* domainDestination, CDomain* domainSource, CExtractDomain* extractDomain)",
50           << "Extract size is greater than size of domain source"
51           << "Size ni_glo of domain source " <<domainSource->getId() << " is " << domainSource->ni_glo.getValue()  << std::endl
52           << "Extract size is " << extractNi_ );
53  }
54
55  if (extractNj_ > domainSource->nj_glo.getValue())
56  {
57    ERROR("CDomainAlgorithmExtract::CDomainAlgorithmExtract(CDomain* domainDestination, CDomain* domainSource, CExtractDomain* extractDomain)",
58           << "Extract size is greater than size of domain source"
59           << "Size nj_glo of domain source " <<domainSource->getId() << " is " << domainSource->nj_glo.getValue()  << std::endl
60           << "Extract size is " << extractNj_ );
61  }
62
63  // Calculate the size of local domain
64  int ind, indLocSrc, indLocDest, iIdxSrc, jIdxSrc, destIBegin = -1, destJBegin = -1, niDest = 0, njDest = 0, ibeginDest, jbeginDest ;
65  int indGloDest, indGloSrc, niGloSrc = domainSrc_->ni_glo, iSrc, jSrc;
66  for (int j = 0; j < domainSrc_->nj.getValue(); j++)
67  {
68    for (int i = 0; i < domainSrc_->ni.getValue(); i++)
69    {
70      ind = j*domainSrc_->ni + i;
71      iIdxSrc = domainSrc_->i_index(ind);
72      if ((iIdxSrc >= extractIBegin_) && (iIdxSrc <= extractIEnd_))
73      {
74        jIdxSrc = domainSrc_->j_index(ind);
75        if ((jIdxSrc >= extractJBegin_) && (jIdxSrc <= extractJEnd_))
76        {
77          if ((niDest == 0) && (njDest == 0))
78          {
79            destIBegin = i;
80            destJBegin = j;
81          }
82          if (i == destIBegin) ++njDest;
83        }
84        if (j == destJBegin) ++niDest;
85
86      }
87    }
88  }
89  ibeginDest = destIBegin + domainSrc_->ibegin - extractIBegin_;
90  jbeginDest = destJBegin + domainSrc_->jbegin - extractJBegin_;
91  domainDest_->ni_glo.setValue(extractNi_);
92  domainDest_->nj_glo.setValue(extractNj_);
93  domainDest_->ni.setValue(niDest);
94  domainDest_->nj.setValue(njDest);
95  domainDest_->ibegin.setValue(ibeginDest);
96  domainDest_->jbegin.setValue(jbeginDest);
97  domainDest_->i_index.resize(niDest*njDest);
98  domainDest_->j_index.resize(niDest*njDest);
99
100  domainDest_->data_ni.setValue(niDest);
101  domainDest_->data_nj.setValue(njDest);
102  domainDest_->data_ibegin.setValue(0);  // local position
103  domainDest_->data_jbegin.setValue(0);  // local position
104  domainDest_->data_i_index.resize(niDest*njDest); // local position
105  domainDest_->data_j_index.resize(niDest*njDest); // local position
106
107  domainDest_->domainMask.resize(niDest*njDest);
108
109  if (!domainSrc_->lonvalue_1d.isEmpty())
110  {
111    if (domainDest_->type == CDomain::type_attr::rectilinear)
112    {
113      domainDest_->lonvalue_1d.resize(niDest);
114      domainDest_->latvalue_1d.resize(njDest);
115    }
116    else if (domainDest_->type == CDomain::type_attr::unstructured)
117    {
118      domainDest_->lonvalue_1d.resize(niDest);
119      domainDest_->latvalue_1d.resize(niDest);
120    }
121  }
122  else if (!domainSrc_->lonvalue_2d.isEmpty())
123  {
124    domainDest_->lonvalue_2d.resize(niDest,njDest);
125    domainDest_->latvalue_2d.resize(niDest,njDest);
126  }
127
128  if (domainSrc_->hasBounds)
129  {
130    if (!domainSrc_->bounds_lon_2d.isEmpty())
131    {
132      domainDest_->bounds_lon_2d.resize(domainDest_->nvertex, niDest, njDest);
133      domainDest_->bounds_lon_2d.resize(domainDest_->nvertex, niDest, njDest);
134    }
135    else if (!domainSrc_->bounds_lon_1d.isEmpty())
136    {
137      domainDest_->bounds_lon_1d.resize(domainDest_->nvertex, niDest);
138      domainDest_->bounds_lon_1d.resize(domainDest_->nvertex, niDest);
139    }
140  }
141  if (domainSrc_->hasArea) domainDest_->area.resize(niDest,njDest);
142
143  this->transformationMapping_.resize(1);
144  this->transformationWeight_.resize(1);
145  TransformationIndexMap& transMap = this->transformationMapping_[0];
146  TransformationWeightMap& transWeight = this->transformationWeight_[0];
147
148  for (int iDest = 0; iDest < niDest; iDest++)
149  {
150    iSrc = iDest + destIBegin;
151    for (int jDest = 0; jDest < njDest; jDest++)
152    {
153      jSrc = jDest + destJBegin;
154      ind = jSrc * domainSrc_->ni + iSrc;
155      iIdxSrc = domainSrc_->i_index(ind);
156      jIdxSrc = domainSrc_->j_index(ind);
157      indLocDest = jDest*niDest + iDest;
158      indGloDest = (jDest + jbeginDest)*extractNi_ + (iDest + ibeginDest);
159      indLocSrc = (jDest+destJBegin)*domainSrc_->ni + (iDest+destIBegin);
160      indGloSrc = (jIdxSrc )* niGloSrc + iIdxSrc;
161      domainDest_->i_index(indLocDest) = iDest + ibeginDest;                                             // i_index contains global positions
162      domainDest_->j_index(indLocDest) = jDest + jbeginDest;                                             // i_index contains global positions
163      domainDest_->data_i_index(indLocDest) = (domainSrc_->data_dim == 1) ? indLocDest : iDest;          // data_i_index contains local positions
164      domainDest_->data_j_index(indLocDest) = (domainSrc_->data_dim == 1) ? 0 :jDest;                    // data_i_index contains local positions
165      domainDest_->domainMask(indLocDest) = domainSrc_->domainMask(indLocSrc);
166
167      if (domainSrc_->hasArea)
168        domainDest_->area(iDest,jDest) = domainSrc_->area(iSrc,jSrc);
169
170      if (domainSrc_->hasBounds)
171      {
172        if (!domainSrc_->bounds_lon_2d.isEmpty())
173        {
174          for (int n = 0; n < domainSrc_->nvertex; ++n)
175          {
176            domainDest_->bounds_lon_2d(n,iDest,jDest) = domainSrc_->bounds_lon_2d(n,iSrc,jSrc);
177            domainDest_->bounds_lat_2d(n,iDest,jDest) = domainSrc_->bounds_lat_2d(n,iSrc,jSrc);
178          }
179        }
180        else if (!domainSrc_->bounds_lon_1d.isEmpty())
181        {
182          for (int n = 0; n < domainSrc_->nvertex; ++n)
183          {
184            domainDest_->bounds_lon_1d(n,iDest) = domainSrc_->bounds_lon_1d(n,iSrc);
185            domainDest_->bounds_lat_1d(n,iDest) = domainSrc_->bounds_lat_1d(n,iSrc);
186          }
187        }
188      }
189
190      if (domainSrc_->hasLonLat)
191      {
192        if (domainDest_->type == CDomain::type_attr::rectilinear)
193        {
194          domainDest_->latvalue_1d(jDest) = domainSrc_->latvalue_1d(jSrc);
195        }
196        else if (domainDest_->type == CDomain::type_attr::curvilinear)
197        {
198          domainDest_->lonvalue_2d(iDest,jDest) = domainSrc_->lonvalue_2d(iSrc,jSrc);
199          domainDest_->latvalue_2d(iDest,jDest) = domainSrc_->latvalue_2d(iSrc,jSrc);
200        }
201      }
202
203      transMap[indGloDest].push_back(indGloSrc);
204      transWeight[indGloDest].push_back(1.0);
205
206    }
207    if (domainSrc_->hasLonLat)
208    {
209      if (domainDest_->type == CDomain::type_attr::unstructured)
210      {
211        domainDest_->lonvalue_1d(iDest) = domainSrc_->lonvalue_1d(iSrc);
212        domainDest_->latvalue_1d(iDest) = domainSrc_->latvalue_1d(iSrc);
213      }
214      else if (domainDest_->type == CDomain::type_attr::rectilinear)
215      {
216        domainDest_->lonvalue_1d(iDest) = domainSrc_->lonvalue_1d(iSrc);
217      }
218    }
219  }
220
221}
222
223/*!
224  Compute the index mapping between domain on grid source and one on grid destination
225*/
226void CDomainAlgorithmExtract::computeIndexSourceMapping_(const std::vector<CArray<double,1>* >& dataAuxInputs)
227{
228}
229
230
231}
Note: See TracBrowser for help on using the repository browser.