lar_cluster3d::SpacePointHit3DBuilder Class Reference

SpacePointHit3DBuilder class definiton. More...

Inheritance diagram for lar_cluster3d::SpacePointHit3DBuilder:

Public Types
enum	TimeValues { COLLECTARTHITS = 0, BUILDTHREEDHITS = 1, BUILDNEWHITS = 2, NUMTIMEVALUES }
	enumerate the possible values for time checking if monitoring timing More...
using	RecobHitToPtrMap = std::unordered_map< const recob::Hit *, art::Ptr< recob::Hit >>
	Defines a structure mapping art representation to internal. More...

Public Member Functions
	SpacePointHit3DBuilder (fhicl::ParameterSet const &pset)
	Constructor. More...
void	produces (art::ProducesCollector &) override
	Each algorithm may have different objects it wants "produced" so use this to let the top level producer module "know" what it is outputting. More...
void	Hit3DBuilder (art::Event &evt, reco::HitPairList &hitPairList, RecobHitToPtrMap &) override
	Given a set of recob hits, run DBscan to form 3D clusters. More...
float	getTimeToExecute (IHit3DBuilder::TimeValues index) const override
	If monitoring, recover the time to execute a particular function. More...

Private Types
using	Hit2DVector = std::vector< reco::ClusterHit2D >

Private Member Functions
void	clear ()
	clear the tuple vectors before processing next event More...
float	chargeIntegral (float, float, float, int, int) const
	Perform charge integration between limits. More...

Private Attributes
art::InputTag	fSpacePointProducerLabel
	Data members to follow. More...
art::InputTag	fHitProducerLabel
bool	fDoWireAssns
bool	fDoRawDigitAssns
float	m_maxHit3DChiSquare
	Provide ability to select hits based on "chi square". More...
bool	m_outputHistograms
	Take the time to create and fill some histograms for diagnostics. More...
bool	fEnableMonitoring
std::vector< float >	fTimeVector
TTree *	m_tupleTree
	output analysis tree More...
std::vector< float >	m_deltaTimeVec
std::vector< float >	m_chiSquare3DVec
std::vector< float >	m_maxPullVec
std::vector< float >	m_overlapFractionVec
std::vector< float >	m_overlapRangeVec
std::vector< float >	m_maxSideVecVec
std::vector< float >	m_pairWireDistVec
std::vector< float >	m_smallChargeDiffVec
std::vector< int >	m_smallIndexVec
std::vector< float >	m_qualityMetricVec
std::vector< float >	m_spacePointChargeVec
std::vector< float >	m_hitAsymmetryVec
Hit2DVector	m_clusterHit2DMasterVec
const geo::Geometry *	fGeometry
const geo::WireReadoutGeom *	fWireReadoutGeom

Detailed Description

SpacePointHit3DBuilder class definiton.

Definition at line 57 of file SpacePointHit3DBuilder_tool.cc.

Member Typedef Documentation

using lar_cluster3d::SpacePointHit3DBuilder::Hit2DVector = std::vector<reco::ClusterHit2D>

private

Definition at line 99 of file SpacePointHit3DBuilder_tool.cc.

using lar_cluster3d::IHit3DBuilder::RecobHitToPtrMap = std::unordered_map<const recob::Hit*, art::Ptr<recob::Hit>>

inherited

Defines a structure mapping art representation to internal.

Definition at line 43 of file IHit3DBuilder.h.

Member Enumeration Documentation

enum lar_cluster3d::IHit3DBuilder::TimeValues

inherited

enumerate the possible values for time checking if monitoring timing

Enumerator
COLLECTARTHITS
BUILDTHREEDHITS
BUILDNEWHITS
NUMTIMEVALUES

Definition at line 56 of file IHit3DBuilder.h.

{ COLLECTARTHITS = 0, BUILDTHREEDHITS = 1, BUILDNEWHITS = 2, NUMTIMEVALUES };

Constructor & Destructor Documentation

