tss::TrackShowerHits Class Reference

Inheritance diagram for tss::TrackShowerHits:

Public Member Functions
	TrackShowerHits (fhicl::ParameterSet const &p)
	TrackShowerHits (TrackShowerHits const &)=delete
	TrackShowerHits (TrackShowerHits &&)=delete
TrackShowerHits &	operator= (TrackShowerHits const &)=delete
TrackShowerHits &	operator= (TrackShowerHits &&)=delete

Private Member Functions
void	produce (art::Event &e) override
bool	sortHits (const art::Event &evt)

Private Attributes
cryo_tpc_view_hitmap	fHitMap
art::ServiceHandle < geo::Geometry const >	fGeom
bool	fHugeShowers
bool	fShowersBySeg2D
tss::SimpleClustering	fSimpleClustering
tss::Segmentation2D	fSegmentation2D
std::string	fHitModuleLabel

Detailed Description

Definition at line 32 of file TrackShowerHits_module.cc.

Constructor & Destructor Documentation

tss::TrackShowerHits::TrackShowerHits ( fhicl::ParameterSet const &  p )

explicit

Definition at line 58 of file TrackShowerHits_module.cc.

    : EDProducer{p}, fSegmentation2D(p.get<fhicl::ParameterSet>("Segmentation2DAlg"))
  {
    fHitModuleLabel = p.get<std::string>("HitModuleLabel");
    fHugeShowers = p.get<bool>("FindHugeShowers");
    fShowersBySeg2D = p.get<bool>("FindMoreShowers");

    produces<std::vector<recob::Cluster>>();
    produces<art::Assns<recob::Cluster, recob::Hit>>();
  }

tss::TrackShowerHits::TrackShowerHits ( TrackShowerHits const &  )

delete

tss::TrackShowerHits::TrackShowerHits ( TrackShowerHits &&  )

delete

Member Function Documentation

TrackShowerHits& tss::TrackShowerHits::operator= ( TrackShowerHits const &  )

delete

TrackShowerHits& tss::TrackShowerHits::operator= ( TrackShowerHits &&  )

delete

void tss::TrackShowerHits::produce ( art::Event &  e )

overrideprivate

Definition at line 98 of file TrackShowerHits_module.cc.

  {
    std::unique_ptr<std::vector<recob::Cluster>> clusters(new std::vector<recob::Cluster>);
    std::unique_ptr<art::Assns<recob::Cluster, recob::Hit>> clu2hit(
      new art::Assns<recob::Cluster, recob::Hit>);

    if (sortHits(evt)) {
      unsigned int cidx = 0;
      const unsigned int emTag = 0x10000;

      for (auto tpc_iter = fGeom->begin_TPC_id(); tpc_iter != fGeom->end_TPC_id(); tpc_iter++) {
        for (const auto& v : fHitMap[tpc_iter->Cryostat][tpc_iter->TPC]) {
          auto cls = fSimpleClustering.run(v.second);

          if (fHugeShowers) {
            mf::LogVerbatim("TrackShowerHits") << "Find huge EM showers (cores).";

            int c = 0, clsSize = cls.size();
            while (c < clsSize) {
              if (cls[c].hits().size() < 2) {
                c++;
                continue;
              }

              std::vector<const tss::Hit2D*> trks, ems;
              fSegmentation2D.splitHitsNaive(cls[c], trks, ems);
              cls.erase(cls.begin() + c);
              clsSize--;

              cls.emplace_back(Cluster2D(trks));
              cls.emplace_back(Cluster2D(ems));
              cls.back().tagEM(true);
            }
          }

          if (fShowersBySeg2D) {
            mf::LogVerbatim("TrackShowerHits") << "Find EM showers by density of vtxs.";

            int c = 0, clsSize = cls.size();
            while (c < clsSize) {
              if (cls[c].isEM() || (cls[c].hits().size() < 2)) {
                c++;
                continue;
              }

              auto segs = fSegmentation2D.run(cls[c]);

              for (const auto& s : segs)
                cls.emplace_back(Cluster2D(s));

              cls.erase(cls.begin() + c);
              clsSize--;
            }
          }

          for (auto& c : cls) {
            if (!c.hits().size()) continue; // skip 0-size clusters

            if (!c.isEM()) continue; // create clusters only for em parts now

            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,
                             c.hits().size(),
                             0.0F,
                             0.0F,
                             cidx + emTag,
                             (geo::View_t)c.hits().front()->View(),
                             c.hits().front()->Hit2DPtr()->WireID().planeID()));

            std::vector<art::Ptr<recob::Hit>> hits2d;
            hits2d.reserve(c.hits().size());

            for (auto h2d : c.hits())
              hits2d.push_back(h2d->Hit2DPtr());

            if (hits2d.size()) util::CreateAssn(*this, evt, *clusters, hits2d, *clu2hit);

            ++cidx;
          }
        }
      }
    }
    else
      mf::LogWarning("TrackShowerHits") << "Hits not found in the event.";

    evt.put(std::move(clusters));
    evt.put(std::move(clu2hit));
  }

bool tss::TrackShowerHits::sortHits ( const art::Event &  evt )

private

Definition at line 71 of file TrackShowerHits_module.cc.

  {
    auto const detProp =
      art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(evt);
    fHitMap.clear();

    art::Handle<std::vector<recob::Hit>> hitListHandle;
    std::vector<art::Ptr<recob::Hit>> hitlist;
    if (evt.getByLabel(fHitModuleLabel, hitListHandle)) {
      art::fill_ptr_vector(hitlist, hitListHandle);

      unsigned int cryo, tpc, view;
      for (auto const& h : hitlist) {
        cryo = h->WireID().Cryostat;
        tpc = h->WireID().TPC;
        view = h->WireID().Plane;

        fHitMap[cryo][tpc][view].emplace_back(detProp, h);
      }
      return true;
    }
    else
      return false;
  }

Member Data Documentation

art::ServiceHandle<geo::Geometry const> tss::TrackShowerHits::fGeom

private

Definition at line 47 of file TrackShowerHits_module.cc.

cryo_tpc_view_hitmap tss::TrackShowerHits::fHitMap

private

Definition at line 44 of file TrackShowerHits_module.cc.

std::string tss::TrackShowerHits::fHitModuleLabel

private

Definition at line 54 of file TrackShowerHits_module.cc.

bool tss::TrackShowerHits::fHugeShowers

private

Definition at line 49 of file TrackShowerHits_module.cc.

tss::Segmentation2D tss::TrackShowerHits::fSegmentation2D

private

Definition at line 52 of file TrackShowerHits_module.cc.

bool tss::TrackShowerHits::fShowersBySeg2D

private

Definition at line 49 of file TrackShowerHits_module.cc.

tss::SimpleClustering tss::TrackShowerHits::fSimpleClustering

private

Definition at line 51 of file TrackShowerHits_module.cc.

---

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

• TrackShowerHits_module.cc