CshapeFunction_global_homogeneous.h

Go to the documentation of this file.

/**********************************************************************
 * Copyright (C) 2012, The YaDICs Project Developers. 
 * See the COPYRIGHT file at the top-level directory of this distribution ./COPYRIGHT.
 * See ./COPYING file for copying and redistribution conditions.
 * 
 * This file is part of YaDICs.
 * YaDICs is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * YaDICs is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with YaDICs.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * Information about how to use the software are provided at http://yadic.univ-lille1.fr/
 **********************************************************************/


#ifndef CSHAPEFUNCTION_GLOBAL_HOMOGENEOUS
#define CSHAPEFUNCTION_GLOBAL_HOMOGENEOUS

#include "CshapeFunction_global_rigidBody.h"

template<typename T,typename Timg> 
class CshapeFunction_global_homogeneous : public CshapeFunction_global_rigidBody<T,Timg>
{
  
  public:

    std::vector<int> m_modHD;//Required Homogeneous Deformation modes
    std::vector<int> m_range;//mode range
    
    CshapeFunction_global_homogeneous() : CshapeFunction_global_rigidBody<T,Timg>()
    {// constructor

      this->class_name = "CshapeFunction_global_homogeneous";
      
    }
 
    virtual void init(CParameterNetCDF &fp)
    {//fill m_modHD vector with the indice of required Homogeneous deformation modes from parameter.nc
      
      //look for the Rigid Body set of required modes.
      CshapeFunction_global_rigidBody<T,Timg>::init(fp);
      
      //identify the Homogeneous Deformation modes withins this->m_mods[] and store them within m_modHD[]
      m_modHD.clear();
      m_range.clear();
      for (int i=0; i<this->m_mods.size(); i++)
      {//checking for rigid body modes
        if (this->m_mods[i] == "D"){m_modHD.push_back(i);m_range.push_back(0);}
        if (this->m_mods[i] == "Exx"){m_modHD.push_back(i);m_range.push_back(1);}
        if (this->m_mods[i] == "Eyy"){m_modHD.push_back(i);m_range.push_back(2);}
        if (this->m_mods[i] == "Ezz"){m_modHD.push_back(i);m_range.push_back(3);}
        if (this->m_mods[i] == "Exy"){m_modHD.push_back(i);m_range.push_back(4);}
        if (this->m_mods[i] == "Exz"){m_modHD.push_back(i);m_range.push_back(5);}
        if (this->m_mods[i] == "Eyz"){m_modHD.push_back(i);m_range.push_back(6);}
      }
      
      if (this->m_verbose){std::cout<<"\tmodes HD : [ ";for (int i=0; i<m_modHD.size(); i++){std::cout<<m_modHD[i]<<" ";}std::cout<<"]\n";}
      
    }
 
    virtual void exec(const CImg<Timg> &box, const std::vector<T> &x, CImgList<T> &N)
    {// assign CImgList<T> N[dimensions][modes] for required Homogeneous Deformation and RB modes at coordonate (x,y,z)

      //RigidBody modes
      CshapeFunction_global_rigidBody<T,Timg>::exec(box, x,  N);
      
      set(x, m_modHD, m_range, N);
      
    }
    
    void set(const std::vector<T> &x, const std::vector<int> &md, const std::vector<int> &rg, CImgList<T> &N)
    {//should be improved, copy of CshapeFunction_global_rigidbody<T,Timg>::set
      
      cimglist_for(N,dim)
      {//for every dimensions
      
        for(int mode=0; mode<md.size(); mode++)
        {//for every modes

          N[dim][md[mode]] = shape(dim, rg[mode], x);
        }
        
      }
      
    }

    T shape(const int &dim, const int &range, const std::vector<T> &x)
    {//return shape
      
    
      switch(dim)
      {
      
        case 0:
          switch(range)
          {
            case 0: return x[0]; break;
            case 1: return x[0]; break;
            case 2: return 0; break;
            case 3: return 0; break;
            case 4: return x[1]; break;
            case 5: return x[2]; break;
            case 6: return 0; break;
            default:
            {
              std::cerr<<this->class_name<<"::"<<": error: mode="<<range<<" is unknown\n"<<std::flush;
              return 0;
            }
            
          }; break;
        case 1:
          switch(range)
          {
            case 0: return x[1]; break;
            case 1: return 0; break;
            case 2: return x[1]; break;
            case 3: return 0; break;
            case 4: return x[0]; break;
            case 5: return 0; break;
            case 6: return x[2]; break;
            default:
            {
              std::cerr<<this->class_name<<"::"<<": error: mode="<<range<<" is unknown\n"<<std::flush;
              return 0;
            }
          }; break;
        case 2:
          switch(range)
          {
            case 0: return x[2]; break;
            case 1: return 0; break;
            case 2: return 0; break;
            case 3: return x[2]; break;
            case 4: return 0; break;
            case 5: return x[2]; break;
            case 6: return x[1]; break;
            default:
            {
              std::cerr<<this->class_name<<"::"<<": error: mode="<<range<<" is unknown\n"<<std::flush;
              return 0;
            }
          }; break;
        default:
        {
          std::cerr<<this->class_name<<"::"<<": error: dim="<<dim<<" is unknown\n"<<std::flush;
          return 0;
        }
        
      }

    }
  
};

#endif