JStart.hh

Go to the documentation of this file.

#ifndef __JFIT__JSTART__
#define __JFIT__JSTART__
 
#include <istream>
#include <ostream>
 
 
/**
 * \file
 * Auxiliary method to locate start and end point of muon trajectory.
 * \author mdejong
 */
namespace JFIT {}
namespace JPP { using namespace JFIT; }
 
namespace JFIT {
 
  /**
   * Auxiliary class for start or end point evaluation.
   */
  struct JStart {
    /**
     * Default constructor.
     */
    JStart() :
      Pmin1(0.0),
      Pmin2(0.0)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  Pmin1              minimal probability single observation
     * \param  Pmin2              minimal probability each of two consecutive observations
     */
    JStart(const double Pmin1,
           const double Pmin2)
    {
      this->Pmin1 = Pmin1;
      this->Pmin2 = Pmin2;
    }
 
    
    /**
     * Check validity of start or end point conditions.
     *
     * \return                     true if valid; else false
     */
    bool is_valid() const
    {
      return (Pmin1 > 0.0 && Pmin2 > 0.0);
    }
    
    
    /**
     * Evaluate start or end point conditions.
     *
     * The template parameter should correspond to a data type which has the member method: 
     * <pre>
     *     double getP() const;    // return probability
     * </pre>
     *
     * \param  observation         observation
     * \return                     true if start or end point; else false
     */
    template<class JHit_t>
    bool operator()(const JHit_t& observation) const
    {
      return observation.getP() < Pmin1;
    }
 
    
    /**
     * Evaluate start or end point conditions.
     *
     * The template parameter should correspond to a data type which has the member method: 
     * <pre>
     *     double getP() const;    // return probability
     * </pre>
     *
     * \param  first               first  observation
     * \param  second              second observation
     * \return                     true if start or end point; else false
     */
    template<class JHit_t>
    bool operator()(const JHit_t& first,
                    const JHit_t& second) const
    {
      return ((first.getP() < Pmin1) ||
              (first.getP() < Pmin2 && second.getP() < Pmin2));
    }
 
  
    /**
     * Get start or end point of muon trajectory.
     * 
     * The template parameter should correspond to a data type which has the member method: 
     * <pre>
     *     double getP() const;    // return probability
     * </pre>
     * The input data should have been sorted along the muon path.
     *
     * \param  __begin            begin of data
     * \param  __end              end   of data
     */
    template<class T>
    inline T find(T __begin, T __end) const
    {
      if (__begin != __end) {
        for (T q = __begin, p = q++; q != __end; ++p, ++q) {
          if ((*this)(*p,*q)) {
            return p;
          }
        }
      }
      
      return __end;
    }
 
    
    /**
     * Read parameters from input.
     *
     * \param  in                  input stream
     * \param  parameters          parameters
     * \return                     input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JStart& parameters)
    {
      in >> parameters.Pmin1 >> parameters.Pmin2;
 
      return in;
    }
 
 
    /**
     * Write parameters to output.
     *
     * \param  out                 output stream
     * \param  parameters          parameters
     * \return                     output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JStart& parameters)
    {
      out << parameters.Pmin1 << ' ' << parameters.Pmin2;
 
      return out;
    }
    
 
    double Pmin1;              //!< minimal probability single observation
    double Pmin2;              //!< minimal probability each of two consecutive observations
  };
}
 
#endif