CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
GEMClusterProcessor Class Reference

#include <GEMClusterProcessor.h>

Public Member Functions

void clear ()
 
 GEMClusterProcessor (int region, unsigned station, unsigned chamber, const edm::ParameterSet &conf)
 
std::vector< GEMInternalCluster > getClusters (int bx) const
 
std::vector< GEMInternalCluster > getClusters (int bx, int deltaBX) const
 
std::vector< GEMInternalCluster > getCoincidenceClusters (int bx) const
 
bool hasGE21Geometry16Partitions () const
 
std::vector< GEMCoPadDigi > readoutCoPads () const
 
void run (const GEMPadDigiClusterCollection *)
 

Private Member Functions

void addCoincidenceClusters (const GEMPadDigiClusterCollection *)
 
void addSingleClusters (const GEMPadDigiClusterCollection *)
 
void doCoordinateConversion ()
 

Private Attributes

const int chamber_
 
std::vector< GEMInternalCluster > clusters_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1a_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1a_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1b_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1b_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME21_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME21_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1a_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1a_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1b_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1b_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME21_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME21_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME11_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME11_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME21_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME21_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME11_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME11_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME21_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME21_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME11_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME11_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME21_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME21_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME11_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME11_odd_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME21_even_
 
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME21_odd_
 
bool hasGE21Geometry16Partitions_
 
bool isEven_
 
unsigned int maxDeltaBX_
 
unsigned int maxDeltaPad_
 
unsigned int maxDeltaRoll_
 
std::vector< std::string > padToEsME1aFiles_
 
std::vector< std::string > padToEsME1bFiles_
 
std::vector< std::string > padToEsME21Files_
 
std::vector< std::string > padToHsME1aFiles_
 
std::vector< std::string > padToHsME1bFiles_
 
std::vector< std::string > padToHsME21Files_
 
const int region_
 
std::vector< std::string > rollToMaxWgME11Files_
 
std::vector< std::string > rollToMaxWgME21Files_
 
std::vector< std::string > rollToMinWgME11Files_
 
std::vector< std::string > rollToMinWgME21Files_
 
const int station_
 

Detailed Description

Author
Sven Dildick (Rice University)

Definition at line 19 of file GEMClusterProcessor.h.

Constructor & Destructor Documentation

◆ GEMClusterProcessor()

GEMClusterProcessor::GEMClusterProcessor ( int  region,
unsigned  station,
unsigned  chamber,
const edm::ParameterSet &  conf 
)

Normal constructor.

Definition at line 7 of file GEMClusterProcessor.cc.

8  : region_(region), station_(station), chamber_(chamber) {
9  isEven_ = chamber_ % 2 == 0;
10 
11  if (station_ == 1) {
12  const edm::ParameterSet copad(conf.getParameter<edm::ParameterSet>("copadParamGE11"));
13  maxDeltaPad_ = copad.getParameter<unsigned int>("maxDeltaPad");
14  maxDeltaRoll_ = copad.getParameter<unsigned int>("maxDeltaRoll");
15  maxDeltaBX_ = copad.getParameter<unsigned int>("maxDeltaBX");
16 
17  padToHsME1aFiles_ = conf.getParameter<std::vector<std::string>>("padToHsME1aFiles");
18  padToHsME1bFiles_ = conf.getParameter<std::vector<std::string>>("padToHsME1bFiles");
19 
20  padToEsME1aFiles_ = conf.getParameter<std::vector<std::string>>("padToEsME1aFiles");
21  padToEsME1bFiles_ = conf.getParameter<std::vector<std::string>>("padToEsME1bFiles");
22 
23  rollToMaxWgME11Files_ = conf.getParameter<std::vector<std::string>>("rollToMaxWgME11Files");
24  rollToMinWgME11Files_ = conf.getParameter<std::vector<std::string>>("rollToMinWgME11Files");
25 
26  GEMCSCLUT_pad_hs_ME1a_even_ = std::make_unique<CSCLUTReader>(padToHsME1aFiles_[0]);
27  GEMCSCLUT_pad_hs_ME1a_odd_ = std::make_unique<CSCLUTReader>(padToHsME1aFiles_[1]);
28  GEMCSCLUT_pad_hs_ME1b_even_ = std::make_unique<CSCLUTReader>(padToHsME1bFiles_[0]);
29  GEMCSCLUT_pad_hs_ME1b_odd_ = std::make_unique<CSCLUTReader>(padToHsME1bFiles_[1]);
30 
31  GEMCSCLUT_pad_es_ME1a_even_ = std::make_unique<CSCLUTReader>(padToEsME1aFiles_[0]);
32  GEMCSCLUT_pad_es_ME1a_odd_ = std::make_unique<CSCLUTReader>(padToEsME1aFiles_[1]);
33  GEMCSCLUT_pad_es_ME1b_even_ = std::make_unique<CSCLUTReader>(padToEsME1bFiles_[0]);
34  GEMCSCLUT_pad_es_ME1b_odd_ = std::make_unique<CSCLUTReader>(padToEsME1bFiles_[1]);
35 
36  GEMCSCLUT_roll_l1_min_wg_ME11_even_ = std::make_unique<CSCLUTReader>(rollToMinWgME11Files_[0]);
37  GEMCSCLUT_roll_l1_min_wg_ME11_odd_ = std::make_unique<CSCLUTReader>(rollToMinWgME11Files_[1]);
38  GEMCSCLUT_roll_l2_min_wg_ME11_even_ = std::make_unique<CSCLUTReader>(rollToMinWgME11Files_[2]);
39  GEMCSCLUT_roll_l2_min_wg_ME11_odd_ = std::make_unique<CSCLUTReader>(rollToMinWgME11Files_[3]);
40 
41  GEMCSCLUT_roll_l1_max_wg_ME11_even_ = std::make_unique<CSCLUTReader>(rollToMaxWgME11Files_[0]);
42  GEMCSCLUT_roll_l1_max_wg_ME11_odd_ = std::make_unique<CSCLUTReader>(rollToMaxWgME11Files_[1]);
43  GEMCSCLUT_roll_l2_max_wg_ME11_even_ = std::make_unique<CSCLUTReader>(rollToMaxWgME11Files_[2]);
44  GEMCSCLUT_roll_l2_max_wg_ME11_odd_ = std::make_unique<CSCLUTReader>(rollToMaxWgME11Files_[3]);
45  }
46 
47  if (station_ == 2) {
48  // by default set to true
49  hasGE21Geometry16Partitions_ = true;
50 
51  const edm::ParameterSet copad(conf.getParameter<edm::ParameterSet>("copadParamGE21"));
52  maxDeltaPad_ = copad.getParameter<unsigned int>("maxDeltaPad");
53  maxDeltaRoll_ = copad.getParameter<unsigned int>("maxDeltaRoll");
54  maxDeltaBX_ = copad.getParameter<unsigned int>("maxDeltaBX");
55 
56  padToHsME21Files_ = conf.getParameter<std::vector<std::string>>("padToHsME21Files");
57  padToEsME21Files_ = conf.getParameter<std::vector<std::string>>("padToEsME21Files");
58 
59  rollToMaxWgME21Files_ = conf.getParameter<std::vector<std::string>>("rollToMaxWgME21Files");
60  rollToMinWgME21Files_ = conf.getParameter<std::vector<std::string>>("rollToMinWgME21Files");
61 
62  GEMCSCLUT_pad_hs_ME21_even_ = std::make_unique<CSCLUTReader>(padToHsME21Files_[0]);
63  GEMCSCLUT_pad_hs_ME21_odd_ = std::make_unique<CSCLUTReader>(padToHsME21Files_[1]);
64  GEMCSCLUT_pad_es_ME21_even_ = std::make_unique<CSCLUTReader>(padToEsME21Files_[0]);
65  GEMCSCLUT_pad_es_ME21_odd_ = std::make_unique<CSCLUTReader>(padToEsME21Files_[1]);
66 
67  GEMCSCLUT_roll_l1_min_wg_ME21_even_ = std::make_unique<CSCLUTReader>(rollToMinWgME21Files_[0]);
68  GEMCSCLUT_roll_l1_min_wg_ME21_odd_ = std::make_unique<CSCLUTReader>(rollToMinWgME21Files_[1]);
69  GEMCSCLUT_roll_l2_min_wg_ME21_even_ = std::make_unique<CSCLUTReader>(rollToMinWgME21Files_[2]);
70  GEMCSCLUT_roll_l2_min_wg_ME21_odd_ = std::make_unique<CSCLUTReader>(rollToMinWgME21Files_[3]);
71 
72  GEMCSCLUT_roll_l1_max_wg_ME21_even_ = std::make_unique<CSCLUTReader>(rollToMaxWgME21Files_[0]);
73  GEMCSCLUT_roll_l1_max_wg_ME21_odd_ = std::make_unique<CSCLUTReader>(rollToMaxWgME21Files_[1]);
74  GEMCSCLUT_roll_l2_max_wg_ME21_even_ = std::make_unique<CSCLUTReader>(rollToMaxWgME21Files_[2]);
75  GEMCSCLUT_roll_l2_max_wg_ME21_odd_ = std::make_unique<CSCLUTReader>(rollToMaxWgME21Files_[3]);
76  }
77 }

