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 secondary (bool sec) ; 
  bool secondary () 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