TrackCleanUpAlg.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file  TrackCle/// TrackCleanUpAlg.h                                                                                              
/// \brief   Preforms clean up on tracks on the MIP assumption
///                                                                                                                      
/// \author  ksachdev@physics.umn.edu                                                                                    
////////////////////////////////////////////////////////////////////////     


#ifndef TrackCleanUpAlg_h
#define TrackCleanUpAlg_h

#include "fhiclcpp/ParameterSet.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/Ptr.h"

#include "GeometryObjects/OfflineChan.h"
#include "Geometry/Geometry.h"


namespace rb
{ 
  class Cluster;
  class Track;
  class CellHit;
  struct WeightedHit;
}


namespace murem
{

  class TrackCleanUpAlg 
  {

  public:
    explicit TrackCleanUpAlg(fhicl::ParameterSet const& pset);
    ~TrackCleanUpAlg();

    void reconfigure(const fhicl::ParameterSet& pset);
  
    /// \brief A function to disentangle the muon track from the hadronic 
    /// energy close to the vertex. Returns a vector of rb::WeightedHits
    /// where the hit is the cellhits that were on the given track and
    /// weight is the fraction of the energy in the hit that came from 
    /// the track. mipRangeLow, mipRangeHigh, mipValue and vertexRegionDeDxCutOff
    /// are pointers that point to the value of mip range limits, 
    /// peak values andthe dedx cut off used to find the vertex region.                                                                            
    /// If these pointers are not provided, the default values are used.                                                                           
    /// The default values are good for muons, not for other particles.
    std::vector<rb::WeightedHit>  CleanUpTrack(const    rb::Track &muonTrack,  
                                               const    rb::Cluster &slice,
                                               double*  mipRangeHigh = NULL,
                                               double*  mipRangeLow = NULL,
                                               double*  mipValue = NULL,
                                               double*  vertexRegionDeDxCutOff = NULL);
    
    
    /// \brief A function to decide how large a vertex region should be 
    /// considered for clean up. vertexRegion is an array of two ints.
    /// 0th element is the track trajectory point in the x-view that 
    /// marks the end of the vertexRegion in the x-view and the 1st 
    /// element is that in the y-view. vertexRegionDeDxCutOff is 
    /// the dedx cut off used to find the vertex region.                                                                            
    /// If these pointers are not provided, the default values are used.                                                                           
    /// The default values are good for muons, not for other particles.    
    void ComputeVertexRegion(const rb::Track &muonTrack,
                             int     *vertexRegion,
                             double*  vertexRegionDeDxCutOff = NULL);


    /// \brief A function to decide how large a vertex region should be 
    /// considered for clean up. vertexRegion is an array of two ints.
    /// 0th element is the plane in the x-view that marks the end of the 
    /// vertexRegion in the x-view and the 1st element marks the end of 
    /// vertexRegion in the y-view. vertexRegionDeDxCutOff is                                                                                    
    /// the dedx cut off used to find the vertex region.                                                                                           
    /// If these pointers are not provided, the default values are used.                                                                           
    /// The default values are good for muons, not for other particles.
    void LastVertexPlanes(const rb::Track &muonTrack, 
                          int     *vertexPlanes,
                          double*  vertexRegionDeDxCutOff = NULL);

    /// \brief Calculates the total hadronic energy on the provided track
    /// based on the assumption of MIP. mipRangeLow, mipRangeHigh, 
    /// mipValue and vertexRegionDeDxCutOff are pointers that point to 
    /// the value of mip range limits, peak values and the the dedx cut 
    /// off used to find the vertex region. If these pointers are not 
    /// provided, the default values are used.                          
    /// The default values are good for muons, not for other particles.
    float ExtraEOnTrack(const rb::Track &track, 
                        const rb::Cluster &slice,
                        double*  mipRangeHigh = NULL,
                        double*  mipRangeLow = NULL,
                        double*  mipValue = NULL,
                        double*  vertexRegionDeDxCutOff = NULL);

    float ExtraEOnTrackInGeV(const rb::Track &track,
                             const rb::Cluster &slice,
                             double*  mipRangeHigh = NULL,
                             double*  mipRangeLow = NULL,
                             double*  mipValue = NULL,
                             double*  vertexRegionDeDxCutOff = NULL);

    /// \brief Calculates the total hadronic energy on the provided track
    /// based on the assumption of MIP for each plane in the vertex region. 
    /// mipRangeLow, mipRangeHigh, mipValue and vertexRegionDeDxCutOff are 
    /// pointers that point to the value of mip range limits, peak values 
    /// and the the dedx cut off used to find the vertex region. If these 
    /// pointers are not provided, the default values are used.                          
    /// The default values are good for muons, not for other particles.
    std::map<int, float> ExtraEOnTrackPlanes(const rb::Track &track, 
                        const rb::Cluster &slice,
                        double*  mipRangeHigh = NULL,
                        double*  mipRangeLow = NULL,
                        double*  mipValue = NULL,
                        double*  vertexRegionDeDxCutOff = NULL);
    
