GyotoPolishDoughnut.h

Go to the documentation of this file.

/*
    Copyright (c) 2012-2016, 2018-2019 Frederic Vincent, Odele Straub,
                                       Thibaut Paumard

    This file is part of Gyoto.

    Gyoto 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.

    Gyoto 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 Gyoto.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __GyotoPolishDoughnut_H_
#define __GyotoPolishDoughnut_H_

namespace Gyoto{
  namespace Astrobj { class PolishDoughnut; }
 class FactoryMessenger;
}

#include <GyotoStandardAstrobj.h>
#include <GyotoFunctors.h>
#include <GyotoHooks.h>
#include <GyotoThermalBremsstrahlungSpectrum.h>
#include <GyotoThermalSynchrotronSpectrum.h>
#include <GyotoPowerLawSynchrotronSpectrum.h>

class Gyoto::Astrobj::PolishDoughnut
: public Astrobj::Standard,
  protected Gyoto::Hook::Listener
{
  friend class Gyoto::SmartPointer<Gyoto::Astrobj::PolishDoughnut>;

 // Data :
 // -----
protected:
 SmartPointer<Spectrum::ThermalBremsstrahlung> spectrumBrems_;
 SmartPointer<Spectrum::ThermalSynchrotron> spectrumSynch_;
 SmartPointer<Spectrum::PowerLawSynchrotron> spectrumPLSynch_;
 double l0_; 
 double lambda_; 
 double W_surface_; 
 double W_centre_; 
 double r_cusp_; 
 double r_centre_; 
 double r_torusouter_ ; 
 double DeltaWm1_; 
 double central_enthalpy_cgs_; 
 double central_temperature_; 
 double beta_; 
 double magnetizationParameter_; 
 double aa_; 
 double aa2_; 
 size_t spectral_oversampling_;
 bool angle_averaged_; 
 bool bremsstrahlung_; 


 double deltaPL_; 

 bool adaf_; 
 double ADAFtemperature_; 
 double ADAFdensity_; 

 bool changecusp_; 
 bool rochelobefilling_; 
 bool defangmomrinner_; 
 double rintorus_; 

 // Constructors - Destructor
 // -------------------------
public:
 GYOTO_OBJECT; // This object has Properties
 GYOTO_OBJECT_THREAD_SAFETY;
#ifdef GYOTO_USE_XERCES
 // We need to filter some properties when writing XML
 void fillProperty(Gyoto::FactoryMessenger *fmp, Property const &p) const;
#endif
 PolishDoughnut() ; 
 PolishDoughnut(const PolishDoughnut& ) ;                
 virtual  PolishDoughnut* clone() const;
 virtual ~PolishDoughnut() ;                        


 // Mutators / assignment
 // ---------------------
public:
 // Accessors
 // ---------
public:
 double getL0() const; 
 // void   setL0(double l0); set by lambda_

 double lambda() const; 
 void   lambda(double lambda); 

 double centralEnthalpyPerUnitVolume() const; 
 double centralEnthalpyPerUnitVolume(std::string const &unit) const; 
 void   centralEnthalpyPerUnitVolume(double density); 
 void   centralEnthalpyPerUnitVolume(double density, std::string const &unit); 

 double centralTemp() const; 
 void   centralTemp(double val); 

 double beta() const; 
 void   beta(double beta);

 void magnetizationParameter(double rr);
 double magnetizationParameter()const;

 void   spectralOversampling(size_t); 
 size_t spectralOversampling() const ; 

 bool changeCusp() const; 
 void changeCusp(bool t); 
 bool bremsstrahlung() const; 
 void bremsstrahlung(bool brems); 
 bool angleAveraged() const; 
 void angleAveraged(bool komis); 
 void nonThermalDeltaExpo(std::vector<double> const &v);
 std::vector<double> nonThermalDeltaExpo() const;
 void angmomrinner(std::vector<double> const &v);
 std::vector<double> angmomrinner() const;
 void adafparams(std::vector<double> const &v);
 std::vector<double> adafparams() const;
 void adaf(bool t);
 bool adaf() const;
 void setParameter(Gyoto::Property const &p,
                   std::string const & name,
                   std::string const & content,
                   std::string const & unit);

 // Read only members, depend on lambda
 double getWsurface() const; 
 double getWcentre() const; 
 double getRcusp() const; 
 double getRcentre() const; 

 using Standard::metric;
 virtual void metric(Gyoto::SmartPointer<Gyoto::Metric::Generic>);

 // ASTROBJ API
 // -----------
 int Impact(Photon *ph, size_t index,
                            Astrobj::Properties *data);

 virtual double operator()(double const coord[4]) ;

  // ASTROBJ processHitQuantities API
  // --------------------------------
protected:
  virtual void tell(Gyoto::Hook::Teller * msg);
  virtual void getVelocity(double const pos[4], double vel[4]) ;
  using Standard::integrateEmission;

  virtual void integrateEmission(double * I, double const * boundaries,
                                 size_t const * chaninds, size_t nbnu,
                                 double dsem, state_t const &cph, double const *co) const;

  virtual void radiativeQ(double Inu[], double Taunu[], 
                          double const nu_em[], size_t nbnu,
                          double dsem, state_t const &coord_ph,
                          double const coord_obj[8]=NULL) const ;

 // PURELY INTERNAL TO ASTROBJ
 // --------------------------
 private:
  double potential(double r, double theta) const;

  class intersection_t : public Gyoto::Functor::Double_Double_const {
  public:
    intersection_t(PolishDoughnut* parent);
    PolishDoughnut * papa;
    virtual double operator() (double) const;
  };
  friend class intersection_t;

 intersection_t intersection; 

  class outerradius_t : public Gyoto::Functor::Double_Double_const {
  public:
    const PolishDoughnut * papa;
    virtual double operator() (double) const;
  };

 // Outputs
 // -------
 public:

 friend std::ostream& operator<<(std::ostream& , const PolishDoughnut& ) ;

 public:


};

#endif