source: XIOS/trunk/src/node/grid.cpp @ 421

Last change on this file since 421 was 421, checked in by ymipsl, 10 years ago

suppress warning due to french accents -> english traduction of error messages

YM

File size: 17.6 KB
Line 
1
2#include "grid.hpp"
3
4#include "attribute_template.hpp"
5#include "object_template.hpp"
6#include "group_template.hpp"
7#include "message.hpp"
8#include <iostream>
9#include "xmlioserver_spl.hpp"
10#include "type.hpp"
11#include "context.hpp"
12#include "context_client.hpp"
13#include "array_new.hpp"
14
15namespace xios {
16
17   /// ////////////////////// Définitions ////////////////////// ///
18
19   CGrid::CGrid(void)
20      : CObjectTemplate<CGrid>(), CGridAttributes()
21      , withAxis(false), isChecked(false), axis(), domain()
22      , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1)
23   { /* Ne rien faire de plus */ }
24
25   CGrid::CGrid(const StdString & id)
26      : CObjectTemplate<CGrid>(id), CGridAttributes()
27      , withAxis(false), isChecked(false), axis(), domain()
28      , storeIndex(1), out_i_index(1), out_j_index(1), out_l_index(1)
29   { /* Ne rien faire de plus */ }
30
31   CGrid::~CGrid(void)
32   { 
33 //     this->axis.reset() ;
34//      this->domain.reset() ;
35    deque< CArray<int, 1>* >::iterator it ;
36   
37    for(deque< CArray<int,1>* >::iterator it=storeIndex.begin(); it!=storeIndex.end();it++)  delete *it ;
38    for(deque< CArray<int,1>* >::iterator it=out_i_index.begin();it!=out_i_index.end();it++) delete *it ;
39    for(deque< CArray<int,1>* >::iterator it=out_j_index.begin();it!=out_j_index.end();it++) delete *it ;
40    for(deque< CArray<int,1>* >::iterator it=out_l_index.begin();it!=out_l_index.end();it++) delete *it ;
41
42    for(map<int,CArray<int,1>* >::iterator it=out_i_fromClient.begin();it!=out_i_fromClient.end();it++) delete it->second ;
43    for(map<int,CArray<int,1>* >::iterator it=out_j_fromClient.begin();it!=out_j_fromClient.end();it++) delete it->second ;
44    for(map<int,CArray<int,1>* >::iterator it=out_l_fromClient.begin();it!=out_l_fromClient.end();it++) delete it->second ;
45
46   }
47
48   ///---------------------------------------------------------------
49
50   StdString CGrid::GetName(void)    { return (StdString("grid")); }
51   StdString CGrid::GetDefName(void) { return (CGrid::GetName()); }
52   ENodeType CGrid::GetType(void)    { return (eGrid); }
53
54   //----------------------------------------------------------------
55
56   const std::deque< CArray<int,1>* > & CGrid::getStoreIndex(void) const
57   { 
58      return (this->storeIndex );
59   }
60
61   //---------------------------------------------------------------
62
63   const std::deque< CArray<int,1>* > & CGrid::getOutIIndex(void)  const
64   { 
65      return (this->out_i_index ); 
66   }
67
68   //---------------------------------------------------------------
69
70   const std::deque< CArray<int,1>* > & CGrid::getOutJIndex(void)  const
71   { 
72      return (this->out_j_index ); 
73   }
74
75   //---------------------------------------------------------------
76
77   const std::deque< CArray<int,1>* > & CGrid::getOutLIndex(void)  const
78   { 
79      return (this->out_l_index ); 
80   }
81
82   //---------------------------------------------------------------
83
84   const CAxis*   CGrid::getRelAxis  (void) const
85   { 
86      return (this->axis ); 
87   }
88
89   //---------------------------------------------------------------
90
91   const CDomain* CGrid::getRelDomain(void) const
92   { 
93      return (this->domain ); 
94   }
95
96   //---------------------------------------------------------------
97
98   bool CGrid::hasAxis(void) const 
99   { 
100      return (this->withAxis); 
101   }
102
103   //---------------------------------------------------------------
104
105   StdSize CGrid::getDimension(void) const
106   {
107      return ((this->withAxis)?3:2);
108   }
109
110   //---------------------------------------------------------------
111
112/*
113   std::vector<StdSize> CGrid::getLocalShape(void) const
114   {
115      std::vector<StdSize> retvalue;
116      retvalue.push_back(domain->zoom_ni_loc.getValue());
117      retvalue.push_back(domain->zoom_nj_loc.getValue());
118      if (this->withAxis)
119         retvalue.push_back(this->axis->zoom_size.getValue());
120      return (retvalue);
121   }
122*/
123   //---------------------------------------------------------------
124   
125/*
126   StdSize CGrid::getLocalSize(void) const
127   {
128      StdSize retvalue = 1;
129      std::vector<StdSize> shape_ = this->getLocalShape();
130      for (StdSize s = 0; s < shape_.size(); s++)
131         retvalue *= shape_[s];
132      return (retvalue);
133   }
134*/
135   //---------------------------------------------------------------
136/*
137   std::vector<StdSize> CGrid::getGlobalShape(void) const
138   {
139      std::vector<StdSize> retvalue;
140      retvalue.push_back(domain->ni.getValue());
141      retvalue.push_back(domain->nj.getValue());
142      if (this->withAxis)
143         retvalue.push_back(this->axis->size.getValue());
144      return (retvalue);
145   }
146*/
147   //---------------------------------------------------------------
148
149/*   
150   StdSize CGrid::getGlobalSize(void) const
151   {
152      StdSize retvalue = 1;
153      std::vector<StdSize> shape_ = this->getGlobalShape();
154      for (StdSize s = 0; s < shape_.size(); s++)
155         retvalue *= shape_[s];
156      return (retvalue);
157   }
158*/
159   StdSize CGrid::getDataSize(void) const
160   {
161      StdSize retvalue=domain->data_ni.getValue() ;
162      if (domain->data_dim.getValue()==2) retvalue*=domain->data_nj.getValue() ;
163      if (this->withAxis) retvalue*=this->axis->size.getValue() ;
164
165      return (retvalue);
166   }
167
168   //---------------------------------------------------------------
169
170   void CGrid::solveReference(void)
171   {
172      if (this->isChecked) return;
173      CContext* context = CContext::getCurrent() ;
174      CContextClient* client=context->client ;
175     
176      this->solveDomainRef() ;
177      this->solveAxisRef() ;
178       
179      if (context->hasClient)
180      {
181         checkMask() ;
182         this->computeIndex() ;
183
184         this->storeIndex.push_front(new CArray<int,1>() );
185         this->out_i_index.push_front(new CArray<int,1>());
186         this->out_j_index.push_front(new CArray<int,1>());
187         this->out_l_index.push_front(new CArray<int,1>());
188      }
189//      this->computeIndexServer();
190      this->isChecked = true;
191   }
192
193
194   void CGrid::checkMask(void)
195   {
196      using namespace std;
197
198      unsigned int niu = domain->ni, nju = domain->nj;
199      unsigned int nlu = 1 ;
200      if (hasAxis()) nlu=axis->size ;
201
202      if (!mask.isEmpty())
203      {
204         if ((mask.extent(0) != niu) ||
205             (mask.extent(1) != nju) ||
206             (mask.extent(2) != nlu))
207             ERROR("CGrid::checkAttributes(void)",
208                  <<"The mask has not the same size than the local grid") ;
209      }
210      else 
211      {
212        mask.resize(niu,nju,nlu) ;
213        mask=true  ;
214      }
215     
216      CArray<bool,2>& domainMask = domain->mask ;
217      for (int l=0; l < nlu ; l++)
218        for (int j=0; j < nju ; j++)
219          for(int i=0; i<niu ; i++) mask(i,j,l) = mask(i,j,l) && domainMask(i,j) ;
220       
221     
222   }
223   
224   //---------------------------------------------------------------
225
226   void CGrid::solveDomainRef(void)
227   {
228      if (!domain_ref.isEmpty())
229      {
230         if (CDomain::has(domain_ref.getValue()))
231         {
232            this->domain = CDomain::get(domain_ref.getValue()) ;
233            domain->checkAttributes() ;
234         }
235         else ERROR("CGrid::solveDomainRef(void)",
236                     << "Wrong domain reference") ;
237      }
238      else ERROR("CGrid::solveDomainRef(void)",
239                  << "Domain reference is not defined") ;
240   }
241
242   //---------------------------------------------------------------
243
244   void CGrid::solveAxisRef(void)
245   {
246      if (!axis_ref.isEmpty())
247      {
248         this->withAxis = true ;
249         if (CAxis::get(axis_ref.getValue()))
250         {
251            this->axis = CAxis::get(axis_ref.getValue()) ;
252            axis->checkAttributes() ;
253         }
254         else ERROR("CGrid::solveAxisRef(void)",
255                    << "Wrong axis reference") ;
256      }
257      else withAxis = false ;
258   }
259
260   //---------------------------------------------------------------
261
262   void CGrid::computeIndex(void)
263   {   
264   
265      const int ni   = domain->ni.getValue() ,
266                nj   = domain->nj.getValue() ,
267                size = (this->hasAxis()) ? axis->size.getValue() : 1 ,
268                lbegin = (this->hasAxis()) ? axis->zoom_begin.getValue()-1 : 0 ,
269                lend = (this->hasAxis()) ? axis->zoom_end.getValue()-1 : 0 ;
270
271
272      const int data_dim     = domain->data_dim.getValue() ,
273                data_n_index = domain->data_n_index.getValue() ,
274                data_ibegin  = domain->data_ibegin.getValue() ,
275                data_jbegin  = (data_dim == 2)
276                             ? domain->data_jbegin.getValue() : -1;
277
278      CArray<int,1> data_i_index = domain->data_i_index ;
279      CArray<int,1> data_j_index = domain->data_j_index ;
280     
281
282      int indexCount = 0;
283
284      for(int l = 0; l < size ; l++)
285      {
286         for(int n = 0, i = 0, j = 0; n < data_n_index; n++)
287         {
288            int temp_i = data_i_index(n) + data_ibegin,
289                temp_j = (data_dim == 1) ? -1
290                       : data_j_index(n) + data_jbegin;
291            i = (data_dim == 1) ? (temp_i - 1) % ni
292                                : (temp_i - 1) ;
293            j = (data_dim == 1) ? (temp_i - 1) / ni
294                                : (temp_j - 1) ;
295
296            if ((l >=lbegin && l<= lend) &&
297                (i >= 0 && i < ni) &&
298                (j >= 0 && j < nj) && mask(i,j,l))
299               indexCount++ ;
300         }
301      }
302     
303      storeIndex[0]  = new CArray<int,1>(indexCount) ;
304      out_i_index[0] = new CArray<int,1>(indexCount) ;
305      out_j_index[0] = new CArray<int,1>(indexCount) ;
306      out_l_index[0] = new CArray<int,1>(indexCount) ;
307     
308      storeIndex_client.resize(indexCount) ;
309      out_i_client.resize(indexCount) ;
310      out_j_client.resize(indexCount) ;
311      out_l_client.resize(indexCount) ;
312     
313     
314      for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
315      {
316         for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++)
317         {
318            int temp_i = data_i_index(n) + data_ibegin,
319                temp_j = (data_dim == 1) ? -1
320                       : data_j_index(n) + data_jbegin;
321            i = (data_dim == 1) ? (temp_i - 1) % ni
322                                : (temp_i - 1) ;
323            j = (data_dim == 1) ? (temp_i - 1) / ni
324                                : (temp_j - 1) ;
325
326            if ((l >= lbegin && l <= lend) &&
327                (i >= 0 && i < ni) &&
328                (j >= 0 && j < nj) && mask(i,j,l))
329            {
330               (*storeIndex[0])(indexCount) = count ;
331               (*out_l_index[0])(indexCount) = l ;
332               (*out_i_index[0])(indexCount) = i ;
333               (*out_j_index[0])(indexCount) = j ;
334               
335               storeIndex_client(indexCount) = count ;
336               out_i_client(indexCount)=i+domain->ibegin_client-1 ;
337               out_j_client(indexCount)=j+domain->jbegin_client-1 ;
338               out_l_client(indexCount)=l-lbegin ;
339               indexCount++ ;
340            }
341         }
342      }
343      sendIndex() ;
344
345
346   }
347
348   //----------------------------------------------------------------
349
350   CGrid* CGrid::createGrid(CDomain* domain)
351   {
352      StdString new_id = StdString("__") + domain->getId() + StdString("__") ;
353      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
354      grid->domain_ref.setValue(domain->getId());
355      return (grid);
356   }
357
358   CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis)
359   {
360      StdString new_id = StdString("__") + domain->getId() +
361                         StdString("_") + axis->getId() + StdString("__") ;
362      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ;
363      grid->domain_ref.setValue(domain->getId());
364      grid->axis_ref.setValue(axis->getId());
365      return (grid);
366   }
367
368   //----------------------------------------------------------------
369
370   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 3>& field) 
371   {
372      CArray<int,1>& out_i=*out_i_fromClient[rank] ;
373      CArray<int,1>& out_j=*out_j_fromClient[rank] ;
374      CArray<int,1>& out_l=*out_l_fromClient[rank] ;
375     
376      for(StdSize n = 0; n < stored.numElements(); n++)
377         field(out_i(n), out_j(n), out_l(n)) = stored(n) ;
378   }
379
380   void CGrid::outputField(int rank, const CArray<double, 1>& stored,  CArray<double, 2>& field) 
381   {
382      CArray<int,1>& out_i=*out_i_fromClient[rank] ;
383      CArray<int,1>& out_j=*out_j_fromClient[rank] ;
384     
385      for(StdSize n = 0; n < stored.numElements(); n++)
386         field(out_i(n), out_j(n)) = stored(n) ;   }
387
388   //---------------------------------------------------------------
389
390   void CGrid::outputField(int rank,const CArray<double, 1>& stored,  CArray<double, 1>& field)
391   {
392      CArray<int,1>& out_i=*out_i_fromClient[rank] ;
393 
394      for(StdSize n = 0; n < stored.numElements(); n++)
395         field(out_i(n)) = stored(n) ;
396   }
397
398   //----------------------------------------------------------------
399 
400
401   void CGrid::storeField_arr
402      (const double * const data, CArray<double, 1>& stored) const
403   {
404      const StdSize size = storeIndex_client.numElements() ;
405
406      stored.resize(size) ;
407      for(StdSize i = 0; i < size; i++) stored(i) = data[storeIndex_client(i)] ;
408   }
409   
410   //---------------------------------------------------------------
411
412  void CGrid::sendIndex(void)
413  {
414    CContext* context = CContext::getCurrent() ;
415    CContextClient* client=context->client ;
416   
417    CEventClient event(getType(),EVENT_ID_INDEX) ;
418    int rank ;
419    list<shared_ptr<CMessage> > list_msg ;
420    list< CArray<int,1>* > list_out_i,list_out_j,list_out_l ;
421     
422    for(int ns=0;ns<domain->connectedServer.size();ns++)
423    {
424       rank=domain->connectedServer[ns] ;
425       int ib=domain->ib_srv[ns] ;
426       int ie=domain->ie_srv[ns] ;
427       int jb=domain->jb_srv[ns] ;
428       int je=domain->je_srv[ns] ;
429       
430       int i,j ;
431       int nb=0 ;
432       for(int k=0;k<storeIndex_client.numElements();k++)
433       {
434         i=out_i_client(k) ;
435         j=out_j_client(k) ;
436         if (i>=ib-1 && i<=ie-1 && j>=jb-1 && j<=je-1) nb++ ; 
437       }
438       
439       CArray<int,1> storeIndex(nb) ;
440       CArray<int,1> out_i(nb) ;
441       CArray<int,1> out_j(nb) ;
442       CArray<int,1> out_l(nb) ;
443 
444       
445       nb=0 ;
446       for(int k=0;k<storeIndex_client.numElements();k++)
447       {
448         i=out_i_client(k) ;
449         j=out_j_client(k) ;
450         if (i>=ib-1 && i<=ie-1 && j>=jb-1 && j<=je-1) 
451         {
452            storeIndex(nb)=k ;
453            out_i(nb)=out_i_client(k) ;
454            out_j(nb)=out_j_client(k) ;
455            out_l(nb)=out_l_client(k) ;
456            nb++ ;
457         }
458       }
459       
460       storeIndex_toSrv.insert( pair<int,CArray<int,1>* >(rank,new CArray<int,1>(storeIndex) )) ;
461       nbSenders.insert(pair<int,int>(rank,domain->nbSenders[ns])) ;
462       list_msg.push_back(shared_ptr<CMessage>(new CMessage)) ;
463       list_out_i.push_back(new CArray<int,1>(out_i)) ;
464       list_out_j.push_back(new CArray<int,1>(out_j)) ;
465       list_out_l.push_back(new CArray<int,1>(out_l)) ;
466
467       *list_msg.back()<<getId()<<*list_out_i.back()<<*list_out_j.back()<<*list_out_l.back() ;
468       event.push(rank,domain->nbSenders[ns],*list_msg.back()) ;
469    }
470    client->sendEvent(event) ;
471
472    for(list<CArray<int,1>* >::iterator it=list_out_i.begin();it!=list_out_i.end();it++) delete *it ;
473    for(list<CArray<int,1>* >::iterator it=list_out_j.begin();it!=list_out_j.end();it++) delete *it ;
474    for(list<CArray<int,1>* >::iterator it=list_out_l.begin();it!=list_out_l.end();it++) delete *it ;
475   
476  }
477 
478  void CGrid::recvIndex(CEventServer& event)
479  {
480    list<CEventServer::SSubEvent>::iterator it ;
481    for (it=event.subEvents.begin();it!=event.subEvents.end();++it)
482    {
483      int rank=it->rank;
484      CBufferIn* buffer=it->buffer;
485      string domainId ;
486      *buffer>>domainId ;
487      get(domainId)->recvIndex(rank,*buffer) ;
488    }
489  }
490 
491  void CGrid::recvIndex(int rank, CBufferIn& buffer)
492  {
493    CArray<int,1> out_i ;
494    CArray<int,1> out_j ;
495    CArray<int,1> out_l ;
496   
497    buffer>>out_i>>out_j>>out_l ;
498   
499    out_i -= domain->zoom_ibegin_srv-1 ;
500    out_j -= domain->zoom_jbegin_srv-1 ;
501   
502    out_i_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_i) )) ;
503    out_j_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_j) )) ;
504    out_l_fromClient.insert(pair< int,CArray<int,1>* >(rank,new CArray<int,1>(out_l) )) ;
505  }
506
507  bool CGrid::dispatchEvent(CEventServer& event)
508  {
509     
510    if (SuperClass::dispatchEvent(event)) return true ;
511    else
512    {
513      switch(event.type)
514      {
515        case EVENT_ID_INDEX :
516          recvIndex(event) ;
517          return true ;
518          break ;
519 
520        default :
521          ERROR("bool CDomain::dispatchEvent(CEventServer& event)",
522                <<"Unknown Event") ;
523          return false ;
524      }
525    }
526  }
527
528   void CGrid::inputFieldServer(const std::deque< CArray<double, 1>* > storedClient, CArray<double, 1>&  storedServer) const
529   {
530      if ((this->storeIndex.size()-1 ) != storedClient.size())
531         ERROR("void CGrid::inputFieldServer(const std::deque< CArray<double, 1>* > storedClient, CArray<double, 1>&  storedServer) const",
532                << "[ Expected received field = " << (this->storeIndex.size()-1) << ", "
533                << "[ received fiedl = "    << storedClient.size() << "] "
534                << "Data from clients are missing!") ;
535      storedServer.resize(storeIndex[0]->numElements());
536         
537      for (StdSize i = 0, n = 0; i < storedClient.size(); i++)
538         for (StdSize j = 0; j < storedClient[i]->numElements(); j++)
539            storedServer(n++) = (*storedClient[i])(j);
540   }
541
542   void CGrid::outputFieldToServer(CArray<double,1>& fieldIn, int rank, CArray<double,1>& fieldOut)
543   {
544     CArray<int,1>& index = *storeIndex_toSrv[rank] ;
545     int nb=index.numElements() ;
546     fieldOut.resize(nb) ;
547     
548     for(int k=0;k<nb;k++) fieldOut(k)=fieldIn(index(k)) ;
549    }
550   ///---------------------------------------------------------------
551
552} // namespace xios
Note: See TracBrowser for help on using the repository browser.