References chamber_, GEMCSCLUT_pad_es_ME1a_even_, GEMCSCLUT_pad_es_ME1a_odd_, GEMCSCLUT_pad_es_ME1b_even_, GEMCSCLUT_pad_es_ME1b_odd_, GEMCSCLUT_pad_es_ME21_even_, GEMCSCLUT_pad_es_ME21_odd_, GEMCSCLUT_pad_hs_ME1a_even_, GEMCSCLUT_pad_hs_ME1a_odd_, GEMCSCLUT_pad_hs_ME1b_even_, GEMCSCLUT_pad_hs_ME1b_odd_, GEMCSCLUT_pad_hs_ME21_even_, GEMCSCLUT_pad_hs_ME21_odd_, GEMCSCLUT_roll_l1_max_wg_ME11_even_, GEMCSCLUT_roll_l1_max_wg_ME11_odd_, GEMCSCLUT_roll_l1_max_wg_ME21_even_, GEMCSCLUT_roll_l1_max_wg_ME21_odd_, GEMCSCLUT_roll_l1_min_wg_ME11_even_, GEMCSCLUT_roll_l1_min_wg_ME11_odd_, GEMCSCLUT_roll_l1_min_wg_ME21_even_, GEMCSCLUT_roll_l1_min_wg_ME21_odd_, GEMCSCLUT_roll_l2_max_wg_ME11_even_, GEMCSCLUT_roll_l2_max_wg_ME11_odd_, GEMCSCLUT_roll_l2_max_wg_ME21_even_, GEMCSCLUT_roll_l2_max_wg_ME21_odd_, GEMCSCLUT_roll_l2_min_wg_ME11_even_, GEMCSCLUT_roll_l2_min_wg_ME11_odd_, GEMCSCLUT_roll_l2_min_wg_ME21_even_, GEMCSCLUT_roll_l2_min_wg_ME21_odd_, edm::ParameterSet::getParameter(), hasGE21Geometry16Partitions_, isEven_, maxDeltaBX_, maxDeltaPad_, maxDeltaRoll_, padToEsME1aFiles_, padToEsME1bFiles_, padToEsME21Files_, padToHsME1aFiles_, padToHsME1bFiles_, padToHsME21Files_, rollToMaxWgME11Files_, rollToMaxWgME21Files_, rollToMinWgME11Files_, rollToMinWgME21Files_, and station_.

Member Function Documentation

◆ addCoincidenceClusters()

void GEMClusterProcessor::addCoincidenceClusters ( const GEMPadDigiClusterCollection *  in_clusters)
private

Definition at line 134 of file GEMClusterProcessor.cc.

