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_;
 
  // 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;
 
 
  // 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