metric.hpp

/*
    Copyright 2017 Philippe Grandclement
 
    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_HPP_
#define __METRIC_HPP_
#include "metric_tensor.hpp"
#include "vector.hpp" 
#include "scalar.hpp"
 
namespace Kadath {
class Space ;
class Tensor ;
class Term_eq ;
class Metric_tensor ;
class System_of_eqs ;
class Base_tensor ;
 
 
class Metric : public Memory_mapped {
 
    protected:
        const Space& espace ; 
 
        const System_of_eqs* syst ; 
 
        mutable MMPtr_array<Term_eq> p_met_cov ;
        mutable MMPtr_array<Term_eq> p_met_con ;
        mutable MMPtr_array<Term_eq> p_christo ;
        mutable MMPtr_array<Term_eq> p_riemann ;
        mutable MMPtr_array<Term_eq> p_ricci_tensor ;
        mutable MMPtr_array<Term_eq> p_ricci_scalar ;
        mutable MMPtr_array<Term_eq> p_dirac ;
        mutable MMPtr_array<Term_eq> p_det_cov ;
        int type_tensor ; 
        
    protected:
        Metric (const Space&) ; 
        virtual void compute_con (int) const ; 
        virtual void compute_cov (int) const ; 
        virtual void compute_christo (int) const ; 
        virtual void compute_riemann (int) const ; 
        virtual void compute_ricci_tensor (int) const ; 
        virtual void compute_ricci_scalar (int) const ; 
        virtual void compute_dirac (int) const ; 
        virtual void compute_det_cov (int) const ; 
 
    public:
        Metric (const Metric&) ; 
 
        virtual ~Metric() ; 
        virtual void update() ; 
        virtual void update(int dd) ;
 
        virtual void manipulate_ind (Term_eq& so, int ind) const ;
 
        virtual Term_eq derive_partial (int typeder, char nameder, const Term_eq& so) const ;
        virtual Term_eq derive (int typeder, char nameder, const Term_eq& so) const ;
 
        virtual Term_eq derive_flat (int typeder, char nameder, const Term_eq& so) const ;
 
        virtual const Metric* get_background() const ; 
 
        virtual int give_type (int) const ; 
        
        // Extraction :
        const Term_eq* give_term (int typemet, int dd) const ;
        const Term_eq* give_christo (int dd) const ;
        const Term_eq* give_riemann (int dd) const ;
        const Term_eq* give_ricci_tensor (int dd) const ;
        const Term_eq* give_ricci_scalar (int dd) const ;
        const Term_eq* give_dirac (int dd) const ;
        const Term_eq* give_det_cov (int dd) const ;
        
        friend class System_of_eqs ;
        friend class Metric_flat ;
        friend class Metric_dirac ;
        friend class Metric_conf ;
        friend class Domain_nucleus ;
        friend class Domain_shell ;
        friend class Domain_compact ;
        friend class Domain_bispheric_rect ;
        friend class Domain_bispheric_chi_first ;
        friend class Domain_bispheric_eta_first ;
        friend class Domain_shell_outer_adapted ;
        friend class Domain_shell_inner_adapted ;
        friend class Domain_nucleus_symphi ;
        friend class Domain_shell_symphi ;
        friend class Domain_compact_symphi ;
} ;
 
class Metric_flat : public Metric {
 
  protected:
    const Base_tensor& basis ; 
  
    public:
        Metric_flat (const Space& sp, const Base_tensor& bb) ;
        Metric_flat (const Metric_flat& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;      
        virtual void compute_christo (int) const ;
        virtual void compute_ricci_tensor (int) const ;
        virtual void compute_ricci_scalar (int) const ;
    
  private:
    Term_eq derive_partial_spher (int tder, char indder, const Term_eq& so) const ;
    Term_eq derive_partial_cart (int tder, char indder, const Term_eq& so) const ;
 
    Term_eq derive_partial_mtz (int tder, char indder, const Term_eq& so) const ;
 
    Term_eq derive_spher (int tder, char indder, const Term_eq& so) const ;
 
    
    Term_eq derive_cart (int tder, char indder, const Term_eq& so) const ;
 
    Term_eq derive_mtz (int tder, char indder, const Term_eq& so) const ;
 
 
    Term_eq derive_with_other_spher (int tder, char indder, const Term_eq& so, const Metric* othermet) const ;
 
    Term_eq derive_with_other_mtz (int tder, char indder, const Term_eq& so, const Metric* othermet) const ;
 
    Term_eq derive_with_other_cart (int tder, char indder, const Term_eq& so, const Metric* othermet) const ;
    
    public:
        virtual void update() ;
        virtual void update(int) ;
        virtual void manipulate_ind (Term_eq&, int) const ;
        virtual Term_eq derive_partial (int, char, const Term_eq&) const ;
        virtual Term_eq derive (int, char, const Term_eq&) const ;
 
        Term_eq derive_with_other (int tder, char indder, const Term_eq& so, const Metric* othermet) const ;
 
        virtual void set_system (System_of_eqs& syst, const char* name) ;   
        
        virtual int give_type (int) const ;
} ;
 
class Metric_general : public Metric {
 
    protected:
      Metric_tensor* p_met ; 
      const Base_tensor& basis ; 
      Metric_flat fmet ; 
      int place_syst ; 
 
    public:
        Metric_general (Metric_tensor&) ; 
        Metric_general (const Metric_general& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;      
        virtual void compute_christo (int) const ;      
        virtual void compute_riemann (int) const ;      
        virtual void compute_ricci_tensor (int) const ;
        virtual void compute_dirac (int) const ;
    
    public:
        virtual ~Metric_general() ;
        virtual Term_eq derive (int, char, const Term_eq&) const ;
        virtual void set_system (System_of_eqs& syst, const char* name) ;
        virtual Term_eq derive_flat (int, char, const Term_eq&) const ;
        
        virtual int give_type (int) const ;
} ;
class Metric_const : public Metric_general {
 
    public:
        Metric_const (Metric_tensor&) ; 
        Metric_const (const Metric_const& ) ; 
    
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;
 
 
    public:
        virtual ~Metric_const() ;
 
        virtual void set_system (System_of_eqs& syst, const char* name) ;
} ;
 
class Metric_conf : public Metric {
 
    protected:
      Metric_tensor* p_met ; 
      const Base_tensor& basis ;  
      Metric_flat fmet ;  
      int place_syst ; 
 
 
 
    public:
        Metric_conf (Metric_tensor&) ; 
        Metric_conf (const Metric_conf& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;      
        virtual void compute_christo (int) const ;      
        virtual void compute_riemann (int) const ;      
        virtual void compute_ricci_tensor (int) const ;
        virtual void compute_dirac (int) const ;
    
    public:
        virtual ~Metric_conf() ;
        virtual Term_eq derive (int, char, const Term_eq&) const ;  
        virtual void set_system (System_of_eqs& syst, const char* name) ;
        virtual Term_eq derive_flat (int, char, const Term_eq&) const ;
        
        virtual int give_type (int) const ;
} ;
 
 class Metric_dirac : public Metric_conf {
 
    public:
        Metric_dirac (Metric_tensor&) ; 
        Metric_dirac (const Metric_dirac& ) ;
        const Metric_flat& get_fmet () const {return fmet;} ;
 
    protected:
        virtual void compute_ricci_tensor (int) const ;
        virtual void compute_ricci_scalar (int) const ;
        
 
    public:
        virtual ~Metric_dirac() ;
} ;
 
class Metric_dirac_const : public Metric_dirac {
 
    public:
        Metric_dirac_const (Metric_tensor&) ; 
        Metric_dirac_const (const Metric_dirac_const& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;
 
    public:
        virtual ~Metric_dirac_const() ; 
        virtual void set_system (System_of_eqs& syst, const char* name) ;
} ;
 class Metric_harmonic : public Metric_general {
 
    public:
        Metric_harmonic (Metric_tensor&) ; 
        Metric_harmonic (const Metric_harmonic& ) ;
        const Metric_flat& get_fmet () const {return fmet;} ;
 
    protected:
        virtual void compute_ricci_tensor (int) const ;
        virtual void compute_ricci_scalar (int) const ;
        virtual void compute_det_cov (int) const ;
 
    public:
        virtual ~Metric_harmonic() ;
} ;
 
class Metric_conf_factor : public Metric {
 
    protected:
      Metric_tensor* p_met ; 
      const Base_tensor& basis ; 
      Metric_flat fmet ; 
          Scalar conformal ; 
      Vector grad_conf ; 
      int place_syst ; 
 
    public:
        Metric_conf_factor (Metric_tensor&, const Scalar& conf) ; 
        Metric_conf_factor (const Metric_conf_factor& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;      
        virtual void compute_christo (int) const ;      
        virtual void compute_riemann (int) const ;      
        virtual void compute_ricci_tensor (int) const ;
    
    public:
        virtual ~Metric_conf_factor() ;
        virtual Term_eq derive (int, char, const Term_eq&) const ;
        virtual void set_system (System_of_eqs& syst, const char* name) ;
        virtual Term_eq derive_flat (int, char, const Term_eq&) const ;
        
        virtual int give_type (int) const ;
} ;
 
class Metric_conf_factor_const : public Metric_conf_factor {
 
    public:
        Metric_conf_factor_const (Metric_tensor&, const Scalar& conf) ; 
        Metric_conf_factor_const (const Metric_conf_factor_const& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;
 
 
    public:
        virtual ~Metric_conf_factor_const() ;
 
        virtual void set_system (System_of_eqs& syst, const char* name) ;
} ;
 
class Metric_cfc : public Metric {
 
    protected:
      Scalar* p_conf ; 
      const Base_tensor& basis ;  
      Metric_flat fmet ;  
      int place_syst ; 
 
    public:
        Metric_cfc (Scalar&, const Base_tensor&) ; 
        Metric_cfc (const Metric_cfc& ) ; 
 
    protected:
        virtual void compute_con (int) const ;
        virtual void compute_cov (int) const ;          
        virtual void compute_christo (int) const ;      
        virtual void compute_riemann (int) const ;      
        virtual void compute_ricci_tensor (int) const ;
        
    public:
        virtual ~Metric_cfc() ;
 
        virtual void set_system (System_of_eqs& syst, const char* name) ;
        
        virtual Term_eq derive (int, char, const Term_eq&) const ;
        virtual Term_eq derive_flat (int, char, const Term_eq&) const ;
    
        virtual int give_type (int) const ;
} ;
 
 
}
#endif