lar_cluster3d::SpacePointHit3DBuilder::SpacePointHit3DBuilder ( fhicl::ParameterSet const &  pset )

explicit

Constructor.

Parameters

pset

Definition at line 137 of file SpacePointHit3DBuilder_tool.cc.

References clear(), fDoRawDigitAssns, fDoWireAssns, fEnableMonitoring, fGeometry, fHitProducerLabel, fSpacePointProducerLabel, fWireReadoutGeom, Get, fhicl::ParameterSet::get(), m_chiSquare3DVec, m_deltaTimeVec, m_hitAsymmetryVec, m_maxHit3DChiSquare, m_maxPullVec, m_maxSideVecVec, m_outputHistograms, m_overlapFractionVec, m_overlapRangeVec, m_pairWireDistVec, m_qualityMetricVec, m_smallChargeDiffVec, m_smallIndexVec, m_spacePointChargeVec, and m_tupleTree.

  {
    fSpacePointProducerLabel = pset.get<art::InputTag>("SpacePointProducerLabel");
    fHitProducerLabel = pset.get<art::InputTag>("HitProducerLabel");
    fDoWireAssns = pset.get<bool>("DoWireAssns", true);
    fDoRawDigitAssns = pset.get<bool>("DoRawDigitAssns", true);
    fEnableMonitoring = pset.get<bool>("EnableMonitoring", true);
    m_maxHit3DChiSquare = pset.get<float>("MaxHitChiSquare", 6.0);
    m_outputHistograms = pset.get<bool>("OutputHistograms", false);

    // Access ART's TFileService, which will handle creating and writing
    // histograms and n-tuples for us.
    art::ServiceHandle<art::TFileService> tfs;

    if (m_outputHistograms) {
      m_tupleTree = tfs->make<TTree>("Hit3DBuilderTree", "Tree by StandardHit3DBuilder");

      clear();

      m_tupleTree->Branch("DeltaTime2D", "std::vector<float>", &m_deltaTimeVec);
      m_tupleTree->Branch("ChiSquare3D", "std::vector<float>", &m_chiSquare3DVec);
      m_tupleTree->Branch("MaxPullValue", "std::vector<float>", &m_maxPullVec);
      m_tupleTree->Branch("OverlapFraction", "std::vector<float>", &m_overlapFractionVec);
      m_tupleTree->Branch("OverlapRange", "std::vector<float>", &m_overlapRangeVec);
      m_tupleTree->Branch("MaxSideVec", "std::vector<float>", &m_maxSideVecVec);
      m_tupleTree->Branch("PairWireDistVec", "std::vector<float>", &m_pairWireDistVec);
      m_tupleTree->Branch("SmallChargeDiff", "std::vector<float>", &m_smallChargeDiffVec);
      m_tupleTree->Branch("SmallChargeIdx", "std::vector<int>", &m_smallIndexVec);
      m_tupleTree->Branch("QualityMetric", "std::vector<float>", &m_qualityMetricVec);
      m_tupleTree->Branch("SPCharge", "std::vector<float>", &m_spacePointChargeVec);
      m_tupleTree->Branch("HitAsymmetry", "std::vector<float>", &m_hitAsymmetryVec);
    }

    fGeometry = art::ServiceHandle<geo::Geometry const>().get();
    fWireReadoutGeom = &art::ServiceHandle<geo::WireReadout const>()->Get();
  }

Member Function Documentation

float lar_cluster3d::SpacePointHit3DBuilder::chargeIntegral ( float  peakMean, float  peakAmp, float  peakSigma, int  low, int  hi  ) const

private

Perform charge integration between limits.

Definition at line 553 of file SpacePointHit3DBuilder_tool.cc.

References DEFINE_ART_CLASS_TOOL.

Referenced by getTimeToExecute(), and Hit3DBuilder().

  {
    float integral(0);

    for (int sigPos = low; sigPos < hi; sigPos++) {
      float arg = (float(sigPos) - peakMean + 0.5) / peakSigma;
      integral += peakAmp * std::exp(-0.5 * arg * arg);
    }

    return integral;
  }

