JTriggerMXShower_t.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JTRIGGERMXSHOWER_T__
#define __JTRIGGER__JTRIGGERMXSHOWER_T__
 
#include <TObject.h>
 
 
/**
 * \author mdejong
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
namespace JTRIGGER {
 
  /**
   * Shower trigger parameters.
   */
  struct JTriggerMXShower_t
  {
    /**
     * Trigger parameters.
     */
    class JParameters
    {
    public:      
      /**
       * Default constructor.
       */
      JParameters()
      {
        reset();
      }
 
      
      /**
       * Constructor.
       *
       * \param  enabled          enabled status of trigger
       * \param  numberOfHits     minimal number of hits    to trigger event
       * \param  numberOfModules  minimal number of modules to trigger event
       * \param  DMax_m           maximal distance between PMTs [m]
       * \param  TMaxExtra_ns     maximal extra time [ns]
       * \param  RMax_m           maximal distance of generated vertices to root hit [m]
       * \param  Xv_m             step size for generation of vertices [m]
       * \param  factoryLimit     maximal number of hits to apply trigger logic (above this limit, always trigger)
       */
      JParameters(const bool    enabled,
                  const int     numberOfHits,
                  const int     numberOfModules,
                  const double  DMax_m,
                  const double  TMaxExtra_ns,
                  const double  RMax_m,
                  const double  Xv_m,
                  const int     factoryLimit)
      {
        this->enabled         = enabled;
        this->numberOfHits    = numberOfHits;
        this->numberOfModules = numberOfModules;
        this->DMax_m          = DMax_m;
        this->TMaxExtra_ns    = TMaxExtra_ns;
        this->RMax_m          = RMax_m;
        this->Xv_m            = Xv_m;
        this->factoryLimit    = factoryLimit;
      }
 
 
      /**
       * Virtual destructor.
       */
      virtual ~JParameters()
      {}
      
 
      /**
       * Reset trigger parameters.
       */
      void reset()
      {
        enabled         = false;
        numberOfHits    = 8;
        numberOfModules = 8;
        DMax_m          = 43.0;
        TMaxExtra_ns    = 20.0;
        RMax_m          = 0.0;
        Xv_m            = 0.0;
        factoryLimit    = 100;
      }
 
 
      /**
       * Equality
       *
       * \param  parameters       trigger parameters
       * \return                  true if equals; else false
       */
      bool equals(const JParameters& parameters) const
      {
        return (enabled         == parameters.enabled         &&
                numberOfHits    == parameters.numberOfHits    &&
                numberOfModules == parameters.numberOfModules &&
                DMax_m          == parameters.DMax_m          &&
                TMaxExtra_ns    == parameters.TMaxExtra_ns    &&
                RMax_m          == parameters.RMax_m          &&
                Xv_m            == parameters.Xv_m            &&
                factoryLimit    == parameters.factoryLimit);
      }
 
 
      ClassDef(JParameters,4);
 
 
      bool   enabled;             ///< enabled status of trigger
      int    numberOfHits;        ///< minimal number of hits    to trigger event
      int    numberOfModules;     ///< minimal number of modules to trigger event
      double DMax_m;              ///< maximal distance between PMTs [m]
      double TMaxExtra_ns;        ///< maximal extra time [ns]
      double RMax_m;              ///< maximal distance of generated vertices to root hit [m]
      double Xv_m;                ///< step size for generation of vertices [m]
      int    factoryLimit;        ///< maximal number of hits to apply trigger logic (above this limit, always trigger)
    };
  };
}
 
#endif