spheroid.h

/*
 *  Definition of Lorene class Spheroid
 *
 */

/*
 *   Copyright (c) 2006  Nicolas Vasset, Jerome Novak & Jose-Luis Jaramillo
 *
 *   This file is part of LORENE.
 *
 *   LORENE is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   LORENE 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 LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef __SPHEROID_H_ 
#define __SPHEROID_H_ 

/*
 * $Id: spheroid.h,v 1.13 2014/10/13 08:52:36 j_novak Exp $
 * $Log: spheroid.h,v $
 * Revision 1.13  2014/10/13 08:52:36  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.12  2008/12/10 13:53:56  jl_jaramillo
 * versions developed at Meudon in Novemver 2008
 *
 * Revision 1.11  2008/11/12 15:18:32  n_vasset
 * New definition for the computation of Ricci scalar (instead of Ricci
 * tensor previously)
 *
 * Revision 1.10  2008/07/09 08:48:23  n_vasset
 * protected member zeta added.
 *
 * Revision 1.9  2008/06/04 12:31:56  n_vasset
 * new functions multipole_mass and multipole_angu.
 *
 * Revision 1.8  2008/06/03 14:32:23  n_vasset
 * dzpuis corrections (provisory). New function mass implemented.
 *
 * Revision 1.7  2006/09/07 08:39:43  j_novak
 * Minor changes.
 *
 * Revision 1.6  2006/07/03 10:12:51  n_vasset
 * adding of flag isphere
 *
 * Revision 1.5  2006/06/13 08:07:55  n_vasset
 *   Addition of 2 members
 *
 * Revision 1.4  2006/06/08 09:50:49  n_vasset
 * corrected version for coordinates transformation
 *
 * Revision 1.3  2006/06/07 14:32:24  n_vasset
 * modified constructor for 3d projector (Sym_tensor to Tensor)
 *
 * Revision 1.2  2006/05/26 13:25:42  j_novak
 * Removed a 'const'
 *
 * Revision 1.1  2006/05/26 13:20:42  j_novak
 * New class spheroid.
 *
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/spheroid.h,v 1.13 2014/10/13 08:52:36 j_novak Exp $
 *
 */
#include "metric.h"

namespace Lorene {
class Spheroid {


    // Data : 
    // -----
    protected:
        Scalar h_surf ; 

    Tensor jac2d ;

        Tensor proj ;

    Sym_tensor qq ; 
   
        Vector ss ;

    Vector ephi;

    Metric qab ;  

    Scalar ricci; 

    Sym_tensor hh ; 

    Scalar trk ; 

    Vector ll ;  

    Sym_tensor jj ; 

    Scalar fff;

    Scalar ggg;

        /*** */

    Scalar zeta;

        bool issphere ;  


    // Derived data : 
    // ------------
    protected:
    mutable Scalar* p_sqrt_q ; 
    mutable double* p_area ;   
    mutable double* p_angu_mom ; 
    mutable double* p_mass ; 
    mutable double* p_multipole_mass ;
    mutable double* p_multipole_angu ;
    mutable double* p_epsilon_A_minus_one ; 
    mutable double* p_epsilon_P_minus_one ; 
    mutable Scalar* p_theta_plus ; 
    mutable Scalar* p_theta_minus ; 
    mutable Sym_tensor* p_shear ; 
        mutable Tensor* p_delta ; 



    // Constructors - Destructor
    // -------------------------
    public:
    Spheroid(const Map_af& map, double radius) ;  
    Spheroid(const Scalar& h_in, const Metric& gamij, const Sym_tensor& Kij) ;
    Spheroid(const Spheroid& ) ;        

    Spheroid(FILE* ) ;          

    virtual ~Spheroid() ;           
 

    // Memory management
    // -----------------
    protected:
    virtual void del_deriv() const ; 
    
    void set_der_0x0() const ; 


    // Mutators / assignment
    // ---------------------
    public:
    void operator=(const Spheroid&) ;   
    

    void set_ephi(const Scalar&) ; 