void lar_cluster3d::SpacePointHit3DBuilder::clear ( )

private

clear the tuple vectors before processing next event

Definition at line 186 of file SpacePointHit3DBuilder_tool.cc.

References m_chiSquare3DVec, m_deltaTimeVec, m_hitAsymmetryVec, m_maxPullVec, m_maxSideVecVec, m_overlapFractionVec, m_overlapRangeVec, m_pairWireDistVec, m_qualityMetricVec, m_smallChargeDiffVec, m_smallIndexVec, and m_spacePointChargeVec.

Referenced by getTimeToExecute(), Hit3DBuilder(), and SpacePointHit3DBuilder().

  {
    m_deltaTimeVec.clear();
    m_chiSquare3DVec.clear();
    m_maxPullVec.clear();
    m_overlapFractionVec.clear();
    m_overlapRangeVec.clear();
    m_maxSideVecVec.clear();
    m_pairWireDistVec.clear();
    m_smallChargeDiffVec.clear();
    m_smallIndexVec.clear();
    m_qualityMetricVec.clear();
    m_spacePointChargeVec.clear();
    m_hitAsymmetryVec.clear();
  }

float lar_cluster3d::SpacePointHit3DBuilder::getTimeToExecute ( IHit3DBuilder::TimeValues  index ) const

inlineoverridevirtual

If monitoring, recover the time to execute a particular function.

Implements lar_cluster3d::IHit3DBuilder.

Definition at line 83 of file SpacePointHit3DBuilder_tool.cc.

References chargeIntegral(), clear(), and fTimeVector.

    {
      return fTimeVector.at(index);
    }

void lar_cluster3d::SpacePointHit3DBuilder::Hit3DBuilder ( art::Event &  evt, reco::HitPairList &  hitPairList, RecobHitToPtrMap &  recobHitToArtPtrMap  )

overridevirtual

Given a set of recob hits, run DBscan to form 3D clusters.

Parameters

hitPairList	The input list of 3D hits to run clustering on
clusterParametersList	A list of cluster objects (parameters from associated hits)

Recover the 2D hits from art and fill out the local data structures for the 3D clustering

Implements lar_cluster3d::IHit3DBuilder.

Definition at line 202 of file SpacePointHit3DBuilder_tool.cc.

