et_bin_bhns_extr_hydro.C

/*
 *  Methods of the class Et_bin_bhns_extr for computing hydro quantities
 *  in the Kerr-Schild background metric or in the conformally flat one
 *  with extreme mass ratio
 *
 *    (see file et_bin_bhns_extr.h for documentation).
 *
 */
 
/*
 *   Copyright (c) 2004-2005 Keisuke Taniguchi
 *
 *   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
 *
 */
 
 
 
/*
 * $Id: et_bin_bhns_extr_hydro.C,v 1.4 2016/12/05 16:17:52 j_novak Exp $
 * $Log: et_bin_bhns_extr_hydro.C,v $
 * Revision 1.4  2016/12/05 16:17:52  j_novak
 * Suppression of some global variables (file names, loch, ...) to prevent redefinitions
 *
 * Revision 1.3  2014/10/13 08:52:55  j_novak
 * Lorene classes and functions now belong to the namespace Lorene.
 *
 * Revision 1.2  2005/02/28 23:14:16  k_taniguchi
 * Modification to include the case of the conformally flat background metric
 *
 * Revision 1.1  2004/11/30 20:49:34  k_taniguchi
 * *** empty log message ***
 *
 *
 * $Header: /cvsroot/Lorene/C++/Source/Etoile/et_bin_bhns_extr_hydro.C,v 1.4 2016/12/05 16:17:52 j_novak Exp $
 *
 */
 
// Lorene headers
#include "et_bin_bhns_extr.h"
#include "etoile.h"
#include "coord.h"
#include "unites.h"
 
