SpacePointAlg.h

Go to the documentation of this file.

#ifndef SPACEPOINTALG_H
#define SPACEPOINTALG_H

#include <vector>
#include <string>
#include "fhiclcpp/ParameterSet.h"
#include "canvas/Persistency/Common/PtrVector.h"

class TH1F;
namespace sim {
  struct IDE;
}
namespace trkf{
  class KHitTrack;
}
namespace recob{
  class Hit;
  class SpacePoint;
}

namespace trkf {

  class SpacePointAlg {
  public:

    // Constructor.
    SpacePointAlg(const fhicl::ParameterSet& pset);

    // Destructor.
    ~SpacePointAlg();

    // Configuration Accessors.

    bool filter() const {return fFilter;}
    bool merge() const {return fMerge;}
    double maxDT() const {return fMaxDT;}
    double maxS() const {return fMaxS;}
    int minViews() const {return fMinViews;}
    bool enableU() const {return fEnableU;}
    bool enableV() const {return fEnableV;}
    bool enableW() const {return fEnableW;}

    // Update configuration parameters.
    void reconfigure(const fhicl::ParameterSet& pset);

    // Print constants obtained from geometry and properties services.
    void update() const;

    // Corrected time accessors.
    double correctedTime(const recob::Hit& hit) const;

    // Spatial separation of hits (zero if two or fewer).
    double separation(const art::PtrVector<recob::Hit>& hits) const;

    // Test whether the specified hits are compatible with a space point.
    // The last two arguments can be used to override the default cuts.
    bool compatible(const art::PtrVector<recob::Hit>& hits,
                    bool useMC = false) const;

    // Fill a single simple space point using the specified hits.
    // Hits are assumed to be compatible.
    void fillSpacePoint(const art::PtrVector<recob::Hit>& hits,
                        std::vector<recob::SpacePoint>& sptv,
                        int sptid) const;

    void fillSpacePoints(std::vector<recob::SpacePoint>& spts,
                         std::multimap<double, KHitTrack> const& trackMap) const;

    // Fill a single complex space point using the specified hits.
    // Complex space points allow multiple hits in one plane.
    // Hits are assumed to be compatible.
    void fillComplexSpacePoint(const art::PtrVector<recob::Hit>& hits,
                               std::vector<recob::SpacePoint> &sptv,
                               int sptid) const;

    // Fill a vector of space points from an unsorted collection of hits.
    // Space points are generated for all compatible combinations of hits.
    void makeSpacePoints(const art::PtrVector<recob::Hit>& hits,
                         std::vector<recob::SpacePoint>& spts) const;

    // Fill a vector of space points compatible with mc truth information 
    void makeMCTruthSpacePoints(const art::PtrVector<recob::Hit>& hits,
                                std::vector<recob::SpacePoint>& spts) const;

    // Get hits associated with a particular space point, based on most recent 
    // invocation of any make*SpacePoints method.
    const art::PtrVector<recob::Hit>& getAssociatedHits(const recob::SpacePoint& spt) const;

    // Clear space point to Hit associations.
    void clearHitMap() const {fSptHitMap.clear();}

    // Return number of space point to Hit associations.
    int numHitMap() const {return fSptHitMap.size();}

  private:

    // This is the real method for calculating space points (each of
    // the public make*SpacePoints methods comes here).
    void makeSpacePoints(const art::PtrVector<recob::Hit>& hits,
                         std::vector<recob::SpacePoint>& spts,
                         bool useMC) const;

    // Configuration paremeters.

    double fMaxDT;          
    double fMaxS;           
    int fMinViews;          
    bool fEnableU;          
    bool fEnableV;          
    bool fEnableW;          
    bool fFilter;           
    bool fMerge;            
    bool fPreferColl;       
    double fTickOffsetU;    
    double fTickOffsetV;    
    double fTickOffsetW;    

    // Temporary variables.

    struct HitMCInfo
    {
      std::vector<int> trackIDs;       
      std::vector<double> xyz;         
      std::vector<const recob::Hit*> pchit;   
      std::vector<double> dist2;              
    };
    mutable std::map<const recob::Hit*, HitMCInfo> fHitMCMap;
    mutable std::map<int, art::PtrVector<recob::Hit> > fSptHitMap;
  };
}

#endif