References util::abs(), lar_cluster3d::IHit3DBuilder::BUILDTHREEDHITS, recob::Hit::Channel(), geo::WireReadoutGeom::ChannelToWire(), chargeIntegral(), clear(), geo::CryostatID::Cryostat, fDoRawDigitAssns, fDoWireAssns, fEnableMonitoring, fGeometry, fHitProducerLabel, fSpacePointProducerLabel, fTimeVector, fWireReadoutGeom, art::Ptr< T >::get(), art::ProductRetriever::getByLabel(), reco::ClusterHit2D::getHit(), reco::ClusterHit2D::getStatusBits(), reco::ClusterHit2D::getTimeTicks(), art::Handle< T >::isValid(), geo::kCollection, m_chiSquare3DVec, m_clusterHit2DMasterVec, m_deltaTimeVec, m_hitAsymmetryVec, m_maxPullVec, m_outputHistograms, m_overlapFractionVec, m_overlapRangeVec, m_qualityMetricVec, m_smallChargeDiffVec, m_smallIndexVec, m_spacePointChargeVec, m_tupleTree, geo::GeometryCore::Ncryostats(), geo::GeometryCore::NTPC(), lar_cluster3d::IHit3DBuilder::NUMTIMEVALUES, recob::Hit::PeakTime(), geo::PlaneID::Plane, recob::HitRefinerAssociator::put_into(), recob::Hit::RMS(), reco::ClusterHit2D::setStatusBit(), reco::ClusterHit2D::SHAREDINTRIPLET, geo::TPCID::TPC, detinfo::trigger_offset(), recob::HitRefinerAssociator::use_hits(), reco::ClusterHit2D::USEDINTRIPLET, weight, geo::WireID::Wire, reco::ClusterHit2D::WireID(), recob::Hit::WireID(), geo::WireID::WireID(), and recob::SpacePoint::XYZ().

  {
    fTimeVector.resize(NUMTIMEVALUES, 0.);

    cet::cpu_timer theClockMakeHits;

    if (fEnableMonitoring) theClockMakeHits.start();

    // Start by recovering the associations between space points and hits
    art::Handle<art::Assns<recob::Hit, recob::SpacePoint>> hitSpacePointAssnsHandle;
    evt.getByLabel(fSpacePointProducerLabel, hitSpacePointAssnsHandle);

    if (!hitSpacePointAssnsHandle.isValid()) return;

    // Get a hit refiner for the output hit collection
    recob::HitRefinerAssociator hitRefiner(evt, fHitProducerLabel, fDoWireAssns, fDoRawDigitAssns);

    // We need to spin through the associations first to build a map between the SpacePoints and
    // the WireID associated to the collection plane... where for APA style TPCs this will be
    // unambiguous (note that this is not true for ICARUS!)
    using SpacePointToWireIDMap = std::unordered_map<const recob::SpacePoint*, geo::WireID>;

    SpacePointToWireIDMap spacePointToWireIDMap;

    for (const auto& assnPair : *hitSpacePointAssnsHandle) {
      if (assnPair.first->SignalType() == geo::kCollection)
        spacePointToWireIDMap[assnPair.second.get()] = assnPair.first->WireID();
    }

    // First step is to loop through and get a mapping between space points and associated hits
    // and, importantly, a list of unique hits (and mapping between art ptr and hit)
    using OldHitToNewHitMap = std::map<const recob::Hit*, const recob::Hit*>;
    using SpacePointHitVecMap = std::map<const recob::SpacePoint*, std::vector<const recob::Hit*>>;

    OldHitToNewHitMap oldHitToNewHitMap;
    SpacePointHitVecMap spacePointHitVecMap;

    // We need a container for our new hits...
    std::unique_ptr<std::vector<recob::Hit>> newHitVecPtr(new std::vector<recob::Hit>);

    // reserve a chunk of memory... cannot be more hits than 3 x # spacer points...
    newHitVecPtr->reserve(3 * hitSpacePointAssnsHandle->size());

    // Use this handy art utility to make art::Ptr objects to the new recob::Hits for use in the output phase
    art::PtrMaker<recob::Hit> ptrMaker(evt);

    for (auto& assnPair : *hitSpacePointAssnsHandle) {
      const art::Ptr<recob::SpacePoint> spacePoint = assnPair.second;
      const art::Ptr<recob::Hit>& recobHit = assnPair.first;

      // If we have seen this hit before then no need to create new hit
      if (oldHitToNewHitMap.find(recobHit.get()) == oldHitToNewHitMap.end()) {
        // Recover the reference WireID from our previous map
        geo::WireID refWireID = spacePointToWireIDMap[spacePoint.get()];
        geo::WireID thisWireID = recobHit.get()->WireID();

        // Recover the list of possible WireIDs from the geometry service
        const std::vector<geo::WireID>& wireIDs =
          fWireReadoutGeom->ChannelToWire(recobHit.get()->Channel());

        // Loop to find match
        for (const auto& wireID : wireIDs) {
          if (wireID.TPC != refWireID.TPC || wireID.Cryostat != refWireID.Cryostat) continue;
          thisWireID = wireID;
          break;
        }

        // Create and save the new recob::Hit with the correct WireID
        newHitVecPtr->emplace_back(recob::HitCreator(*recobHit.get(), thisWireID).copy());

        // Recover a pointer to it...
        recob::Hit* newHit = &newHitVecPtr->back();

        spacePointHitVecMap[spacePoint.get()].push_back(newHit);

        recobHitToArtPtrMap[newHit] = ptrMaker(newHitVecPtr->size() - 1);
        oldHitToNewHitMap[recobHit.get()] = newHit;
      }
      else
        spacePointHitVecMap[spacePoint.get()].push_back(oldHitToNewHitMap[recobHit.get()]);
    }

    // We'll want to correct the hit times for the plane offsets
    // (note this is already taken care of when converting to position)
    std::map<geo::PlaneID, double> planeOffsetMap;

    auto const clock_data =
      art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
    auto const det_prop =
      art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt, clock_data);

    // Initialize the plane to hit vector map
    for (size_t cryoIdx = 0; cryoIdx < fGeometry->Ncryostats(); cryoIdx++) {
      for (size_t tpcIdx = 0; tpcIdx < fGeometry->NTPC(); tpcIdx++) {
        // What we want here are the relative offsets between the planes
        // Note that plane 0 is assumed the "first" plane and is the reference
        planeOffsetMap[geo::PlaneID(cryoIdx, tpcIdx, 0)] = 0.;
        planeOffsetMap[geo::PlaneID(cryoIdx, tpcIdx, 1)] =
          det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 1)) -
          det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 0));
        planeOffsetMap[geo::PlaneID(cryoIdx, tpcIdx, 2)] =
          det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 2)) -
          det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 0));

        std::cout << "***> plane 0 offset: " << planeOffsetMap[geo::PlaneID(cryoIdx, tpcIdx, 0)]
                  << ", plane 1: " << planeOffsetMap[geo::PlaneID(cryoIdx, tpcIdx, 1)]
                  << ", plane 2: " << planeOffsetMap[geo::PlaneID(cryoIdx, tpcIdx, 2)] << std::endl;
        std::cout << "     Det prop plane 0: "
                  << det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 0))
                  << ", plane 1: " << det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 1))
                  << ", plane 2: " << det_prop.GetXTicksOffset(geo::PlaneID(cryoIdx, tpcIdx, 2))
                  << ", Trig: " << trigger_offset(clock_data) << std::endl;
      }
    }

    // We need temporary mapping from recob::Hit's to our 2D hits
    using RecobHitTo2DHitMap = std::map<const recob::Hit*, const reco::ClusterHit2D*>;

    RecobHitTo2DHitMap recobHitTo2DHitMap;

    // Set the size of the container for our hits
    m_clusterHit2DMasterVec.clear();
    m_clusterHit2DMasterVec.reserve(oldHitToNewHitMap.size());

    // Now go throught the list of unique hits and create the 2D hits we'll use
    for (auto& hitPair : oldHitToNewHitMap) {
      const recob::Hit* recobHit = hitPair.second;
      const geo::WireID& hitWireID(recobHit->WireID());

      double hitPeakTime(
        recobHit->PeakTime() -
        planeOffsetMap.at(hitWireID.planeID())); //planeOffsetMap[hitWireID.planeID()]);
      double xPosition(det_prop.ConvertTicksToX(
        recobHit->PeakTime(), hitWireID.Plane, hitWireID.TPC, hitWireID.Cryostat));

      m_clusterHit2DMasterVec.emplace_back(0, 0., 0., xPosition, hitPeakTime, hitWireID, recobHit);

      recobHitTo2DHitMap[recobHit] = &m_clusterHit2DMasterVec.back();
    }

    // Now we can go through the space points and build our 3D hits
    for (auto& pointPair : spacePointHitVecMap) {
      const recob::SpacePoint* spacePoint = pointPair.first;
      const std::vector<const recob::Hit*>& recobHitVec = pointPair.second;

      if (recobHitVec.size() != 3) {
        std::cout << "************>>>>>> do not have 3 hits associated to space point! "
                  << recobHitVec.size() << " ***************" << std::endl;
        continue;
      }

      reco::ClusterHit2DVec hitVector(recobHitVec.size());

      for (const auto& recobHit : recobHitVec) {
        const reco::ClusterHit2D* hit2D = recobHitTo2DHitMap.at(recobHit);

        hitVector[hit2D->WireID().Plane] = hit2D;
      }

      // Set up to get average peak time, hitChiSquare, etc.
      unsigned int statusBits(0x7);
      float avePeakTime(0.);
      float weightSum(0.);

      // And get the wire IDs
      std::vector<geo::WireID> wireIDVec = {geo::WireID(), geo::WireID(), geo::WireID()};

      // First loop through the hits to get WireIDs and calculate the averages
      for (size_t planeIdx = 0; planeIdx < 3; planeIdx++) {
        const reco::ClusterHit2D* hit2D = hitVector[planeIdx];

        wireIDVec[planeIdx] = hit2D->WireID();

        if (hit2D->getStatusBits() & reco::ClusterHit2D::USEDINTRIPLET)
          hit2D->setStatusBit(reco::ClusterHit2D::SHAREDINTRIPLET);

        hit2D->setStatusBit(reco::ClusterHit2D::USEDINTRIPLET);

        float hitRMS = hit2D->getHit()->RMS();
        float weight = 1. / (hitRMS * hitRMS);
        float peakTime = hit2D->getTimeTicks();

        avePeakTime += peakTime * weight;
        weightSum += weight;
      }

      avePeakTime /= weightSum;

      // Armed with the average peak time, now get hitChiSquare and the sig vec
      float hitChiSquare(0.);
      float sigmaPeakTime(std::sqrt(1. / weightSum));
      std::vector<float> hitDelTSigVec;

      for (const auto& hit2D : hitVector) {
        float hitRMS = hit2D->getHit()->RMS();
        float combRMS = std::sqrt(hitRMS * hitRMS - sigmaPeakTime * sigmaPeakTime);
        float peakTime = hit2D->getTimeTicks();
        float deltaTime = peakTime - avePeakTime;
        float hitSig = deltaTime / combRMS;

        hitChiSquare += hitSig * hitSig;

        hitDelTSigVec.emplace_back(std::fabs(hitSig));
      }

      if (m_outputHistograms) m_chiSquare3DVec.push_back(hitChiSquare);

      // Need to determine the hit overlap ranges
      int lowMinIndex(std::numeric_limits<int>::max());
      int lowMaxIndex(std::numeric_limits<int>::min());
      int hiMinIndex(std::numeric_limits<int>::max());
      int hiMaxIndex(std::numeric_limits<int>::min());

      // This loop through hits to find min/max values for the common overlap region
      for (const auto& hit2D : hitVector) {
        int hitStart = hit2D->getHit()->PeakTime() - 2. * hit2D->getHit()->RMS() - 0.5;
        int hitStop = hit2D->getHit()->PeakTime() + 2. * hit2D->getHit()->RMS() + 0.5;

        lowMinIndex = std::min(hitStart, lowMinIndex);
        lowMaxIndex = std::max(hitStart, lowMaxIndex);
        hiMinIndex = std::min(hitStop + 1, hiMinIndex);
        hiMaxIndex = std::max(hitStop + 1, hiMaxIndex);
      }

      // Keep only "good" hits...
      if (hitChiSquare < m_maxHit3DChiSquare && hiMinIndex > lowMaxIndex) {
        // One more pass through hits to get charge
        std::vector<float> chargeVec;

        for (const auto& hit2D : hitVector)
          chargeVec.push_back(chargeIntegral(hit2D->getHit()->PeakTime(),
                                             hit2D->getHit()->PeakAmplitude(),
                                             hit2D->getHit()->RMS(),
                                             lowMaxIndex,
                                             hiMinIndex));

        float totalCharge =
          std::accumulate(chargeVec.begin(), chargeVec.end(), 0.) / float(chargeVec.size());
        float overlapRange = float(hiMinIndex - lowMaxIndex);
        float overlapFraction = overlapRange / float(hiMaxIndex - lowMinIndex);

        // Set up to compute the charge asymmetry
        std::vector<float> smallestChargeDiffVec;
        std::vector<float> chargeAveVec;
        float smallestDiff(std::numeric_limits<float>::max());
        size_t chargeIndex(0);

        for (size_t idx = 0; idx < 3; idx++) {
          size_t leftIdx = (idx + 2) % 3;
          size_t rightIdx = (idx + 1) % 3;

          smallestChargeDiffVec.push_back(std::abs(chargeVec[leftIdx] - chargeVec[rightIdx]));
          chargeAveVec.push_back(float(0.5 * (chargeVec[leftIdx] + chargeVec[rightIdx])));

          if (smallestChargeDiffVec.back() < smallestDiff) {
            smallestDiff = smallestChargeDiffVec.back();
            chargeIndex = idx;
          }

          // Take opportunity to look at peak time diff
          if (m_outputHistograms) {
            float deltaPeakTime =
              hitVector[leftIdx]->getTimeTicks() - hitVector[rightIdx]->getTimeTicks();

            m_deltaTimeVec.push_back(deltaPeakTime);
          }
        }

        float chargeAsymmetry = (chargeAveVec[chargeIndex] - chargeVec[chargeIndex]) /
                                (chargeAveVec[chargeIndex] + chargeVec[chargeIndex]);

        // If this is true there has to be a negative charge that snuck in somehow
        if (chargeAsymmetry < -1. || chargeAsymmetry > 1.) {
          const geo::WireID& hitWireID = hitVector[chargeIndex]->WireID();

          std::cout << "============> Charge asymmetry out of range: " << chargeAsymmetry
                    << " <============" << std::endl;
          std::cout << "     hit C: " << hitWireID.Cryostat << ", TPC: " << hitWireID.TPC
                    << ", Plane: " << hitWireID.Plane << ", Wire: " << hitWireID.Wire << std::endl;
          std::cout << "     charge: " << chargeVec[0] << ", " << chargeVec[1] << ", "
                    << chargeVec[2] << std::endl;
          std::cout << "     index: " << chargeIndex << ", smallest diff: " << smallestDiff
                    << std::endl;
          continue;
        }

        // Usurping "deltaPeakTime" to be the maximum pull
        float deltaPeakTime = *std::max_element(hitDelTSigVec.begin(), hitDelTSigVec.end());

        if (m_outputHistograms) {
          m_smallChargeDiffVec.push_back(smallestDiff);
          m_smallIndexVec.push_back(chargeIndex);
          m_maxPullVec.push_back(deltaPeakTime);
          m_qualityMetricVec.push_back(hitChiSquare);
          m_spacePointChargeVec.push_back(totalCharge);
          m_overlapFractionVec.push_back(overlapFraction);
          m_overlapRangeVec.push_back(overlapRange);
          m_hitAsymmetryVec.push_back(chargeAsymmetry);
        }

        Eigen::Vector3f position(
          float(spacePoint->XYZ()[0]), float(spacePoint->XYZ()[1]), float(spacePoint->XYZ()[2]));

        // Create the 3D cluster hit
        hitPairList.emplace_back(0,
                                 statusBits,
                                 position,
                                 totalCharge,
                                 avePeakTime,
                                 deltaPeakTime,
                                 sigmaPeakTime,
                                 hitChiSquare,
                                 overlapFraction,
                                 chargeAsymmetry,
                                 0.,
                                 0.,
                                 hitVector,
                                 hitDelTSigVec,
                                 wireIDVec);
      }
    }

    // Now we give the new hits to the refinery
    // Note that one advantage of using this utility is that it handles the
    // Hit/Wire and Hit/RawDigit associations all behind the scenes for us
    hitRefiner.use_hits(std::move(newHitVecPtr));

    // Output the new hit collection to the event
    hitRefiner.put_into();

    // Handle tree output too
    m_tupleTree->Fill();

    clear();

    if (fEnableMonitoring) {
      theClockMakeHits.stop();

      fTimeVector[BUILDTHREEDHITS] = theClockMakeHits.accumulated_real_time();
    }

    mf::LogDebug("Cluster3D") << ">>>>> 3D hit building done, found " << hitPairList.size()
                              << " 3D Hits" << std::endl;
  }