134  {
135  // Build coincidences
136  for (auto det_range = in_clusters->begin(); det_range != in_clusters->end(); ++det_range) {
137  const GEMDetId& id = (*det_range).first;
138 
139  // coincidence pads are not built for ME0
140  if (id.isME0())
141  continue;
142 
143  // same chamber (no restriction on the roll number)
144  if (id.region() != region_ or id.station() != station_ or id.chamber() != chamber_)
145  continue;
146 
147  // all coincidences detIDs will have layer=1
148  if (id.layer() != 1)
149  continue;
150 
151  // find all corresponding ids with layer 2 and same roll that differs at most maxDeltaRoll_
152  for (unsigned int roll = id.roll() - maxDeltaRoll_; roll <= id.roll() + maxDeltaRoll_; ++roll) {
153  GEMDetId co_id(id.region(), id.ring(), id.station(), 2, id.chamber(), roll);
154 
155  auto co_clusters_range = in_clusters->get(co_id);
156 
157  // empty range = no possible coincidence pads
158  if (co_clusters_range.first == co_clusters_range.second)
159  continue;
160 
161  // now let's correlate the pads in two layers of this partition
162  const auto& pads_range = (*det_range).second;
163  for (auto p = pads_range.first; p != pads_range.second; ++p) {
164  // ignore 8-partition GE2/1 pads
165  if (id.isGE21() and p->nPartitions() == GEMPadDigiCluster::GE21) {
166  hasGE21Geometry16Partitions_ = false;
167  continue;
168  }
169 
170  // only consider valid pads
171  if (!p->isValid())
172  continue;
173 
174  for (auto co_p = co_clusters_range.first; co_p != co_clusters_range.second; ++co_p) {
175  // only consider valid clusters
176  if (!co_p->isValid())
177  continue;
178 
179  // check the match in BX
180  if ((unsigned)std::abs(p->bx() - co_p->bx()) > maxDeltaBX_)
181  continue;
182 
183  // get the corrected minimum and maximum of cluster 1
184  int cl1_min = p->pads().front() - maxDeltaPad_;
185  int cl1_max = p->pads().back() + maxDeltaPad_;
186 
187  // get the minimum and maximum of cluster 2
188  int cl2_min = co_p->pads().front();
189  int cl2_max = co_p->pads().back();
190 
191  // match condition
192  const bool condition1(cl1_min <= cl2_min and cl1_max >= cl2_min);
193  const bool condition2(cl1_min <= cl2_max and cl1_max >= cl2_max);
194  const bool match(condition1 or condition2);
195 
196  if (!match)
197  continue;
198 
199  // make a new coincidence
200  clusters_.emplace_back(id, *p, *co_p);
201  }
202  }
203  }
204  }
205 }

References funct::abs(), relativeConstraints::chamber, chamber_, clusters_, GEMPadDigiCluster::GE21, hasGE21Geometry16Partitions_, GeomDetEnumerators::isME0(), phase1PixelTopology::layer, match(), maxDeltaBX_, maxDeltaPad_, maxDeltaRoll_, or, AlCaHLTBitMon_ParallelJobs::p, HLT_FULL_cff::region, region_, relativeConstraints::ring, relativeConstraints::station, and station_.

Referenced by run().

◆ addSingleClusters()

void GEMClusterProcessor::addSingleClusters ( const GEMPadDigiClusterCollection *  in_clusters)
private

Definition at line 207 of file GEMClusterProcessor.cc.

207  {
208  // first get the coincidences
209  const std::vector<GEMInternalCluster>& coincidences = clusters_;
210 
211  // now start add single clusters
212  for (auto det_range = in_clusters->begin(); det_range != in_clusters->end(); ++det_range) {
213  const GEMDetId& id = (*det_range).first;
214 
215  // ignore ME0
216  if (id.isME0())
217  continue;
218 
219  // same chamber (no restriction on the roll number)
220  if (id.region() != region_ or id.station() != station_ or id.chamber() != chamber_)
221  continue;
222 
223  const auto& clusters_range = (*det_range).second;
224  for (auto p = clusters_range.first; p != clusters_range.second; ++p) {
225  // only consider valid clusters
226  if (!p->isValid())
227  continue;
228 
229  // ignore 8-partition GE2/1 pads
230  if (id.isGE21() and p->nPartitions() == GEMPadDigiCluster::GE21) {
231  hasGE21Geometry16Partitions_ = false;
232  continue;
233  }
234 
235  // ignore clusters already contained in a coincidence cluster
236  if (std::find_if(std::begin(coincidences), std::end(coincidences), [p](const GEMInternalCluster& q) {
237  return q.has_cluster(*p);
238  }) != std::end(coincidences))
239  continue;
240 
241  // put the single clusters into the collection
242  if (id.layer() == 1)
243  clusters_.emplace_back(id, *p, GEMPadDigiCluster());
244  else
245  clusters_.emplace_back(id, GEMPadDigiCluster(), *p);
246  }
247  }
248 }

References chamber_, clusters_, mps_fire::end, GEMPadDigiCluster::GE21, hasGE21Geometry16Partitions_, GeomDetEnumerators::isME0(), phase1PixelTopology::layer, or, AlCaHLTBitMon_ParallelJobs::p, submitPVResolutionJobs::q, HLT_FULL_cff::region, region_, and station_.

Referenced by run().

◆ clear()

void GEMClusterProcessor::clear ( void  )

Clear copad vector

Definition at line 79 of file GEMClusterProcessor.cc.

79 { clusters_.clear(); }

References clusters_.

Referenced by run().

◆ doCoordinateConversion()

void GEMClusterProcessor::doCoordinateConversion ( )
private

Definition at line 250 of file GEMClusterProcessor.cc.

