LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
SpacePointFinder_module.cc
Go to the documentation of this file.
1 //
2 // Name: SpacePointFinder_module.cc
3 //
4 // Purpose: Module SpacePointFinder.
5 //
6 // Configuration parameters.
7 //
8 // ClusterModuleLabel: // Cluster module label (e.g. "dbcluster").
9 // MinHits: // Ignore clusters with fewer than this number of hits.
10 // ClusterAssns: // If true, make associations between space points and clusters.
11 // SpacePointAlg: // Configuration for SpacePointtAlg algoriithm.
12 //
13 // Created: 15-Dec-2011 H. Greenlee
14 //
15 
16 #include <cassert>
17 
24 
33 
34 namespace trkf {
35 
37  public:
38  explicit SpacePointFinder(fhicl::ParameterSet const& pset);
39 
40  private:
41  void produce(art::Event& evt) override;
42  void endJob() override;
43 
44  // Fcl Attributes.
45 
46  SpacePointAlg fSptalg; // Algorithm object.
47  std::string fClusterModuleLabel;
48  unsigned int fMinHits; // Minimum number of hits per cluster.
49  bool fClusterAssns; // Make Cluster-SpacePoint associations.
50 
51  // Statistics.
52 
53  int fNumEvent; // Number of events.
54  int fNumSpt2; // Number of 2-view space points.
55  int fNumSpt3; // Number of 3-view space points.
56  };
57 
59 
60  //----------------------------------------------------------------------------
61  SpacePointFinder::SpacePointFinder(const fhicl::ParameterSet& pset)
62  //
63  // Purpose: Constructor.
64  //
65  // Arguments: pset - Module parameters.
66  //
67  : EDProducer{pset}
68  , fSptalg(pset.get<fhicl::ParameterSet>("SpacePointAlg"))
69  , fMinHits(0)
70  , fClusterAssns(false)
71  , fNumEvent(0)
72  , fNumSpt2(0)
73  , fNumSpt3(0)
74  {
75  fClusterModuleLabel = pset.get<std::string>("ClusterModuleLabel");
76  fMinHits = pset.get<unsigned int>("MinHits");
77  fClusterAssns = pset.get<bool>("ClusterAssns");
78 
79  produces<std::vector<art::PtrVector<recob::SpacePoint>>>();
80  produces<std::vector<recob::SpacePoint>>();
81  produces<art::Assns<recob::SpacePoint, recob::Hit>>();
82  if (fClusterAssns) produces<art::Assns<recob::SpacePoint, recob::Cluster>>();
83 
84  // Report.
85 
86  mf::LogInfo("SpacePointFinder")
87  << "SpacePointFinder configured with the following parameters:\n"
88  << " ClusterModuleLabel = " << fClusterModuleLabel << "\n"
89  << " Minimum Hits per Cluster = " << fMinHits << "\n"
90  << " Cluster associations = " << fClusterAssns;
91  }
92 
93  //----------------------------------------------------------------------------
95  //
96  // Purpose: Produce method.
97  //
98  // Arguments: event - Art event.
99  //
100  {
101  ++fNumEvent;
102 
103  // Get Services.
104 
106 
107  // Get clusters.
108 
110  evt.getByLabel(fClusterModuleLabel, clusterh);
111 
112  // Make a double or triple loop over clusters in distinct views
113  // (depending on minimum number of views configured in SpacePointAlg).
114 
115  if (clusterh.isValid()) {
116 
117  // Make a collection of space points that will be inserted into the event.
118 
119  std::unique_ptr<std::vector<art::PtrVector<recob::SpacePoint>>> sptvecs(
121  std::unique_ptr<std::vector<recob::SpacePoint>> spts(new std::vector<recob::SpacePoint>);
122  std::unique_ptr<art::Assns<recob::SpacePoint, recob::Hit>> sphitassn(
124  std::unique_ptr<art::Assns<recob::SpacePoint, recob::Cluster>> spclassn(
126 
127  // Make a hit vector which will be used to store hits to be passed
128  // to SpacePointAlg.
129 
132 
133  auto const clockData =
135  auto const detProp =
137 
138  // Loop over first cluster.
139 
140  int nclus = clusterh->size();
141  for (int iclus = 0; iclus < nclus; ++iclus) {
142  art::Ptr<recob::Cluster> piclus(clusterh, iclus);
143  geo::View_t iview = piclus->View();
144 
145  std::vector<art::Ptr<recob::Hit>> ihits = fm.at(iclus);
146 
147  // Test first view.
148 
149  if (ihits.size() >= fMinHits &&
150  ((iview == geo::kU && fSptalg.enableU()) || (iview == geo::kV && fSptalg.enableV()) ||
151  (iview == geo::kZ && fSptalg.enableW()))) {
152 
153  // Store hits from first view into hit vector.
154 
155  unsigned int nihits = ihits.size();
156  hits.clear();
157  hits.reserve(nihits);
158  for (std::vector<art::Ptr<recob::Hit>>::const_iterator i = ihits.begin();
159  i != ihits.end();
160  ++i)
161  hits.push_back(*i);
162 
163  // Loop over second cluster.
164 
165  for (int jclus = 0; jclus < iclus; ++jclus) {
166  art::Ptr<recob::Cluster> pjclus(clusterh, jclus);
167  geo::View_t jview = pjclus->View();
168 
169  std::vector<art::Ptr<recob::Hit>> jhits = fm.at(jclus);
170 
171  // Test second view.
172 
173  if (jhits.size() >= fMinHits &&
174  ((jview == geo::kU && fSptalg.enableU()) ||
175  (jview == geo::kV && fSptalg.enableV()) ||
176  (jview == geo::kZ && fSptalg.enableW())) &&
177  jview != iview) {
178 
179  // Store hits from second view into hit vector.
180 
181  unsigned int njhits = jhits.size();
182  assert(hits.size() >= nihits);
183  //hits.resize(nihits);
184  while (hits.size() > nihits)
185  hits.pop_back();
186  assert(hits.size() == nihits);
187  hits.reserve(nihits + njhits);
188  for (std::vector<art::Ptr<recob::Hit>>::const_iterator j = jhits.begin();
189  j != jhits.end();
190  ++j)
191  hits.push_back(*j);
192 
193  // If two-view space points are allowed, make them here.
194 
195  if (fSptalg.minViews() <= 2) {
196  std::vector<recob::SpacePoint> new_spts;
197  fSptalg.makeSpacePoints(clockData, detProp, hits, new_spts);
198 
199  // If we found some space points, insert them into the event.
200 
201  if (new_spts.size() > 0) {
202  fNumSpt2 += new_spts.size();
204  clusters.reserve(2);
205  clusters.push_back(piclus);
206  clusters.push_back(pjclus);
207 
208  // Insert newly found space points into event collection.
209 
210  int nspt = spts->size();
211  spts->insert(spts->end(), new_spts.begin(), new_spts.end());
212 
213  // Associate space points with hits and clusters.
214 
216  for (unsigned int ispt = nspt; ispt < spts->size(); ++ispt) {
217  const recob::SpacePoint& spt = (*spts)[ispt];
219  util::CreateAssn(evt, *spts, hits, *sphitassn, ispt);
220  if (fClusterAssns) util::CreateAssn(evt, *spts, clusters, *spclassn, ispt);
221 
222  // make the PtrVector for this collection of space points
223  // Do not reproduce the following lines
224  // Contact brebel@fnal.gov if you think you need to reproduce these lines.
225  art::ProductID spid = evt.getProductID<std::vector<recob::SpacePoint>>();
226  art::Ptr<recob::SpacePoint> spptr(spid, ispt, evt.productGetter(spid));
227  sptvec.push_back(spptr);
228  }
229  sptvecs->push_back(sptvec);
230  }
231  }
232 
233  // Loop over third cluster.
234 
235  for (int kclus = 0; kclus < jclus; ++kclus) {
236  art::Ptr<recob::Cluster> pkclus(clusterh, kclus);
237  geo::View_t kview = pkclus->View();
238 
239  std::vector<art::Ptr<recob::Hit>> khits = fm.at(kclus);
240 
241  // Test third view.
242 
243  if (khits.size() >= fMinHits &&
244  ((kview == geo::kU && fSptalg.enableU()) ||
245  (kview == geo::kV && fSptalg.enableV()) ||
246  (kview == geo::kZ && fSptalg.enableW())) &&
247  kview != iview && kview != jview) {
248 
249  // Store hits from third view into hit vector.
250 
251  unsigned int nkhits = khits.size();
252  assert(hits.size() >= nihits + njhits);
253  //hits.resize(nihits + njhits);
254  while (hits.size() > nihits + njhits)
255  hits.pop_back();
256  assert(hits.size() == nihits + njhits);
257  hits.reserve(nihits + njhits + nkhits);
258  for (std::vector<art::Ptr<recob::Hit>>::const_iterator k = khits.begin();
259  k != khits.end();
260  ++k)
261  hits.push_back(*k);
262 
263  // Make three-view space points.
264 
265  std::vector<recob::SpacePoint> new_spts;
266  fSptalg.makeSpacePoints(clockData, detProp, hits, new_spts);
267 
268  // If we found some space points, insert them into the event.
269 
270  if (new_spts.size() > 0) {
271  fNumSpt3 += new_spts.size();
273  clusters.reserve(3);
274  clusters.push_back(piclus);
275  clusters.push_back(pjclus);
276  clusters.push_back(pkclus);
277 
278  // Insert newly found space points into event collection.
279 
280  int nspt = spts->size();
281  spts->insert(spts->end(), new_spts.begin(), new_spts.end());
282 
283  // Associate space points with hits and clusters.
284 
286  for (unsigned int ispt = nspt; ispt < spts->size(); ++ispt) {
287  const recob::SpacePoint& spt = (*spts)[ispt];
289  util::CreateAssn(evt, *spts, hits, *sphitassn, ispt);
290  if (fClusterAssns) util::CreateAssn(evt, *spts, clusters, *spclassn, ispt);
291 
292  // make the PtrVector for this collection of space points
293  // Do not reproduce the following lines
294  // Contact brebel@fnal.gov if you think you need to reproduce these lines.
295  art::ProductID spid = evt.getProductID<std::vector<recob::SpacePoint>>();
296  art::Ptr<recob::SpacePoint> spptr(spid, ispt, evt.productGetter(spid));
297  sptvec.push_back(spptr);
298  }
299  sptvecs->push_back(sptvec);
300  }
301  }
302  }
303  }
304  }
305  }
306  }
307 
308  // Add space points and associations to event.
309 
310  evt.put(std::move(spts));
311  evt.put(std::move(sptvecs));
312  evt.put(std::move(sphitassn));
313  if (fClusterAssns) evt.put(std::move(spclassn));
314  }
315  }
316 
317  //----------------------------------------------------------------------------
319  //
320  // Purpose: Print summary.
321  //
322  {
323  mf::LogInfo("SpacePointFinder")
324  << "SpacePointFinder statistics:\n"
325  << " Number of events = " << fNumEvent << "\n"
326  << " Number of 2-view space points created = " << fNumSpt2 << "\n"
327  << " Number of 3-view space points created = " << fNumSpt3;
328  }
329 }
SpacePointFinder(fhicl::ParameterSet const &pset)
void reserve(size_type n)
Definition: PtrVector.h:337
bool enableW() const noexcept
Definition: SpacePointAlg.h:93
bool enableV() const noexcept
Definition: SpacePointAlg.h:92
ProductID getProductID(std::string const &instance_name="") const
enum geo::_plane_proj View_t
Enumerate the possible plane projections.
MaybeLogger_< ELseverityLevel::ELsev_info, false > LogInfo
Planes which measure V.
Definition: geo_types.h:136
Declaration of signal hit object.
EDProducer(fhicl::ParameterSet const &pset)
Definition: EDProducer.cc:6
Planes which measure Z direction.
Definition: geo_types.h:138
int minViews() const noexcept
Definition: SpacePointAlg.h:90
const art::PtrVector< recob::Hit > & getAssociatedHits(const recob::SpacePoint &spt) const
bool isValid() const noexcept
Definition: Handle.h:203
PutHandle< PROD > put(std::unique_ptr< PROD > &&edp, std::string const &instance={})
Definition: Event.h:77
auto vector(Vector const &v)
Returns a manipulator which will print the specified array.
Definition: DumpUtils.h:289
Planes which measure U.
Definition: geo_types.h:135
void hits()
Definition: readHits.C:15
EDProductGetter const * productGetter(ProductID const pid) const
#define DEFINE_ART_MODULE(klass)
Definition: ModuleMacros.h:65
void push_back(Ptr< U > const &p)
Definition: PtrVector.h:435
parameter set interface
void makeSpacePoints(detinfo::DetectorClocksData const &clockData, detinfo::DetectorPropertiesData const &detProp, const art::PtrVector< recob::Hit > &hits, std::vector< recob::SpacePoint > &spts) const
Declaration of cluster object.
size_type size() const
Definition: PtrVector.h:302
bool CreateAssn(art::Event &evt, std::vector< T > const &a, art::Ptr< U > const &b, art::Assns< U, T > &assn, std::string a_instance, size_t index=UINT_MAX)
Creates a single one-to-one association.
geo::View_t View() const
Returns the view for this cluster.
Definition: Cluster.h:714
bool getByLabel(std::string const &label, std::string const &instance, Handle< PROD > &result) const
Utility object to perform functions of association.
bool enableU() const noexcept
Definition: SpacePointAlg.h:91
void pop_back()
Definition: PtrVector.h:457
TCEvent evt
Definition: DataStructs.cxx:8
Algorithm for generating space points from hits.
void clear()
Definition: PtrVector.h:533
art framework interface to geometry description
void produce(art::Event &evt) override