void lar_cluster3d::SpacePointHit3DBuilder::produces ( art::ProducesCollector &  collector )

overridevirtual

Each algorithm may have different objects it wants "produced" so use this to let the top level producer module "know" what it is outputting.

Implements lar_cluster3d::IHit3DBuilder.

Definition at line 176 of file SpacePointHit3DBuilder_tool.cc.

References fDoRawDigitAssns, fDoWireAssns, and art::ProducesCollector::produces().

  {
    collector.produces<std::vector<recob::Hit>>();

    if (fDoWireAssns) collector.produces<art::Assns<recob::Wire, recob::Hit>>();
    if (fDoRawDigitAssns) collector.produces<art::Assns<raw::RawDigit, recob::Hit>>();
  }

Member Data Documentation

bool lar_cluster3d::SpacePointHit3DBuilder::fDoRawDigitAssns

private

Definition at line 107 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), produces(), and SpacePointHit3DBuilder().

bool lar_cluster3d::SpacePointHit3DBuilder::fDoWireAssns

private

Definition at line 106 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), produces(), and SpacePointHit3DBuilder().

bool lar_cluster3d::SpacePointHit3DBuilder::fEnableMonitoring

private

Definition at line 111 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

const geo::Geometry* lar_cluster3d::SpacePointHit3DBuilder::fGeometry

