GyotoPhoton.h

Go to the documentation of this file.

/*
    Copyright 2011-2016 Frederic Vincent, 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 __GyotoPhoton_H_ 
#define __GyotoPhoton_H_ 

#include "GyotoFunctors.h"

namespace Gyoto{
  class Photon;
  namespace Astrobj { class Generic; }
}

#include <GyotoDefs.h>
#include <GyotoMetric.h>
#include <GyotoScreen.h>
#include <GyotoWorldline.h>
#include <GyotoObject.h>

#include <float.h>

class Gyoto::Photon
: public Gyoto::Worldline,
  public Gyoto::SmartPointee,
  public Gyoto::Object
{
  friend class Gyoto::SmartPointer<Gyoto::Photon>;
  // Data : 
  // -----

 protected:

  SmartPointer<Gyoto::Astrobj::Generic> object_;


  double freq_obs_;


  double transmission_freqobs_;


  SmartPointer<Spectrometer::Generic> spectro_;


  double * transmission_;

  int nb_cross_eqplane_;

  // Constructors - Destructor
  // -------------------------

 public:
  GYOTO_OBJECT;
  GYOTO_OBJECT_THREAD_SAFETY;
  GYOTO_WORLDLINE;
  virtual std::string className() const ; 
  virtual std::string className_l() const ; 

  Photon() ; 
  Photon(const Photon& ) ;                
  Photon* clone() const ; 
 protected:  
  Photon(Photon* orig, size_t i0, int dir, double step_max);
 public:
  Photon(SmartPointer<Metric::Generic> gg, SmartPointer<Astrobj::Generic> obj, 
         double* coord) ;

  Photon(SmartPointer<Metric::Generic> gg, SmartPointer<Astrobj::Generic> obj, 
         SmartPointer<Screen> screen, double d_alpha, double d_delta);

  virtual ~Photon() ;                        
  
  virtual double getMass() const ; 

  void astrobj(SmartPointer<Astrobj::Generic>);
  SmartPointer<Astrobj::Generic> astrobj() const ;

  using Worldline::metric;
  // Set Worldline::metric_ as well as the Astrobj metric
  void metric(SmartPointer<Metric::Generic>);


  void spectrometer(SmartPointer<Spectrometer::Generic> spr);
  SmartPointer<Spectrometer::Generic> spectrometer() const ;

  void freqObs(double);
  double freqObs() const;

  void nb_cross_eqplane(int);
  int nb_cross_eqplane() const;


  // Mutators / assignment
  // ---------------------
 public:
  using Worldline::setInitialCondition;


  void setInitialCondition(SmartPointer<Metric::Generic> gg,
                           SmartPointer<Astrobj::Generic> obj,
                           const double coord[8]) ;


  void setInitialCondition(SmartPointer<Metric::Generic> gg,
                           SmartPointer<Astrobj::Generic> obj,
                           const double coord[8],
                           const double Ephi[4],
                           const double Etheta[4]) ;


  void setInitialCondition(SmartPointer<Metric::Generic> gg,
                           SmartPointer<Astrobj::Generic> obj,
                           SmartPointer<Screen> screen,
                           double d_alpha,
                           double d_delta);


  int hit(Astrobj::Properties *data=NULL);

  double findMin(Functor::Double_constDoubleArray* object,
                 double t1, double t2, double &tmin,
                 double threshold = DBL_MIN) ;


  void findValue(Functor::Double_constDoubleArray* object,
                 double value,
                 double tinside, double &toutside) ;

#ifdef GYOTO_USE_XERCES
  virtual void setParameters(FactoryMessenger *fmp) ;
  static SmartPointer<Photon> Subcontractor(Gyoto::FactoryMessenger*);
#endif

    /* transmission stuff */
 public:
  void resetTransmission() ;


  double getTransmission(size_t i) const ;


  double getTransmissionMax() const ;


  double const * getTransmission() const ;


  virtual void transmit(size_t i, double t);

  virtual void transfer(double * Inu, double * Qnu, double * Unu, double * Vnu,
                        double const * aInu, double const * aQnu,
                        double const * aUnu, double const * aVnu,
                        double const * rQnu, double const * rUnu, double const * rVnu) ;

 private:
  void _allocateTransmission();

 public:
  class Refined;

};

class Gyoto::Photon::Refined : public Gyoto::Photon {
 protected:
  Photon * parent_; 
 public:
  Refined(Photon *parent, size_t i, int dir, double step_max);
  virtual void transmit(size_t i, double t);
  virtual void transfer(double * Inu, double * Qnu, double * Unu, double * Vnu,
                        double const * aInu, double const * aQnu,
                        double const * aUnu, double const * aVnu,
                        double const * rQnu, double const * rUnu, double const * rVnu) ;
};


#endif