JHeadToolkit.hh

Go to the documentation of this file.

#ifndef __JAANET_JHEADTOOLKIT__
#define __JAANET_JHEADTOOLKIT__
 
#include "evt/Vec.hh"
#include "evt/Head.hh"
 
#include "JGeometry3D/JPosition3D.hh"
#include "JGeometry3D/JCylinder3D.hh"
#include "JAAnet/JHead.hh"
 
 
/**
 * \author mdejong
 */
namespace JAANET {
 
  using JGEOMETRY3D::JPosition3D;
  using JGEOMETRY3D::JCylinder3D;
 
 
  /**
   * Match header for MUPAGE.
   */
  struct getMUPAGEHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getMUPAGEHeader()
    {
      this->livetime.numberOfSeconds = 1.0;
 
      this->push(&JHead::livetime);
    }
  };
 
 
  /**
   * Match header for genhen.
   */
  struct getGenhenHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getGenhenHeader()
    {
      this->physics.resize(1);
      this->physics[0].program = JHead::GENHEN;
 
      this->push(&JHead::physics);
    }
  };
 
 
  /**
   * Match header for genie.
   */
  struct getGenieHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getGenieHeader()
    {
      this->physics.resize(1);
      this->physics[0].program = JHead::GENIE;
 
      this->push(&JHead::physics);
    }
  };
 
 
  /**
   * Match header for gseagen.
   */
  struct getGSeaGenHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getGSeaGenHeader()
    {
      this->physics.resize(1);
      this->physics[0].program = JHead::GSEAGEN;
 
      this->push(&JHead::physics);
    }
  };
 
 
  /**
   * Match header for JSirene.cc.
   */
  struct getSireneHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getSireneHeader()
    {
      this->simul.resize(1);
      this->simul[0].program = JHead::JSIRENE;
 
      this->push(&JHead::simul);
    }
  };
 
 
  /**
   * Match header for km3.
   */
  struct getKM3Header :
    public JHead
  {
    /**
     * Default constructor.
     */
    getKM3Header()
    {
      this->simul.resize(1);
      this->simul[0].program = JHead::KM3;
 
      this->push(&JHead::simul);
    }
  };
 
 
  /**
   * Match header for km3.
   */
  struct getKM3SimHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getKM3SimHeader()
    {
      this->simul.resize(1);
      this->simul[0].program = JHead::KM3SIM;
 
      this->push(&JHead::simul);
    }
  };
 
 
  /**
   * Match header for Corsika.
   */
  struct getCorsikaHeader :
    public JHead
  {
    /**
     * Constructor.
     *
     * \param  A             atomic number
     * \param  Z             proton number
     */
    getCorsikaHeader(const int A,
                     const int Z)
    {
      primary.type = A*100 + Z;
 
      this->push(&JHead::primary);
    }
  };
 
 
  /**
   * Match header for DAQ.
   */
  struct getDAQHeader :
    public JHead
  {
    /**
     * Default constructor.
     */
    getDAQHeader()
    {
      this->DAQ.livetime_s = 1.0;
 
      this->push(&JHead::DAQ);
    }
  };
 
 
  /**
   * 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 header.match(getMUPAGEHeader(), false);
  }
 
 
  /**
   * 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 header.match(getGenhenHeader(), false);
  }
 
 
  /**
   * 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 (header.match(getGenieHeader(),   false) ||
            header.match(getGSeaGenHeader(), false));
  }
 
 
  /**
   * Check for detector simulation.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is processed with JSirene; else false
   */
  inline bool is_sirene(const JHead& header)
  {
    return header.match(getSireneHeader(), false);
  }
 
 
  /**
   * Check for detector simulation.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is processed with km3; else false
   */
  inline bool is_km3(const JHead& header)
  {
    return header.match(getKM3Header(), false);
  }
 
 
  /**
   * Check for detector simulation.
   *
   * \param  header        header
   * \return               true if this Monte Carlo is processed with KM3Sim; else false
   */
  inline bool is_km3sim(const JHead& header)
  {
    return header.match(getKM3SimHeader(), false);
  }
 
 
  /**
   * Check for real data.
   *
   * \param  header        header
   * \return               true if this header corresponds to real data; else false
   */
  inline bool is_daq(const JHead& header)
  {
    return header.match(getDAQHeader(), false);
  }
 
 
  /**
   * Get object from header.
   *
   * \param  header   header
   * \return          object
   */
  template<class T>
  inline T get(const JHead& header);
 
 
  /**
   * 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  header   header
   * \return          cylinder
   */
  template<>
  inline JCylinder3D get(const JHead& header)
  {
    using namespace JGEOMETRY2D;
 
    return JCylinder3D(JCircle2D(JVector2D(), header.can.r),
                       header.can.zmin,
                       header.can.zmax);
  }
}
 
#endif