#include <EmTrack.h>

Classes
struct	Config

Public Types
using	key = std::tuple< unsigned int, unsigned int, unsigned int >

using	cryo_tpc_view_keymap = std::map< key, std::vector< size_t >>

Public Member Functions
	EmTrack (Config const &c, std::string const &s, art::ProducesCollector &pc)

void	produce (art::Event &e)

Private Types
using	writer = anab::MVAWriter< N >

Private Member Functions
bool	isViewSelected (int view) const

void	make_clusters (art::Event &evt, std::vector< art::Ptr< recob::Hit >> const &hitPtrList, std::vector< char > const &hitInFA, EmTrack::cryo_tpc_view_keymap const &hitMap)

void	make_tracks (art::Event const &evt, std::vector< char > const &hitInFA)
	make tracks More...

cryo_tpc_view_keymap	create_hitmap (std::vector< art::Ptr< recob::Hit >> const &hitPtrList) const

std::vector< char >	classify_hits (art::Event const &evt, EmTrack::cryo_tpc_view_keymap const &hitMap, std::vector< art::Ptr< recob::Hit >> const &hitPtrList)

Private Attributes
const size_t	fBatchSize

std::unique_ptr< PointIdAlgTools::IPointIdAlg >	fPointIdAlgTool

writer	fMVAWriter

const art::InputTag	fWireProducerLabel

const art::InputTag	fHitModuleLabel

const art::InputTag	fClusterModuleLabel

const art::InputTag	fTrackModuleLabel

const bool	fDoClusters

const bool	fDoTracks

const std::vector< int >	fViews

const art::InputTag	fNewClustersTag

Detailed Description

template<size_t N>
class nnet::EmTrack< N >

Definition at line 31 of file EmTrack.h.

Member Typedef Documentation

template<size_t N>

using nnet::EmTrack< N >::cryo_tpc_view_keymap = std::map<key, std::vector<size_t>>

Definition at line 34 of file EmTrack.h.

template<size_t N>

using nnet::EmTrack< N >::key = std::tuple<unsigned int, unsigned int, unsigned int>

Definition at line 33 of file EmTrack.h.

template<size_t N>

using nnet::EmTrack< N >::writer = anab::MVAWriter<N>

private

Definition at line 78 of file EmTrack.h.

Constructor & Destructor Documentation

template<size_t N>

nnet::EmTrack< N >::EmTrack	(	EmTrack< N >::Config const &	config,
		std::string const &	s,
		art::ProducesCollector &	pc
	)

explicit

Definition at line 394 of file EmTrack.h.

     : fBatchSize(config.BatchSize())
     , fPointIdAlgTool(art::make_tool<PointIdAlgTools::IPointIdAlg>(
         config.PointIdAlg.get_PSet()))
     , fMVAWriter(collector, "emtrkmichel")
     , fWireProducerLabel(config.WireLabel())
     , fHitModuleLabel(config.HitModuleLabel())
     , fClusterModuleLabel(config.ClusterModuleLabel())
     , fTrackModuleLabel(config.TrackModuleLabel())
     , fDoClusters(!fClusterModuleLabel.label().empty())
     , fDoTracks(!fTrackModuleLabel.label().empty())
     , fViews(config.Views())
     , fNewClustersTag(
         module_label,
         "",
         art::ServiceHandle<art::TriggerNamesService const>()->getProcessName())
   {
     fMVAWriter.template produces_using<recob::Hit>();
 
     if (!fClusterModuleLabel.label().empty()) {
       collector.produces<std::vector<recob::Cluster>>();
       collector.produces<art::Assns<recob::Cluster, recob::Hit>>();
 
       fMVAWriter.template produces_using<recob::Cluster>();
     }
 
     if (!fTrackModuleLabel.label().empty()) {
       fMVAWriter.template produces_using<recob::Track>();
     }
   }

Member Function Documentation

template<size_t N>

std::vector< char > nnet::EmTrack< N >::classify_hits	(	art::Event const &	evt,
		EmTrack< N >::cryo_tpc_view_keymap const &	hitMap,
		std::vector< art::Ptr< recob::Hit >> const &	hitPtrList
	)

private

