CshapeFunction_global_rigidBody.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_RIGIDBODY
#define CSHAPEFUNCTION_GLOBAL_RIGIDBODY

#include "CshapeFunction_global.h"

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

    std::vector<int> m_modRB;//Required RigidBody modes
    std::vector<int> m_range;//mode range

    CshapeFunction_global_rigidBody() : CshapeFunction_global<T,Timg>()
    {//constructor

      this->class_name = "CshapeFunction_global_rigidBody";
      
    }
 
    virtual void init(CParameterNetCDF &fp)
    {//fill m_modRB vector with the indice of required Rigid Body modes from parameter.nc
      
      //look for the entire set of required modes.
      CshapeFunction_global<T,Timg>::init(fp);
      
      //identify the RigidBody modes withins this->m_mods[] and store them within m_modRB[]
      m_modRB.clear();
      m_range.clear();
      for (int i=0; i<this->m_mods.size(); i++)
      {//checking for rigid body modes
        if (this->m_mods[i] == "Tx"){m_modRB.push_back(i);m_range.push_back(0);}
        if (this->m_mods[i] == "Ty"){m_modRB.push_back(i);m_range.push_back(1);}
        if (this->m_mods[i] == "Tz"){m_modRB.push_back(i);m_range.push_back(2);}
        if (this->m_mods[i] == "Rz"){m_modRB.push_back(i);m_range.push_back(3);}
        if (this->m_mods[i] == "Ry"){m_modRB.push_back(i);m_range.push_back(4);}
        if (this->m_mods[i] == "Rx"){m_modRB.push_back(i);m_range.push_back(5);}
      }
      
      if (this->m_verbose){std::cout<<"\tmodes RB : [ ";for (int i=0; i<m_modRB.size(); i++){std::cout<<m_modRB[i]<<" ";}std::cout<<"]\n";}
      if (this->m_verbose){std::cout<<"\trang RB : [ ";for (int i=0; i<m_range.size(); i++){std::cout<<m_range[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 rigid body modes at coordonate (x,y,z)
    
      set(x, m_modRB, m_range, N);
      
    }
    
    void set(const std::vector<T> &x, const std::vector<int> &md, const std::vector<int> &rg, CImgList<T> &N)
    {
      
      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 1; break;
            case 1: return 0; break;
            case 2: return 0; break;
            case 3: return -x[1]; break;
            case 4: return x[2]; break;
            case 5: 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 0; break;
            case 1: return 1; break;
            case 2: return 0; break;
            case 3: return x[0]; break;
            case 4: return 0; break;
            case 5: 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 0; break;
            case 1: return 0; break;
            case 2: return 1; break;
            case 3: return 0; break;
            case 4: return -x[0]; break;
            case 5: 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