SpacePointAlg.h

Go to the documentation of this file.

#ifndef SPACEPOINTALG_H
#define SPACEPOINTALG_H

#include <map>
#include <vector>

#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
namespace fhicl {
  class ParameterSet;
}

namespace detinfo {
  class DetectorClocksData;
  class DetectorPropertiesData;
}

namespace trkf {
  class KHitTrack;
}
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/SpacePoint.h"

namespace trkf {

  class SpacePointAlg {
  public:
    SpacePointAlg(const fhicl::ParameterSet& pset);

    // Configuration Accessors.

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

    // Print constants obtained from geometry and properties services.
    void update(detinfo::DetectorPropertiesData const& detProp) const;

    // Corrected time accessors.
    double correctedTime(detinfo::DetectorPropertiesData const& detProp,
                         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(detinfo::DetectorPropertiesData const& detProp,
                    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(detinfo::DetectorPropertiesData const& detProp,
                        const art::PtrVector<recob::Hit>& hits,
                        std::vector<recob::SpacePoint>& sptv,
                        int sptid) const;

    void fillSpacePoints(detinfo::DetectorPropertiesData const& detProp,
                         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(detinfo::DetectorPropertiesData const& detProp,
                               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(detinfo::DetectorClocksData const& clockData,
                         detinfo::DetectorPropertiesData const& detProp,
                         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(detinfo::DetectorClocksData const& clockData,
                                detinfo::DetectorPropertiesData const& detProp,
                                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(detinfo::DetectorClocksData const& clockData,
                         detinfo::DetectorPropertiesData const& detProp,
                         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