Definition at line 332 of file EmTrack.h.

   {
     auto hitID = fMVAWriter.template initOutputs<recob::Hit>(
       fHitModuleLabel, hitPtrList.size(), fPointIdAlgTool->outputLabels());
 
     auto const clockData =
       art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(evt);
     auto const detProp =
       art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(
         evt, clockData);
     auto wireHandle =
       evt.getValidHandle<std::vector<recob::Wire>>(fWireProducerLabel);
     std::vector<char> hitInFA(hitPtrList.size(),
                               0); // tag hits in fid. area as 1, use 0 for hits
                                   // close to the projectrion edges
     for (auto const& [key, hits] : hitMap) {
       auto const& [cryo, tpc, view] = key;
       if (!isViewSelected(view))
         continue; // should not happen, hits were selected
 
       fPointIdAlgTool->setWireDriftData(
         clockData, detProp, *wireHandle, view, tpc, cryo);
 
       // (1) do all hits in this plane
       // ------------------------------------------------
       for (size_t idx = 0; idx < hits.size(); idx += fBatchSize) {
         std::vector<std::pair<unsigned int, float>> points;
         std::vector<size_t> keys;
         for (size_t k = 0; k < fBatchSize; ++k) {
           if (idx + k >= hits.size()) {
             break;
           } // careful about the tail
 
           size_t h = hits[idx + k]; // h is the Ptr< recob::Hit >::key()
           const recob::Hit& hit = *(hitPtrList[h]);
           points.emplace_back(hit.WireID().Wire, hit.PeakTime());
           keys.push_back(h);
         }
 
         auto batch_out = fPointIdAlgTool->predictIdVectors(points);
         if (points.size() != batch_out.size()) {
           throw cet::exception("EmTrack")
             << "hits processing failed" << std::endl;
         }
 
         for (size_t k = 0; k < points.size(); ++k) {
           size_t h = keys[k];
           fMVAWriter.setOutput(hitID, h, batch_out[k]);
           if (fPointIdAlgTool->isInsideFiducialRegion(points[k].first,
                                                       points[k].second)) {
             hitInFA[h] = 1;
           }
         }
       } // hits done
         // ------------------------------------------------------------------
     }
     return hitInFA;
   }

template<size_t N>

EmTrack< N >::cryo_tpc_view_keymap nnet::EmTrack< N >::create_hitmap ( std::vector< art::Ptr< recob::Hit >> const & hitPtrList ) const

private

Definition at line 312 of file EmTrack.h.

   {
     cryo_tpc_view_keymap hitMap;
     for (auto const& hptr : hitPtrList) {
       auto const& h = *hptr;
       unsigned int view = h.WireID().Plane;
       if (!isViewSelected(view))
         continue;
 
       unsigned int cryo = h.WireID().Cryostat;
       unsigned int tpc = h.WireID().TPC;
 
       hitMap[{cryo, tpc, view}].push_back(hptr.key());
     }
     return hitMap;
   }

template<size_t N>

bool nnet::EmTrack< N >::isViewSelected ( int view ) const

private

Definition at line 452 of file EmTrack.h.

   {
     if (fViews.empty())
       return true;
     return cet::search_all(fViews, view);
   }

template<size_t N>

void nnet::EmTrack< N >::make_clusters	(	art::Event &	evt,
		std::vector< art::Ptr< recob::Hit >> const &	hitPtrList,
		std::vector< char > const &	hitInFA,
		EmTrack< N >::cryo_tpc_view_keymap const &	hitMap
	)

private

