JPDFTransformer.hh

Go to the documentation of this file.

#ifndef __JPHYSICS__JPDFTRANSFORMER__
#define __JPHYSICS__JPDFTRANSFORMER__
 
#include <cmath>
 
#include "JLang/JCC.hh"
#include "JIO/JSerialisable.hh"
#include "JTools/JConstants.hh"
#include "JTools/JMultiMapTransformer.hh"
#include "JTools/JFunction1D_t.hh"
#include "JTools/JGrid.hh"
#include "JPhysics/JPDFToolkit.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JPHYSICS {}
namespace JPP { using namespace JPHYSICS; }
 
namespace JPHYSICS {
 
  using JIO::JReader;
  using JIO::JWriter;
  using JTOOLS::JMultiMapTransformer;
 
 
  /**
   * Template definition of transformer of the Probability Density Functions of the time response of a PMT.
   */
  template<unsigned int N, class JArgument_t>
  class JPDFTransformer;
 
 
  /**
   * Template specialisation of transformer of the 1D Probability Density Functions of the time response of a PMT.
   *
   * PDFs are evaluated by interpolation for:
   *   -# distance of closest approach of the muon to the PMT [m]
   *   -# arrival time [ns]
   *
   * The evaluation of the weights is based on:
   *   -# effective attenuation length
   */
  template<class JArgument_t>
  class JPDFTransformer<1, JArgument_t>  :
    public JTOOLS::JMultiMapTransformer<1, JArgument_t>
  {
  public:
 
    typedef JTOOLS::JMultiMapTransformer<1, JArgument_t>             JMultiMapTransformer_t;
 
    typedef typename JMultiMapTransformer_t::clone_type              clone_type;
    typedef typename JMultiMapTransformer_t::argument_type           argument_type;
    typedef typename JMultiMapTransformer_t::const_array_type        const_array_type;
 
    using JMultiMapTransformer_t::getWeight;
 
    static double getRmin() { return 0.01; }                                 // shortest distance of approach [m]
 
 
    /**
     * Default constructor.
     */
    JPDFTransformer() :
      __ln   (0.0),
      __alpha(0),
      __kmin (0.0),
      __kmax (0.0)
    {}
 
 
    /**
     * Constructor.
     *  
     * \param  ln           Effective attenuation length [m]
     * \param  alpha        Distance dependence (power term)
     * \param  kmin         Minimal kappa
     * \param  kmax         Maximal kappa
     */
    JPDFTransformer(const double ln,
                    const int    alpha,
                    const double kmin,
                    const double kmax) :
      __ln   (ln),
      __alpha(alpha),
      __kmin (kmin),
      __kmax (kmax)
    {}
 
 
    /**
     * Clone object.
     * 
     * \return            pointer to newly created JPDFTransformer
     */
    virtual clone_type clone() const 
    {
      return new JPDFTransformer(*this);
    }
 
 
    /**
     * Evaluate dt value as a function of {R}.
     *
     * \param  buffer     {R}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type putXn(const_array_type& buffer, const argument_type xn) const
    {
      using namespace JTOOLS;
 
      const double R = buffer[0];
 
      double x = xn;
 
      const double t0 =  R * getTanThetaC() * getInverseSpeedOfLight();
      const double t1 =  R * __kmin * getInverseSpeedOfLight();
 
      x -= t1 - t0;
      
      if (__kmax > __kmin) {
        x /= R * (__kmax - __kmin) * getInverseSpeedOfLight();
      }
 
      return x;
    }
 
 
    /**
     * Evaluate dt value as a function of {R}.
     *
     * \param  buffer     {R}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type getXn(const_array_type& buffer, const argument_type xn) const
    {
      using namespace JTOOLS;
 
      const double R = buffer[0];
 
      double x = xn;
 
      if (__kmax > __kmin) {
        x *= R * (__kmax - __kmin) * getInverseSpeedOfLight();
      }
 
      const double t0 =  R * getTanThetaC() * getInverseSpeedOfLight();
      const double t1 =  R * __kmin * getInverseSpeedOfLight();
      
      x += t1 - t0;
 
      return x;
    }
 
 
    /**
     * Weight function.
     *
     * \param  buffer     {R}
     * \return            weight
     */
    virtual double getWeight(const_array_type& buffer) const
    {
      using namespace JTOOLS;
 
      const double R = buffer[0];
 
      const double n   = getIndexOfRefraction();
      const double ct0 = 1.0 / n;
      const double st0 = sqrt((1.0 + ct0)*(1.0 - ct0));
    
      const double d  = sqrt(getRmin()*getRmin() + R*R) / st0;
    
      return exp(-d/__ln) / pow(d,__alpha);
    }
 
 
    /**
     * Read PDF transformer from input.
     *
     * \param  in         reader
     * \return            reader
     */
    virtual JReader& read(JReader& in)
    {
      in >> __ln;
      in >> __alpha;
      in >> __kmin;
      in >> __kmax;
 
      return in;
    }
 
 
    /**
     * Write PDF transformer to output.
     *
     * \param  out        writer
     * \return            writer
     */
    virtual JWriter& write(JWriter& out) const
    {
      out << __ln;
      out << __alpha;
      out << __kmin;
      out << __kmax;
 
      return out;
    }
 
 
    /**
     * Print PDF transformer to output stream.
     *
     * \param  out        output stream
     * \return            output stream
     */
    std::ostream& print(std::ostream& out) const
    {
      using std::endl;
 
      out << "Effective attenuation length [m]   " << __ln    << endl;
      out << "Distance dependence (power term)   " << __alpha << endl;
      out << "Minimal kappa                      " << __kmin  << endl;
      out << "Maximal kappa                      " << __kmax  << endl;
 
      return out;
    }
 
 
    double __ln;                 //!< Effective attenuation length [m]
    int    __alpha;              //!< Distance dependence (power term)
    double __kmin;               //!< minimal kappa
    double __kmax;               //!< maximal kappa
  };
 
 
  /**
   * Template specialisation of transformer of the 2D Probability Density Functions of the time response of a PMT.
   *
   * PDFs are evaluated by interpolation for:
   *   -# distance between EM shower and PMT [m]
   *   -# cosine angle EM shower direction and EM shower - PMT position
   *   -# arrival time [ns]
   *
   * The evaluation of the weights is based on:
   *   -# effective attenuation length
   *   -# emission profile of the photons
   */
  template<class JArgument_t>
  class JPDFTransformer<2, JArgument_t> : 
    public JTOOLS::JMultiMapTransformer<2, JArgument_t>
  {
  public:
 
    typedef JTOOLS::JMultiMapTransformer<2, JArgument_t>             JMultiMapTransformer_t;
 
    typedef typename JMultiMapTransformer_t::clone_type              clone_type;
    typedef typename JMultiMapTransformer_t::argument_type           argument_type;
    typedef typename JMultiMapTransformer_t::const_array_type        const_array_type;
 
    using JMultiMapTransformer_t::getWeight;
 
    static double getDmin() { return 0.01; }                                 // shortest distance [m]
 
 
    /**
     * Default constructor.
     */
    JPDFTransformer() :
      __ln   (0.0),
      __alpha(0),
      __kmin (0.0),
      __kmax (0.0),
      getShowerProbability()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  ln         Effective attenuation length [m]
     * \param  alpha      Distance dependence (power term)
     * \param  kmin       Minimal kappa
     * \param  kmax       Maximal kappa
     * \param  geant      Function photon emission from EM-shower
     * \param  bmin       Baseline photon emission from EM-shower
     */
    JPDFTransformer(const double  ln,
                    const int     alpha,
                    const double  kmin,
                    const double  kmax,
                    const JGeant& geant,
                    const double  bmin) :
      __ln   (ln),
      __alpha(alpha),
      __kmin (kmin),
      __kmax (kmax),
      getShowerProbability(geant)
    {
      getShowerProbability.add(bmin);
      getShowerProbability.compile();
    }
 
 
    /**
     * Clone object.
     * 
     * \return            pointer to newly created JPDFTransformer
     */
    virtual clone_type clone() const 
    {
      return new JPDFTransformer(*this);
    }
 
 
    /**
     * Evaluate dt value as a function of {D, cd}.
     *
     * \param  buffer     {D, cd}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type putXn(const_array_type& buffer, const argument_type xn) const
    {
      using namespace JTOOLS;
 
      const double D  = buffer[0];
      //const double cd = buffer[1];
 
      double x = xn;
 
      const double t0 =  D * getIndexOfRefraction() * getInverseSpeedOfLight();
      const double t1 =  D * __kmin * getInverseSpeedOfLight();
 
      x -= t1 - t0;
 
      if (__kmax > __kmin) {
        x /= D * (__kmax - __kmin) * getInverseSpeedOfLight();
      }
 
      return x;
    }
 
 
    /**
     * Evaluate dt value as a function of {D, cd}.
     *
     * \param  buffer     {D, cd}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type getXn(const_array_type& buffer, const argument_type xn) const
    {
      using namespace JTOOLS;
 
      const double D  = buffer[0];
      //const double cd = buffer[1];
 
      double x = xn;
 
      if (__kmax > __kmin) {
        x *= D * (__kmax - __kmin) * getInverseSpeedOfLight();
      }
 
      const double t0 =  D * getIndexOfRefraction() * getInverseSpeedOfLight();
      const double t1 =  D * __kmin * getInverseSpeedOfLight();
 
      x += t1 - t0;
 
      return x;
    }
 
 
    /**
     * Weight function.
     *
     * \param  buffer     {D, cd}
     * \return            weight
     */
    virtual double getWeight(const_array_type& buffer) const
    {
      using namespace JTOOLS;
 
      const double D  = buffer[0];
      const double cd = buffer[1];
 
      const double d  = sqrt(getDmin()*getDmin() + D*D);
 
      return getShowerProbability(getIndexOfRefractionPhase(), cd) * exp(-d/__ln) / pow(d,__alpha);
    }
 
 
    /**
     * Read PDF transformer from input.
     *
     * \param  in         reader
     * \return            reader
     */
    virtual JReader& read(JReader& in)
    {
      in >> __ln;
      in >> __alpha;
      in >> __kmin;
      in >> __kmax;
      in >> getShowerProbability;
 
      return in;
    }
 
 
    /**
     * Write PDF transformer to output.
     *
     * \param  out        writer
     * \return            writer
     */
    virtual JWriter& write(JWriter& out) const
    {
      out << __ln;
      out << __alpha;
      out << __kmin;
      out << __kmax;
      out << getShowerProbability;
 
      return out;
    }
 
 
    /**
     * Print PDF transformer to output stream.
     *
     * \param  out        output stream
     * \return            output stream
     */
    std::ostream& print(std::ostream& out) const
    {
      using std::endl;
 
      out << "Effective attenuation length [m]   " << __ln    << endl;
      out << "Distance dependence (power term)   " << __alpha << endl;
      out << "Minimal kappa                      " << __kmin  << endl;
      out << "Maximal kappa                      " << __kmax  << endl;
 
      return out;
    }
 
 
    double __ln;                 //!< Effective attenuation length [m]
    int    __alpha;              //!< Distance dependence (power term)
    double __kmin;               //!< minimal kappa
    double __kmax;               //!< maximal kappa
    JGeant getShowerProbability;
  };
 
 
  /**
   * Template specialisation of transformer of the 3D Probability Density Functions of the time response of a PMT.
   *
   * PDFs are evaluated by interpolation for:
   *   -# distance of closest approach of the muon to the PMT [m]
   *   -# zenith    angle of the PMT
   *   -# azimuthal angle of the PMT
   *   -# arrival time [ns]
   *
   * The evaluation of the weights is based on:
   *   -# effective attenuation length
   *   -# emission profile of the photons
   *   -# angular acceptance of PMT
   */
  template<class JArgument_t>
  class JPDFTransformer<3, JArgument_t> : 
    public JTOOLS::JMultiMapTransformer<3, JArgument_t>
  {
  public:
 
    typedef JPDFTransformer             <1, JArgument_t>             JFunction1DTransformer_t; 
    typedef JTOOLS::JMultiMapTransformer<3, JArgument_t>             JMultiMapTransformer_t;
 
    typedef typename JMultiMapTransformer_t::clone_type              clone_type;
    typedef typename JMultiMapTransformer_t::argument_type           argument_type;
    typedef typename JMultiMapTransformer_t::const_array_type        const_array_type;
 
    typedef JTOOLS::JGridPolint1Function1D_t                         JFunction1D_t;
 
    using JMultiMapTransformer_t::getWeight;
 
    static double getRmin() { return 0.01; }                                 // shortest distance of approach [m]
 
 
    /**
     * Default constructor.
     */
    JPDFTransformer() :
      transformer(),
      getAngularAcceptance()
    {}
 
 
    /**
     * Constructor.
     *  
     * \param  ln         Effective attenuation length [m]
     * \param  alpha      Distance dependence (power term)
     * \param  kmin       Minimal kappa
     * \param  kmax       Maximal kappa
     * \param  pmt        Function angular acceptance of PMT
     * \param  amin       Baseline angular acceptance of PMT
     */
    template<class T>
    JPDFTransformer(const double ln,
                    const int    alpha,
                    const double kmin,
                    const double kmax,
                    T            pmt,
                    const double amin) :
      transformer(ln, alpha, kmin, kmax),
      getAngularAcceptance()
    {
      getAngularAcceptance.configure(JTOOLS::make_grid(1000, -1.0, +1.0), pmt);
      getAngularAcceptance.add(amin);
      getAngularAcceptance.compile();
      getAngularAcceptance.setExceptionHandler(new JFunction1D_t::JDefaultResult(0.0));
    }
 
 
    /**
     * Clone object.
     * 
     * \return            pointer to newly created JPDFTransformer
     */
    virtual clone_type clone() const 
    {
      return new JPDFTransformer(*this);
    }
 
 
    /**
     * Evaluate dt value as a function of {R, theta, phi}.
     *
     * \param  buffer     {R, theta, phi}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type putXn(const_array_type& buffer, const argument_type xn) const
    {
      return transformer.putXn(buffer, xn);
    }
 
 
    /**
     * Evaluate dt value as a function of {R, theta, phi}.
     *
     * \param  buffer     {R, theta, phi}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type getXn(const_array_type& buffer, const argument_type xn) const
    {
      return transformer.getXn(buffer, xn);
    }
 
 
    /**
     * Weight function.
     *
     * \param  buffer     {R, theta, phi}
     * \return            weight
     */
    virtual double getWeight(const_array_type& buffer) const
    {
      using namespace JTOOLS;
 
      const double theta = buffer[1];
      const double phi   = buffer[2];
 
      const double n   = getIndexOfRefraction();
      const double ct0 = 1.0 / n;
      const double st0 = sqrt((1.0 + ct0)*(1.0 - ct0));
    
      const double px = sin(theta)*cos(phi);
      //const double py = sin(theta)*sin(phi);
      const double pz = cos(theta);
    
      const double ct = st0*px + ct0*pz;
    
      return transformer.getWeight(buffer) * getAngularAcceptance(ct);
    }
 
 
    /**
     * Read PDF transformer from input.
     *
     * \param  in         reader
     * \return            reader
     */
    virtual JReader& read(JReader& in)
    {
      in >> transformer;
      in >> getAngularAcceptance;
 
      getAngularAcceptance.compile();
 
      return in;
    }
 
 
    /**
     * Write PDF transformer to output.
     *
     * \param  out        writer
     * \return            writer
     */
    virtual JWriter& write(JWriter& out) const
    {
      out << transformer;
      out << getAngularAcceptance;
 
      return out;
    }
 
 
    /**
     * Print PDF transformer to output stream.
     *
     * \param  out        output stream
     * \return            output stream
     */
    std::ostream& print(std::ostream& out) const
    {
      return transformer.print(out);
    }
 
 
    JFunction1DTransformer_t transformer;
    JFunction1D_t            getAngularAcceptance;
  };
 
 
  /**
   * Template specialisation of transformer of the 4D Probability Density Functions of the time response of a PMT.
   *
   * PDFs are evaluated by interpolation for:
   *   -# distance between EM shower and PMT [m]
   *   -# cosine angle EM shower direction and EM shower - PMT position
   *   -# zenith    angle of the PMT
   *   -# azimuthal angle of the PMT
   *   -# arrival time [ns]
   *
   * The evaluation of the weights is based on:
   *   -# effective attenuation length
   *   -# angular acceptance of PMT
   */
  template<class JArgument_t>
  class JPDFTransformer<4, JArgument_t> : 
    public JTOOLS::JMultiMapTransformer<4, JArgument_t>
  {
  public:
 
    typedef JPDFTransformer             <2, JArgument_t>             JFunction2DTransformer_t;
    typedef JTOOLS::JMultiMapTransformer<4, JArgument_t>             JMultiMapTransformer_t;
 
    typedef typename JMultiMapTransformer_t::clone_type              clone_type;
    typedef typename JMultiMapTransformer_t::argument_type           argument_type;
    typedef typename JMultiMapTransformer_t::const_array_type        const_array_type;
 
    typedef JTOOLS::JGridPolint1Function1D_t                         JFunction1D_t;
 
    using JMultiMapTransformer_t::getWeight;
 
    static double getDmin() { return 0.01; }                                 // shortest distance [m]
 
 
    /**
     * Default constructor.
     */
    JPDFTransformer() :
      transformer(),
      getAngularAcceptance()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  ln         Effective attenuation length [m]
     * \param  alpha      Distance dependence (power term)
     * \param  kmin       Minimal kappa
     * \param  kmax       Maximal kappa
     * \param  geant      Function photon emission from EM-shower
     * \param  bmin       Baseline photon emission from EM-shower
     * \param  pmt        Function angular acceptance of PMT
     * \param  amin       Baseline angular acceptance of PMT
     */
    template<class T>
    JPDFTransformer(const double ln,
                    const int    alpha,
                    const double kmin,
                    const double kmax,
                    const JGeant geant,
                    const double bmin,
                    T            pmt,
                    const double amin) :
      transformer(ln, alpha, kmin, kmax, geant, bmin),
      getAngularAcceptance()
    {
      getAngularAcceptance.configure(JTOOLS::make_grid(1000, -1.0, +1.0), pmt);
      getAngularAcceptance.add(amin);
      getAngularAcceptance.compile();
      getAngularAcceptance.setExceptionHandler(new JFunction1D_t::JDefaultResult(0.0));
    }
 
 
    /**
     * Clone object.
     * 
     * \return            pointer to newly created JPDFTransformer
     */
    virtual clone_type clone() const 
    {
      return new JPDFTransformer(*this);
    }
 
 
    /**
     * Evaluate dt value as a function of {D, cd, theta, phi}.
     *
     * \param  buffer     {D, cd, theta, phi}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type putXn(const_array_type& buffer, const argument_type xn) const
    {
      return transformer.putXn(buffer, xn);
    }
 
 
    /**
     * Evaluate dt value as a function of {D, cd, theta, phi}.
     *
     * \param  buffer     {D, cd, theta, phi}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type getXn(const_array_type& buffer, const argument_type xn) const
    {
      return transformer.getXn(buffer, xn);
    }
 
 
    /**
     * Weight function.
     *
     * \param  buffer     {D, cd, theta, phi}
     * \return            weight
     */
    virtual double getWeight(const_array_type& buffer) const
    {
      const double cd    = buffer[1];
      const double theta = buffer[2];
      const double phi   = buffer[3];
 
      const double ct0 = cd;
      const double st0 = sqrt((1.0 + ct0)*(1.0 - ct0));
    
      const double px = sin(theta)*cos(phi);
      //const double py = sin(theta)*sin(phi);
      const double pz = cos(theta);
    
      const double ct = st0*px + ct0*pz;
 
      return transformer.getWeight(buffer) * getAngularAcceptance(ct);
    }
 
 
    /**
     * Read PDF transformer from input.
     *
     * \param  in         reader
     * \return            reader
     */
    virtual JReader& read(JReader& in)
    {
      in >> transformer;
      in >> getAngularAcceptance;
 
      getAngularAcceptance.compile();
 
      return in;
    }
 
 
    /**
     * Write PDF transformer to output.
     *
     * \param  out        writer
     * \return            writer
     */
    virtual JWriter& write(JWriter& out) const
    {
      out << transformer;
      out << getAngularAcceptance;
 
      return out;
    }
 
 
    /**
     * Print PDF transfomer to output stream.
     *
     * \param  out        output stream
     * \return            output stream
     */
    std::ostream& print(std::ostream& out) const
    {
      return transformer.print(out);
    }
 
 
    JFunction2DTransformer_t transformer;
    JFunction1D_t            getAngularAcceptance;
  };
 
 
  /**
   * Template specialisation of transformer of the 5D Probability Density Functions of the time response of a PMT.
   *
   * PDFs are evaluated by interpolation for:
   *   -# energy of the track
   *   -# distance between EM shower and PMT [m]
   *   -# cosine angle EM shower direction and EM shower - PMT position
   *   -# zenith    angle of the PMT
   *   -# azimuthal angle of the PMT
   *   -# arrival time [ns]
   *
   * The evaluation of the weights is based on:
   *   -# effective attenuation length
   *   -# angular acceptance of PMT
   */
  template<class JArgument_t>
  class JPDFTransformer<5, JArgument_t> : 
    public JTOOLS::JMultiMapTransformer<5, JArgument_t>
  {
  public:
    
    typedef JPDFTransformer             <4, JArgument_t>             JFunction4DTransformer_t;
    typedef JPDFTransformer             <2, JArgument_t>             JFunction2DTransformer_t;
    typedef JTOOLS::JMultiMapTransformer<5, JArgument_t>             JMultiMapTransformer_t;
    
    typedef typename JMultiMapTransformer_t::clone_type              clone_type;
    typedef typename JMultiMapTransformer_t::argument_type           argument_type;
    typedef typename JMultiMapTransformer_t::const_array_type        const_array_type;
    
    typedef JTOOLS::JGridPolint1Function1D_t                         JFunction1D_t;
    
    using JMultiMapTransformer_t::getWeight;
    
    static double getDmin() { return 0.01; }                                 // shortest distance [m]
    
    
    /**
     * Default constructor.
     */
    JPDFTransformer() :
      transformer()
    {}    
 
    
    /**
     * Constructor.
     *
     * \param  ln         Effective attenuation length [m]
     * \param  alpha      Distance dependence (power term)
     * \param  kmin       Minimal kappa
     * \param  kmax       Maximal kappa
     * \param  geant      Function photon emission from EM-shower
     * \param  bmin       Baseline photon emission from EM-shower
     * \param  pmt        Function angular acceptance of PMT
     * \param  amin       Baseline angular acceptance of PMT
     */
    
    template<class T>
    JPDFTransformer(const double ln,
                    const int    alpha,
                    const double kmin,
                    const double kmax,
                    const JGeant geant,
                    const double bmin,
                    T            pmt,
                    const double amin) :
      transformer(ln, alpha, kmin, kmax, geant, bmin, pmt, amin)
    {}
        
    /**
     * Clone object.
     * 
     * \return            pointer to newly created JPDFTransformer
     */
    virtual clone_type clone() const 
    {
      return new JPDFTransformer(*this);
    }
    
    
    /**
     * Evaluate dt value as a function of {E, D, cd, theta, phi}.
     *
     * \param  buffer     {E, D, cd, theta, phi}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type putXn(const_array_type& buffer, const argument_type xn) const
    {
      return transformer.putXn(buffer.pop_front(), xn);
    }
    
    
    /**
     * Evaluate dt value as a function of {E, D, cd, theta, phi}.
     *
     * \param  buffer     {E, D, cd, theta, phi}
     * \param  xn         old dt value
     * \return            new dt value
     */
    virtual argument_type getXn(const_array_type& buffer, const argument_type xn) const
    {
      return transformer.getXn(buffer.pop_front(), xn);
    }
    
    
    /**
     * Weight function.
     *
     * \param  buffer     {E, D, cd, theta, phi}
     * \return            weight
     */
    virtual double getWeight(const_array_type& buffer) const
    { 
      const double E     = buffer[0];
      return transformer.getWeight(buffer.pop_front()) / E;
    }
    
    
    /**
     * Read PDF transformer from input.
     *
     * \param  in         reader
     * \return            reader
     */
    virtual JReader& read(JReader& in)
    {
      in >> transformer;
      
      return in;
    }
    
  
    /**
     * Write PDF transformer to output.
     *
     * \param  out        writer
     * \return            writer
     */
    virtual JWriter& write(JWriter& out) const
    {
      out << transformer;
      
      return out;
    }
    
    
    /**
     * Print PDF transfomer to output stream.
     *
     * \param  out        output stream
     * \return            output stream
     */
    std::ostream& print(std::ostream& out) const
    {
      return transformer.print(out);
    }
    
    JFunction4DTransformer_t transformer;
  };
}
 
#endif