250  {
251  // loop on clusters
252  for (auto& cluster : clusters_) {
253  if (cluster.cl1().isValid()) {
254  // starting coordinates
255  const int layer1_first_pad = cluster.layer1_pad();
256  const int layer1_last_pad = layer1_first_pad + cluster.layer1_size() - 1;
257 
258  // calculate the 1/2-strip
259  int layer1_pad_to_first_hs = -1;
260  int layer1_pad_to_last_hs = -1;
261  int layer1_pad_to_first_hs_me1a = -1;
262  int layer1_pad_to_last_hs_me1a = -1;
263 
264  // ME1/1
265  if (station_ == 1) {
266  if (isEven_) {
267  // ME1/b
268  layer1_pad_to_first_hs = GEMCSCLUT_pad_hs_ME1b_even_->lookup(layer1_first_pad);
269  layer1_pad_to_last_hs = GEMCSCLUT_pad_hs_ME1b_even_->lookup(layer1_last_pad);
270  // ME1/a
271  layer1_pad_to_first_hs_me1a = GEMCSCLUT_pad_hs_ME1a_even_->lookup(layer1_first_pad);
272  layer1_pad_to_last_hs_me1a = GEMCSCLUT_pad_hs_ME1a_even_->lookup(layer1_last_pad);
273  } else {
274  // ME1/b
275  layer1_pad_to_first_hs = GEMCSCLUT_pad_hs_ME1b_odd_->lookup(layer1_first_pad);
276  layer1_pad_to_last_hs = GEMCSCLUT_pad_hs_ME1b_odd_->lookup(layer1_last_pad);
277  // ME1/a
278  layer1_pad_to_first_hs_me1a = GEMCSCLUT_pad_hs_ME1a_odd_->lookup(layer1_first_pad);
279  layer1_pad_to_last_hs_me1a = GEMCSCLUT_pad_hs_ME1a_odd_->lookup(layer1_last_pad);
280  }
281  }
282  // ME2/1
283  if (station_ == 2) {
284  if (isEven_) {
285  layer1_pad_to_first_hs = GEMCSCLUT_pad_hs_ME21_even_->lookup(layer1_first_pad);
286  layer1_pad_to_last_hs = GEMCSCLUT_pad_hs_ME21_even_->lookup(layer1_last_pad);
287  } else {
288  layer1_pad_to_first_hs = GEMCSCLUT_pad_hs_ME21_odd_->lookup(layer1_first_pad);
289  layer1_pad_to_last_hs = GEMCSCLUT_pad_hs_ME21_odd_->lookup(layer1_last_pad);
290  }
291  }
292  // middle 1/2-strip
293  int layer1_middle_hs = 0.5 * (layer1_pad_to_first_hs + layer1_pad_to_last_hs);
294  int layer1_middle_hs_me1a = 0.5 * (layer1_pad_to_first_hs_me1a + layer1_pad_to_last_hs_me1a);
295 
296  // set the values
297  cluster.set_layer1_first_hs(layer1_pad_to_first_hs);
298  cluster.set_layer1_last_hs(layer1_pad_to_last_hs);
299  cluster.set_layer1_middle_hs(layer1_middle_hs);
300 
301  if (station_ == 1) {
302  cluster.set_layer1_first_hs_me1a(layer1_pad_to_first_hs_me1a);
303  cluster.set_layer1_last_hs_me1a(layer1_pad_to_last_hs_me1a);
304  cluster.set_layer1_middle_hs_me1a(layer1_middle_hs_me1a);
305  }
306  // calculate the 1/8-strips
307  int layer1_pad_to_first_es = -1;
308  int layer1_pad_to_last_es = -1;
309 
310  int layer1_pad_to_first_es_me1a = -1;
311  int layer1_pad_to_last_es_me1a = -1;
312 
313  // ME1/1
314  if (station_ == 1) {
315  if (isEven_) {
316  // ME1/b
317  layer1_pad_to_first_es = GEMCSCLUT_pad_es_ME1b_even_->lookup(layer1_first_pad);
318  layer1_pad_to_last_es = GEMCSCLUT_pad_es_ME1b_even_->lookup(layer1_last_pad);
319  // ME1/a
320  layer1_pad_to_first_es_me1a = GEMCSCLUT_pad_es_ME1a_even_->lookup(layer1_first_pad);
321  layer1_pad_to_last_es_me1a = GEMCSCLUT_pad_es_ME1a_even_->lookup(layer1_last_pad);
322  } else {
323  // ME1/b
324  layer1_pad_to_first_es = GEMCSCLUT_pad_es_ME1b_odd_->lookup(layer1_first_pad);
325  layer1_pad_to_last_es = GEMCSCLUT_pad_es_ME1b_odd_->lookup(layer1_last_pad);
326  // ME1/a
327  layer1_pad_to_first_es_me1a = GEMCSCLUT_pad_es_ME1a_odd_->lookup(layer1_first_pad);
328  layer1_pad_to_last_es_me1a = GEMCSCLUT_pad_es_ME1a_odd_->lookup(layer1_last_pad);
329  }
330  }
331  // ME2/1
332  if (station_ == 2) {
333  if (isEven_) {
334  layer1_pad_to_first_es = GEMCSCLUT_pad_es_ME21_even_->lookup(layer1_first_pad);
335  layer1_pad_to_last_es = GEMCSCLUT_pad_es_ME21_even_->lookup(layer1_last_pad);
336  } else {
337  layer1_pad_to_first_es = GEMCSCLUT_pad_es_ME21_odd_->lookup(layer1_first_pad);
338  layer1_pad_to_last_es = GEMCSCLUT_pad_es_ME21_odd_->lookup(layer1_last_pad);
339  }
340  }
341  // middle 1/8-strip
342  int layer1_middle_es = 0.5 * (layer1_pad_to_first_es + layer1_pad_to_last_es);
343  int layer1_middle_es_me1a = 0.5 * (layer1_pad_to_first_es_me1a + layer1_pad_to_last_es_me1a);
344 
345  cluster.set_layer1_first_es(layer1_pad_to_first_es);
346  cluster.set_layer1_last_es(layer1_pad_to_last_es);
347  cluster.set_layer1_middle_es(layer1_middle_es);
348 
349  if (station_ == 1) {
350  cluster.set_layer1_first_es_me1a(layer1_pad_to_first_es_me1a);
351  cluster.set_layer1_last_es_me1a(layer1_pad_to_last_es_me1a);
352  cluster.set_layer1_middle_es_me1a(layer1_middle_es_me1a);
353  }
354 
355  // calculate the wiregroups
356  // need to subtract 1 to use the LUTs
357  const int roll = cluster.roll() - 1;
358 
359  int roll_l1_to_min_wg = -1;
360  int roll_l1_to_max_wg = -1;
361 
362  // ME1/1
363  if (station_ == 1) {
364  if (isEven_) {
365  roll_l1_to_min_wg = GEMCSCLUT_roll_l1_min_wg_ME11_even_->lookup(roll);
366  roll_l1_to_max_wg = GEMCSCLUT_roll_l1_max_wg_ME11_even_->lookup(roll);
367  } else {
368  roll_l1_to_min_wg = GEMCSCLUT_roll_l1_min_wg_ME11_odd_->lookup(roll);
369  roll_l1_to_max_wg = GEMCSCLUT_roll_l1_max_wg_ME11_odd_->lookup(roll);
370  }
371  }
372 
373  // ME2/1
374  if (station_ == 2) {
375  if (isEven_) {
376  roll_l1_to_min_wg = GEMCSCLUT_roll_l1_min_wg_ME21_even_->lookup(roll);
377  roll_l1_to_max_wg = GEMCSCLUT_roll_l1_max_wg_ME21_even_->lookup(roll);
378  } else {
379  roll_l1_to_min_wg = GEMCSCLUT_roll_l1_min_wg_ME21_odd_->lookup(roll);
380  roll_l1_to_max_wg = GEMCSCLUT_roll_l1_max_wg_ME21_odd_->lookup(roll);
381  }
382  }
383 
384  // set the values
385  cluster.set_layer1_min_wg(roll_l1_to_min_wg);
386  cluster.set_layer1_max_wg(roll_l1_to_max_wg);
387  }
388 
389  if (cluster.cl2().isValid()) {
390  // starting coordinates
391  const int layer2_first_pad = cluster.layer2_pad();
392  const int layer2_last_pad = layer2_first_pad + cluster.layer2_size() - 1;
393 
394  // calculate the 1/2-strip
395  int layer2_pad_to_first_hs = -1;
396  int layer2_pad_to_last_hs = -1;
397  int layer2_pad_to_first_hs_me1a = -1;
398  int layer2_pad_to_last_hs_me1a = -1;
399 
400  if (station_ == 1) {
401  if (isEven_) {
402  // ME1/b
403  layer2_pad_to_first_hs = GEMCSCLUT_pad_hs_ME1b_even_->lookup(layer2_first_pad);
404  layer2_pad_to_last_hs = GEMCSCLUT_pad_hs_ME1b_even_->lookup(layer2_last_pad);
405  // ME1/a
406  layer2_pad_to_first_hs_me1a = GEMCSCLUT_pad_hs_ME1a_even_->lookup(layer2_first_pad);
407  layer2_pad_to_last_hs_me1a = GEMCSCLUT_pad_hs_ME1a_even_->lookup(layer2_last_pad);
408  } else {
409  // ME1/b
410  layer2_pad_to_first_hs = GEMCSCLUT_pad_hs_ME1b_odd_->lookup(layer2_first_pad);
411  layer2_pad_to_last_hs = GEMCSCLUT_pad_hs_ME1b_odd_->lookup(layer2_last_pad);
412  // ME1/a
413  layer2_pad_to_first_hs_me1a = GEMCSCLUT_pad_hs_ME1a_odd_->lookup(layer2_first_pad);
414  layer2_pad_to_last_hs_me1a = GEMCSCLUT_pad_hs_ME1a_odd_->lookup(layer2_last_pad);
415  }
416  }
417  // ME2/1
418  if (station_ == 2) {
419  if (isEven_) {
420  layer2_pad_to_first_hs = GEMCSCLUT_pad_hs_ME21_even_->lookup(layer2_first_pad);
421  layer2_pad_to_last_hs = GEMCSCLUT_pad_hs_ME21_even_->lookup(layer2_last_pad);
422  } else {
423  layer2_pad_to_first_hs = GEMCSCLUT_pad_hs_ME21_odd_->lookup(layer2_first_pad);
424  layer2_pad_to_last_hs = GEMCSCLUT_pad_hs_ME21_odd_->lookup(layer2_last_pad);
425  }
426  }
427  // middle 1/2-strip
428  int layer2_middle_hs = 0.5 * (layer2_pad_to_first_hs + layer2_pad_to_last_hs);
429  int layer2_middle_hs_me1a = 0.5 * (layer2_pad_to_first_hs_me1a + layer2_pad_to_last_hs_me1a);
430 
431  // set the values
432  cluster.set_layer2_first_hs(layer2_pad_to_first_hs);
433  cluster.set_layer2_last_hs(layer2_pad_to_last_hs);
434  cluster.set_layer2_middle_hs(layer2_middle_hs);
435 
436  if (station_ == 1) {
437  cluster.set_layer2_first_hs_me1a(layer2_pad_to_first_hs_me1a);
438  cluster.set_layer2_last_hs_me1a(layer2_pad_to_last_hs_me1a);
439  cluster.set_layer2_middle_hs_me1a(layer2_middle_hs_me1a);
440  }
441  // calculate the 1/8-strips
442  int layer2_pad_to_first_es = -1;
443  int layer2_pad_to_last_es = -1;
444 
445  int layer2_pad_to_first_es_me1a = -1;
446  int layer2_pad_to_last_es_me1a = -1;
447 
448  if (station_ == 1) {
449  if (isEven_) {
450  // ME1/b
451  layer2_pad_to_first_es = GEMCSCLUT_pad_es_ME1b_even_->lookup(layer2_first_pad);
452  layer2_pad_to_last_es = GEMCSCLUT_pad_es_ME1b_even_->lookup(layer2_last_pad);
453  // ME1/a
454  layer2_pad_to_first_es_me1a = GEMCSCLUT_pad_es_ME1a_even_->lookup(layer2_first_pad);
455  layer2_pad_to_last_es_me1a = GEMCSCLUT_pad_es_ME1a_even_->lookup(layer2_last_pad);
456  } else {
457  // ME1/b
458  layer2_pad_to_first_es = GEMCSCLUT_pad_es_ME1b_odd_->lookup(layer2_first_pad);
459  layer2_pad_to_last_es = GEMCSCLUT_pad_es_ME1b_odd_->lookup(layer2_last_pad);
460  // ME1/a
461  layer2_pad_to_first_es_me1a = GEMCSCLUT_pad_es_ME1a_odd_->lookup(layer2_first_pad);
462  layer2_pad_to_last_es_me1a = GEMCSCLUT_pad_es_ME1a_odd_->lookup(layer2_last_pad);
463  }
464  }
465 
466  // ME2/1
467  if (station_ == 2) {
468  if (isEven_) {
469  layer2_pad_to_first_es = GEMCSCLUT_pad_es_ME21_even_->lookup(layer2_first_pad);
470  layer2_pad_to_last_es = GEMCSCLUT_pad_es_ME21_even_->lookup(layer2_last_pad);
471  } else {
472  layer2_pad_to_first_es = GEMCSCLUT_pad_es_ME21_odd_->lookup(layer2_first_pad);
473  layer2_pad_to_last_es = GEMCSCLUT_pad_es_ME21_odd_->lookup(layer2_last_pad);
474  }
475  }
476  // middle 1/8-strip
477  int layer2_middle_es = 0.5 * (layer2_pad_to_first_es + layer2_pad_to_last_es);
478  int layer2_middle_es_me1a = 0.5 * (layer2_pad_to_first_es_me1a + layer2_pad_to_last_es_me1a);
479 
480  cluster.set_layer2_first_es(layer2_pad_to_first_es);
481  cluster.set_layer2_last_es(layer2_pad_to_last_es);
482  cluster.set_layer2_middle_es(layer2_middle_es);
483 
484  if (station_ == 1) {
485  cluster.set_layer2_first_es_me1a(layer2_pad_to_first_es_me1a);
486  cluster.set_layer2_last_es_me1a(layer2_pad_to_last_es_me1a);
487  cluster.set_layer2_middle_es_me1a(layer2_middle_es_me1a);
488  }
489  }
490 
491  // calculate the wiregroups
492  // need to subtract 1 to use the LUTs
493  const int roll = cluster.roll() - 1;
494 
495  int roll_l2_to_min_wg = -1;
496  int roll_l2_to_max_wg = -1;
497 
498  // ME1/1
499  if (station_ == 1) {
500  if (isEven_) {
501  roll_l2_to_min_wg = GEMCSCLUT_roll_l2_min_wg_ME11_even_->lookup(roll);
502  roll_l2_to_max_wg = GEMCSCLUT_roll_l2_max_wg_ME11_even_->lookup(roll);
503  } else {
504  roll_l2_to_min_wg = GEMCSCLUT_roll_l2_min_wg_ME11_odd_->lookup(roll);
505  roll_l2_to_max_wg = GEMCSCLUT_roll_l2_max_wg_ME11_odd_->lookup(roll);
506  }
507  }
508 
509  // ME2/1
510  if (station_ == 2) {
511  if (isEven_) {
512  roll_l2_to_min_wg = GEMCSCLUT_roll_l2_min_wg_ME21_even_->lookup(roll);
513  roll_l2_to_max_wg = GEMCSCLUT_roll_l2_max_wg_ME21_even_->lookup(roll);
514  } else {
515  roll_l2_to_min_wg = GEMCSCLUT_roll_l2_min_wg_ME21_odd_->lookup(roll);
516  roll_l2_to_max_wg = GEMCSCLUT_roll_l2_max_wg_ME21_odd_->lookup(roll);
517  }
518  }
519 
520  // set the values
521  cluster.set_layer2_min_wg(roll_l2_to_min_wg);
522  cluster.set_layer2_max_wg(roll_l2_to_max_wg);
523  }
524 }

