JHit_t.hh

Go to the documentation of this file.

#ifndef __JAANET__JHIT_T__
#define __JAANET__JHIT_T__
 
#include <vector>
#include <algorithm>
 
#include "evt/Hit.hh" 
 
 
/**
 * \author mdejong
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  /**
   * Auxiliary class to set-up Hit.
   *
   * This class is primarily used to limit the size of a Monte Carlo hit and 
   * thereby the memory usage of applications in case of large numbers of hits. 
   */
  struct JHit_t 
  {
    /**
     * Constructor.
     *
     * \param  id       identifier
     * \param  pmt_id   PMT identifier
     * \param  type     type
     * \param  origin   origin
     * \param  t        time [ns]
     * \param  npe      number of photo-electrons
     */
    JHit_t(const int    id,
           const int    pmt_id,
           const int    type,
           const int    origin,
           const double t,
           const int    npe)
    {
      this->id     = id;
      this->pmt_id = pmt_id;
      this->type   = type;
      this->origin = origin;
      this->t      = t;
      this->npe    = npe;
    }
 
 
    /**
     * Type conversion operator.
     *
     * \return          hit
     */
    operator const Hit& () const
    {
      static Hit hit;
 
      hit.id     = this->id;
      hit.pmt_id = this->pmt_id;
      hit.type   = this->type;
      hit.origin = this->origin;
      hit.pure_t = this->t;
      hit.pure_a = this->npe;
      hit.t      = this->t;
      hit.a      = this->npe;
 
      return hit;
    }
 
 
    /**
     * Less than operator for hits.
     *
     * First hit is defined as:
     *    -# smallest PMT identifier;
     *    -# earliest time if same PMT identifier;
     *
     * \param  first            first  hit
     * \param  second           second hit
     * \return                  true if first hit earlier than second hit; else false
     */
    friend inline bool operator<(const JHit_t& first, const JHit_t& second)
    {
      if (first.pmt_id == second.pmt_id)
        return first.t      < second.t;
      else
        return first.pmt_id < second.pmt_id;
    }
    
    
    int    id;
    int    pmt_id;
    int    type;
    int    origin;
    double t;
    int    npe;
  };
 
 
  /**
   * Auxiliary data structure for list of hits with hit merging capability.
   */
  struct JHits_t :
    public std::vector<JHit_t>
  {
    /**
     * Merge hits on same PMT that are within given time window.
     *
     * The earliest hit has the sum of the number of photo-electrons of all following hits within given time window.\n
     * The hit identifiers are subsequently set in ascending order, starting at one.
     *
     * \param  Tmax_ns             maximal time difference [ns]
     */
    void merge(const double Tmax_ns)
    {
      using namespace std;
 
      if (!this->empty()) {
 
        sort(this->begin(), this->end());
      
        iterator in  = this->begin();
        iterator out = this->begin();
      
        out->id = 1;                              // set first hit identifier
      
        while (++in != this->end()) {
        
          if (out->pmt_id == in->pmt_id && in->t - out->t <= Tmax_ns) {
 
            out->npe += in->npe;                  // accumulate number of photo-electrons
            
          } else {
            
            int id = out->id;
 
            ++out;                                // increment desitination address
 
            *out = *in;                           // copy first new hit
 
            out->id = ++id;                       // set hit identifier
          }
        }
 
        this->erase(++out, this->end());          // remove hits
      }
    }
  };
}
 
#endif