metric_AADS.hpp

/*
    Copyright 2017 Gregoire Martinon
 
    This file is part of Kadath.
 
    Kadath 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.
 
    Kadath 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 Kadath.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef __METRIC__AADS_HPP_
#define __METRIC__AADS_HPP_
#include "metric.hpp"
#include "scalar.hpp"
#include "space.hpp"
#include "system_of_eqs.hpp"
#include "tensor.hpp"
#include "term_eq.hpp"
#include "name_tools.hpp"
#include "metric_tensor.hpp"
#include "base_tensor.hpp"
#include "vector.hpp"
#include <cmath>
#include <vector>
#include <string>
#include "gsl/gsl_permutation.h"
 
namespace Kadath {
using std::vector;
 
class Metric_ADS : public Metric
{
   protected :
      int m_nd;             
      double m_L;           
      Scalar m_rho2;        
      Scalar m_eps;         
      Base_tensor* p_basis; 
 
   public:
      Metric_ADS(const Space& space); 
      Metric_ADS(const Metric_ADS& so); 
      virtual void manipulate_ind(Term_eq& so, int ind) const;  
      virtual Term_eq derive(int type_der, char ind_der, const Term_eq&) const;
      virtual void set_system(System_of_eqs& syst, const char* name);
      virtual ~Metric_ADS();                               
 
   protected:
      virtual void compute_cov(int d) const;
      virtual void compute_con(int d) const;
      virtual void compute_christo(int d) const;
      virtual void compute_riemann(int d) const;
      virtual void compute_ricci_tensor(int d) const;
      virtual void compute_ricci_scalar(int d) const;
      virtual void update(int d);                  
      virtual void update();
    
      void init_system(System_of_eqs& syst, const char* name_back_cov, const char* name_back_con, const char* name_back_ricci);  // put the covariant and contravariant metric in cst of the system
      void init_system(System_of_eqs& syst, const char* name_back_cov, const char* name_back_con, const char* name_back_gam, const char* name_back_ricci);  // put the covariant and contravariant metric in cst of the system
 
   private:
 
      Term_eq derive_simple(const Term_eq& so) const;
 
      Term_eq div_eps(Term_eq& so, int n) const;
 
      Term_eq mul_eps(Term_eq& so, int n) const;
 
   friend class Metric_AADS;
};
 
 
class Metric_AADS : public Metric
{
   protected:
      int m_nd;                      
      int m_place_syst;              
      double m_L;                    
      mutable bool m_doder;          
      Metric_ADS m_ads;              
      Metric_tensor* p_hmet;         
      Vector* p_der_eps;             
      Base_tensor* p_basis;          
 
   private:
      mutable Term_eq** p_h;         
      mutable Term_eq** p_k;         
 
      Term_eq derive_simple(const Term_eq& so) const;
 
   public:
      Metric_AADS(const Space& space, Metric_tensor& hmet); 
      Metric_AADS(const Metric_AADS& so);            
      virtual void manipulate_ind(Term_eq& so, int ind) const;  
      virtual Term_eq derive(int type_der, char ind_der, const Term_eq& so) const;
 
      void set_system(System_of_eqs& syst, const char* name_met, const char* name_hmet);
      void set_system(System_of_eqs& syst, const char* name_met, const char* name_hmet, const char* name_back_cov, const char* name_back_con, const char* name_back_ricci); 
      void set_system(System_of_eqs& syst, const char* name_met, const char* name_hmet, const char* name_back_cov, const char* name_back_con, const char* name_back_gam, const char* name_back_ricci); 
 
      virtual const Metric* get_background() const;                    
      virtual ~Metric_AADS();                               
 
   protected:
      virtual void compute_cov(int d) const;
      virtual void compute_con(int d) const;
      virtual void compute_christo(int d) const;      
      virtual void compute_ricci_tensor(int d) const;
      virtual void compute_ricci_scalar(int d) const;
 
      virtual void update(int d);                     
      virtual void update();                        
};
}
#endif