private

Definition at line 133 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

art::InputTag lar_cluster3d::SpacePointHit3DBuilder::fHitProducerLabel

private

Definition at line 105 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

art::InputTag lar_cluster3d::SpacePointHit3DBuilder::fSpacePointProducerLabel

private

Data members to follow.

Definition at line 104 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::fTimeVector

mutableprivate

Definition at line 112 of file SpacePointHit3DBuilder_tool.cc.

Referenced by getTimeToExecute(), and Hit3DBuilder().

const geo::WireReadoutGeom* lar_cluster3d::SpacePointHit3DBuilder::fWireReadoutGeom

private

Definition at line 134 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_chiSquare3DVec

mutableprivate

Definition at line 118 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

Hit2DVector lar_cluster3d::SpacePointHit3DBuilder::m_clusterHit2DMasterVec

mutableprivate

Definition at line 131 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_deltaTimeVec

mutableprivate

Definition at line 117 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_hitAsymmetryVec

mutableprivate

Definition at line 128 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

float lar_cluster3d::SpacePointHit3DBuilder::m_maxHit3DChiSquare

private

Provide ability to select hits based on "chi square".

Definition at line 108 of file SpacePointHit3DBuilder_tool.cc.

Referenced by SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_maxPullVec

mutableprivate

Definition at line 119 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_maxSideVecVec