References clusters_, GEMCSCLUT_pad_es_ME1a_even_, GEMCSCLUT_pad_es_ME1a_odd_, GEMCSCLUT_pad_es_ME1b_even_, GEMCSCLUT_pad_es_ME1b_odd_, GEMCSCLUT_pad_es_ME21_even_, GEMCSCLUT_pad_es_ME21_odd_, GEMCSCLUT_pad_hs_ME1a_even_, GEMCSCLUT_pad_hs_ME1a_odd_, GEMCSCLUT_pad_hs_ME1b_even_, GEMCSCLUT_pad_hs_ME1b_odd_, GEMCSCLUT_pad_hs_ME21_even_, GEMCSCLUT_pad_hs_ME21_odd_, GEMCSCLUT_roll_l1_max_wg_ME11_even_, GEMCSCLUT_roll_l1_max_wg_ME11_odd_, GEMCSCLUT_roll_l1_max_wg_ME21_even_, GEMCSCLUT_roll_l1_max_wg_ME21_odd_, GEMCSCLUT_roll_l1_min_wg_ME11_even_, GEMCSCLUT_roll_l1_min_wg_ME11_odd_, GEMCSCLUT_roll_l1_min_wg_ME21_even_, GEMCSCLUT_roll_l1_min_wg_ME21_odd_, GEMCSCLUT_roll_l2_max_wg_ME11_even_, GEMCSCLUT_roll_l2_max_wg_ME11_odd_, GEMCSCLUT_roll_l2_max_wg_ME21_even_, GEMCSCLUT_roll_l2_max_wg_ME21_odd_, GEMCSCLUT_roll_l2_min_wg_ME11_even_, GEMCSCLUT_roll_l2_min_wg_ME11_odd_, GEMCSCLUT_roll_l2_min_wg_ME21_even_, GEMCSCLUT_roll_l2_min_wg_ME21_odd_, isEven_, and station_.

