GyotoSimBridge.h

Go to the documentation of this file.

/*
    Copyright 2024 Aimar Nicolas, Irene Urso

    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 __GyotoSimBridge_H_ 
#define __GyotoSimBridge_H_ 

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstring>
#include <string>

#include <GyotoBlackBodySpectrum.h>
#include <GyotoKappaDistributionSynchrotronSpectrum.h>
#include <GyotoPowerLawSynchrotronSpectrum.h>
#include <GyotoThermalSynchrotronSpectrum.h>
#include <GyotoFitsRW.h>
#include <GyotoStandardAstrobj.h>
#include <GyotoMetric.h>

namespace Gyoto{
  namespace Astrobj { class SimBridge; }
}

class Gyoto::Astrobj::SimBridge : public Gyoto::Astrobj::Standard, public FitsRW {
  friend class Gyoto::SmartPointer<Gyoto::Astrobj::SimBridge>;
 
 protected:
  SmartPointer<Spectrum::BlackBody> spectrumBB_; 
  SmartPointer<Spectrum::KappaDistributionSynchrotron> spectrumKappaSynch_; // kappa-distribution synchrotron spectrum
  SmartPointer<Spectrum::PowerLawSynchrotron> spectrumPLSynch_; // PL-distribution synchrotron spectrum
  SmartPointer<Spectrum::ThermalSynchrotron> spectrumThermalSynch_; // Thermal distribution synchrotron spectrum

 private:
  std::string dirname_; 
  std::string fname_; 
  bool temperature_; 
  bool circularmotion_; 
  bool cunninghamvel_; 
  bool BinFile_; 
  std::string emission_; // Type of emission : Black Body or synchrotron from electron distribution (thermal, PL, kappa)
  double PLindex_; 
  double gammaMin_; 
  double gammaMax_; 
  
  double magnetizationParameter_; 
  
  double floortemperature_; 

  int emisInFile_[4]; 
  int absInFile_[4]; 
  int rotInFile_[3]; 

  protected:
  //Number of dimensions (maximum 4D : [t, r, theta, phi] or [t, x, y, z]). When the number of dimension is lower than 4, the array of the complement dimension(s) is of length 1 (in the FITS files headers).
  double* time_array_; 
  double* x1_array_; 
  double* x2_array_; 
  double* x3_array_; 
  double* nu_array_; 

  int ntime_; 
  int nx1_; 
  int nx2_; 
  int nx3_; 
  int nnu_; 

  std::string* boundCond_; 

  // Constructors - Destructor
  // -------------------------
 public:
  GYOTO_OBJECT;

  SimBridge(); 
  
  SimBridge(const SimBridge& ) ;
  virtual SimBridge* clone () const; 
  
  virtual ~SimBridge(); 

  virtual std::string className() const ; 
  virtual std::string className_l() const ; 
  
  // Accessors
  // ---------
 public:
  void directory(std::string const &d); 
  std::string directory() const; 
  void filename(std::string const &d); 
  std::string filename() const; 
  void PLindex(double pl); 
  double PLindex()const; 
  void gammaMin(double gmin); 
  double gammaMin() const; 
  void gammaMax(double gmax); 
  double gammaMax() const; 
  void circularMotion(bool t); 
  bool circularMotion() const; 
  void cunninghamVel(bool t); 
  bool cunninghamVel() const; 
  void floorTemperature(double t); 
  double floorTemperature()const; 
  void magnetization(double ss); 
  double magnetization() const; 
  void boundaryConditions(std::string const &sbc); 
  std::string boundaryConditions() const; 
  void emissionType(std::string const &kind); 
  std::string emissionType() 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 ;

  virtual void radiativeQ(double *Inu, double *Qnu, double *Unu, double *Vnu,
                          Eigen::Matrix4d *Onu, double const *nuem , size_t nbnu, double dsem,
                          state_t const &coord_ph, double const *coord_obj) const ;

  virtual void getVelocity(double const pos[4], double vel[4]);

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

  private:
  int getIndex(double const tcur) const;

};

#endif