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

#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)
   {
      const int ni   = domain->ni ,
                nj   = domain->nj ,
                size = (hasAxis) ? (int)axis->size : 1 ;

      /*std::cout << ni   << " : "
                  << nj   << " : "
                  << size << std::endl;*/

      const int data_dim     = domain->data_dim ,
                data_n_index = domain->data_n_index ,
                data_ibegin  = domain->data_ibegin ,
                data_jbegin  = (data_dim == 2) ? (int)domain->data_jbegin : -1;

      Array<int, 1>& data_i_index =* domain->data_i_index ,
                     data_j_index =* domain->data_j_index ;

      /*std::cout << data_n_index        << " : "
                  << data_i_index.size() << " : "
                  << data_j_index.size()  << std::endl;*/

      Array<bool, 2>& mask = *domain->mask ;

      int indexCount = 0;

      for(int l = 0; l < size ; l++)
      {
         for(int n = 0, i = 0, j = 0; n < data_n_index; n++)
         {
            int temp_i = data_i_index(n) + data_ibegin,
                temp_j = (data_dim == 1) ? -1
                       : data_j_index(n) + data_jbegin;
            i = (data_dim == 1) ? (temp_i - 2) % ni
                                : (temp_i - 1) ;
            j = (data_dim == 1) ? (temp_i - 2) / ni
                                : (temp_j - 1) ;

            if ((i >= 0 && i < ni) &&
                (j >= 0 && j < nj) && mask(i, j))
               indexCount++ ;
         }
      }

      //std::cout << indexCount  << std::endl;

       storeIndex.resize(indexCount) ;
      out_l_index.resize(indexCount) ;
      out_i_index.resize(indexCount) ;
      out_j_index.resize(indexCount) ;

      for(int count = 0, indexCount = 0,  l = 0; l < size; l++)
      {
         for(int n = 0, i = 0, j = 0; n < data_n_index; n++, count++)
         {
            int temp_i = data_i_index(n) + data_ibegin,
                temp_j = (data_dim == 1) ? -1
                       : data_j_index(n) + data_jbegin;
            i = (data_dim == 1) ? (temp_i - 2) % ni
                                : (temp_i - 1) ;
            j = (data_dim == 1) ? (temp_i - 2) / ni
                                : (temp_j - 1) ;

            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__