Referenced by run().

◆ getClusters() [1/2]

std::vector< GEMInternalCluster > GEMClusterProcessor::getClusters ( int  bx) const

Definition at line 95 of file GEMClusterProcessor.cc.

95  {
96  std::vector<GEMInternalCluster> output;
97 
98  for (const auto& cl : clusters_) {
99  // valid single clusters with the right BX
100  if (cl.bx() == bx and cl.isValid()) {
101  output.push_back(cl);
102  }
103  }
104 
105  return output;
106 }

References l1GtPatternGenerator_cfi::bx, GetRecoTauVFromDQM_MC_cff::cl, clusters_, and convertSQLitetoXML_cfg::output.

◆ getClusters() [2/2]

std::vector< GEMInternalCluster > GEMClusterProcessor::getClusters ( int  bx,
int  deltaBX 
) const

Definition at line 108 of file GEMClusterProcessor.cc.

108  {
109  std::vector<GEMInternalCluster> output;
110 
111  for (const auto& cl : clusters_) {
112  // valid single clusters with the right BX
113  if (std::abs(cl.bx() - bx) <= deltaBX and cl.isValid()) {
114  output.push_back(cl);
115  }
116  }
117 
118  return output;
119 }

References funct::abs(), l1GtPatternGenerator_cfi::bx, GetRecoTauVFromDQM_MC_cff::cl, clusters_, and convertSQLitetoXML_cfg::output.

◆ getCoincidenceClusters()

std::vector< GEMInternalCluster > GEMClusterProcessor::getCoincidenceClusters ( int  bx) const

Definition at line 121 of file GEMClusterProcessor.cc.

121  {
122  std::vector<GEMInternalCluster> output;
123 
124  for (const auto& cl : clusters_) {
125  // valid coincidences with the right BX
126  if (cl.bx() == bx and cl.isCoincidence()) {
127  output.push_back(cl);
128  }
129  }
130 
131  return output;
132 }

References l1GtPatternGenerator_cfi::bx, GetRecoTauVFromDQM_MC_cff::cl, clusters_, and convertSQLitetoXML_cfg::output.

◆ hasGE21Geometry16Partitions()

bool GEMClusterProcessor::hasGE21Geometry16Partitions ( ) const
inline

Definition at line 42 of file GEMClusterProcessor.h.

42 { return hasGE21Geometry16Partitions_; }

References hasGE21Geometry16Partitions_.

◆ readoutCoPads()

std::vector< GEMCoPadDigi > GEMClusterProcessor::readoutCoPads ( ) const

Returns vector of CoPads in the read-out time window, if any.

Definition at line 526 of file GEMClusterProcessor.cc.

526  {
527  std::vector<GEMCoPadDigi> output;
528 
529  // loop on clusters
530  for (const auto& cluster : clusters_) {
531  // ignore single clusters
532  if (!cluster.isCoincidence())
533  continue;
534 
535  // construct coincidence pads out of the centers of the coincidence clusters
536  output.emplace_back(cluster.roll(), cluster.mid1(), cluster.mid2());
537  }
538 
539  return output;
540 }

References clusters_, and convertSQLitetoXML_cfg::output.

◆ run()

void GEMClusterProcessor::run ( const GEMPadDigiClusterCollection *  in_clusters)

Runs the CoPad processor code.

Definition at line 81 of file GEMClusterProcessor.cc.

81  {
82  // Step 1: clear the GEMInternalCluster vector
83  clear();
84 
85  // Step 2: put coincidence clusters in GEMInternalCluster vector
86  addCoincidenceClusters(in_clusters);
87 
88  // Step 3: put single clusters in GEMInternalCluster vector who are not part of any coincidence cluster
89  addSingleClusters(in_clusters);
90 
91  // Step 4: translate the cluster central pad numbers into 1/8-strip number for matching with CSC trigger primitives
92  doCoordinateConversion();
93 }