    std::map<int, float> ExtraEOnTrackPlanesInGeV(const rb::Track &track,
                         const rb::Cluster &slice,
                         double*  mipRangeHigh = NULL,
                         double*  mipRangeLow = NULL,
                         double*  mipValue = NULL,
                         double*  vertexRegionDeDxCutOff = NULL);

    /// \brief Returns a vector of rb::WeightedHit that have been impacted by 
    /// the CleanUp procedure. hits are all the hits on the muonTrack \a
    /// within the vertex region and weight indicates the fraction of energy
    /// deposited in the cell that belonged to the track. mipRangeLow, 
    /// mipRangeHigh, mipValue and vertexRegionDeDxCutOff are pointers 
    /// that point to the value of mip range limits, peak values and the 
    /// dedx cut off used to find the vertex region. If these pointers 
    /// are not provided, the default values are used.                                           
    /// The default values are good for muons, not for other particles.
    std::vector<rb::WeightedHit> CleanUpWeightedHits(const rb::Track &muonTrack,  
                                                     const rb::Cluster &slice,
                                                     double*  mipRangeHigh = NULL,
                                                     double*  mipRangeLow = NULL,
                                                     double*  mipValue = NULL,
                                                     double*  vertexRegionDeDxCutOff = NULL);

    /// A function to calculate the energy, dE/dx and tracklength of a track through a plane                   
    std::map<unsigned int, double> DeDxInPlane( const rb::Track &muonTrack );    

    /// A function for total energy calculation in terms of MIP
    float TrackEinMIP (const rb::Track &track);

  private:

    /// FHiCL Parameters
    //@{
    /// Extra energy on track
    float fExtraEOnTrack;

    /// A map of planes in the vertex region of a track and the extra energy found on them
    std::map< int, float > fExtraEOnTrackPlanes;

    /// Default lower bound of allowed MIP range (FHiCL parameter)
    float fMipRangeLow;

    /// Default upper bound of allowed MIP range (FHiCL parameter)
    float fMipRangeHigh;

    /// Default MIP value in GeV/cm (FHiCL parameter)
    float fMipValue;

    /// Default vertex region dedx cut off value (FHiCL parameter)
    float fVertexRegionDeDxCutOff;
    
    /// the same as fMipRangeLow but in GeV/cm units (FHiCL parameter)
    float fMipRangeLowInGev;
    
    /// the same as fMipRangeHigh but in GeV/cm units (FHiCL parameter)
    float fMipRangeHighInGev;
 
    /// the same as fMipValue but in GeV/cm units (FHiCL parameter)
    float fMipValueInGev;

    /// the same as fVertexRegionDeDxCutOff but in GeV/cm units (FHiCL parameter)
    float fVertexRegionDeDxCutOffInGev;
    //@}

    /// Handle to Geometry service                                                                     
    art::ServiceHandle<geo::Geometry> fgeom;
    
    /// Trajectories points in x view
    std::vector<int> fTrajX;

    /// Trajectories points in y view
    std::vector<int> fTrajY;

    /// A vector of planes on muon track with hits in them.            
    std::vector<int > fPlanes;          

    /// A vector of X-view planes on muon track with hits in them.            
    std::vector<int > fPlanesX;          

    /// A vector of Y-view planes on muon track with hits in them.            
    std::vector<int > fPlanesY;          

    /// A map of plane and energy in plane left by the track           
    std::map<unsigned int, double> fPlaneEnergy;      

    /// A map of plane and track length through plane                  
    std::map<unsigned int, double> fPlaneTrkLength;   

    /// A map of plane and average dedx over this and the next 2 planes
    std::map<unsigned int, double> fAvgDeDx;          
    
    /// A map of plane and dE/dX of the track in the plane             
    std::map<unsigned int, double> fPlaneDeDx;        

    /// A map of cell and energy in Plane left by the track                                                  
    std::map<geo::OfflineChan, double> fCellEnergy; 

    /// A vector of \ref rb::WeightedHit that are impacted by CleanUp procedure
    std::vector<rb::WeightedHit> fCleanUpWeightedHits;

    /// A map to store the cell numbers that are in each plane of the track
    std::map<int, std::vector<art::Ptr<rb::CellHit> > > fPlaneHits;

    /// A function to check if the given dE/dx is consistent with MIP                                         
    int   IsMIP( double dEdX) const;
        
    /// A function to reset the weight of a \ref rb::WeightedHit in a given vector of WeightedHits                  
    std::vector<rb::WeightedHit> ResetHitWeight( std::vector< rb::WeightedHit > &trackHits,  
                                                 art::Ptr<rb::CellHit>          &hit,
                                                 float                          &weight);
 
    /// Sorts a vector of cellhits in ascending order by distance from the trajPt on track. 
    void SortByDistFromTrack( std::vector< art::Ptr<rb::CellHit> >&hits, 
                              const rb::Track &track, int plane);
  };
 
}

#endif // TrackCleanUpAlg_h
      
////////////////////////////////////////////////////////////////////////