GyotoScenery.h

Go to the documentation of this file.

/*
    Copyright 2011-2016, 2018-2019 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 __GyotoScenery_H_ 
#define __GyotoScenery_H_ 

namespace Gyoto{
  class Scenery;
}

#include <GyotoDefs.h>
#include <GyotoSmartPointer.h>
#include <GyotoObject.h>
#include <GyotoAstrobj.h>
#include <GyotoMetric.h>
#include <GyotoScreen.h>
#include <GyotoPhoton.h>
#include <GyotoConverters.h>

#ifdef HAVE_MPI
#include "GyotoFactory.h"
#include <boost/mpi/environment.hpp>
#include <boost/mpi/communicator.hpp>
#endif


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

  SmartPointer<Screen> screen_;


  double delta_; // default integration step for the photons


  Gyoto::Quantity_t quantities_;

  Gyoto::Photon ph_; 

  size_t nthreads_; 

  int nprocesses_; 

# ifdef HAVE_UDUNITS
  Gyoto::SmartPointer<Gyoto::Units::Converter> intensity_converter_;
  Gyoto::SmartPointer<Gyoto::Units::Converter> spectrum_converter_;
  Gyoto::SmartPointer<Gyoto::Units::Converter> binspectrum_converter_;
# endif

 public:
  GYOTO_OBJECT_THREAD_SAFETY;
# ifdef HAVE_MPI

  boost::mpi::communicator * mpi_team_;
# endif
  static bool am_worker;


  void mpiSpawn(int nbchildren);

  void mpiTerminate ();


  void mpiClone();

  enum mpi_tag {give_task, read_scenery, terminate,
                raytrace, raytrace_done, ready,
                impactcoords, noimpactcoords};

  void mpiTask(mpi_tag &tag);


  static void mpiWorker();

  // Constructors - Destructor
  // -------------------------
 public:
  GYOTO_OBJECT;
  GYOTO_WORLDLINE;
  Scenery(); 
  Scenery (const Scenery& o); 
  Scenery * clone() const; 


  Scenery(SmartPointer<Metric::Generic>, SmartPointer<Screen>, SmartPointer<Astrobj::Generic>);
  
  ~Scenery();

  // Mutators / assignment
  // ---------------------
 public:
  // Accessors
  // ---------
  SmartPointer<Metric::Generic> metric() const; 

  void metric(SmartPointer<Metric::Generic>);  
  SmartPointer<Screen> screen() const; 

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

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


  SmartPointer<Photon> clonePhoton() const; 

  SmartPointer<Photon> clonePhoton(size_t i, size_t j);

  SmartPointer<Photon> clonePhoton(double a, double d);

  void updatePhoton(); 

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

  void initCoord(std::vector<double> c);
  std::vector<double> initCoord() const;



  void setRequestedQuantities(Quantity_t quant) ;


  void requestedQuantitiesString(std::string const &squant) ;

  Quantity_t getRequestedQuantities() const ;

  std::string requestedQuantitiesString() const ;


  size_t getScalarQuantitiesCount(Quantity_t *q=NULL) const ;


  size_t getSpectralQuantitiesCount(Quantity_t *q=NULL) const ;

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

  void adaptive (bool mode) ; 
  bool adaptive () const ; 

  void integrator(std::string type);
  std::string integrator() const;

  double deltaMin() const;
  void deltaMin(double h1);

  double deltaMax() const;

  void deltaMax(double h1);

  double deltaMaxOverR() const;
  void deltaMaxOverR(double t);

  void absTol(double);
  double absTol()const;
  void relTol(double);
  double relTol()const;

  void maxCrossEqplane(double);
  double maxCrossEqplane()const;
  
  void secondary (bool sec) ; 
  bool secondary () const ; 

  void integ31(bool integ); 
  bool integ31() const ; 

  void parallelTransport (bool pt) ; 
  bool parallelTransport () const ; 

  void maxiter (size_t miter) ; 
  size_t maxiter () const ; 

  void nThreads(size_t); 
  size_t nThreads() const ; 

  void nProcesses(size_t); 
  size_t nProcesses() const ; 

  void intensityConverter(std::string unit);
  void spectrumConverter(std::string unit);
  void binSpectrumConverter(std::string unit);


  void setPropertyConverters(Gyoto::Astrobj::Properties *prop);

  // Worker:
 public:

  void rayTrace(
#ifdef GYOTO_SWIGIMPORTED
                Coord2dSet & ij,
#else
                Screen::Coord2dSet & ij,
#endif
                Astrobj::Properties *data,
                double * impactcoords=NULL);


  void operator() (size_t i, size_t j, Astrobj::Properties *data,
                   double * impactcoords = NULL, Photon * ph = NULL);


  void operator() (double alpha, double delta, Astrobj::Properties *data,
                   Photon * ph = NULL);

#ifdef GYOTO_USE_XERCES
 public:
  // Override fillProperty() to issue InitCoord only if it was set
  void fillProperty(FactoryMessenger *fmp, Property const &p) const ;
  // Override fillElement to fill metric, screen and astrobj first
  void fillElement(FactoryMessenger *fmp) const;
  static SmartPointer<Scenery> Subcontractor(Gyoto::FactoryMessenger*);

#endif
 
};

#endif