References addCoincidenceClusters(), addSingleClusters(), clear(), and doCoordinateConversion().

Member Data Documentation

◆ chamber_

const int GEMClusterProcessor::chamber_
private

Definition at line 60 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), and GEMClusterProcessor().

◆ clusters_

std::vector<GEMInternalCluster> GEMClusterProcessor::clusters_
private

Definition at line 70 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), clear(), doCoordinateConversion(), getClusters(), getCoincidenceClusters(), and readoutCoPads().

◆ GEMCSCLUT_pad_es_ME1a_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_es_ME1a_even_
private

Definition at line 94 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_es_ME1a_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_es_ME1a_odd_
private

Definition at line 95 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_es_ME1b_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_es_ME1b_even_
private

Definition at line 96 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_es_ME1b_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_es_ME1b_odd_
private

Definition at line 97 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_es_ME21_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_es_ME21_even_
private

Definition at line 98 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_es_ME21_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_es_ME21_odd_
private

Definition at line 99 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_hs_ME1a_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1a_even_
private

Definition at line 87 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_hs_ME1a_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1a_odd_
private

Definition at line 88 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_hs_ME1b_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1b_even_
private

Definition at line 89 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_hs_ME1b_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1b_odd_
private

Definition at line 90 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_hs_ME21_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_hs_ME21_even_
private

Definition at line 91 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_pad_hs_ME21_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_pad_hs_ME21_odd_
private

Definition at line 92 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_max_wg_ME11_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME11_even_
private

Definition at line 101 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_max_wg_ME11_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME11_odd_
private

Definition at line 102 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_max_wg_ME21_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME21_even_
private

Definition at line 105 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_max_wg_ME21_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME21_odd_
private

Definition at line 106 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_min_wg_ME11_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME11_even_
private

Definition at line 103 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_min_wg_ME11_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME11_odd_
private

Definition at line 104 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_min_wg_ME21_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME21_even_
private

Definition at line 107 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l1_min_wg_ME21_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME21_odd_
private

Definition at line 108 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_max_wg_ME11_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME11_even_
private

Definition at line 110 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_max_wg_ME11_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME11_odd_
private

Definition at line 111 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_max_wg_ME21_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME21_even_
private

Definition at line 114 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_max_wg_ME21_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME21_odd_
private

Definition at line 115 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_min_wg_ME11_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME11_even_
private

Definition at line 112 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_min_wg_ME11_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME11_odd_
private

Definition at line 113 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_min_wg_ME21_even_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME21_even_
private

Definition at line 116 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ GEMCSCLUT_roll_l2_min_wg_ME21_odd_

std::unique_ptr<CSCLUTReader> GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME21_odd_
private

Definition at line 117 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ hasGE21Geometry16Partitions_

bool GEMClusterProcessor::hasGE21Geometry16Partitions_
private

Definition at line 67 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), GEMClusterProcessor(), and hasGE21Geometry16Partitions().

◆ isEven_

bool GEMClusterProcessor::isEven_
private

Definition at line 61 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

◆ maxDeltaBX_

unsigned int GEMClusterProcessor::maxDeltaBX_
private

Definition at line 64 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and GEMClusterProcessor().

◆ maxDeltaPad_

unsigned int GEMClusterProcessor::maxDeltaPad_
private

Definition at line 63 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and GEMClusterProcessor().

◆ maxDeltaRoll_

unsigned int GEMClusterProcessor::maxDeltaRoll_
private

Definition at line 65 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and GEMClusterProcessor().

◆ padToEsME1aFiles_

std::vector<std::string> GEMClusterProcessor::padToEsME1aFiles_
private

Definition at line 77 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ padToEsME1bFiles_

std::vector<std::string> GEMClusterProcessor::padToEsME1bFiles_
private

Definition at line 78 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ padToEsME21Files_

std::vector<std::string> GEMClusterProcessor::padToEsME21Files_
private

Definition at line 79 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ padToHsME1aFiles_

std::vector<std::string> GEMClusterProcessor::padToHsME1aFiles_
private

Definition at line 73 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ padToHsME1bFiles_

std::vector<std::string> GEMClusterProcessor::padToHsME1bFiles_
private

Definition at line 74 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ padToHsME21Files_

std::vector<std::string> GEMClusterProcessor::padToHsME21Files_
private

Definition at line 75 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ region_

const int GEMClusterProcessor::region_
private

Chamber id (trigger-type labels).

Definition at line 58 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and addSingleClusters().

◆ rollToMaxWgME11Files_

std::vector<std::string> GEMClusterProcessor::rollToMaxWgME11Files_
private

Definition at line 81 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ rollToMaxWgME21Files_

std::vector<std::string> GEMClusterProcessor::rollToMaxWgME21Files_
private

Definition at line 83 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ rollToMinWgME11Files_

std::vector<std::string> GEMClusterProcessor::rollToMinWgME11Files_
private

Definition at line 82 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ rollToMinWgME21Files_

std::vector<std::string> GEMClusterProcessor::rollToMinWgME21Files_
private

Definition at line 84 of file GEMClusterProcessor.h.

Referenced by GEMClusterProcessor().

◆ station_

const int GEMClusterProcessor::station_
private

Definition at line 59 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), doCoordinateConversion(), and GEMClusterProcessor().