mutableprivate

Definition at line 122 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), and SpacePointHit3DBuilder().

bool lar_cluster3d::SpacePointHit3DBuilder::m_outputHistograms

private

Take the time to create and fill some histograms for diagnostics.

Definition at line 109 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_overlapFractionVec

mutableprivate

Definition at line 120 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_overlapRangeVec

mutableprivate

Definition at line 121 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_pairWireDistVec

mutableprivate

Definition at line 123 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_qualityMetricVec

mutableprivate

Definition at line 126 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_smallChargeDiffVec

mutableprivate

Definition at line 124 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<int> lar_cluster3d::SpacePointHit3DBuilder::m_smallIndexVec

mutableprivate

Definition at line 125 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

std::vector<float> lar_cluster3d::SpacePointHit3DBuilder::m_spacePointChargeVec

mutableprivate

Definition at line 127 of file SpacePointHit3DBuilder_tool.cc.

Referenced by clear(), Hit3DBuilder(), and SpacePointHit3DBuilder().

TTree* lar_cluster3d::SpacePointHit3DBuilder::m_tupleTree

private

output analysis tree

Definition at line 115 of file SpacePointHit3DBuilder_tool.cc.

Referenced by Hit3DBuilder(), and SpacePointHit3DBuilder().

---

The documentation for this class was generated from the following file:

• larreco/v10_01_12/source/larreco/RecoAlg/Cluster3DAlgs/SpacePointHit3DBuilder_tool.cc