ActivityTrigger_module.cc
Go to the documentation of this file.
1 ////////////////////////////////////////////////////////////////////////
2 // Class: ActivityTrigger
3 // Module Type: filter
4 // File: ActivityTrigger_module.cc
5 //
6 // Generated at Wed Sep 12 16:15:01 2012 by Nova DDT using artmod
7 // from art v1_01_01.
8 ////////////////////////////////////////////////////////////////////////
9 
15 
22 
23 #include "DAQDataFormats/DAQDataFormats.h"
24 
25 #include <string>
26 #include <algorithm>
27 #include <unordered_set>
28 
29 namespace novaddt {
30  class ActivityTrigger;
31 }
32 
34 
35 public:
36  explicit ActivityTrigger(fhicl::ParameterSet const & p);
37  virtual ~ActivityTrigger();
38 
39  virtual bool filter(art::Event & e);
40 
41 private:
42 
43  std::string _hitsModuleLabel; ///< label of module making the HitList
44  std::string _hitsInstanceLabel; ///< instance label making the HitList
45  unsigned int _minHits; ///< Minimum number of hits in the slice
46  unsigned int _minPlanesView; ///< Minimum planes (unique) on each view
47  unsigned int _minPlanes; ///< Minimum planes (unique) the hits are spread in any view
48  unsigned int _maxNearWindow; ///< Maximum window where to look for near planes
49  unsigned int _minNearPlanes; ///< Minimum number of near planes
50  unsigned int _prescale; ///< holds prescaling variable from fcl file
51 
52  unsigned int _triggerCounts = 0;
53  unsigned int _evtCounts = 0;
54 };
55 
56 //---------------------------------------------------------------------
58  : _hitsModuleLabel (p.get<std::string >("HitModuleLabel" ))
59  , _hitsInstanceLabel(p.get<std::string >("HitInstanceLabel"))
60  , _minHits (p.get<unsigned int>("MinHits" ))
61  , _minPlanesView (p.get<unsigned int>("MinPlanesView" ))
62  , _minPlanes (p.get<unsigned int>("MinPlanes" ))
63  , _maxNearWindow (p.get<unsigned int>("MaxNearWindow" ))
64  , _minNearPlanes (p.get<unsigned int>("MinNearPlanes" ))
65  , _prescale (p.get<unsigned int>("prescale" ))
66 {
67  produces< std::vector<novaddt::TriggerDecision> >();
68  //produces< art::Assns<novaddt::TriggerDecision, novaddt::HitList> >();
69 }
70 
71 //---------------------------------------------------------------------
73 {
74  // Clean up dynamic memory and other resources here.
75 }
76 
77 //---------------------------------------------------------------------
79 {
80  //std::cout << "--- ActivityTrigger filter\n";
81  ++_evtCounts;
82 
83  // Retrieve the (grouped) hit list for this event
86 
87  // Allocate the vector for the trigger decisions that we may make (and write to the event)
88  std::unique_ptr<std::vector<novaddt::TriggerDecision>> td(new std::vector<novaddt::TriggerDecision>);
89 
90  /**************************************************************************
91  * Activity Trigger Algorithm *
92  * *
93  * Essentially all we do is count the number of hits we have in slice *
94  * if it is over a given threshold then we write it out. *
95  * *
96  * Overlaps with the beam (numi) trigger are handled via an inhibit at *
97  * the global trigger level *
98  * *
99  * However there are a couple of additional cuts we put on the data, *
100  * first in addition to having at least N hits we require that they *
101  * extend over at least Mx planes in the X view, and analogously with *
102  * the Y view. We also require the total number of planes to be larger *
103  * than P. Finally, we perform a continuity check, asking for K planes *
104  * with hits whithin a W window. *
105  * *
106  * This allows the trigger to be tuned in the following manners *
107  * Increase: N = more hits (more activity, larger showers) *
108  * Increase: Mx and P = more "horizontal" (z-aligned) activity *
109  * Decrease M or P = more "vertical" (x/y-aligned activity) *
110  * Increase K: longer continuous tracks *
111  * Decrease W: less gaps are allowed. If W<K or any of them is set to 0 *
112  * no continuity check is performed *
113  **************************************************************************/
114 
115  std::unordered_set<int> XplaneList;
116  std::unordered_set<int> YplaneList;
117  std::unordered_set<int> planeList;
118 
119  // Loop over the slices in the event
120  for(unsigned int i=0; i<hits->n_groups(); ++i){
121 
122  // Get the hits for the current slice
123  novaddt::HitList theSliceHits = hits->get(i);
124 
125  XplaneList.clear();
126  YplaneList.clear();
127  planeList.clear();
128  bool fContinuity = false;
129  // Safety checks in case we mess up the fickle file
130  if(_maxNearWindow < _minNearPlanes) fContinuity = true;
131  if(!(_maxNearWindow * _minNearPlanes)) fContinuity = true;
132 
133  // Test to see how many hits are in the slice
134  if (theSliceHits.size() >= _minHits){
135  // Fill the unique planes
136  for(unsigned int j=0; j < theSliceHits.size(); ++j){
137  auto thePlane = theSliceHits.at(j).Plane().val;
138  auto theView = theSliceHits.at(j).View().val;
139  // Push the plane into list of unique planes in the proper view
140  if(theView == daqchannelmap::X_VIEW) XplaneList.insert(thePlane);
141  else if(theView == daqchannelmap::Y_VIEW) YplaneList.insert(thePlane);
142  planeList.insert(thePlane);
143  } // endfor j
144 
145  if((XplaneList.size() + YplaneList.size()) >= _minPlanes){
146  // If there are enough planes, check by view
147  if(XplaneList.size() >= _minPlanesView){
148  if(YplaneList.size() >= _minPlanesView){
149  /**********************************************************
150  * Check for continuity. This means a minimum number of *
151  * planes _minNearPlanes within a window of _maxNearPlanes *
152  * (e.g., 4 out of 5 planes, a la MINOS) *
153  **********************************************************/
154  for(auto iPlane=planeList.begin(); iPlane!=planeList.end(); ++iPlane)
155  {
156  if(!fContinuity)
157  {
158  unsigned int fNearPlanes = 0;
159  for(unsigned int j=1; j<=_maxNearWindow; ++j)
160  fNearPlanes += planeList.count(*iPlane+j);
161 
162  if(fNearPlanes >= _minNearPlanes)
163  fContinuity = true;
164  }
165  } // end of continuity check
166 
167  if(fContinuity)
168  {
169  /******************************************************
170  * EVENTS THAT MAKE IT HERE SHOULD GENERATE A TRIGGER *
171  ******************************************************/
172  // Internal prescale
173  ++_triggerCounts;
174  if (_triggerCounts % _prescale == _prescale - 1){
175  // Store a trigger decision for this slice
176  td->emplace_back(theSliceHits.front().TDC().val,
177  theSliceHits.back().TDC().val - theSliceHits.front().TDC().val,
179  _prescale);
180  } // end of issue trigger decision
181  } // end of cointinuity check
182  } // endif gt minYPlanes
183  } // endif gt minXPlanes
184  } // endif gt minPlanes
185  } // end of check on hit list size
186  } // end loop on hit groups
187 
188  bool goodTrigger = (td->size() > 0);
189 
190  e.put(std::move(td));
191  //e.put(std::move(assn));
192 
193  //std::cout << "Frequency: " << _triggerCounts*1./(_evtCounts*5.e-3) << " pm " // Fraction of passing per event. One event lasts 5 ms
194  // << sqrt(_triggerCounts*(_evtCounts-_triggerCounts)*1./_evtCounts)/(_evtCounts*5.e-3) << " Hz" << std::endl; // Binomial Error
195 
196  return goodTrigger;
197 }
198 
unsigned int _prescale
holds prescaling variable from fcl file
std::vector< DAQHit > HitList
Definition: HitList.h:15
const char * p
Definition: xmltok.h:285
unsigned int _minPlanes
Minimum planes (unique) the hits are spread in any view.
std::string _hitsInstanceLabel
instance label making the HitList
DEFINE_ART_MODULE(TestTMapFile)
virtual bool filter(art::Event &e)
Identifier for the Y measuring view of the detector (side)
ProductID put(std::unique_ptr< PROD > &&product)
Definition: Event.h:102
void hits()
Definition: readHits.C:15
Identifier for the X measuring view of the detector (top)
ActivityTrigger(fhicl::ParameterSet const &p)
const double j
Definition: BetheBloch.cxx:29
bool getByLabel(std::string const &label, std::string const &productInstanceName, Handle< PROD > &result) const
Definition: DataViewImpl.h:344
void clear()
Definition: Handle.h:236
unsigned int _maxNearWindow
Maximum window where to look for near planes.
Float_t e
Definition: plot.C:35
std::string _hitsModuleLabel
label of module making the HitList
unsigned int _minNearPlanes
Minimum number of near planes.
unsigned int _minPlanesView
Minimum planes (unique) on each view.
unsigned int _minHits
Minimum number of hits in the slice.
enum BeamMode string