source: XMLIO_V2/dev/dev_rv/src/XMLIO/grid.hpp @ 127

#ifndef __GRID__
#define __GRID__

using XMLIOSERVER::XML::XMLNode;
using XMLIOSERVER::XML::THashAttributes;

namespace XMLIOSERVER
{
   class CGrid : public ObjectTemplate<CGrid>, public GridAttribut
   {
      public:

         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 */ }

         const CAxis*   getRelAxis  (void) const { return (axis); }
         const CDomain* getRelDomain(void) const { return (domain); }

         const Array<int, 1>& getStoreIndex(void) const { return (storeIndex); }
         const Array<int, 1>& getOutIIndex(void)  const { return (out_i_index); }
         const Array<int, 1>& getOutJIndex(void)  const { return (out_j_index); }
         const Array<int, 1>& getOutLIndex(void)  const { return (out_l_index); }

         void solveReference(void)
         { this->solveDomainRef() ; this->solveAxisRef() ; this->computeIndex() ; }

         void 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 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(?).
         }

         inline void computeIndex(void);

         bool _hasAxis(void) const { return (hasAxis); }

         template <class T>
            void storeField(const T& field, Array<double, 1>& stored) const
         { this->storeField_arr(field.dataFirst(), stored) ; }

         template <class T>
            inline void outputField(const Array<double, 1>& stored, T&) const;

      public : /* virtual */

         virtual ~CGrid(void)
         { /* Ne rien faire de plus */ }

      public : /* static */

         static string GetName   (void) { return ("grid"); }
         static string GetDefName(void) { return (CGrid::GetName()); }

         static 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);
         }

         static 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);
         }

      protected :

         void storeField_arr(const double* const data, Array<double, 1>& stored) const
         {
            const int size = storeIndex.size() ;
            stored.resize(shape(size)) ;
            for(int i = 0; i < size; i++)
               stored(i) = data[storeIndex(i)] ;
         }

      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

   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; 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++, count++)
         {
            if (data_dim == 1)
            {
               i = (data_i_index(n) + data_ibegin) % ni ;
               j = (data_i_index(n) + data_ibegin) / ni ;
            }
            else // (dat_dim == 2)
            {
               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) = count ;
               out_l_index(indexCount) = l ;
               out_i_index(indexCount) = i ;
               out_j_index(indexCount) = j ;
               indexCount++ ;
            }
         }
      }
   }

   template<>
      void CGrid::outputField(const Array<double, 1>& stored, Array<double, 2>& outField) const
   {
      for(int n = 0; n < storeIndex.size(); n++)
         outField(out_i_index(n), out_j_index(n)) = stored(n) ;
   }

   template<>
      void CGrid::outputField(const Array<double, 1>& stored, Array<double, 3>& outField) const
   {
      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__