Changeset 120 for XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp

Timestamp:

09/08/10 15:02:31 (14 years ago)

Author:

hozdoba

Message:

Mise à jour intermédiaire ...
A venir : commit d'une version stable intégrant l'écriture de fichiers NetCDF4.
(en cours de finalisation actuellement)

File:

• XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp (modified) (1 diff)

XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp

@@ -7 +7 @@
 namespace XMLIOSERVER
 {
-   class CGrid: public ObjectTemplate<CGrid>, public GridAttribut
+   class CGrid : public ObjectTemplate<CGrid>, public GridAttribut
    {
       public:
 
-         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut()
-         {/* Ne rien faire de plus */}
-         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut()
-         {/* Ne rien faire de plus */}
+         CGrid(void) : ObjectTemplate<CGrid>(), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
+         { /* Ne rien faire de plus */ }
+         CGrid(const string& _id) : ObjectTemplate<CGrid>(_id), GridAttribut(), hasAxis(false), axis(NULL), domain(NULL)
+         { /* Ne rien faire de plus */ }
 
          static string GetName(void) { return ("grid"); }
+
+         inline void solveReference(void) ;
+         inline void solveDomainRef(void) ;
+         inline void solveAxisRef(void) ;
+
+         inline void computeIndex(void);
+
+         inline void storeField(const Array<double,1>& field, Array<double,1>& stored);
+         inline void storeField(const Array<double,2>& field, Array<double,1>& stored);
+         inline void storeField(const Array<double,3>& field, Array<double,1>& stored);
+         inline void storeField(const double* const data, Array<double,1>& stored);
+
+         inline void outputField(const Array<double,1>& stored, Array<double,2>& outField);
+         inline void outputField(const Array<double,1>& stored, Array<double,3>& outField);
+
+         inline static CGrid* CreateObject(const CDomain* const a_domain, const CAxis* const a_axis);
+         inline static CGrid* CreateObject(const CDomain* const a_domain);
 
          virtual ~CGrid(void)
          { /* Ne rien faire de plus */ }
 
+
+      private:
+
+         bool hasAxis ;
+
+         CAxis* axis ;
+         CDomain* domain ;
+
+         Array<int,1> storeIndex ;
+         Array<int,1> out_i_index ;
+         Array<int,1> out_j_index ;
+         Array<int,1> out_l_index ;
+
    }; // class CGrid
 
+
+   CGrid* CGrid::CreateObject(const CDomain* const a_domain, const CAxis* const a_axis)
+   {
+      string new_id = string("___") + a_domain->getId() + string("_") + a_axis->getId() + string("__") ;
+      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+      grid->domain_ref = a_domain->getId() ;
+      grid->axis_ref = a_axis->getId() ;
+
+      return (grid);
+   }
+
+   CGrid* CGrid::CreateObject(const CDomain* const a_domain)
+   {
+      string new_id = string("___") + a_domain->getId() + string("__") ;
+      CGrid* const grid = ObjectTemplate<CGrid>::CreateObject(new_id) ;
+
+      grid->domain_ref = a_domain->getId() ;
+
+      return (grid);
+   }
+
+   void CGrid::solveReference(void)
+   {
+      static bool isReferenceSolved = false;
+      if (isReferenceSolved) return;
+
+      // Résolution de chacune des références et indexation.
+      solveDomainRef() ;
+      solveAxisRef() ;
+      computeIndex() ;
+
+      isReferenceSolved = true ;
+   }
+
+   void CGrid::solveDomainRef(void)
+   {
+      if (domain_ref.hasValue())
+      {
+         if (CDomain::HasObject(domain_ref))
+         {
+           domain=CDomain::GetObject(domain_ref) ;
+           domain->check() ;
+         }
+         else ERROR("Référence au domaine incorrecte") ;
+      }
+      else ERROR("Domaine non défini") ;
+   }
+
+   void CGrid::solveAxisRef(void)
+   {
+      if (axis_ref.hasValue())
+      {
+         hasAxis = true ;
+         if (CAxis::HasObject(axis_ref)) axis = CAxis::GetObject(axis_ref) ;
+         else ERROR("Référence a l'axe incorrecte") ;
+      }
+      else hasAxis = false ; // hasAxis est normalement déjà à false(?).
+   }
+
+   void CGrid::computeIndex(void)
+   {
+      int ni = domain->ni ;
+      int nj = domain->nj ;
+      int size = (hasAxis) ? (int)axis->size : 1 ;
+      int data_dim = domain->data_dim ;
+      int data_n_index = domain->data_n_index ;
+      int data_ibegin  = domain->data_ibegin ;
+      int data_jbegin  = (data_dim == 2) ? (int)domain->data_jbegin : -1;
+
+      Array<int,1>& data_i_index =* domain->data_i_index ;
+      Array<int,1>& data_j_index =* domain->data_j_index ;
+      Array<bool,2>& mask =* domain->mask ;
+      int i, j, l, n ;
+      int count, indexCount ;
+
+      for(indexCount=0, l=0; l<size ; l++)
+      {
+         for(n=0, indexCount=0; n<data_n_index; n++)
+         {
+            if (data_dim == 1)
+            {
+               i = (data_i_index(n) + data_ibegin) % ni ;
+               j = (data_i_index(n) + data_ibegin) / ni ;
+               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+            }
+            else
+            {
+               i = data_i_index(n) + data_ibegin ;
+               j = data_j_index(n) + data_jbegin ;
+               cout<<i<<" "<<j<<" "<<mask(i,j)<<endl ;
+            }
+
+            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j) ) indexCount++ ;
+         }
+      }
+
+      storeIndex.resize(indexCount) ;
+      out_l_index.resize(indexCount) ;
+      out_i_index.resize(indexCount) ;
+      out_j_index.resize(indexCount) ;
+
+      for(count=0, indexCount=0, l=0; l<size; l++)
+      {
+         for(n=0; n<data_n_index; n++)
+         {
+            if (data_dim == 1)
+            {
+               i = (data_i_index(n) + data_ibegin) % ni ;
+               j = (data_i_index(n) + data_ibegin) / ni ;
+            }
+            else
+            {
+               i = data_i_index(n) + data_ibegin ;
+               j = data_j_index(n) + data_jbegin ;
+            }
+
+            if (i>=0 && i<ni && j>=0 && j<nj && mask(i,j))
+            {
+               storeIndex(indexCount) = n ;
+               out_l_index(indexCount) = l ;
+               out_i_index(indexCount) = i ;
+               out_j_index(indexCount) = j ;
+               indexCount++ ;
+            }
+            count++ ;
+         }
+      }
+
+      cout << "Out of CGrid::ComputeIndex" << endl ;
+      cout << storeIndex << endl ;
+      cout << out_i_index << endl ;
+      cout << out_j_index << endl ;
+      cout << out_l_index << endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 1>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 1"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 2>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 2"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const Array<double, 3>& field, Array<double, 1>& stored)
+   {
+      storeField(field.dataFirst(), stored) ;
+      //cout<<"Stored 3"<<stored<<endl ;
+   }
+
+   void CGrid::storeField(const double* const data, Array<double, 1>& stored)
+   {
+      int size = storeIndex.size() ;
+      //cout << "size " << size << endl ;
+
+      stored.resize(shape(size)) ;
+      //cout << "Stored " << stored << endl ;
+
+      for(int i = 0; i < size; i++) stored(i) = data[storeIndex(i)] ;
+      //cout << "Stored " << stored << endl ;
+   }
+
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField)
+   {
+      for(int n = 0; n < storeIndex.size(); n++)
+         outField(out_i_index(n), out_j_index(n)) = stored(n) ;
+   }
+
+   void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField)
+   {
+      for(int n = 0; n < storeIndex.size(); n++)
+         outField(out_i_index(n), out_j_index(n), out_l_index(n)) = stored(n) ;
+   }
 } // namespace XMLIOSERVER
 
+
 DECLARE_GROUP(Grid)
 
+
+
 #endif // __GRID__