CshapeFunction_global_blade.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_BLADE
#define CSHAPEFUNCTION_GLOBAL_BLADE


#include "CshapeFunction_global_rigidBody.h"

template<typename T,typename Timg> 
class CshapeFunction_global_blade : public CshapeFunction_global_rigidBody<T,Timg>
{
  
  public:
    
    std::vector<int> m_modFlex, m_modComp;//Required Flexion and compresion modes
    std::vector<float> m_lambda;
    int m_p; 
    float m_length;//power for shape function and blade length

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

      this->class_name = "CshapeFunction_global_blade";
      
    }
    
    virtual void init(CParameterNetCDF &fp)
    {//fill m_modFlex vector with the indice of required Blade Flexion mode from parameter.nc

      CshapeFunction_global_rigidBody<T,Timg>::init(fp);
      
      m_modFlex.clear();
      for (int i=0; i<this->m_mods.size(); i++){if (this->m_mods[i].compare(0,1,"F") == 0){m_modFlex.push_back(i);}}
      if (this->m_verbose){std::cout<<"\tmodes Flex : [ ";for (int i=0; i<m_modFlex.size(); i++){std::cout<<m_modFlex[i]<<" ";}std::cout<<"]\n";}
      
      m_modComp.clear();
      for (int i=0; i<this->m_mods.size(); i++){if (this->m_mods[i].compare(0,1,"C") == 0){m_modComp.push_back(i);}}
      if (this->m_verbose){std::cout<<"\tmodes Comp : [ ";for (int i=0; i<m_modComp.size(); i++){std::cout<<m_modComp[i]<<" ";}std::cout<<"]\n";}
      
      std::string att_name("length");
      int error = fp.loadAttribute(att_name,m_length);
      if (this->m_verbose){std::cout<<"\tblade length : "<<m_length<<"\n";}

      m_p = 1;//power
      
      lambda(m_modFlex);
      
    }
 
    virtual void exec(const CImg<Timg> &box, const std::vector<T> &x, CImgList<T> &N)
    {// assign CImgList<T> N[dimensions][modes] for required Flexion and RB modes at coordonate (x,y,z)
      
      double xx = x[0];
      double yy = x[1];

      //fill Rigid Body mods
      CshapeFunction_global_rigidBody<T,Timg>::exec(box, x, N);
      
      //fill flexion mods
      for (int mod=0; mod<m_modFlex.size(); mod++)
      {
        N(0, m_modFlex[mod]) = -yy*dflex( xx, mod, m_lambda, m_length, m_p);
        N(1, m_modFlex[mod]) = flex(xx, mod, m_lambda, m_length, m_p);
      }
      
      //fill compression mods
      for (int mod=0; mod<m_modComp.size(); mod++)
      {
        N(0, m_modComp[mod]) = compress( xx, mod, m_length, m_p);
        N(1, m_modComp[mod]) = 0;
      }

    }
    
    void lambda(const std::vector<int> &modFlex)
    {// fill lambda vector
      
      m_lambda.clear();
      
      for (int i=0; i<modFlex.size(); i++)
      {
        switch(i)
        {
          case 0: m_lambda.push_back(1.8751); break;
          case 1: m_lambda.push_back(4.6940); break;
          default: m_lambda.push_back( (2*(i+1)-1)*this->m_pi/2 ); break;//periodic solution over 2 mode
        }
      }
      
    }

    T flex(const double &x, const int &mod, const std::vector<float> &lambda, const float &L, const int &pow = 1) const
    {// implement flexion shape function for a specific mode
      
      double a(lambda[mod]/L);
      
      return  std::pow( std::sin(a*x) - std::sinh(a*x) - (std::sin(lambda[mod]) + std::sinh(lambda[mod]))/(std::cos(lambda[mod]) + std::cosh(lambda[mod]))*(std::cos(a*x) - std::cosh(a*x)) ,pow); 
      
    }
  
    T dflex(const double &x, const int &mod, const std::vector<float> &lambda, const float &L, const int &pow = 1) const
    {// implement the first derivative of flexion shape function for a specific mode
      
      double a(lambda[mod]/L);
      
      return  std::pow( a*(std::cos(a*x) - std::cosh(a*x) - (std::sin(lambda[mod]) + std::sinh(lambda[mod]))/(std::cos(lambda[mod]) + std::cosh(lambda[mod]))*(-std::sin(a*x)-std::sinh(a*x)) ), pow);
      
    }
  
    T d2flex(const double &x, const int &mod, const std::vector<float> &lambda, const float &L, const int &pow = 1) const
    {// implement the second derivative of flexion shape function for a specific mode
      
      T a(lambda[mod]/L);
      
      return  std::pow( std::pow(a,2) * ( -std::sin(a*x) - std::sinh(a*x) - (std::sin(lambda[mod])+std::sinh(lambda[mod]))/(std::cos(lambda[mod])+std::cosh(lambda[mod])) *(-std::cos(a*x)-std::cosh(a*x)) ), pow);
      
    }
  
    T compress(const double &x, const int &mod, const float &L, const int &pow = 1) const
    {// implement compression shape function for a specific mode

      return  std::pow(std::sin((2*(mod+1)-1)*this->m_pi/2*x/L) ,pow);
      
    }
 
};

#endif