CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
ClustersFromRawProducer.cc
Go to the documentation of this file.
1 /*
2  */
5 
8 
11 
15 
17 
24 
26 #include <sstream>
27 #include <memory>
28 #include <atomic>
29 #include <mutex>
30 
32 
33 // #define VIDEBUG
34 #ifdef VIDEBUG
35 #include <iostream>
36 #define COUT std::cout << "VI "
37 #else
38 #define COUT LogDebug("")
39 #endif
40 
41 namespace {
42  std::unique_ptr<sistrip::FEDBuffer> fillBuffer(int fedId, const FEDRawDataCollection& rawColl) {
43  std::unique_ptr<sistrip::FEDBuffer> buffer;
44 
45  // Retrieve FED raw data for given FED
46  const FEDRawData& rawData = rawColl.FEDData(fedId);
47 
48  // Check on FEDRawData pointer
49  if
50  UNLIKELY(!rawData.data()) {
51  if (edm::isDebugEnabled()) {
52  edm::LogWarning(sistrip::mlRawToCluster_) << "[ClustersFromRawProducer::" << __func__ << "]"
53  << " NULL pointer to FEDRawData for FED id " << fedId;
54  }
55  return buffer;
56  }
57 
58  // Check on FEDRawData size
59  if
60  UNLIKELY(!rawData.size()) {
61  if (edm::isDebugEnabled()) {
62  edm::LogWarning(sistrip::mlRawToCluster_) << "[ClustersFromRawProducer::" << __func__ << "]"
63  << " FEDRawData has zero size for FED id " << fedId;
64  }
65  return buffer;
66  }
67 
68  // construct FEDBuffer
69  try {
70  buffer.reset(new sistrip::FEDBuffer(rawData.data(), rawData.size()));
71  if
72  UNLIKELY(!buffer->doChecks(false))
73  throw cms::Exception("FEDBuffer") << "FED Buffer check fails for FED ID" << fedId << ".";
74  } catch (const cms::Exception& e) {
75  if (edm::isDebugEnabled()) {
77  << "Exception caught when creating FEDBuffer object for FED " << fedId << ": " << e.what();
78  }
79  return std::unique_ptr<sistrip::FEDBuffer>();
80  }
81 
82  /*
83  // dump of FEDRawData to stdout
84  if ( dump_ ) {
85  std::stringstream ss;
86  RawToDigiUnpacker::dumpRawData( fedId, rawData, ss );
87  LogTrace(mlRawToDigi_)
88  << ss.str();
89  }
90  */
91 
92  return buffer;
93  }
94 
95  class ClusterFiller final : public StripClusterizerAlgorithm::output_t::Getter {
96  public:
97  ClusterFiller(const FEDRawDataCollection& irawColl,
98  StripClusterizerAlgorithm& iclusterizer,
100  bool idoAPVEmulatorCheck,
101  bool legacy,
102  bool hybridZeroSuppressed)
103  : rawColl(irawColl),
104  clusterizer(iclusterizer),
105  rawAlgos(irawAlgos),
106  doAPVEmulatorCheck(idoAPVEmulatorCheck),
107  legacy_(legacy),
108  hybridZeroSuppressed_(hybridZeroSuppressed) {
109  incTot(clusterizer.allDetIds().size());
110  for (auto& d : done)
111  d = nullptr;
112  }
113 
114  ~ClusterFiller() override { printStat(); }
115 
117 
118  private:
119  std::unique_ptr<sistrip::FEDBuffer> buffers[1024];
120  std::atomic<sistrip::FEDBuffer*> done[1024];
121 
122  const FEDRawDataCollection& rawColl;
123 
126 
127  // March 2012: add flag for disabling APVe check in configuration
128  bool doAPVEmulatorCheck;
129 
130  bool legacy_;
131  bool hybridZeroSuppressed_;
132 
133 #ifdef VIDEBUG
134  struct Stat {
135  Stat() : totDet(0), detReady(0), detSet(0), detAct(0), detNoZ(0), detAbrt(0), totClus(0) {}
136  std::atomic<int> totDet; // all dets
137  std::atomic<int> detReady; // dets "updated"
138  std::atomic<int> detSet; // det actually set not empty
139  std::atomic<int> detAct; // det actually set with content
140  std::atomic<int> detNoZ; // det actually set with content
141  std::atomic<int> detAbrt; // det aborted
142  std::atomic<int> totClus; // total number of clusters
143  };
144 
145  mutable Stat stat;
146  // void zeroStat() const { stat = std::move(Stat()); }
147  void incTot(int n) const { stat.totDet = n; }
148  void incReady() const { stat.detReady++; }
149  void incSet() const { stat.detSet++; }
150  void incAct() const { stat.detAct++; }
151  void incNoZ() const { stat.detNoZ++; }
152  void incAbrt() const { stat.detAbrt++; }
153  void incClus(int n) const { stat.totClus += n; }
154  void printStat() const {
155  COUT << "VI clusters " << stat.totDet << ',' << stat.detReady << ',' << stat.detSet << ',' << stat.detAct << ','
156  << stat.detNoZ << ',' << stat.detAbrt << ',' << stat.totClus << std::endl;
157  }
158 
159 #else
160  static void zeroStat() {}
161  static void incTot(int) {}
162  static void incReady() {}
163  static void incSet() {}
164  static void incAct() {}
165  static void incNoZ() {}
166  static void incAbrt() {}
167  static void incClus(int) {}
168  static void printStat() {}
169 #endif
170  };
171 } // namespace
172 
174 public:
176  : onDemand(conf.getParameter<bool>("onDemand")),
177  cabling_(nullptr),
178  clusterizer_(StripClusterizerAlgorithmFactory::create(conf.getParameter<edm::ParameterSet>("Clusterizer"))),
179  rawAlgos_(SiStripRawProcessingFactory::create(conf.getParameter<edm::ParameterSet>("Algorithms"))),
180  doAPVEmulatorCheck_(conf.existsAs<bool>("DoAPVEmulatorCheck") ? conf.getParameter<bool>("DoAPVEmulatorCheck")
181  : true),
182  legacy_(conf.existsAs<bool>("LegacyUnpacker") ? conf.getParameter<bool>("LegacyUnpacker") : false),
183  hybridZeroSuppressed_(conf.getParameter<bool>("HybridZeroSuppressed")) {
184  productToken_ = consumes<FEDRawDataCollection>(conf.getParameter<edm::InputTag>("ProductLabel"));
185  produces<edmNew::DetSetVector<SiStripCluster> >();
186  assert(clusterizer_.get());
187  assert(rawAlgos_.get());
188  }
189 
190  void beginRun(const edm::Run&, const edm::EventSetup& es) override { initialize(es); }
191 
192  void produce(edm::Event& ev, const edm::EventSetup& es) override {
193  initialize(es);
194 
195  // get raw data
197  ev.getByToken(productToken_, rawData);
198 
199  std::unique_ptr<edmNew::DetSetVector<SiStripCluster> > output(
201  std::shared_ptr<edmNew::DetSetVector<SiStripCluster>::Getter>(std::make_shared<ClusterFiller>(
202  *rawData, *clusterizer_, *rawAlgos_, doAPVEmulatorCheck_, legacy_, hybridZeroSuppressed_)),
203  clusterizer_->allDetIds())
205 
206  if (onDemand)
207  assert(output->onDemand());
208 
209  output->reserve(15000, 24 * 10000);
210 
211  if (!onDemand) {
212  run(*rawData, *output);
213  output->shrink_to_fit();
214  COUT << output->dataSize() << " clusters from " << output->size() << " modules" << std::endl;
215  }
216 
217  ev.put(std::move(output));
218  }
219 
220 private:
221  void initialize(const edm::EventSetup& es);
222 
224 
225 private:
226  bool onDemand;
227 
229 
231 
232  std::unique_ptr<StripClusterizerAlgorithm> clusterizer_;
233  std::unique_ptr<SiStripRawProcessingAlgorithms> rawAlgos_;
234 
235  // March 2012: add flag for disabling APVe check in configuration
237 
238  bool legacy_;
240 };
241 
244 
246  (*clusterizer_).initialize(es);
247  cabling_ = (*clusterizer_).cabling();
248  (*rawAlgos_).initialize(es);
249 }
250 
252  ClusterFiller filler(rawColl, *clusterizer_, *rawAlgos_, doAPVEmulatorCheck_, legacy_, hybridZeroSuppressed_);
253 
254  // loop over good det in cabling
255  for (auto idet : clusterizer_->allDetIds()) {
257 
258  filler.fill(record);
259 
260  if (record.empty())
261  record.abort();
262 
263  } // end loop over dets
264 }
265 
266 namespace {
267  template <typename OUT>
268  OUT unpackZS(const sistrip::FEDChannel& chan, sistrip::FEDReadoutMode mode, uint16_t stripOffset, OUT out) {
269  using namespace sistrip;
270  switch (mode) {
273  auto unpacker = FEDZSChannelUnpacker::zeroSuppressedLiteModeUnpacker(chan);
274  while (unpacker.hasData()) {
275  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc());
276  unpacker++;
277  }
278  } break;
281  auto unpacker = FEDBSChannelUnpacker::zeroSuppressedLiteModeUnpacker(chan, 10);
282  while (unpacker.hasData()) {
283  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc());
284  unpacker++;
285  }
286  } break;
289  switch (chan.packetCode()) {
291  auto unpacker = FEDZSChannelUnpacker::zeroSuppressedModeUnpacker(chan);
292  while (unpacker.hasData()) {
293  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc());
294  unpacker++;
295  }
296  } break;
298  auto unpacker = FEDBSChannelUnpacker::zeroSuppressedModeUnpacker(chan, 10);
299  while (unpacker.hasData()) {
300  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc());
301  unpacker++;
302  }
303  } break;
305  auto unpacker = FEDBSChannelUnpacker::zeroSuppressedModeUnpacker(chan, 8);
306  while (unpacker.hasData()) {
307  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc() << 2);
308  unpacker++;
309  }
310  } break;
312  auto unpacker = FEDBSChannelUnpacker::zeroSuppressedModeUnpacker(chan, 8);
313  while (unpacker.hasData()) {
314  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc() << 1);
315  unpacker++;
316  }
317  } break;
318  default:
319  edm::LogWarning(mlRawToCluster_) << "[ClustersFromRawProducer::" << __func__ << "]"
320  << " invalid packet code " << chan.packetCode() << " for zero-suppressed.";
321  }
322  } break;
325  auto unpacker = FEDZSChannelUnpacker::zeroSuppressedLiteModeUnpacker(chan);
326  while (unpacker.hasData()) {
327  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc() << 1);
328  unpacker++;
329  }
330  } break;
333  auto unpacker = FEDZSChannelUnpacker::zeroSuppressedLiteModeUnpacker(chan);
334  while (unpacker.hasData()) {
335  *out++ = SiStripDigi(stripOffset + unpacker.sampleNumber(), unpacker.adc() << 2);
336  unpacker++;
337  }
338  } break;
339  default:;
340  }
341  return out;
342  }
343 
344  class StripByStripAdder {
345  public:
346  typedef std::output_iterator_tag iterator_category;
347  typedef void value_type;
348  typedef void difference_type;
349  typedef void pointer;
350  typedef void reference;
351 
352  StripByStripAdder(StripClusterizerAlgorithm& clusterizer,
355  : clusterizer_(clusterizer), state_(state), record_(record) {}
356 
357  StripByStripAdder& operator=(SiStripDigi digi) {
358  clusterizer_.stripByStripAdd(state_, digi.strip(), digi.adc(), record_);
359  return *this;
360  }
361 
362  StripByStripAdder& operator*() { return *this; }
363  StripByStripAdder& operator++() { return *this; }
364  StripByStripAdder& operator++(int) { return *this; }
365 
366  private:
367  StripClusterizerAlgorithm& clusterizer_;
370  };
371 } // namespace
372 
374  try { // edmNew::CapacityExaustedException
375  incReady();
376 
377  auto idet = record.id();
378 
379  COUT << "filling " << idet << std::endl;
380 
381  auto const& det = clusterizer.stripByStripBegin(idet);
382  if (!det.valid())
383  return;
385 
386  incSet();
387 
388  // Loop over apv-pairs of det
389  for (auto const conn : clusterizer.currentConnection(det)) {
390  if
391  UNLIKELY(!conn) continue;
392 
393  const uint16_t fedId = conn->fedId();
394 
395  // If fed id is null or connection is invalid continue
396  if
397  UNLIKELY(!fedId || !conn->isConnected()) { continue; }
398 
399  // If Fed hasnt already been initialised, extract data and initialise
401  if (!buffer) {
402  buffer = fillBuffer(fedId, rawColl).release();
403  if (!buffer) {
404  continue;
405  }
406  sistrip::FEDBuffer* exp = nullptr;
407  if (done[fedId].compare_exchange_strong(exp, buffer))
408  buffers[fedId].reset(buffer);
409  else {
410  delete buffer;
411  buffer = done[fedId];
412  }
413  }
414  assert(buffer);
415 
416  buffer->setLegacyMode(legacy_);
417 
418  // check channel
419  const uint8_t fedCh = conn->fedCh();
420 
421  if
422  UNLIKELY(!buffer->channelGood(fedCh, doAPVEmulatorCheck)) {
423  if (edm::isDebugEnabled()) {
424  std::ostringstream ss;
425  ss << "Problem unpacking channel " << fedCh << " on FED " << fedId;
427  }
428  continue;
429  }
430 
431  // Determine APV std::pair number
432  uint16_t ipair = conn->apvPairNumber();
433 
434  const sistrip::FEDReadoutMode mode = buffer->readoutMode();
435  const sistrip::FEDLegacyReadoutMode lmode =
437 
438  if
439  LIKELY((!legacy_) && (mode > sistrip::READOUT_MODE_VIRGIN_RAW) && (mode < sistrip::READOUT_MODE_SPY) &&
440  (mode != sistrip::READOUT_MODE_PROC_RAW)) {
441  // ZS modes
442  try {
443  auto perStripAdder = StripByStripAdder(clusterizer, state, record);
444  if
445  LIKELY(!hybridZeroSuppressed_) { unpackZS(buffer->channel(fedCh), mode, ipair * 256, perStripAdder); }
446  else {
447  const uint32_t id = conn->detId();
448  edm::DetSet<SiStripDigi> unpDigis{id};
449  unpDigis.reserve(256);
450  unpackZS(buffer->channel(fedCh), mode, ipair * 256, std::back_inserter(unpDigis));
452  rawAlgos.convertHybridDigiToRawDigiVector(unpDigis, workRawDigis);
453  edm::DetSet<SiStripDigi> suppDigis{id};
454  rawAlgos.suppressHybridData(id, ipair * 2, workRawDigis, suppDigis);
455  std::copy(std::begin(suppDigis), std::end(suppDigis), perStripAdder);
456  }
457  } catch (edmNew::CapacityExaustedException const&) {
458  throw;
459  } catch (const cms::Exception& e) {
460  if (edm::isDebugEnabled()) {
462  << "Unordered clusters for channel " << fedCh << " on FED " << fedId << ": " << e.what();
463  }
464  continue;
465  }
466  }
467  else if (legacy_ && (lmode == sistrip::READOUT_MODE_LEGACY_ZERO_SUPPRESSED_REAL ||
470  clusterizer.addFed(state, unpacker, ipair, record);
471  } else if (legacy_ && (lmode == sistrip::READOUT_MODE_LEGACY_ZERO_SUPPRESSED_LITE_REAL ||
474  while (unpacker.hasData()) {
475  clusterizer.stripByStripAdd(state, ipair * 256 + unpacker.sampleNumber(), unpacker.adc(), record);
476  unpacker++;
477  }
478  } else if (!legacy_ ? (mode == sistrip::READOUT_MODE_VIRGIN_RAW)
481  std::vector<int16_t> samples;
482  switch (buffer->channel(fedCh).packetCode()) {
484  auto unpacker = sistrip::FEDRawChannelUnpacker::virginRawModeUnpacker(buffer->channel(fedCh));
485  while (unpacker.hasData()) {
486  samples.push_back(unpacker.adc());
487  unpacker++;
488  }
489  } break;
491  auto unpacker = sistrip::FEDBSChannelUnpacker::virginRawModeUnpacker(buffer->channel(fedCh), 10);
492  while (unpacker.hasData()) {
493  samples.push_back(unpacker.adc());
494  unpacker++;
495  }
496  } break;
498  auto unpacker = sistrip::FEDBSChannelUnpacker::virginRawModeUnpacker(buffer->channel(fedCh), 8);
499  while (unpacker.hasData()) {
500  samples.push_back(unpacker.adc() << 2);
501  unpacker++;
502  }
503  } break;
505  auto unpacker = sistrip::FEDBSChannelUnpacker::virginRawModeUnpacker(buffer->channel(fedCh), 8);
506  while (unpacker.hasData()) {
507  samples.push_back(unpacker.adc() << 1);
508  unpacker++;
509  }
510  } break;
511  default:
513  << "[ClustersFromRawProducer::" << __func__ << "]"
514  << " invalid packet code " << buffer->channel(fedCh).packetCode() << " for virgin raw.";
515  }
516  // un-multiplex the digis (from readout to physical order)
517  std::vector<int16_t> digis;
518  for (uint16_t i = 0; i != samples.size(); ++i) {
519  // move bits around: 2-0->7-5 , 4-3->4-3 , 6-5->2-1 , 7->0
520  const auto readout = ((i & 0x7) << 5) + (i & (0x3 << 3)) + ((i & (0x3 << 5)) >> 4) + ((i & (0x1 << 7)) >> 7);
521  digis.push_back(samples[readout]);
522  }
523  //process raw
524  uint32_t id = conn->detId();
525  edm::DetSet<SiStripDigi> zsdigis(id);
526  //rawAlgos_->subtractorPed->subtract( id, ipair*256, digis);
527  //rawAlgos_->subtractorCMN->subtract( id, digis);
528  //rawAlgos_->suppressor->suppress( digis, zsdigis);
529  uint16_t firstAPV = ipair * 2;
530  rawAlgos.suppressVirginRawData(id, firstAPV, digis, zsdigis);
531  for (const auto digi : zsdigis) {
532  clusterizer.stripByStripAdd(state, digi.strip(), digi.adc(), record);
533  }
534 
535  } else if (!legacy_ ? (mode == sistrip::READOUT_MODE_PROC_RAW)
538  // create unpacker
541 
542  // unpack
543  std::vector<int16_t> digis;
544  while (unpacker.hasData()) {
545  digis.push_back(unpacker.adc());
546  unpacker++;
547  }
548 
549  //process raw
550  uint32_t id = conn->detId();
551  edm::DetSet<SiStripDigi> zsdigis(id);
552  //rawAlgos_->subtractorCMN->subtract( id, digis);
553  //rawAlgos_->suppressor->suppress( digis, zsdigis);
554  uint16_t firstAPV = ipair * 2;
555  rawAlgos.suppressProcessedRawData(id, firstAPV, digis, zsdigis);
556  for (edm::DetSet<SiStripDigi>::const_iterator it = zsdigis.begin(); it != zsdigis.end(); it++) {
557  clusterizer.stripByStripAdd(state, it->strip(), it->adc(), record);
558  }
559  } else {
561  << "[ClustersFromRawProducer::" << __func__ << "]"
562  << " FEDRawData readout mode " << mode << " from FED id " << fedId << " not supported.";
563  continue;
564  }
565  } // end loop over conn
566 
567  clusterizer.stripByStripEnd(state, record);
568 
569  incAct();
570 
571  if (record.full()) {
572  edm::LogError(sistrip::mlRawToCluster_) << "too many Sistrip Clusters to fit space allocated for OnDemand for "
573  << record.id() << ' ' << record.size();
574  record.abort();
575  incAbrt();
576  }
577 
578  if (!record.empty())
579  incNoZ();
580 
581  COUT << "filled " << record.size() << std::endl;
582  for (auto const& cl : record)
583  COUT << cl.firstStrip() << ',' << cl.amplitudes().size() << std::endl;
584  incClus(record.size());
585  } catch (edmNew::CapacityExaustedException const&) {
586  edm::LogError(sistrip::mlRawToCluster_) << "too many Sistrip Clusters to fit space allocated for OnDemand";
587  }
588 }
iterator end()
Definition: DetSet.h:59
static FEDRawChannelUnpacker procRawModeUnpacker(const FEDChannel &channel)
T getParameter(std::string const &) const
static const uint8_t PACKET_CODE_ZERO_SUPPRESSED8_BOTBOT
static AlgebraicMatrix initialize()
bool isDebugEnabled()
static FEDZSChannelUnpacker zeroSuppressedModeUnpacker(const FEDChannel &channel)
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:131
static std::unique_ptr< StripClusterizerAlgorithm > create(const edm::ParameterSet &)
void beginRun(const edm::Run &, const edm::EventSetup &es) override
void run(const FEDRawDataCollection &rawColl, edmNew::DetSetVector< SiStripCluster > &output)
static const char mlRawToCluster_[]
JetCorrectorParameters::Record record
Definition: classes.h:7
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:525
SiStripAPVRestorer::digivector_t digivector_t
static FEDRawChannelUnpacker virginRawModeUnpacker(const FEDChannel &channel)
FEDReadoutMode readoutMode() const
#define nullptr
#define LIKELY(x)
Definition: Likely.h:20
bool ev
char const * what() const override
Definition: Exception.cc:103
void initialize(const edm::EventSetup &es)
static FEDBSChannelUnpacker virginRawModeUnpacker(const FEDChannel &channel, uint16_t num_bits)
virtual bool channelGood(const uint8_t internalFEDannelNum, const bool doAPVeCheck=true) const
size_t size() const
Lenght of the data buffer in bytes.
Definition: FEDRawData.h:45
sistrip classes
static const uint8_t PACKET_CODE_ZERO_SUPPRESSED8_TOPBOT
static const uint8_t PACKET_CODE_ZERO_SUPPRESSED10
void setLegacyMode(bool legacy)
static const uint8_t PACKET_CODE_VIRGIN_RAW10
void reserve(size_t s)
Definition: DetSet.h:66
void produce(edm::Event &ev, const edm::EventSetup &es) override
static const uint8_t PACKET_CODE_ZERO_SUPPRESSED
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
const FEDRawData & FEDData(int fedid) const
retrieve data for fed
const uint16_t & strip() const
Definition: SiStripDigi.h:33
FEDLegacyReadoutMode legacyReadoutMode() const
#define end
Definition: vmac.h:39
std::unique_ptr< StripClusterizerAlgorithm > clusterizer_
A Digi for the silicon strip detector, containing both strip and adc information, and suitable for st...
Definition: SiStripDigi.h:12
const FEDChannel & channel(const uint8_t internalFEDChannelNum) const
static const uint8_t PACKET_CODE_VIRGIN_RAW8_TOPBOT
d
Definition: ztail.py:151
iterator begin()
Definition: DetSet.h:58
static const uint8_t PACKET_CODE_VIRGIN_RAW8_BOTBOT
static FEDZSChannelUnpacker zeroSuppressedLiteModeUnpacker(const FEDChannel &channel)
SiStripDetCabling const * cabling_
chan
lumi = TPaveText(lowX+0.38, lowY+0.061, lowX+0.45, lowY+0.161, "NDC") lumi.SetBorderSize( 0 ) lumi...
SiStripClusterizerFromRaw(const edm::ParameterSet &conf)
#define begin
Definition: vmac.h:32
HLT enums.
const unsigned char * data() const
Return a const pointer to the beginning of the data buffer.
Definition: FEDRawData.cc:24
#define COUT
MatrixMeschach operator*(const MatrixMeschach &mat1, const MatrixMeschach &mat2)
#define UNLIKELY(x)
Definition: Likely.h:21
collection_type::const_iterator const_iterator
Definition: DetSet.h:32
const uint16_t & adc() const
Definition: SiStripDigi.h:34
std::unique_ptr< SiStripRawProcessingAlgorithms > rawAlgos_
edm::EDGetTokenT< FEDRawDataCollection > productToken_
def move(src, dest)
Definition: eostools.py:511
static const uint8_t PACKET_CODE_VIRGIN_RAW
Definition: Run.h:45