JHeadToolkit.hh

Go to the documentation of this file.

#ifndef __JAANET_JHEADTOOLKIT__
#define __JAANET_JHEADTOOLKIT__

#include <istream>
#include <ostream>

#include "evt/Vec.hh"
#include "evt/Head.hh"

#include "JGeometry3D/JPosition3D.hh"
#include "JGeometry3D/JCylinder3D.hh"

#include "JLang/JEquation.hh"
#include "JLang/JEquationParameters.hh"
#include "JLang/JRedirectString.hh"
#include "JLang/JNullStream.hh"

#include "JROOT/JRootClass.hh"
#include "JROOT/JRootDictionary.hh"
#include "JROOT/JRootStreamer.hh"

#include "JAAnet/JHead.hh"


/**
 * \author mdejong
 */

namespace JROOT {


  using std::vector;   // prevent Doxygen crash


  /**
   * Specialisation of std::vector<JAANET::physics> for reading one element at a time.
   */
  template<>
  struct JRootReader::JHelper< vector<JAANET::physics> >
  {
    /**
     * Read object.
     *
     * \param  reader        ROOT reader
     * \param  object        object
     * \return               ROOT reader
     */
    static JRootReader& getObject(JRootReader& reader, std::vector<JAANET::physics>& object)
    {
      JAANET::physics element;

      JRootReader::getObject(reader, element);

      object.push_back(element);

      return reader;
    }
  };


  /**
   * Specialisation of std::vector<JAANET::physics> for writing only first element.
   */
  template<>
  struct JRootWriter::JHelper< vector<JAANET::physics> > :
    public JRootWriter::JDefaultHelper< vector<JAANET::physics> >
  {
    /**
     * Write object.
     *
     * \param  writer        ROOT writer
     * \param  object        object
     * \return               ROOT writer
     */
    static JRootWriter& putObject(JRootWriter& writer, const std::vector<JAANET::physics>& object)
    {
      if (!object.empty()) {
        JRootWriter::putObject(writer, object[0]);
      }
      
      return writer;
    }
  };
}


namespace JAANET {

  using JGEOMETRY3D::JPosition3D;
  using JGEOMETRY3D::JCylinder3D;
  using JLANG::JEquationParameters;
  using JROOT::JRootDictionary;