namespace Lorene {
void Et_bin_bhns_extr::hydro_euler_extr(const double& mass,
                    const double& sepa) {
 
  using namespace Unites ;
 
    if (kerrschild) {
 
        int nz = mp.get_mg()->get_nzone() ;
    int nzm1 = nz - 1 ;
 
    //--------------------------------
    // Specific relativistic enthalpy           ---> hhh
    //--------------------------------
 
    Tenseur hhh = exp(unsurc2 * ent) ;  // = 1 at the Newtonian limit
    hhh.set_std_base() ;
 
    //----------------------------------------
    // Lorentz factor between the co-orbiting             ---> gam0
    // observer and the Eulerian one
    //----------------------------------------
 
    const Coord& xx = mp.x ;
    const Coord& yy = mp.y ;
    const Coord& zz = mp.z ;
 
    Tenseur r_bh(mp) ;
    r_bh.set_etat_qcq() ;
    r_bh.set() = pow( (xx+sepa)*(xx+sepa) + yy*yy + zz*zz, 0.5) ;
    r_bh.set_std_base() ;
 
    Tenseur xx_cov(mp, 1, COV, ref_triad) ;
    xx_cov.set_etat_qcq() ;
    xx_cov.set(0) = xx + sepa ;
    xx_cov.set(1) = yy ;
    xx_cov.set(2) = zz ;
    xx_cov.set_std_base() ;
 
    Tenseur xsr_cov(mp, 1, COV, ref_triad) ;
    xsr_cov = xx_cov / r_bh ;
    xsr_cov.set_std_base() ;
 
    Tenseur msr(mp) ;
    msr = ggrav * mass / r_bh ;
    msr.set_std_base() ;
 
    Tenseur tmp1(mp) ;
    tmp1.set_etat_qcq() ;
    tmp1.set() = 0 ;
    tmp1.set_std_base() ;
 
    for (int i=0; i<3; i++)
        tmp1.set() += xsr_cov(i) % bsn(i) ;
 
    tmp1.set_std_base() ;
 
    Tenseur tmp2 = 2.*msr % tmp1 % tmp1 ;
    tmp2.set_std_base() ;
 
    for (int i=0; i<3; i++)
        tmp2.set() += bsn(i) % bsn(i) ;
 
    tmp2 = a_car % tmp2 ;
 
    Tenseur gam0 = 1 / sqrt( 1 - unsurc2*tmp2 ) ;
    gam0.set_std_base() ;
 
    //--------------------------------------------
    // Lorentz factor and 3-velocity of the fluid
    //  with respect to the Eulerian observer
    //--------------------------------------------
 
    if (irrotational) {
 
        d_psi.set_std_base() ;
 
        Tenseur xx_con(mp, 1, CON, ref_triad) ;
        xx_con.set_etat_qcq() ;
        xx_con.set(0) = xx + sepa ;
        xx_con.set(1) = yy ;
        xx_con.set(2) = zz ;
        xx_con.set_std_base() ;
 
        Tenseur xsr_con(mp, 1, CON, ref_triad) ;
        xsr_con = xx_con / r_bh ;
        xsr_con.set_std_base() ;
 
        Tenseur tmp3(mp) ;
        tmp3.set_etat_qcq() ;
        tmp3.set() = 0 ;
        tmp3.set_std_base() ;
 
        for (int i=0; i<3; i++)
            tmp3.set() += xsr_con(i) % d_psi(i) ;
 
        tmp3.set_std_base() ;
 
        Tenseur tmp4 = -2.*msr % tmp3 % tmp3 / (1.+2.*msr) ;
        tmp4.set_std_base() ;
 
        for (int i=0; i<3; i++)
            tmp4.set() += d_psi(i) % d_psi(i) ;
 
        tmp4 = tmp4 / a_car ;
 
        gam_euler = sqrt( 1 + unsurc2 * tmp4 / (hhh%hhh) ) ;
 
        gam_euler.set_std_base() ;  // sets the standard spectral bases
                                    // for a scalar field
 
        Tenseur vtmp1 = d_psi / ( hhh % gam_euler % a_car ) ;
                    // COV (a_car correction) -> CON
        Tenseur vtmp2 = -2.* msr % tmp3 % xsr_con / (1.+2.*msr)
          / ( hhh % gam_euler % a_car ) ;
                    // CON
 
        // The assignment of u_euler is performed component by component
        //  because u_euler is contravariant and d_psi is covariant
        if (vtmp1.get_etat() == ETATZERO) {
            u_euler.set_etat_zero() ;
        }
        else {
            assert(vtmp1.get_etat() == ETATQCQ) ;
        u_euler.set_etat_qcq() ;
        for (int i=0; i<3; i++) {
            u_euler.set(i) = vtmp1(i) + vtmp2(i) ;
        }
        u_euler.set_triad( *(vtmp1.get_triad()) ) ;
        }
 
        u_euler.set_std_base() ;
 
    }
    else {          // Rigid rotation
                    // --------------
 
        gam_euler = gam0 ;
        gam_euler.set_std_base() ;  // sets the standard spectral bases
                                    // for a scalar field
 
        u_euler = - bsn ;
 
    }
 
    //--------------------------------------------------------
    // Energy density E with respect to the Eulerian observer
    //--------------------------------------------------------
 
    ener_euler = gam_euler % gam_euler % ( ener + press ) - press ;
 
    //------------------------------------------------------------------
    // Trace of the stress tensor with respect to the Eulerian observer
    //------------------------------------------------------------------
 
    Tenseur stmp1(mp) ;
    stmp1.set_etat_qcq() ;
    stmp1.set() = 0 ;
    stmp1.set_std_base() ;
 
    for (int i=0; i<3; i++)
        stmp1.set() += xsr_cov(i) % u_euler(i) ;
 
    stmp1.set_std_base() ;
 
    Tenseur stmp2 = 2.*msr % stmp1 % stmp1 ;
    stmp2.set_std_base() ;
 
    for (int i=0; i<3; i++)
        stmp2.set() += u_euler(i) % u_euler(i) ;
 
    stmp2 = a_car % stmp2 ;
 
    s_euler = 3 * press + ( ener_euler + press ) * stmp2 ;
    s_euler.set_std_base() ;
 
    //--------------------------------------
    // Lorentz factor between the fluid and     ---> gam
    //  co-orbiting observers
    //--------------------------------------
 
    Tenseur gtmp = 2.*msr % tmp1 % stmp1 ;  //<- bsn^i = - U_0^i
    gtmp.set_std_base() ;
 
    for (int i=0; i<3; i++)
        gtmp.set() += bsn(i) % u_euler(i) ; //<- bsn^i = - U_0^i
 
    gtmp = a_car % gtmp ;
 
    Tenseur tmp = ( 1+unsurc2*gtmp ) ; //<- (minus->plus) because of U_0^i
    tmp.set_std_base() ;
    Tenseur gam = gam0 % gam_euler % tmp ;
 
    //--------------------------------------------
    // Spatial projection of the fluid 3-velocity
    //  with respect to the co-orbiting observer
    //--------------------------------------------
 
    wit_w = gam_euler / gam % u_euler + gam0 % bsn ;
 
    wit_w.set_std_base() ;  // set the bases for spectral expansions
 
    wit_w.annule(nzm1) ;    // zero in the ZEC
 
    //-----------------------------------------
    // Logarithm of the Lorentz factor between
    //  the fluid and co-orbiting observers
    //-----------------------------------------
 
    if (relativistic) {
 
        loggam = log( gam ) ;
        loggam.set_std_base() ;   // set the bases for spectral expansions
 
    }
    else {
        cout << "BH-NS binary systems should be relativistic !!!" << endl ;
        abort() ;
    }
 
    //-------------------------------------------------
    // Velocity fields set to zero in external domains
    //-------------------------------------------------
 
    loggam.annule(nzm1) ;       // zero in the ZEC only
 
    wit_w.annule(nzm1) ;        // zero outside the star
 
    u_euler.annule(nzm1) ;      // zero outside the star
 
    if (loggam.get_etat() != ETATZERO) {
        (loggam.set()).set_dzpuis(0) ;
    }
 
    if (!irrotational) {
 
        gam = 1 ;
        loggam = 0 ;
        wit_w = 0 ;
 
    }
 
    // The derived quantities are obsolete
    // -----------------------------------
 
    Etoile_bin::del_deriv() ;
 
    }
    else {
 
        int nz = mp.get_mg()->get_nzone() ;
    int nzm1 = nz - 1 ;
 
    //--------------------------------
    // Specific relativistic enthalpy           ---> hhh
    //--------------------------------
 
    Tenseur hhh = exp(unsurc2 * ent) ;  // = 1 at the Newtonian limit
    hhh.set_std_base() ;
 
    //----------------------------------------
    // Lorentz factor between the co-orbiting             ---> gam0
    // observer and the Eulerian one
    //----------------------------------------
 
    Tenseur gam0 = 1 / sqrt( 1 - unsurc2*sprod(bsn, bsn) ) ;
    gam0.set_std_base() ;
 
    //--------------------------------------------
    // Lorentz factor and 3-velocity of the fluid
    //  with respect to the Eulerian observer
    //--------------------------------------------
 
    if (irrotational) {
 
        d_psi.set_std_base() ;
 
        gam_euler = sqrt( 1 + unsurc2 * sprod(d_psi, d_psi)
                  / (hhh%hhh) ) ;
 
        gam_euler.set_std_base() ;  // sets the standard spectral bases
                                    // for a scalar field
 
        Tenseur vtmp = d_psi / ( hhh % gam_euler % a_car ) ;
                    // COV (a_car correction) -> CON
 
        // The assignment of u_euler is performed component by component
        //  because u_euler is contravariant and d_psi is covariant
        if (vtmp.get_etat() == ETATZERO) {
            u_euler.set_etat_zero() ;
        }
        else {
            assert(vtmp.get_etat() == ETATQCQ) ;
        u_euler.set_etat_qcq() ;
        for (int i=0; i<3; i++) {
            u_euler.set(i) = vtmp(i) ;
        }
        u_euler.set_triad( *(vtmp.get_triad()) ) ;
        }
 
        u_euler.set_std_base() ;
 
    }
    else {          // Rigid rotation
                    // --------------
 
        gam_euler = gam0 ;
        gam_euler.set_std_base() ;  // sets the standard spectral bases
                                    // for a scalar field
 
        u_euler = - bsn ;
 
    }
 
    //--------------------------------------------------------
    // Energy density E with respect to the Eulerian observer
    //--------------------------------------------------------
 
    ener_euler = gam_euler % gam_euler % ( ener + press ) - press ;
 
    //------------------------------------------------------------------
    // Trace of the stress tensor with respect to the Eulerian observer
    //------------------------------------------------------------------
 
    s_euler = 3 * press + ( ener_euler + press )
      * sprod(u_euler, u_euler) ;
    s_euler.set_std_base() ;
 
    //--------------------------------------
    // Lorentz factor between the fluid and     ---> gam
    //  co-orbiting observers
    //--------------------------------------
 
    Tenseur tmp = ( 1+unsurc2*sprod(bsn, u_euler) ) ;
                                    //<- (minus->plus) because of U_0^i
    tmp.set_std_base() ;
    Tenseur gam = gam0 % gam_euler % tmp ;
 
    //--------------------------------------------
    // Spatial projection of the fluid 3-velocity
    //  with respect to the co-orbiting observer
    //--------------------------------------------
 
    wit_w = gam_euler / gam % u_euler + gam0 % bsn ;
 
    wit_w.set_std_base() ;  // set the bases for spectral expansions
 
    wit_w.annule(nzm1) ;    // zero in the ZEC
 
    //-----------------------------------------
    // Logarithm of the Lorentz factor between
    //  the fluid and co-orbiting observers
    //-----------------------------------------
 
    if (relativistic) {
 
        loggam = log( gam ) ;
        loggam.set_std_base() ;  // set the bases for spectral expansions
 
    }
    else {
        cout << "BH-NS binary systems should be relativistic !!!" << endl ;
        abort() ;
    }
 
    //-------------------------------------------------
    // Velocity fields set to zero in external domains
    //-------------------------------------------------
 
    loggam.annule(nzm1) ;       // zero in the ZEC only
 
    wit_w.annule(nzm1) ;        // zero outside the star
 
    u_euler.annule(nzm1) ;      // zero outside the star
 
    if (loggam.get_etat() != ETATZERO) {
        (loggam.set()).set_dzpuis(0) ;
    }
 
    if (!irrotational) {
 
        gam = 1 ;
        loggam = 0 ;
        wit_w = 0 ;
 
    }
 
    // The derived quantities are obsolete
    // -----------------------------------
 
    Etoile_bin::del_deriv() ;
 
    }
 
}
}