CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
ClustersFromRawProducer.cc
Go to the documentation of this file.
1 /*
2  */
5 
8 
11 
15 
17 
25 
27 #include <sstream>
28 #include <memory>
29 #include <atomic>
30 #include <mutex>
31 
32 // #define VIDEBUG
33 #ifdef VIDEBUG
34 #include <iostream>
35 #define COUT std::cout << "VI "
36 #else
37 #define COUT LogDebug("")
38 #endif
39 
40 namespace {
41  std::unique_ptr<sistrip::FEDBuffer> fillBuffer(int fedId, const FEDRawDataCollection& rawColl) {
42  std::unique_ptr<sistrip::FEDBuffer> buffer;
43 
44  // Retrieve FED raw data for given FED
45  const FEDRawData& rawData = rawColl.FEDData(fedId);
46 
47  // Check on FEDRawData pointer
48  const auto st_buffer = sistrip::preconstructCheckFEDBuffer(rawData);
49  if
51  if (edm::isDebugEnabled()) {
53  << "[ClustersFromRawProducer::" << __func__ << "]" << st_buffer << " for FED ID " << fedId;
54  }
55  return buffer;
56  }
57  buffer = std::make_unique<sistrip::FEDBuffer>(rawData);
58  const auto st_chan = buffer->findChannels();
59  if
61  if (edm::isDebugEnabled()) {
63  << "Exception caught when creating FEDBuffer object for FED " << fedId << ": " << st_chan;
64  }
65  buffer.reset();
66  return buffer;
67  }
68  if
69  UNLIKELY(!buffer->doChecks(false)) {
70  if (edm::isDebugEnabled()) {
72  << "Exception caught when creating FEDBuffer object for FED " << fedId << ": FED Buffer check fails";
73  }
74  buffer.reset();
75  return buffer;
76  }
77 
78  /*
79  // dump of FEDRawData to stdout
80  if ( dump_ ) {
81  std::stringstream ss;
82  RawToDigiUnpacker::dumpRawData( fedId, rawData, ss );
83  LogTrace(mlRawToDigi_)
84  << ss.str();
85  }
86  */
87 
88  return buffer;
89  }
90 
91  class ClusterFiller final : public StripClusterizerAlgorithm::output_t::Getter {
92  public:
93  ClusterFiller(const FEDRawDataCollection& irawColl,
94  StripClusterizerAlgorithm& iclusterizer,
96  bool idoAPVEmulatorCheck,
97  bool legacy,
98  bool hybridZeroSuppressed)
99  : rawColl(irawColl),
100  clusterizer(iclusterizer),
101  rawAlgos(irawAlgos),
102  doAPVEmulatorCheck(idoAPVEmulatorCheck),
103  legacy_(legacy),
104  hybridZeroSuppressed_(hybridZeroSuppressed) {
105  incTot(clusterizer.allDetIds().size());
106  for (auto& d : done)
107  d = nullptr;
108  }
109 
110  ~ClusterFiller() override { printStat(); }
111 
113 
114  private:
115  std::unique_ptr<sistrip::FEDBuffer> buffers[1024];
116  std::atomic<sistrip::FEDBuffer*> done[1024];
117 
118  const FEDRawDataCollection& rawColl;
119 
122 
123  // March 2012: add flag for disabling APVe check in configuration
124  bool doAPVEmulatorCheck;
125 
126  bool legacy_;
127  bool hybridZeroSuppressed_;
128 
129 #ifdef VIDEBUG
130  struct Stat {
131  Stat() : totDet(0), detReady(0), detSet(0), detAct(0), detNoZ(0), detAbrt(0), totClus(0) {}
132  std::atomic<int> totDet; // all dets
133  std::atomic<int> detReady; // dets "updated"
134  std::atomic<int> detSet; // det actually set not empty
135  std::atomic<int> detAct; // det actually set with content
136  std::atomic<int> detNoZ; // det actually set with content
137  std::atomic<int> detAbrt; // det aborted
138  std::atomic<int> totClus; // total number of clusters
139  };
140 
141  mutable Stat stat;
142  // void zeroStat() const { stat = std::move(Stat()); }
143  void incTot(int n) const { stat.totDet = n; }
144  void incReady() const { stat.detReady++; }
145  void incSet() const { stat.detSet++; }
146  void incAct() const { stat.detAct++; }
147  void incNoZ() const { stat.detNoZ++; }
148  void incAbrt() const { stat.detAbrt++; }
149  void incClus(int n) const { stat.totClus += n; }
150  void printStat() const {
151  COUT << "VI clusters " << stat.totDet << ',' << stat.detReady << ',' << stat.detSet << ',' << stat.detAct << ','
152  << stat.detNoZ << ',' << stat.detAbrt << ',' << stat.totClus << std::endl;
153  }
154 
155 #else
156  static void zeroStat() {}
157  static void incTot(int) {}
158  static void incReady() {}
159  static void incSet() {}
160  static void incAct() {}
161  static void incNoZ() {}
162  static void incAbrt() {}
163  static void incClus(int) {}
164  static void printStat() {}
165 #endif
166  };
167 } // namespace
168 
170 public:
172  : onDemand(conf.getParameter<bool>("onDemand")),
173  cabling_(nullptr),
174  clusterizer_(StripClusterizerAlgorithmFactory::create(conf.getParameter<edm::ParameterSet>("Clusterizer"))),
175  rawAlgos_(SiStripRawProcessingFactory::create(conf.getParameter<edm::ParameterSet>("Algorithms"))),
176  doAPVEmulatorCheck_(conf.existsAs<bool>("DoAPVEmulatorCheck") ? conf.getParameter<bool>("DoAPVEmulatorCheck")
177  : true),
178  legacy_(conf.existsAs<bool>("LegacyUnpacker") ? conf.getParameter<bool>("LegacyUnpacker") : false),
179  hybridZeroSuppressed_(conf.getParameter<bool>("HybridZeroSuppressed")) {
180  productToken_ = consumes<FEDRawDataCollection>(conf.getParameter<edm::InputTag>("ProductLabel"));
181  produces<edmNew::DetSetVector<SiStripCluster> >();
182  assert(clusterizer_.get());
183  assert(rawAlgos_.get());
184  }
185 
186  void beginRun(const edm::Run&, const edm::EventSetup& es) override { initialize(es); }
187 
188  void produce(edm::Event& ev, const edm::EventSetup& es) override {
189  initialize(es);
190 
191  // get raw data
193  ev.getByToken(productToken_, rawData);
194 
195  std::unique_ptr<edmNew::DetSetVector<SiStripCluster> > output(
197  std::shared_ptr<edmNew::DetSetVector<SiStripCluster>::Getter>(std::make_shared<ClusterFiller>(
199  clusterizer_->allDetIds())
201 
202  if (onDemand)
203  assert(output->onDemand());
204 
205  output->reserve(15000, 24 * 10000);
206 
207  if (!onDemand) {
208  run(*rawData, *output);
209  output->shrink_to_fit();
210  COUT << output->dataSize() << " clusters from " << output->size() << " modules" << std::endl;
211  }
212 
213  ev.put(std::move(output));
214  }
215 
216 private:
217  void initialize(const edm::EventSetup& es);
218 
220 
221 private:
222  bool onDemand;
223 
225 
227 
228  std::unique_ptr<StripClusterizerAlgorithm> clusterizer_;
229  std::unique_ptr<SiStripRawProcessingAlgorithms> rawAlgos_;
230 
231  // March 2012: add flag for disabling APVe check in configuration
233 
234  bool legacy_;
236 };
237 
240 
242  (*clusterizer_).initialize(es);
243  cabling_ = (*clusterizer_).cabling();
244  (*rawAlgos_).initialize(es);
245 }
246 
249 
250  // loop over good det in cabling
251  for (auto idet : clusterizer_->allDetIds()) {
253 
254  filler.fill(record);
255 
256  if (record.empty())
257  record.abort();
258 
259  } // end loop over dets
260 }
261 
262 namespace {
263  class StripByStripAdder {
264  public:
265  typedef std::output_iterator_tag iterator_category;
266  typedef void value_type;
267  typedef void difference_type;
268  typedef void pointer;
269  typedef void reference;
270 
271  StripByStripAdder(StripClusterizerAlgorithm& clusterizer,
274  : clusterizer_(clusterizer), state_(state), record_(record) {}
275 
276  StripByStripAdder& operator=(SiStripDigi digi) {
277  clusterizer_.stripByStripAdd(state_, digi.strip(), digi.adc(), record_);
278  return *this;
279  }
280 
281  StripByStripAdder& operator*() { return *this; }
282  StripByStripAdder& operator++() { return *this; }
283  StripByStripAdder& operator++(int) { return *this; }
284 
285  private:
286  StripClusterizerAlgorithm& clusterizer_;
289  };
290 
291  template <typename Container>
292  class ADC_back_inserter {
293  public:
294  ADC_back_inserter(Container& c) : c_(c) {}
295 
296  ADC_back_inserter& operator=(SiStripRawDigi digi) {
297  c_.push_back(digi.adc());
298  return *this;
299  }
300  ADC_back_inserter& operator*() { return *this; }
301  ADC_back_inserter& operator++() { return *this; }
302  ADC_back_inserter& operator++(int) { return *this; }
303 
304  private:
305  Container& c_;
306  };
307 } // namespace
308 
310  try { // edmNew::CapacityExaustedException
311  incReady();
312 
313  auto idet = record.id();
314 
315  COUT << "filling " << idet << std::endl;
316 
317  auto const& det = clusterizer.stripByStripBegin(idet);
318  if (!det.valid())
319  return;
321 
322  incSet();
323 
324  // Loop over apv-pairs of det
325  for (auto const conn : clusterizer.currentConnection(det)) {
326  if
327  UNLIKELY(!conn) continue;
328 
329  const uint16_t fedId = conn->fedId();
330 
331  // If fed id is null or connection is invalid continue
332  if
333  UNLIKELY(!fedId || !conn->isConnected()) { continue; }
334 
335  // If Fed hasnt already been initialised, extract data and initialise
337  if (!buffer) {
338  buffer = fillBuffer(fedId, rawColl).release();
339  if (!buffer) {
340  continue;
341  }
342  sistrip::FEDBuffer* exp = nullptr;
343  if (done[fedId].compare_exchange_strong(exp, buffer))
344  buffers[fedId].reset(buffer);
345  else {
346  delete buffer;
347  buffer = done[fedId];
348  }
349  }
350  assert(buffer);
351 
352  buffer->setLegacyMode(legacy_);
353 
354  // check channel
355  const uint8_t fedCh = conn->fedCh();
356 
357  if
358  UNLIKELY(!buffer->channelGood(fedCh, doAPVEmulatorCheck)) {
359  if (edm::isDebugEnabled()) {
360  std::ostringstream ss;
361  ss << "Problem unpacking channel " << fedCh << " on FED " << fedId;
363  }
364  continue;
365  }
366 
367  // Determine APV std::pair number
368  uint16_t ipair = conn->apvPairNumber();
369 
370  const sistrip::FEDReadoutMode mode = buffer->readoutMode();
371  const sistrip::FEDLegacyReadoutMode lmode =
372  legacy_ ? buffer->legacyReadoutMode() : sistrip::READOUT_MODE_LEGACY_INVALID;
373 
374  using namespace sistrip;
375  if
377  auto perStripAdder = StripByStripAdder(clusterizer, state, record);
378  const auto isNonLite = fedchannelunpacker::isNonLiteZS(mode, legacy_, lmode);
379  const uint8_t pCode = (isNonLite ? buffer->packetCode(legacy_, fedCh) : 0);
381  if
382  LIKELY(!hybridZeroSuppressed_) {
384  buffer->channel(fedCh), perStripAdder, ipair * 256, isNonLite, mode, legacy_, lmode, pCode);
385  }
386  else {
387  const uint32_t id = conn->detId();
388  edm::DetSet<SiStripDigi> unpDigis{id};
389  unpDigis.reserve(256);
390  st_ch = fedchannelunpacker::unpackZeroSuppressed(buffer->channel(fedCh),
391  std::back_inserter(unpDigis),
392  ipair * 256,
393  isNonLite,
394  mode,
395  legacy_,
396  lmode,
397  pCode);
399  edm::DetSet<SiStripDigi> suppDigis{id};
400  rawAlgos.suppressHybridData(unpDigis, suppDigis, ipair * 2);
401  std::copy(std::begin(suppDigis), std::end(suppDigis), perStripAdder);
402  }
403  }
406  << "Unordered clusters for channel " << fedCh << " on FED " << fedId << ": " << toString(st_ch);
407  continue;
408  }
409  }
410  else {
412  if (fedchannelunpacker::isVirginRaw(mode, legacy_, lmode)) {
413  std::vector<int16_t> digis;
415  buffer->channel(fedCh), ADC_back_inserter(digis), buffer->channel(fedCh).packetCode());
417  //process raw
418  uint32_t id = conn->detId();
419  edm::DetSet<SiStripDigi> zsdigis(id);
420  //rawAlgos_->subtractorPed->subtract( id, ipair*256, digis);
421  //rawAlgos_->subtractorCMN->subtract( id, digis);
422  //rawAlgos_->suppressor->suppress( digis, zsdigis);
423  uint16_t firstAPV = ipair * 2;
424  rawAlgos.suppressVirginRawData(id, firstAPV, digis, zsdigis);
425  for (const auto digi : zsdigis) {
426  clusterizer.stripByStripAdd(state, digi.strip(), digi.adc(), record);
427  }
428  }
429  } else if (fedchannelunpacker::isProcessedRaw(mode, legacy_, lmode)) {
430  std::vector<int16_t> digis;
431  st_ch = fedchannelunpacker::unpackProcessedRaw(buffer->channel(fedCh), ADC_back_inserter(digis));
433  //process raw
434  uint32_t id = conn->detId();
435  edm::DetSet<SiStripDigi> zsdigis(id);
436  //rawAlgos_->subtractorCMN->subtract( id, digis);
437  //rawAlgos_->suppressor->suppress( digis, zsdigis);
438  uint16_t firstAPV = ipair * 2;
439  rawAlgos.suppressProcessedRawData(id, firstAPV, digis, zsdigis);
440  for (edm::DetSet<SiStripDigi>::const_iterator it = zsdigis.begin(); it != zsdigis.end(); it++) {
441  clusterizer.stripByStripAdd(state, it->strip(), it->adc(), record);
442  }
443  }
444  } else {
446  << "[ClustersFromRawProducer::" << __func__ << "]"
447  << " FEDRawData readout mode " << mode << " from FED id " << fedId << " not supported.";
448  }
451  << "[ClustersFromRawProducer::" << __func__ << "]" << toString(st_ch) << " from FED id " << fedId
452  << " channel " << fedCh;
453  }
454  }
455  } // end loop over conn
456 
457  clusterizer.stripByStripEnd(state, record);
458 
459  incAct();
460 
461  if (record.full()) {
462  edm::LogError(sistrip::mlRawToCluster_) << "too many Sistrip Clusters to fit space allocated for OnDemand for "
463  << record.id() << ' ' << record.size();
464  record.abort();
465  incAbrt();
466  }
467 
468  if (!record.empty())
469  incNoZ();
470 
471  COUT << "filled " << record.size() << std::endl;
472  for (auto const& cl : record)
473  COUT << cl.firstStrip() << ',' << cl.amplitudes().size() << std::endl;
474  incClus(record.size());
475  } catch (edmNew::CapacityExaustedException const&) {
476  edm::LogError(sistrip::mlRawToCluster_) << "too many Sistrip Clusters to fit space allocated for OnDemand";
477  }
478 }
Likely.h
StripClusterizerAlgorithm
Definition: StripClusterizerAlgorithm.h:20
sistrip::fedchannelunpacker::isVirginRaw
bool isVirginRaw(FEDReadoutMode mode, bool legacy=false, FEDLegacyReadoutMode lmode=READOUT_MODE_LEGACY_INVALID)
Definition: SiStripFEDBuffer.h:382
sistrip::fedchannelunpacker::StatusCode::SUCCESS
SiStripRawProcessingFactory.h
electrons_cff.bool
bool
Definition: electrons_cff.py:372
SiStripClusterizerFromRaw::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &es) override
Definition: ClustersFromRawProducer.cc:186
SiStripRawProcessingAlgorithms
Definition: SiStripRawProcessingAlgorithms.h:15
MessageLogger.h
funct::false
false
Definition: Factorize.h:34
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
operator*
MatrixMeschach operator*(const MatrixMeschach &mat1, const MatrixMeschach &mat2)
Definition: MatrixMeschach.cc:117
sistrip::mlRawToCluster_
static const char mlRawToCluster_[]
Definition: ConstantsForLogger.h:24
filterCSVwithJSON.copy
copy
Definition: filterCSVwithJSON.py:36
ESHandle.h
sistrip::fedchannelunpacker::isNonLiteZS
bool isNonLiteZS(FEDReadoutMode mode, bool legacy=false, FEDLegacyReadoutMode lmode=READOUT_MODE_LEGACY_INVALID)
Definition: SiStripFEDBuffer.h:375
edm::DetSet< SiStripDigi >
convertSQLitetoXML_cfg.output
output
Definition: convertSQLitetoXML_cfg.py:32
edm::Run
Definition: Run.h:45
SiStripRawProcessingFactory
Definition: SiStripRawProcessingFactory.h:14
SiStripClusterizerFromRaw::legacy_
bool legacy_
Definition: ClustersFromRawProducer.cc:234
sistrip::toString
std::string toString(fedchannelunpacker::StatusCode status)
Definition: SiStripFEDBuffer.cc:412
edm::EDGetTokenT< FEDRawDataCollection >
FEDRawDataCollection
Definition: FEDRawDataCollection.h:18
edm
HLT enums.
Definition: AlignableModifier.h:19
SiStripClusterizerFromRaw::hybridZeroSuppressed_
bool hybridZeroSuppressed_
Definition: ClustersFromRawProducer.cc:235
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
l1tstage2_dqm_sourceclient-live_cfg.rawData
rawData
Definition: l1tstage2_dqm_sourceclient-live_cfg.py:156
edmNew::DetSetVector::TSFastFiller
Definition: DetSetVectorNew.h:334
GlobalPosition_Frontier_DevDB_cff.record
record
Definition: GlobalPosition_Frontier_DevDB_cff.py:10
SiStripClusterizerFromRaw::productToken_
edm::EDGetTokenT< FEDRawDataCollection > productToken_
Definition: ClustersFromRawProducer.cc:224
SiStripCommissioningClient_cfg.conn
conn
Definition: SiStripCommissioningClient_cfg.py:5
cms::cuda::assert
assert(be >=bs)
edmNew::CapacityExaustedException
Definition: DetSetVectorNew.h:41
EDProducer.h
edmNew::dslv::LazyGetter
Definition: DetSetVectorNew.h:47
beamerCreator.create
def create(alignables, pedeDump, additionalData, outputFile, config)
Definition: beamerCreator.py:44
sistrip::fedchannelunpacker::unpackProcessedRaw
StatusCode unpackProcessedRaw(const FEDChannel &channel, OUT &&out)
Definition: SiStripFEDBuffer.h:405
edm::Handle
Definition: AssociativeIterator.h:50
sistrip::fedchannelunpacker::isProcessedRaw
bool isProcessedRaw(FEDReadoutMode mode, bool legacy=false, FEDLegacyReadoutMode lmode=READOUT_MODE_LEGACY_INVALID)
Definition: SiStripFEDBuffer.h:388
SiStripClusterizerFromRaw
Definition: ClustersFromRawProducer.cc:169
reco::JetExtendedAssociation::Container
edm::AssociationVector< reco::JetRefBaseProd, Values > Container
Definition: JetExtendedAssociation.h:29
end
#define end
Definition: vmac.h:39
FEDRawData
Definition: FEDRawData.h:19
SiStripClusterizerFromRaw::doAPVEmulatorCheck_
bool doAPVEmulatorCheck_
Definition: ClustersFromRawProducer.cc:232
sistrip::FEDReadoutMode
FEDReadoutMode
Definition: SiStripFEDBufferComponents.h:45
edmScanValgrind.buffer
buffer
Definition: edmScanValgrind.py:171
StripClusterizerAlgorithm::State
Definition: StripClusterizerAlgorithm.h:44
GetRecoTauVFromDQM_MC_cff.cl
cl
Definition: GetRecoTauVFromDQM_MC_cff.py:38
contentValuesCheck.ss
ss
Definition: contentValuesCheck.py:33
UNLIKELY
#define UNLIKELY(x)
Definition: Likely.h:21
MakerMacros.h
COUT
#define COUT
Definition: ClustersFromRawProducer.cc:37
SiStripDetCabling.h
SiStripRawDigi
A Digi for the silicon strip detector, containing only adc information, and suitable for storing raw ...
Definition: SiStripRawDigi.h:15
sistrip::fedchannelunpacker::unpackZeroSuppressed
StatusCode unpackZeroSuppressed(const FEDChannel &channel, OUT &&out, uint16_t stripStart, bool isNonLite, FEDReadoutMode mode, bool legacy=false, FEDLegacyReadoutMode lmode=READOUT_MODE_LEGACY_INVALID, uint8_t packetCode=0)
Definition: SiStripFEDBuffer.h:435
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
hgcalPlots.stat
stat
Definition: hgcalPlots.py:1111
fileCollector.done
done
Definition: fileCollector.py:123
SiStripFEDBuffer.h
SiStripRawDigi::adc
uint16_t adc() const
Definition: SiStripRawDigi.h:22
SiStripDetCabling
Definition: SiStripDetCabling.h:21
SiStripClusterizerFromRaw::produce
void produce(edm::Event &ev, const edm::EventSetup &es) override
Definition: ClustersFromRawProducer.cc:188
SiStripDigi::adc
const uint16_t & adc() const
Definition: SiStripDigi.h:34
FEDRawDataCollection::FEDData
const FEDRawData & FEDData(int fedid) const
retrieve data for fed
Definition: FEDRawDataCollection.cc:19
sistrip::FEDLegacyReadoutMode
FEDLegacyReadoutMode
Definition: SiStripFEDBufferComponents.h:64
SiStripClusterizerFromRaw::rawAlgos_
std::unique_ptr< SiStripRawProcessingAlgorithms > rawAlgos_
Definition: ClustersFromRawProducer.cc:229
edm::LogWarning
Definition: MessageLogger.h:141
SiStripClusterizerFromRaw::run
void run(const FEDRawDataCollection &rawColl, edmNew::DetSetVector< SiStripCluster > &output)
Definition: ClustersFromRawProducer.cc:247
funct::true
true
Definition: Factorize.h:173
ntuplemaker.fill
fill
Definition: ntuplemaker.py:304
SiStripDigi::strip
const uint16_t & strip() const
Definition: SiStripDigi.h:33
SiStripConstants.h
SiStripClusterizerFromRaw::onDemand
bool onDemand
Definition: ClustersFromRawProducer.cc:222
edm::ParameterSet
Definition: ParameterSet.h:36
edm::LogError
Definition: MessageLogger.h:183
SiStripCluster.h
Event.h
ParameterSet
Definition: Functions.h:16
trigObjTnPSource_cfi.filler
filler
Definition: trigObjTnPSource_cfi.py:21
sistrip::fedchannelunpacker::unpackVirginRaw
StatusCode unpackVirginRaw(const FEDChannel &channel, OUT &&out, uint8_t packetCode)
Definition: SiStripFEDBuffer.h:410
RecoTauValidation_cfi.reference
reference
Definition: RecoTauValidation_cfi.py:234
sistrip::FEDBufferStatusCode::SUCCESS
FEDRawDataCollection.h
edm::stream::EDProducer
Definition: EDProducer.h:38
SiStripRawProcessingAlgorithms.h
edm::EventSetup
Definition: EventSetup.h:57
reco::JetExtendedAssociation::value_type
Container::value_type value_type
Definition: JetExtendedAssociation.h:30
l1tstage2_dqm_sourceclient-live_cfg.fedId
fedId
Definition: l1tstage2_dqm_sourceclient-live_cfg.py:82
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
SiStripClusterizerFromRaw::cabling_
SiStripDetCabling const * cabling_
Definition: ClustersFromRawProducer.cc:226
SiStripClusterizerFromRaw::initialize
void initialize(const edm::EventSetup &es)
Definition: ClustersFromRawProducer.cc:241
sistrip::FEDBuffer
Definition: SiStripFEDBuffer.h:24
InputTag.h
sistrip::preconstructCheckFEDBuffer
FEDBufferStatusCode preconstructCheckFEDBuffer(const FEDRawData &fedBuffer, bool allowBadBuffer=false)
Definition: SiStripFEDBuffer.h:131
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::DetSet::reserve
void reserve(size_t s)
Definition: DetSet.h:65
edmNew::DetSetVector
Definition: DetSetNew.h:13
sistrip::READOUT_MODE_LEGACY_INVALID
Definition: SiStripFEDBufferComponents.h:65
eostools.move
def move(src, dest)
Definition: eostools.py:511
HLT_2018_cff.clusterizer
clusterizer
Definition: HLT_2018_cff.py:50410
SiStripClusterizerFromRaw::clusterizer_
std::unique_ptr< StripClusterizerAlgorithm > clusterizer_
Definition: ClustersFromRawProducer.cc:228
LIKELY
#define LIKELY(x)
Definition: Likely.h:20
ev
bool ev
Definition: Hydjet2Hadronizer.cc:95
SiStripClusterizerFromRaw::SiStripClusterizerFromRaw
SiStripClusterizerFromRaw(const edm::ParameterSet &conf)
Definition: ClustersFromRawProducer.cc:171
EventSetup.h
StripClusterizerAlgorithmFactory
Definition: StripClusterizerAlgorithmFactory.h:10
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:71
ztail.d
d
Definition: ztail.py:151
SiStripDigi
A Digi for the silicon strip detector, containing both strip and adc information, and suitable for st...
Definition: SiStripDigi.h:12
StripClusterizerAlgorithm.h
ParameterSet.h
sistrip
sistrip classes
Definition: SiStripQualityHelpers.h:14
JetChargeProducer_cfi.exp
exp
Definition: JetChargeProducer_cfi.py:6
edm::Event
Definition: Event.h:73
DetSetVectorNew.h
edm::InputTag
Definition: InputTag.h:15
begin
#define begin
Definition: vmac.h:32
StripClusterizerAlgorithmFactory.h
sistrip::fedchannelunpacker::isZeroSuppressed
bool isZeroSuppressed(FEDReadoutMode mode, bool legacy=false, FEDLegacyReadoutMode lmode=READOUT_MODE_LEGACY_INVALID)
Definition: SiStripFEDBuffer.h:341
edm::DetSet::const_iterator
collection_type::const_iterator const_iterator
Definition: DetSet.h:31