Definition at line 104 of file EmTrack.h.

   {
     // **************** prepare for new clusters ****************
     auto clusters = std::make_unique<std::vector<recob::Cluster>>();
     auto clu2hit = std::make_unique<art::Assns<recob::Cluster, recob::Hit>>();
 
     // ************** get and sort input clusters ***************
     auto cluListHandle =
       evt.getValidHandle<std::vector<recob::Cluster>>(fClusterModuleLabel);
     std::vector<art::Ptr<recob::Cluster>> cluPtrList;
     art::fill_ptr_vector(cluPtrList, cluListHandle);
 
     EmTrack::cryo_tpc_view_keymap cluMap;
     for (auto const& c : cluPtrList) {
       unsigned int view = c->Plane().Plane;
       if (!isViewSelected(view))
         continue;
 
       unsigned int cryo = c->Plane().Cryostat;
       unsigned int tpc = c->Plane().TPC;
 
       cluMap[{cryo, tpc, view}].push_back(c.key());
     }
 
     auto cluID = fMVAWriter.template initOutputs<recob::Cluster>(
       fNewClustersTag, fPointIdAlgTool->outputLabels());
 
     unsigned int cidx = 0; // new clusters index
     art::FindManyP<recob::Hit> hitsFromClusters(
       cluListHandle, evt, fClusterModuleLabel);
     std::vector<bool> hitUsed(hitPtrList.size(),
                               false); // tag hits used in clusters
                                       // clang-format off
         for (auto const & [key, clusters_keys] : cluMap)
         {
             auto const& [cryo, tpc, view]= key;
                                       // clang-format on
       if (!isViewSelected(view))
         continue; // should not happen, clusters were pre-selected
 
       for (size_t c : clusters_keys) // c is the Ptr< recob::Cluster >::key()
       {
         auto v = hitsFromClusters.at(c);
         if (v.empty())
           continue;
 
         for (auto const& hit : v) {
           if (hitUsed[hit.key()]) {
             mf::LogWarning("EmTrack") << "hit already used in another cluster";
           }
           hitUsed[hit.key()] = true;
         }
 
         auto vout = fMVAWriter.template getOutput<recob::Hit>(
           v, [&](art::Ptr<recob::Hit> const& ptr) {
             return (float)hitInFA[ptr.key()];
           });
 
         float pvalue = vout[0] / (vout[0] + vout[1]);
         mf::LogVerbatim("EmTrack")
           << "cluster in tpc:" << tpc << " view:" << view
           << " size:" << v.size() << " p:" << pvalue;
 
         clusters->emplace_back(recob::Cluster(0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               0.0F,
                                               v.size(),
                                               0.0F,
                                               0.0F,
                                               cidx,
                                               (geo::View_t)view,
                                               v.front()->WireID().planeID()));
         util::CreateAssn(evt, *clusters, v, *clu2hit);
         cidx++;
 
         fMVAWriter.addOutput(cluID,
                                       vout); // add copy of the input cluster
       }
 
       // (2b) make single-hit clusters
       // --------------------------------------------
       for (size_t h :
            hitMap.at({cryo, tpc, view})) // h is the Ptr< recob::Hit >::key()
       {
         if (hitUsed[h])
           continue;
 
         auto vout = fMVAWriter.template getOutput<recob::Hit>(h);
         float pvalue = vout[0] / (vout[0] + vout[1]);
 
         mf::LogVerbatim("EmTrack")
           << "single hit in tpc:" << tpc << " view:" << view
           << " wire:" << hitPtrList[h]->WireID().Wire
           << " drift:" << hitPtrList[h]->PeakTime() << " p:" << pvalue;
 
         art::PtrVector<recob::Hit> cluster_hits;
         cluster_hits.push_back(hitPtrList[h]);
         clusters->emplace_back(
           recob::Cluster(0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          0.0F,
                          1,
                          0.0F,
                          0.0F,
                          cidx,
                          (geo::View_t)view,
                          hitPtrList[h]->WireID().planeID()));
         util::CreateAssn(evt, *clusters, cluster_hits, *clu2hit);
         cidx++;
 
         fMVAWriter.addOutput(
           cluID, vout); // add single-hit cluster tagging unclutered hit
       }
       mf::LogVerbatim("EmTrack")
         << "...produced " << cidx - clusters_keys.size()
         << " single-hit clusters.";
     }
 
     evt.put(std::move(clusters));
     evt.put(std::move(clu2hit));
   }

template<size_t N>

void nnet::EmTrack< N >::make_tracks	(	art::Event const &	evt,
		std::vector< char > const &	hitInFA
	)

private

make tracks