    // Accessors
    // ---------
    public:
    const Scalar& get_hsurf() const {return h_surf ; } ;

    const Metric& get_qab() const {return qab ; } ;

    const Scalar& get_ricci() const {return ricci ; } ;

    const Sym_tensor& get_hh() const {return hh ; } ;

    const Sym_tensor& get_qq() const {return qq ; } ;

    const Tensor& get_proj() const {return proj ; } ;

    const Tensor& get_jac2d() const {return jac2d ; } ;

    const Scalar& get_trk() const {return trk; } ;

    const Vector& get_ll() const {return ll;} ;

    const Vector& get_ss() const {return ss;} ;

    const Vector& get_ephi() const {return ephi;};

    const Sym_tensor& get_jj() const {return jj;} ;

    const Scalar& get_fff() const {return fff;} ;
    
    const Scalar& get_ggg() const {return ggg;} ;

    bool get_issphere() const{return issphere;}; 

    Scalar& set_hsurf() {del_deriv() ; return h_surf ; } ;

    Metric& set_qab() {del_deriv() ; return qab ; } ;

    Scalar& set_ricci() {del_deriv() ; return ricci ; } ;

    Sym_tensor& set_qq() {del_deriv() ; return qq ; } ;

    Tensor& set_proj() {del_deriv() ; return proj ; } ;

    Sym_tensor& set_hh() {del_deriv() ; return hh ; } ;

    Scalar& set_trk() {del_deriv() ; return trk; } ;

    Vector& set_ll() {del_deriv() ; return ll;} ;

    Vector& set_ss() {del_deriv() ; return ss;} ;

    Sym_tensor& set_jj() {del_deriv() ; return jj;} ;

    Scalar& set_fff() {del_deriv() ; return fff;} ;

    Scalar& set_ggg() {del_deriv() ; return ggg;} ;

        bool set_issphere() {del_deriv() ; return issphere; };  
      
        void update_from_tslice(const Metric& gamij, const Sym_tensor& Kij) ;
    
    // Computational functions
    // -----------------------
    public:

//  Vector compute_normal(const Metric& gamij) ;

    const Scalar& sqrt_q() const ;

    double area() const ;

    double angu_mom() const ;

    double mass() const;

    double multipole_mass(const int order) const;


    double multipole_angu(const int order) const;



        double epsilon_A_minus_one() const;

    double epsilon_P_minus_one() const;

        const Scalar& theta_plus() const ;

    const Scalar& theta_minus() const ;

    const Sym_tensor& shear () const ;

 
    Tensor derive_cov2dflat(const Tensor& uu) const ; 

  
    const Tensor& delta() const; 

 
    Tensor derive_cov2d(const Tensor& uu) const ; 

    // Outputs
    // -------
    public:
    virtual void sauve(FILE *) const ;      
    
    friend ostream& operator<<(ostream& , const Spheroid& ) ;   

};

ostream& operator<<(ostream& , const Spheroid& ) ;

 //------------------
 //  Class App_hor
 //------------------

class App_hor : public Spheroid {

    // Constructors - Destructor
    // -------------------------
    public:
    App_hor(const Mg3d& grid_angu, double radius) ;  

    App_hor(const Scalar& h_in, const Metric& gamij, const Sym_tensor& Kij) ;
    App_hor(const App_hor& ) ;      

    App_hor(FILE* ) ;           
       
    virtual ~App_hor() ;            
 
    // Mutators / assignment
    // ---------------------
    public:
    void operator=(const App_hor&) ;

    bool check_expansion(double thres = 1.e-7) const ;

    const Sym_tensor& lie_derive_shear(const Scalar& bb, const Scalar& lapse) ;

    const Sym_tensor& lie_derive_theta_plus(const Scalar& bb, const Scalar& lapse);

    const Sym_tensor& lie_derive_theta_minus(const Scalar& bb, const Scalar& lapse);

    const Sym_tensor& lie_derive_q_ab(const Scalar& bb, const Scalar& lapse) ;

    const Scalar& l_non_affinity(const Scalar& bb, const Scalar& lapse) ;
        
} ;
    

}
#endif