  /**
   * Push data of JHead for subsequent copy to Head.
   *
   * \param  header       header
   * \param  p            pointer to data member to be pushed
   */
  template<class T>
  inline void push(JHead& header, T JHead::*p)
  {
    using namespace JPP;

    const int offset = (const char*) &(header.*p) - (const char*) &header;

    const JRootClass cls(getType<JHead>());

    TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();

    for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {

      const JRootClass abc = cls.get(*p);

      if (abc == JRootClass(JType<T>()) && offset == abc.getOffset()) {
        header[p->GetName()] = "";
      }
    }
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \param  generator     generator
   * \return               true if this Monte Carlo is produced by given generator; else false
   */
  inline bool is_physics(const JHead& header, const std::string& generator)
  {
    for (std::vector<physics>::const_iterator i = header.physics.begin(); i != header.physics.end(); ++i) {
      if (i->program == generator) {
        return true;
      }
    }

    return false;
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is produced by JSirene; else false
   */
  inline bool is_sirene(const JHead& header)
  {
    return is_physics(header, JHead::JSIRENE);
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is produced by km3; else false
   */
  inline bool is_km3(const JHead& header)
  {
    return is_physics(header, JHead::KM3);
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is produced by KM3Sim; else false
   */
  inline bool is_km3sim(const JHead& header)
  {
    return !is_km3(header) && !is_sirene(header);
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is produced by genhen; else false
   */
  inline bool is_genhen(const JHead& header)
  {
    return is_physics(header, JHead::GENHEN);
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is produced by genie; else false
   */
  inline bool is_genie(const JHead& header)
  {
    return is_physics(header, JHead::GENIE) || is_physics(header, JHead::GSEAGEN);
  }


  /**
   * Check for generator.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is produced by mupage; else false
   */
  inline bool is_mupage(const JHead& header)
  {
    return is_physics(header, JHead::MUPAGE);
  }


  /**
   * Get object from header.
   *
   * \param  head     header
   * \return          object
   */
  template<class T>
  inline T get(const JHead& head);


  /**
   * Get position offset of detector due to generator.
   *
   * \param  header   header
   * \return          position
   */
  template<>
  inline Vec get(const JHead& header)
  {
    if (is_sirene(header) || is_km3(header)) {

      return header.coord_origin;

    } else {

      if      (is_valid(header.can))
        return Vec(0.0, 0.0, -header.can.zmin);
      else if (is_valid(header.coord_origin))
        return header.coord_origin;
      else
        return Vec(0.0, 0.0, 0.0);
    }
  }


  /**
   * Get position offset of detector due to generator.
   *
   * \param  header   header
   * \return          position
   */
  template<>
  inline JPosition3D get(const JHead& header)
  {
    const Vec pos = get<Vec>(header);

    return JPosition3D(pos.x, pos.y, pos.z);
  }


  /**
   * Get cylinder corresponding to can.
   *
   * \param  head     header
   * \return          cylinder
   */
  template<>
  inline JCylinder3D get(const JHead& head)
  {
    using namespace JGEOMETRY2D;

    return JCylinder3D(JCircle2D(JVector2D(), head.can.r),
                       head.can.zmin,
                       head.can.zmax);
  }


  /**
   * Simple wrapper class around JROOT::JRootDictionary so that other classes
   * could be included in this dictionary if necessary.
   */
  class JAAnetDictionary :
    public JRootDictionary
  {
  private:
    /**
     * Default constructor.
     */
    JAAnetDictionary() :
      JRootDictionary(JRootDictionary::getInstance())
    {
      add<Vec>();
      add< std::vector<JAANET::physics> >();
    }


  public:
    /**
     * Get reference to unique instance of this class object.
     * This JROOT::JRootDictionary object includes the various Monte Carlo data types.
     *
     * \return               reference to this class object
     */
    static JRootDictionary& getInstance()
    {
      static JAAnetDictionary dictionary;

      return dictionary;
    }
  };


  /**
   * Get equation parameters corresponding to Monte Carlo ASCII format, i.e:
   * <pre>
   *    <key>: <value [<value>]*
   *    <key>: <value [<value>]*
   * </pre>
   *
   * \return               equation parameters
   */
  inline const JEquationParameters& getEquationParameters()
  {
    static const JEquationParameters parameters(":", "\n", "", "");

    return parameters;
  }


  /**
   * Read header from input.
   *
   * \param  in         input stream
   * \param  header     header
   * \return            input stream
   */
  inline std::istream& operator>>(std::istream& in, JHead& header)
  {
    using namespace JLANG;
    using namespace JROOT;
    using namespace std;
 
    JRootReader reader(in, getEquationParameters(), JAAnetDictionary::getInstance());
    
    JRootClassReader cls(header);
    
    for (JEquation equation; reader >> equation && equation.getKey() != end_event::Class_Name(); ) {
      
      JRedirectString redirect(reader, equation.getValue());
      
      const JRootClassReader abc = cls.find(equation.getKey().c_str());
      
      if (abc.is_valid()) {     
        reader.getObject(abc);
      }
    }
      
    return in;
  }
  
  
  /**
   * Write header to output.
   *
   * \param  out        output stream
   * \param  header     header
   * \return            output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JHead& header)
  {
    using namespace JLANG;
    using namespace JROOT;
    
    JRootWriter writer(out, getEquationParameters(), JAAnetDictionary::getInstance());
    
    JRootClassWriter cls(header);
    
    TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();
    
    for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
      if (!JRootClass::is_static(*p)) {
        writer.put(p->GetName(), cls.get(*p), true);
      }
    }
      
    return out;
  }
}

#endif