Definition at line 262 of file EmTrack.h.

   {
     auto trkListHandle =
       evt.getValidHandle<std::vector<recob::Track>>(fTrackModuleLabel);
     art::FindManyP<recob::Hit> hitsFromTracks(
       trkListHandle, evt, fTrackModuleLabel);
     std::vector<std::vector<art::Ptr<recob::Hit>>> trkHitPtrList(
       trkListHandle->size());
     for (size_t t = 0; t < trkListHandle->size(); ++t) {
       auto v = hitsFromTracks.at(t);
       size_t nh[3] = {0, 0, 0};
       for (auto const& hptr : v) {
         ++nh[hptr->View()];
       }
       size_t best_view = 2; // collection
       if ((nh[0] >= nh[1]) && (nh[0] > 2 * nh[2]))
         best_view = 0; // ind1
       if ((nh[1] >= nh[0]) && (nh[1] > 2 * nh[2]))
         best_view = 1; // ind2
 
       size_t k = 0;
       while (!isViewSelected(best_view)) {
         best_view = (best_view + 1) % 3;
         if (++k > 3) {
           throw cet::exception("EmTrack")
             << "No views selected at all?" << std::endl;
         }
       }
 
       for (auto const& hptr : v) {
         if (hptr->View() == best_view)
           trkHitPtrList[t].emplace_back(hptr);
       }
     }
 
     auto trkID = fMVAWriter.template initOutputs<recob::Track>(
       fTrackModuleLabel, trkHitPtrList.size(), fPointIdAlgTool->outputLabels());
     for (size_t t = 0; t < trkHitPtrList.size();
          ++t) // t is the Ptr< recob::Track >::key()
     {
       auto vout = fMVAWriter.template getOutput<recob::Hit>(
         trkHitPtrList[t], [&](art::Ptr<recob::Hit> const& ptr) {
           return (float)hitInFA[ptr.key()];
         });
       fMVAWriter.setOutput(trkID, t, vout);
     }
   }

template<size_t N>

void nnet::EmTrack< N >::produce ( art::Event & e )

Definition at line 430 of file EmTrack.h.

   {
     mf::LogVerbatim("EmTrack")
       << "next event: " << evt.run() << " / " << evt.id().event();
     auto hitListHandle =
       evt.getValidHandle<std::vector<recob::Hit>>(fHitModuleLabel);
     std::vector<art::Ptr<recob::Hit>> hitPtrList;
     art::fill_ptr_vector(hitPtrList, hitListHandle);
     const EmTrack::cryo_tpc_view_keymap hitMap = create_hitmap(hitPtrList);
     const std::vector<char> hitInFA = classify_hits(evt, hitMap, hitPtrList);
 
     if (fDoClusters)
       make_clusters(evt, hitPtrList, hitInFA, hitMap);
 
     if (fDoTracks)
       make_tracks(evt, hitInFA);
     fMVAWriter.saveOutputs(evt);
   }

Member Data Documentation

template<size_t N>

const size_t nnet::EmTrack< N >::fBatchSize

private

Definition at line 76 of file EmTrack.h.

template<size_t N>

const art::InputTag nnet::EmTrack< N >::fClusterModuleLabel

private

Definition at line 82 of file EmTrack.h.

template<size_t N>

const bool nnet::EmTrack< N >::fDoClusters

private

Definition at line 84 of file EmTrack.h.

template<size_t N>

const bool nnet::EmTrack< N >::fDoTracks

private

Definition at line 85 of file EmTrack.h.

template<size_t N>

const art::InputTag nnet::EmTrack< N >::fHitModuleLabel

private

Definition at line 81 of file EmTrack.h.

template<size_t N>

writer nnet::EmTrack< N >::fMVAWriter

private

Definition at line 79 of file EmTrack.h.

template<size_t N>

const art::InputTag nnet::EmTrack< N >::fNewClustersTag

private

Definition at line 88 of file EmTrack.h.

template<size_t N>

std::unique_ptr<PointIdAlgTools::IPointIdAlg> nnet::EmTrack< N >::fPointIdAlgTool

private

Definition at line 77 of file EmTrack.h.

template<size_t N>

const art::InputTag nnet::EmTrack< N >::fTrackModuleLabel

private

Definition at line 83 of file EmTrack.h.

template<size_t N>

const std::vector<int> nnet::EmTrack< N >::fViews

private

Definition at line 86 of file EmTrack.h.

template<size_t N>

const art::InputTag nnet::EmTrack< N >::fWireProducerLabel

private

Definition at line 80 of file EmTrack.h.

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

larrecodnn/larrecodnn/ImagePatternAlgs/Modules/EmTrack.h

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

template<size_t N> class nnet::EmTrack< N >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<size_t N>
class nnet::EmTrack< N >