GEMClusterProcessor::padToHsME1bFiles_
std::vector< std::string > padToHsME1bFiles_
Definition: GEMClusterProcessor.h:74
GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME11_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME11_even_
Definition: GEMClusterProcessor.h:110
GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1a_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1a_even_
Definition: GEMClusterProcessor.h:87
GEMClusterProcessor::rollToMinWgME21Files_
std::vector< std::string > rollToMinWgME21Files_
Definition: GEMClusterProcessor.h:84
GEMClusterProcessor::maxDeltaBX_
unsigned int maxDeltaBX_
Definition: GEMClusterProcessor.h:64
GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME11_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME11_odd_
Definition: GEMClusterProcessor.h:104
GEMClusterProcessor::addSingleClusters
void addSingleClusters(const GEMPadDigiClusterCollection *)
Definition: GEMClusterProcessor.cc:207
GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1a_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1a_odd_
Definition: GEMClusterProcessor.h:88
GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME21_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME21_even_
Definition: GEMClusterProcessor.h:105
GEMClusterProcessor::clear
void clear()
Definition: GEMClusterProcessor.cc:79
GEMClusterProcessor::padToEsME21Files_
std::vector< std::string > padToEsME21Files_
Definition: GEMClusterProcessor.h:79
GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME21_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME21_odd_
Definition: GEMClusterProcessor.h:106
convertSQLitetoXML_cfg.output
output
Definition: convertSQLitetoXML_cfg.py:72
relativeConstraints.station
station
Definition: relativeConstraints.py:67
GEMClusterProcessor::rollToMinWgME11Files_
std::vector< std::string > rollToMinWgME11Files_
Definition: GEMClusterProcessor.h:82
GEMClusterProcessor::GEMCSCLUT_pad_es_ME1b_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1b_odd_
Definition: GEMClusterProcessor.h:97
GEMPadDigiCluster
Definition: GEMPadDigiCluster.h:19
GEMClusterProcessor::padToHsME21Files_
std::vector< std::string > padToHsME21Files_
Definition: GEMClusterProcessor.h:75
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
GEMClusterProcessor::clusters_
std::vector< GEMInternalCluster > clusters_
Definition: GEMClusterProcessor.h:70
GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME11_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME11_odd_
Definition: GEMClusterProcessor.h:113
GEMClusterProcessor::padToHsME1aFiles_
std::vector< std::string > padToHsME1aFiles_
Definition: GEMClusterProcessor.h:73
GEMClusterProcessor::maxDeltaPad_
unsigned int maxDeltaPad_
Definition: GEMClusterProcessor.h:63
GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME11_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME11_even_
Definition: GEMClusterProcessor.h:101
GetRecoTauVFromDQM_MC_cff.cl
cl
Definition: GetRecoTauVFromDQM_MC_cff.py:38
GEMClusterProcessor::rollToMaxWgME11Files_
std::vector< std::string > rollToMaxWgME11Files_
Definition: GEMClusterProcessor.h:81
GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME21_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME21_even_
Definition: GEMClusterProcessor.h:116
GEMClusterProcessor::rollToMaxWgME21Files_
std::vector< std::string > rollToMaxWgME21Files_
Definition: GEMClusterProcessor.h:83
GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME21_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME21_even_
Definition: GEMClusterProcessor.h:107
GEMPadDigiCluster::GE21
Definition: GEMPadDigiCluster.h:24
GEMClusterProcessor::GEMCSCLUT_pad_hs_ME21_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME21_even_
Definition: GEMClusterProcessor.h:91
GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME21_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME21_odd_
Definition: GEMClusterProcessor.h:108
mps_fire.end
end
Definition: mps_fire.py:242
GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME21_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME21_even_
Definition: GEMClusterProcessor.h:114
GEMClusterProcessor::GEMCSCLUT_pad_es_ME21_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME21_odd_
Definition: GEMClusterProcessor.h:99
phase1PixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize > layer
Definition: phase1PixelTopology.h:99
GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME11_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME11_odd_
Definition: GEMClusterProcessor.h:111
GEMClusterProcessor::maxDeltaRoll_
unsigned int maxDeltaRoll_
Definition: GEMClusterProcessor.h:65
GEMClusterProcessor::GEMCSCLUT_roll_l1_max_wg_ME11_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_max_wg_ME11_odd_
Definition: GEMClusterProcessor.h:102
edm::ParameterSet
Definition: ParameterSet.h:47
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
GEMClusterProcessor::GEMCSCLUT_pad_es_ME1a_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1a_even_
Definition: GEMClusterProcessor.h:94
GEMDetId
Definition: GEMDetId.h:18
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
HLT_FULL_cff.region
region
Definition: HLT_FULL_cff.py:88286
GEMClusterProcessor::GEMCSCLUT_roll_l1_min_wg_ME11_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l1_min_wg_ME11_even_
Definition: GEMClusterProcessor.h:103
submitPVResolutionJobs.q
q
Definition: submitPVResolutionJobs.py:84
GEMClusterProcessor::GEMCSCLUT_pad_es_ME1b_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1b_even_
Definition: GEMClusterProcessor.h:96
GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1b_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1b_odd_
Definition: GEMClusterProcessor.h:90
GEMClusterProcessor::isEven_
bool isEven_
Definition: GEMClusterProcessor.h:61
GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME21_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME21_odd_
Definition: GEMClusterProcessor.h:117
GEMClusterProcessor::GEMCSCLUT_pad_hs_ME21_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME21_odd_
Definition: GEMClusterProcessor.h:92
GEMClusterProcessor::GEMCSCLUT_pad_hs_ME1b_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_hs_ME1b_even_
Definition: GEMClusterProcessor.h:89
GEMClusterProcessor::GEMCSCLUT_roll_l2_max_wg_ME21_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_max_wg_ME21_odd_
Definition: GEMClusterProcessor.h:115
GEMClusterProcessor::padToEsME1bFiles_
std::vector< std::string > padToEsME1bFiles_
Definition: GEMClusterProcessor.h:78
GEMClusterProcessor::GEMCSCLUT_roll_l2_min_wg_ME11_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_roll_l2_min_wg_ME11_even_
Definition: GEMClusterProcessor.h:112
GeomDetEnumerators::isME0
bool isME0(GeomDetEnumerators::SubDetector m)
Definition: GeomDetEnumerators.cc:96
GEMClusterProcessor::doCoordinateConversion
void doCoordinateConversion()
Definition: GEMClusterProcessor.cc:250
GEMClusterProcessor::padToEsME1aFiles_
std::vector< std::string > padToEsME1aFiles_
Definition: GEMClusterProcessor.h:77
GEMClusterProcessor::chamber_
const int chamber_
Definition: GEMClusterProcessor.h:60
relativeConstraints.ring
ring
Definition: relativeConstraints.py:68
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
GEMClusterProcessor::region_
const int region_
Definition: GEMClusterProcessor.h:58
GEMInternalCluster
Definition: GEMInternalCluster.h:18
GEMClusterProcessor::station_
const int station_
Definition: GEMClusterProcessor.h:59
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
GEMClusterProcessor::addCoincidenceClusters
void addCoincidenceClusters(const GEMPadDigiClusterCollection *)
Definition: GEMClusterProcessor.cc:134
GEMClusterProcessor::GEMCSCLUT_pad_es_ME21_even_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME21_even_
Definition: GEMClusterProcessor.h:98
GEMClusterProcessor::hasGE21Geometry16Partitions_
bool hasGE21Geometry16Partitions_
Definition: GEMClusterProcessor.h:67
GEMClusterProcessor::GEMCSCLUT_pad_es_ME1a_odd_
std::unique_ptr< CSCLUTReader > GEMCSCLUT_pad_es_ME1a_odd_
Definition: GEMClusterProcessor.h:95
Generated for CMSSW Reference Manual by doxygen 1.8.16