Coeff2Hermite.h

Go to the documentation of this file.

/* This file is part of MoDELib, the Mechanics Of Defects Evolution Library.
 *
 *
 * MoDELib is distributed without any warranty under the 
 * GNU General Public License (GPL) v2 <http://www.gnu.org/licenses/>.
 */
 
/**********************************************************************************************************************/
/**********************************************************************************************************************/
#ifndef model_COEFF2HERMITE_H_
#define model_COEFF2HERMITE_H_
 
#include <Eigen/Dense>
#include <CTM.h>
#include <PermutationWithoutRepetition.h>
 
namespace model {
        
        
        /* FillC2H0 *******************************************************************************/
        // case i,j
        template<short unsigned int P,short unsigned int i, short unsigned int j>
        struct FillC2H0 : public FillC2H0<P,i,j-1>{             
                FillC2H0(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H0) : FillC2H0<P,i,j-1>::FillC2H0(C2H0){
                                C2H0(i,j) = 0.0;
                }
        };
        
        // case i,i
        template<short unsigned int P,short unsigned int i>
        struct FillC2H0<P,i,i> : public FillC2H0<P,i,i-1>{
                enum {j=i};
                FillC2H0(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H0) : FillC2H0<P,i,j-1>::FillC2H0(C2H0){
                                C2H0(i,j) = CTM::factorial(i);
                }
        };
        
        // case i,0, i!=0
        template<short unsigned int P,short unsigned int i>
        struct FillC2H0<P,i,0> : public FillC2H0<P,i-1,P>{
                enum {j=0};             
                FillC2H0(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H0) : FillC2H0<P,i-1,P>::FillC2H0(C2H0){
                                C2H0(i,j) = 0.0;
                }
        };
        
        // case i=j=0
        template<short unsigned int P>
        struct FillC2H0<P,0,0>{
                enum {i=0};
                enum {j=0};             
                FillC2H0(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H0){
                                C2H0(i,j) = CTM::factorial(i);
                }
        };
        
        /* FillC2H1 *******************************************************************************/
        // case i,j
        template<short unsigned int P,short unsigned int i, short unsigned int j>
        struct FillC2H1 : public FillC2H1<P,i,j-1>{             
                FillC2H1(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H1) : FillC2H1<P,i,j-1>::FillC2H1(C2H1){
                        C2H1(i,j) = PermutationWithoutRepetition<i>::value(j)*(j>=i);
                }
        };
        
        // case i,0, i!=0
        template<short unsigned int P,short unsigned int i>
        struct FillC2H1<P,i,0> : public FillC2H1<P,i-1,P>{
                enum {j=0};             
                FillC2H1(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H1) : FillC2H1<P,i-1,P>::FillC2H1(C2H1){
                        C2H1(i,j) = PermutationWithoutRepetition<i>::value(j)*(j>=i);
                }
        };
        
        // case i=j=0
        template<short unsigned int P>
        struct FillC2H1<P,0,0>{
                enum {i=0, j=0};        
                FillC2H1(Eigen::Matrix<double,(P+1)/2,(P+1)>& C2H1){
                        C2H1(i,j) = PermutationWithoutRepetition<i>::value(j)*(j>=i);
                }
        };
        
 
        /**********************************************************************************************************************/
        /* Coeff2Hermite<polyDegree> class template ***************************************************************************/
        /**********************************************************************************************************************/
 
        template<short unsigned int polyDegree>
        class Coeff2Hermite{
                                
                enum {polyCoeff=polyDegree+1};
                
                static Eigen::Matrix<double,polyCoeff,polyCoeff> get_C2H(){
                        Eigen::Matrix<double,polyCoeff/2,polyCoeff> temp0;
                        FillC2H0<polyDegree,(polyDegree-1)/2,polyDegree> FH0(temp0);
 
                        Eigen::Matrix<double,polyCoeff/2,polyCoeff> temp1;
                        FillC2H1<polyDegree,(polyDegree-1)/2,polyDegree> FH1(temp1);
                        
                        Eigen::Matrix<double,polyCoeff,polyCoeff> temp;
                        temp<<temp0,temp1;
                        return temp;
                }
                
        public:
 
                static const Eigen::Matrix<double,polyDegree+1,polyDegree+1> C2H;
                static const Eigen::Matrix<double,polyDegree+1,polyDegree+1> C2HT;
 
                static const Eigen::Matrix<double,polyDegree+1,polyDegree+1> H2C;
                static const Eigen::Matrix<double,polyDegree+1,polyDegree+1> H2CT;
 
                
                /* c2h ***********************************************************/
                template<short unsigned int dim>
                static Eigen::Matrix<double,dim,polyCoeff> c2h(const Eigen::Matrix<double,dim,polyCoeff>& C){
                        return C*C2HT;
                }
                
 
                /* h2c ***********************************************************/
                template<short unsigned int dim>
                static Eigen::Matrix<double,dim,polyCoeff> h2c(const Eigen::Matrix<double,dim,polyCoeff>& H){
                        return H*H2CT;
                }
        
        };
 
        /*************************************************************/
        // Static const data members are computed only once at runtime
        template<short unsigned int polyDegree>
        const Eigen::Matrix<double,polyDegree+1,polyDegree+1> Coeff2Hermite<polyDegree>::C2H =Coeff2Hermite<polyDegree>::get_C2H();
 
        template<short unsigned int polyDegree>
        const Eigen::Matrix<double,polyDegree+1,polyDegree+1> Coeff2Hermite<polyDegree>::C2HT=Coeff2Hermite<polyDegree>::get_C2H().transpose();
 
        template<short unsigned int polyDegree>
        const Eigen::Matrix<double,polyDegree+1,polyDegree+1> Coeff2Hermite<polyDegree>::H2C =Coeff2Hermite<polyDegree>::get_C2H().inverse();
 
        template<short unsigned int polyDegree>
        const Eigen::Matrix<double,polyDegree+1,polyDegree+1> Coeff2Hermite<polyDegree>::H2CT=Coeff2Hermite<polyDegree>::get_C2H().inverse().transpose();       
        
}// namespace model
#endif
/**********************************************************************************************************************/
/**********************************************************************************************************************/