source: XMLIO_V2/dev/dev_rv/src/xmlio/node/grid.cpp @ 180

Last change on this file since 180 was 180, checked in by hozdoba, 12 years ago
File size: 9.7 KB
Line 
1#include "grid.hpp"
2
3#include "attribute_template_impl.hpp"
4#include "object_template_impl.hpp"
5#include "group_template_impl.hpp"
6
7namespace xmlioserver {
8namespace tree {
9
10   /// ////////////////////// Définitions ////////////////////// ///
11
12   CGrid::CGrid(void)
13      : CObjectTemplate<CGrid>(), CGridAttributes()
14      , withAxis(false), isChecked(false), axis(), domain()
15      , storeIndex(), out_i_index(), out_j_index(), out_l_index()
16   { /* Ne rien faire de plus */ }
17
18   CGrid::CGrid(const StdString & id)
19      : CObjectTemplate<CGrid>(id), CGridAttributes()
20      , withAxis(false), isChecked(false), axis(), domain()
21      , storeIndex(), out_i_index(), out_j_index(), out_l_index()
22   { /* Ne rien faire de plus */ }
23
24   CGrid::~CGrid(void)
25   { /* Ne rien faire de plus */ }
26
27   ///---------------------------------------------------------------
28
29   StdString CGrid::GetName(void)    { return (StdString("grid")); }
30   StdString CGrid::GetDefName(void) { return (CGrid::GetName()); }
31   ENodeType CGrid::GetType(void)    { return (eGrid); }
32
33   //----------------------------------------------------------------
34
35   const ARRAY(int, 1) & CGrid::getStoreIndex(void) const
36   { 
37      return (this->storeIndex );
38   }
39
40   //---------------------------------------------------------------
41
42   const ARRAY(int, 1) & CGrid::getOutIIndex(void)  const
43   { 
44      return (this->out_i_index ); 
45   }
46
47   //---------------------------------------------------------------
48
49   const ARRAY(int, 1) & CGrid::getOutJIndex(void)  const
50   { 
51      return (this->out_j_index ); 
52   }
53
54   //---------------------------------------------------------------
55
56   const ARRAY(int, 1) & CGrid::getOutLIndex(void)  const
57   { 
58      return (this->out_l_index ); 
59   }
60
61   //---------------------------------------------------------------
62
63   const boost::shared_ptr<CAxis>   CGrid::getRelAxis  (void) const
64   { 
65      return (this->axis ); 
66   }
67
68   //---------------------------------------------------------------
69
70   const boost::shared_ptr<CDomain> CGrid::getRelDomain(void) const
71   { 
72      return (this->domain ); 
73   }
74
75   //---------------------------------------------------------------
76
77   bool CGrid::hasAxis(void) const 
78   { 
79      return (this->withAxis); 
80   }
81
82   //---------------------------------------------------------------
83
84   void CGrid::solveReference(void)
85   {
86      if (this->isChecked) return;
87      this->solveDomainRef() ;
88      this->solveAxisRef() ;
89      this->computeIndex() ;
90      this->isChecked = true;
91   }
92
93   //---------------------------------------------------------------
94
95   void CGrid::solveDomainRef(void)
96   {
97      if (!domain_ref.isEmpty())
98      {
99         if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
100         {
101            this->domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
102            domain->checkAttributes() ;
103         }
104         else ERROR("CGrid::solveDomainRef(void)",
105                     << "Référence au domaine incorrecte") ;
106      }
107      else ERROR("CGrid::solveDomainRef(void)",
108                  << "Domaine non défini") ;
109   }
110
111   //---------------------------------------------------------------
112
113   void CGrid::solveAxisRef(void)
114   {
115      if (!axis_ref.isEmpty())
116      {
117         this->withAxis = true ;
118         if (CObjectFactory::GetObject<CAxis>(axis_ref.getValue()))
119         {
120            this->axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
121            axis->checkAttributes() ;
122         }
123         else ERROR("CGrid::solveAxisRef(void)",
124                    << "Référence a l'axe incorrecte") ;
125      }
126      else withAxis = false ;
127   }
128
129   //---------------------------------------------------------------
130
131   void CGrid::computeIndex(void)
132   {   
133      const int ni   = domain->ni.getValue() ,
134                nj   = domain->nj.getValue() ,
135                size = (this->hasAxis()) ? axis->size.getValue() : 1 ;
136
137      /*std::cout << ni   << " : "
138                  << nj   << " : "
139                  << size << std::endl;*/
140
141      const int data_dim     = domain->data_dim.getValue() ,
142                data_n_index = domain->data_n_index.getValue() ,
143                data_ibegin  = domain->data_ibegin.getValue() ,
144                data_jbegin  = (data_dim == 2)
145                             ? domain->data_jbegin.getValue() : -1;
146
147      ARRAY(int, 1) data_i_index = domain->data_i_index.getValue() ,
148                    data_j_index = domain->data_j_index.getValue() ;
149
150      /*std::cout << data_n_index  << " : "
151                  << data_i_index  << " : "
152                  << data_j_index  << std::endl; */
153
154      ARRAY(bool, 2) mask = domain->mask.getValue() ;
155
156      int indexCount = 0;
157
158      for(int l = 0; l < size ; l++)
159      {
160         for(int n = 0, i = 0, j = 0; n < data_n_index; n++)
161         {
162            int temp_i = (*data_i_index)[n] + data_ibegin,
163                temp_j = (data_dim == 1) ? -1
164                       : (*data_j_index)[n] + data_jbegin;
165            i = (data_dim == 1) ? (temp_i - 2) % ni
166                                : (temp_i - 1) ;
167            j = (data_dim == 1) ? (temp_i - 2) / ni
168                                : (temp_j - 1) ;
169
170            if ((i >= 0 && i < ni) &&
171                (j >= 0 && j < nj) && (*mask)[i][j])
172               indexCount++ ;
173         }
174      }
175     
176      //std::cout << indexCount  << std::endl;
177      ARRAY_ASSIGN(this->storeIndex , int, 1, [indexCount]);
178      ARRAY_ASSIGN(this->out_l_index, int, 1, [indexCount]);
179      ARRAY_ASSIGN(this->out_i_index, int, 1, [indexCount]);
180      ARRAY_ASSIGN(this->out_j_index, int, 1, [indexCount]);
181
182      for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
183      {
184         for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++)
185         {
186            int temp_i = (*data_i_index)[n] + data_ibegin,
187                temp_j = (data_dim == 1) ? -1
188                       : (*data_j_index)[n] + data_jbegin;
189            i = (data_dim == 1) ? (temp_i - 2) % ni
190                                : (temp_i - 1) ;
191            j = (data_dim == 1) ? (temp_i - 2) / ni
192                                : (temp_j - 1) ;
193
194            if ((i >= 0 && i < ni) &&
195                (j >= 0 && j < nj) && (*mask)[i][j])
196            {
197               (*this->storeIndex) [indexCount] = count ;
198               (*this->out_l_index)[indexCount] = l ;
199               (*this->out_i_index)[indexCount] = i ;
200               (*this->out_j_index)[indexCount] = j ;
201               indexCount++ ;
202            }
203         }
204      }
205   }
206
207   //----------------------------------------------------------------
208
209   boost::shared_ptr<CGrid>
210      CGrid::CreateGrid(boost::shared_ptr<CDomain> domain)
211   {
212      StdString new_id = StdString("__") + domain->getId() + StdString("__") ;
213      boost::shared_ptr<CGrid> grid =
214         CGroupFactory::CreateChild(CObjectFactory::GetObject<CGridGroup> ("grid_definition"), new_id);
215      grid->domain_ref.setValue(domain->getId());
216      return (grid);
217   }
218
219   boost::shared_ptr<CGrid>
220      CGrid::CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis)
221   {
222      StdString new_id = StdString("__") + domain->getId() +
223                         StdString("_") + axis->getId() + StdString("__") ;
224      boost::shared_ptr<CGrid> grid =
225         CGroupFactory::CreateChild(CObjectFactory::GetObject<CGridGroup> ("grid_definition"), new_id);
226      grid->domain_ref.setValue(domain->getId());
227      grid->axis_ref.setValue(axis->getId());
228      return (grid);
229   }
230
231   //----------------------------------------------------------------
232
233   template <>
234      void CGrid::outputField
235         (const ARRAY(double, 1) stored,  ARRAY(double, 3) field) const
236   {
237      for(StdSize n = 0; n < storeIndex->num_elements(); n++)
238         (*field)[(*out_i_index)[n]][(*out_j_index)[n]][(*out_l_index)[n]] = (*stored)[n] ;
239   }
240
241   //---------------------------------------------------------------
242
243   template <>
244      void CGrid::outputField
245         (const ARRAY(double, 1) stored,  ARRAY(double, 2) field) const
246   {
247      for(StdSize n = 0; n < storeIndex->num_elements(); n++)
248         (*field)[(*out_i_index)[n]][(*out_j_index)[n]] = (*stored)[n] ;
249   }
250
251   //---------------------------------------------------------------
252
253   template <>
254      void CGrid::outputField
255         (const ARRAY(double, 1) stored,  ARRAY(double, 1) field) const
256   {
257      for(StdSize n = 0; n < storeIndex->num_elements(); n++)
258         (*field)[(*out_i_index)[n]] = (*stored)[n] ;
259   }
260
261   //----------------------------------------------------------------
262
263   void CGrid::storeField_arr
264      (const double * const data, ARRAY(double, 1) stored) const
265   {
266      const StdSize size = storeIndex->num_elements() ;
267      stored->resize(boost::extents[size]) ;
268      for(StdSize i = 0; i < size; i++)
269         (*stored)[i] = data[(*storeIndex)[i]] ;
270   }
271   
272   //---------------------------------------------------------------
273   
274   void CGrid::toBinary  (StdOStream & os) const
275   {
276      SuperClass::toBinary(os);
277      this->storeIndex->toBinary(os);
278      this->out_i_index->toBinary(os);
279      this->out_j_index->toBinary(os);
280      this->out_l_index->toBinary(os);
281   }
282
283   //---------------------------------------------------------------
284   
285   void CGrid::fromBinary(StdIStream & is)
286   {
287      SuperClass::fromBinary(is);
288     
289      ARRAY_CREATE(storeIndex_ , int, 1, [1]);
290      ARRAY_CREATE(out_l_index_, int, 1, [1]);
291      ARRAY_CREATE(out_i_index_, int, 1, [1]);
292      ARRAY_CREATE(out_j_index_, int, 1, [1]);
293     
294      storeIndex_ ->fromBinary(is);
295      out_i_index_->fromBinary(is);
296      out_j_index_->fromBinary(is);
297      out_l_index_->fromBinary(is);
298     
299   }
300
301   ///---------------------------------------------------------------
302
303} // namespace tree
304} // namespace xmlioserver
Note: See TracBrowser for help on using the repository browser.