Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-03-17 10:59:53 

0001 #include "EventFilter/HcalRawToDigi/plugins/HcalRawToDigi.h"
0002 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
0003 #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h"
0004 #include "DataFormats/HcalDigi/interface/HcalUMNioDigi.h"
0005 #include "FWCore/Framework/interface/ESHandle.h"
0006 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0008 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0009 #include <iostream>
0010 #include <unordered_set>
0011 
0012 HcalRawToDigi::HcalRawToDigi(edm::ParameterSet const& conf)
0013     : unpacker_(conf.getUntrackedParameter<int>("HcalFirstFED", int(FEDNumbering::MINHCALFEDID)),
0014                 conf.getParameter<int>("firstSample"),
0015                 conf.getParameter<int>("lastSample")),
0016       filter_(
0017           conf.getParameter<bool>("FilterDataQuality"), conf.getParameter<bool>("FilterDataQuality"), false, 0, 0, -1),
0018       fedUnpackList_(conf.getUntrackedParameter<std::vector<int>>("FEDs", std::vector<int>())),
0019       firstFED_(conf.getUntrackedParameter<int>("HcalFirstFED", FEDNumbering::MINHCALFEDID)),
0020       unpackCalib_(conf.getUntrackedParameter<bool>("UnpackCalib", false)),
0021       unpackZDC_(conf.getUntrackedParameter<bool>("UnpackZDC", false)),
0022       unpackTTP_(conf.getUntrackedParameter<bool>("UnpackTTP", false)),
0023       unpackUMNio_(conf.getUntrackedParameter<bool>("UnpackUMNio", false)),
0024       saveQIE10DataNSamples_(conf.getUntrackedParameter<std::vector<int>>("saveQIE10DataNSamples", std::vector<int>())),
0025       saveQIE10DataTags_(
0026           conf.getUntrackedParameter<std::vector<std::string>>("saveQIE10DataTags", std::vector<std::string>())),
0027       saveQIE11DataNSamples_(conf.getUntrackedParameter<std::vector<int>>("saveQIE11DataNSamples", std::vector<int>())),
0028       saveQIE11DataTags_(
0029           conf.getUntrackedParameter<std::vector<std::string>>("saveQIE11DataTags", std::vector<std::string>())),
0030       silent_(conf.getUntrackedParameter<bool>("silent", true)),
0031       complainEmptyData_(conf.getUntrackedParameter<bool>("ComplainEmptyData", false)),
0032       unpackerMode_(conf.getUntrackedParameter<int>("UnpackerMode", 0)),
0033       expectedOrbitMessageTime_(conf.getUntrackedParameter<int>("ExpectedOrbitMessageTime", -1)) {
0034   electronicsMapLabel_ = conf.getParameter<std::string>("ElectronicsMap");
0035   tok_data_ = consumes<FEDRawDataCollection>(conf.getParameter<edm::InputTag>("InputLabel"));
0036   tok_dbService_ = esConsumes<HcalDbService, HcalDbRecord>();
0037   tok_electronicsMap_ =
0038       esConsumes<HcalElectronicsMap, HcalElectronicsMapRcd>(edm::ESInputTag("", electronicsMapLabel_));
0039 
0040   if (fedUnpackList_.empty()) {
0041     // VME range for back-compatibility
0042     for (int i = FEDNumbering::MINHCALFEDID; i <= FEDNumbering::MAXHCALFEDID; i++)
0043       fedUnpackList_.push_back(i);
0044 
0045     // uTCA range
0046     for (int i = FEDNumbering::MINHCALuTCAFEDID; i <= FEDNumbering::MAXHCALuTCAFEDID; i++)
0047       fedUnpackList_.push_back(i);
0048   }
0049 
0050   unpacker_.setExpectedOrbitMessageTime(expectedOrbitMessageTime_);
0051   unpacker_.setMode(unpackerMode_);
0052   std::ostringstream ss;
0053   for (unsigned int i = 0; i < fedUnpackList_.size(); i++)
0054     ss << fedUnpackList_[i] << " ";
0055   edm::LogInfo("HCAL") << "HcalRawToDigi will unpack FEDs ( " << ss.str() << ")";
0056 
0057   // products produced...
0058   produces<HBHEDigiCollection>();
0059   produces<HFDigiCollection>();
0060   produces<HODigiCollection>();
0061   produces<HcalTrigPrimDigiCollection>();
0062   produces<HOTrigPrimDigiCollection>();
0063   produces<HcalUnpackerReport>();
0064   if (unpackCalib_)
0065     produces<HcalCalibDigiCollection>();
0066   if (unpackZDC_)
0067     produces<ZDCDigiCollection>();
0068   if (unpackTTP_)
0069     produces<HcalTTPDigiCollection>();
0070   if (unpackUMNio_)
0071     produces<HcalUMNioDigi>();
0072   produces<QIE10DigiCollection>();
0073   produces<QIE11DigiCollection>();
0074 
0075   produces<QIE10DigiCollection>("ZDC");
0076   produces<QIE10DigiCollection>("LASERMON");
0077 
0078   // Print a warning if an already
0079   // used tag was requested
0080   if (std::find(saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "ZDC") != saveQIE10DataTags_.end()) {
0081     edm::LogWarning("HcalRawToDigi")
0082         << "Cannot create an additional QIE10 sample with name ZDC, it is already created!  It must be removed along "
0083            "with the corresponding entry in saveQIE10DataNSamples"
0084         << std::endl;
0085     saveQIE10DataTags_.clear();
0086     saveQIE10DataNSamples_.clear();
0087   }
0088   // Print a warning if an already
0089   // used tag was requested
0090   if (std::find(saveQIE10DataTags_.begin(), saveQIE10DataTags_.end(), "LASERMON") != saveQIE10DataTags_.end()) {
0091     edm::LogWarning("HcalRawToDigi")
0092         << "Cannot create an additional QIE10 sample with name LASERMON, it is already created!  It must be removed "
0093            "along with the corresponding entry in saveQIE10DataNSamples"
0094         << std::endl;
0095     saveQIE10DataTags_.clear();
0096     saveQIE10DataNSamples_.clear();
0097   }
0098 
0099   // Print a warning if the two vectors
0100   // for additional qie10 or qie11 data
0101   // are not the same length
0102   if (saveQIE10DataTags_.size() != saveQIE10DataNSamples_.size()) {
0103     edm::LogWarning("HcalRawToDigi")
0104         << "The saveQIE10DataTags and saveQIE10DataNSamples inputs must be the same length!  These will be ignored"
0105         << std::endl;
0106     saveQIE10DataTags_.clear();
0107     saveQIE10DataNSamples_.clear();
0108   }
0109   if (saveQIE11DataTags_.size() != saveQIE11DataNSamples_.size()) {
0110     edm::LogWarning("HcalRawToDigi")
0111         << "The saveQIE11DataTags and saveQIE11DataNSamples inputs must be the same length!  These will be ignored"
0112         << std::endl;
0113     saveQIE11DataTags_.clear();
0114     saveQIE11DataNSamples_.clear();
0115   }
0116 
0117   // If additional qie10 samples were requested,
0118   // declare that we will produce this collection
0119   // with the given tag.  Also store the map
0120   // from nSamples to tag for later use
0121   for (unsigned idx = 0; idx < saveQIE10DataNSamples_.size(); ++idx) {
0122     int nsamples = saveQIE10DataNSamples_[idx];
0123     std::string tag = saveQIE10DataTags_[idx];
0124 
0125     produces<QIE10DigiCollection>(tag);
0126 
0127     saveQIE10Info_[nsamples] = tag;
0128   }
0129 
0130   // If additional qie11 samples were requested,
0131   // declare that we will produce this collection
0132   // with the given tag.  Also store the map
0133   // from nSamples to tag for later use
0134   for (unsigned idx = 0; idx < saveQIE11DataNSamples_.size(); ++idx) {
0135     int nsamples = saveQIE11DataNSamples_[idx];
0136     std::string tag = saveQIE11DataTags_[idx];
0137 
0138     produces<QIE11DigiCollection>(tag);
0139 
0140     saveQIE11Info_[nsamples] = tag;
0141   }
0142 
0143   memset(&stats_, 0, sizeof(stats_));
0144 }
0145 
0146 // Virtual destructor needed.
0147 HcalRawToDigi::~HcalRawToDigi() {}
0148 
0149 void HcalRawToDigi::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0150   edm::ParameterSetDescription desc;
0151   desc.addUntracked<int>("HcalFirstFED", int(FEDNumbering::MINHCALFEDID));
0152   desc.add<int>("firstSample", 0);
0153   desc.add<int>("lastSample", 9);
0154   desc.add<bool>("FilterDataQuality", true);
0155   desc.addUntracked<std::vector<int>>("FEDs", std::vector<int>());
0156   desc.addUntracked<bool>("UnpackZDC", true);
0157   desc.addUntracked<bool>("UnpackCalib", true);
0158   desc.addUntracked<bool>("UnpackUMNio", true);
0159   desc.addUntracked<bool>("UnpackTTP", true);
0160   desc.addUntracked<bool>("silent", true);
0161   desc.addUntracked<std::vector<int>>("saveQIE10DataNSamples", std::vector<int>());
0162   desc.addUntracked<std::vector<std::string>>("saveQIE10DataTags", std::vector<std::string>());
0163   desc.addUntracked<std::vector<int>>("saveQIE11DataNSamples", std::vector<int>());
0164   desc.addUntracked<std::vector<std::string>>("saveQIE11DataTags", std::vector<std::string>());
0165   desc.addUntracked<bool>("ComplainEmptyData", false);
0166   desc.addUntracked<int>("UnpackerMode", 0);
0167   desc.addUntracked<int>("ExpectedOrbitMessageTime", -1);
0168   desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
0169   desc.add<std::string>("ElectronicsMap", "");
0170   descriptions.add("hcalRawToDigi", desc);
0171 }
0172 
0173 // Functions that gets called by framework every event
0174 void HcalRawToDigi::produce(edm::Event& e, const edm::EventSetup& es) {
0175   // Step A: Get Inputs
0176   edm::Handle<FEDRawDataCollection> rawraw;
0177   e.getByToken(tok_data_, rawraw);
0178   // get the mapping
0179   edm::ESHandle<HcalDbService> pSetup = es.getHandle(tok_dbService_);
0180   edm::ESHandle<HcalElectronicsMap> item = es.getHandle(tok_electronicsMap_);
0181   const HcalElectronicsMap* readoutMap = item.product();
0182   filter_.setConditions(pSetup.product());
0183 
0184   // Step B: Create empty output  : three vectors for three classes...
0185   std::vector<HBHEDataFrame> hbhe;
0186   std::vector<HODataFrame> ho;
0187   std::vector<HFDataFrame> hf;
0188   std::vector<HcalTriggerPrimitiveDigi> htp;
0189   std::vector<HcalCalibDataFrame> hc;
0190   std::vector<ZDCDataFrame> zdc;
0191   std::vector<HcalTTPDigi> ttp;
0192   std::vector<HOTriggerPrimitiveDigi> hotp;
0193   HcalUMNioDigi umnio;
0194   auto report = std::make_unique<HcalUnpackerReport>();
0195 
0196   // Heuristics: use ave+(max-ave)/8
0197   if (stats_.max_hbhe > 0)
0198     hbhe.reserve(stats_.ave_hbhe + (stats_.max_hbhe - stats_.ave_hbhe) / 8);
0199   if (stats_.max_ho > 0)
0200     ho.reserve(stats_.ave_ho + (stats_.max_ho - stats_.ave_ho) / 8);
0201   if (stats_.max_hf > 0)
0202     hf.reserve(stats_.ave_hf + (stats_.max_hf - stats_.ave_hf) / 8);
0203   if (stats_.max_calib > 0)
0204     hc.reserve(stats_.ave_calib + (stats_.max_calib - stats_.ave_calib) / 8);
0205   if (stats_.max_tp > 0)
0206     htp.reserve(stats_.ave_tp + (stats_.max_tp - stats_.ave_tp) / 8);
0207   if (stats_.max_tpho > 0)
0208     hotp.reserve(stats_.ave_tpho + (stats_.max_tpho - stats_.ave_tpho) / 8);
0209 
0210   if (unpackZDC_)
0211     zdc.reserve(24);
0212 
0213   HcalUnpacker::Collections colls;
0214   colls.hbheCont = &hbhe;
0215   colls.hoCont = &ho;
0216   colls.hfCont = &hf;
0217   colls.tpCont = &htp;
0218   colls.tphoCont = &hotp;
0219   colls.calibCont = &hc;
0220   colls.zdcCont = &zdc;
0221   colls.umnio = &umnio;
0222   if (unpackTTP_)
0223     colls.ttp = &ttp;
0224 
0225   // make an entry for each additional qie10 collection that is requested
0226   for (const auto& info : saveQIE10Info_) {
0227     colls.qie10Addtl[info.first] = new QIE10DigiCollection(info.first);
0228   }
0229 
0230   // make an entry for each additional qie11 collection that is requested
0231   for (const auto& info : saveQIE11Info_) {
0232     colls.qie11Addtl[info.first] = new QIE11DigiCollection(info.first);
0233   }
0234 
0235   // Step C: unpack all requested FEDs
0236   for (std::vector<int>::const_iterator i = fedUnpackList_.begin(); i != fedUnpackList_.end(); i++) {
0237     const FEDRawData& fed = rawraw->FEDData(*i);
0238     if (fed.size() == 0) {
0239       if (complainEmptyData_) {
0240         if (!silent_)
0241           edm::LogWarning("EmptyData") << "No data for FED " << *i;
0242         report->addError(*i);
0243       }
0244     } else if (fed.size() < 8 * 3) {
0245       if (!silent_)
0246         edm::LogWarning("EmptyData") << "Tiny data " << fed.size() << " for FED " << *i;
0247       report->addError(*i);
0248     } else {
0249       try {
0250         unpacker_.unpack(fed, *readoutMap, colls, *report, silent_);
0251         report->addUnpacked(*i);
0252       } catch (cms::Exception& e) {
0253         if (!silent_)
0254           edm::LogWarning("Unpacking error") << e.what();
0255         report->addError(*i);
0256       } catch (...) {
0257         if (!silent_)
0258           edm::LogWarning("Unpacking exception");
0259         report->addError(*i);
0260       }
0261     }
0262   }
0263 
0264   // gather statistics
0265   stats_.max_hbhe = std::max(stats_.max_hbhe, (int)hbhe.size());
0266   stats_.ave_hbhe = (stats_.ave_hbhe * stats_.n + hbhe.size()) / (stats_.n + 1);
0267   stats_.max_ho = std::max(stats_.max_ho, (int)ho.size());
0268   stats_.ave_ho = (stats_.ave_ho * stats_.n + ho.size()) / (stats_.n + 1);
0269   stats_.max_hf = std::max(stats_.max_hf, (int)hf.size());
0270   stats_.ave_hf = (stats_.ave_hf * stats_.n + hf.size()) / (stats_.n + 1);
0271   stats_.max_tp = std::max(stats_.max_tp, (int)htp.size());
0272   stats_.ave_tp = (stats_.ave_tp * stats_.n + htp.size()) / (stats_.n + 1);
0273   stats_.max_tpho = std::max(stats_.max_tpho, (int)hotp.size());
0274   stats_.ave_tpho = (stats_.ave_tpho * stats_.n + hotp.size()) / (stats_.n + 1);
0275   stats_.max_calib = std::max(stats_.max_calib, (int)hc.size());
0276   stats_.ave_calib = (stats_.ave_calib * stats_.n + hc.size()) / (stats_.n + 1);
0277 
0278   stats_.n++;
0279 
0280   // check HF duplication
0281   std::unordered_set<uint32_t> cacheForHFdup;
0282   unsigned int cntHFdup = 0;
0283   for (auto& hf_digi : hf) {
0284     if (!cacheForHFdup.insert(hf_digi.id().rawId()).second)
0285       cntHFdup++;
0286   }
0287   if (cntHFdup)
0288     edm::LogError("HcalRawToDigi") << "Duplicated HF digis found for " << cntHFdup << " times" << std::endl;
0289 
0290   // Check that additional QIE10 and QIE11 collections
0291   // do not duplicate the default collections
0292   for (const auto& addtl : colls.qie10Addtl) {
0293     if (addtl.second->samples() == colls.qie10->samples()) {
0294       std::string tag = saveQIE10Info_[addtl.second->samples()];
0295       edm::LogWarning("HcalRawToDigi") << "QIE10 data requested to be stored in tag " << tag
0296                                        << " is already stored in the default QIE10 collection.  "
0297                                        << "To avoid duplicating, remove the tag " << tag
0298                                        << " from the saveQIE10DataTags and the value of " << addtl.second->samples()
0299                                        << " from the saveQIE10DataNSamples "
0300                                        << "configurables to HcalRawToDigi" << std::endl;
0301     }
0302   }
0303   for (const auto& addtl : colls.qie11Addtl) {
0304     if (addtl.second->samples() == colls.qie11->samples()) {
0305       std::string tag = saveQIE11Info_[addtl.second->samples()];
0306       edm::LogWarning("HcalRawToDigi") << "QIE11 data requested to be stored in tag " << tag
0307                                        << " is already stored in the default QIE11 collection.  "
0308                                        << "To avoid duplicating, remove the tag " << tag
0309                                        << " from the saveQIE11DataTags and the value of " << addtl.second->samples()
0310                                        << " from the saveQIE11DataNSamples "
0311                                        << "configurables to HcalRawToDigi" << std::endl;
0312     }
0313   }
0314 
0315   // Step B: encapsulate vectors in actual collections
0316   auto hbhe_prod = std::make_unique<HBHEDigiCollection>();
0317   auto hf_prod = std::make_unique<HFDigiCollection>();
0318   auto ho_prod = std::make_unique<HODigiCollection>();
0319   auto htp_prod = std::make_unique<HcalTrigPrimDigiCollection>();
0320   auto hotp_prod = std::make_unique<HOTrigPrimDigiCollection>();
0321   // make qie10 collection if it wasn't made in theunpacker
0322   if (colls.qie10 == nullptr) {
0323     colls.qie10 = new QIE10DigiCollection();
0324   }
0325   std::unique_ptr<QIE10DigiCollection> qie10_prod(colls.qie10);
0326 
0327   // make qie10ZDC collection if it wasn't made in theunpacker
0328   if (colls.qie10ZDC == nullptr) {
0329     colls.qie10ZDC = new QIE10DigiCollection();
0330   }
0331   std::unique_ptr<QIE10DigiCollection> qie10ZDC_prod(colls.qie10ZDC);
0332 
0333   // make qie10Lasermon collection if it wasn't made in theunpacker
0334   if (colls.qie10Lasermon == nullptr) {
0335     colls.qie10Lasermon = new QIE10DigiCollection();
0336   }
0337   std::unique_ptr<QIE10DigiCollection> qie10Lasermon_prod(colls.qie10Lasermon);
0338 
0339   if (colls.qie11 == nullptr) {
0340     colls.qie11 = new QIE11DigiCollection();
0341   }
0342   std::unique_ptr<QIE11DigiCollection> qie11_prod(colls.qie11);
0343 
0344   // follow the procedure for other collections.  Copy the unpacked
0345   // data so that it can be filtered and sorted
0346   std::unordered_map<int, std::unique_ptr<QIE10DigiCollection>> qie10_prodAddtl;
0347   std::unordered_map<int, std::unique_ptr<QIE11DigiCollection>> qie11_prodAddtl;
0348   for (const auto& orig : colls.qie10Addtl) {
0349     qie10_prodAddtl[orig.first] = std::unique_ptr<QIE10DigiCollection>(orig.second);
0350   }
0351   for (const auto& orig : colls.qie11Addtl) {
0352     qie11_prodAddtl[orig.first] = std::unique_ptr<QIE11DigiCollection>(orig.second);
0353   }
0354 
0355   hbhe_prod->swap_contents(hbhe);
0356   if (!cntHFdup)
0357     hf_prod->swap_contents(hf);
0358   ho_prod->swap_contents(ho);
0359   htp_prod->swap_contents(htp);
0360   hotp_prod->swap_contents(hotp);
0361 
0362   // Step C2: filter FEDs, if required
0363   if (filter_.active()) {
0364     HBHEDigiCollection filtered_hbhe = filter_.filter(*hbhe_prod, *report);
0365     HODigiCollection filtered_ho = filter_.filter(*ho_prod, *report);
0366     HFDigiCollection filtered_hf = filter_.filter(*hf_prod, *report);
0367     QIE10DigiCollection filtered_qie10 = filter_.filter(*qie10_prod, *report);
0368     QIE11DigiCollection filtered_qie11 = filter_.filter(*qie11_prod, *report);
0369 
0370     hbhe_prod->swap(filtered_hbhe);
0371     ho_prod->swap(filtered_ho);
0372     hf_prod->swap(filtered_hf);
0373     qie10_prod->swap(filtered_qie10);
0374     qie11_prod->swap(filtered_qie11);
0375 
0376     // apply filter to additional collections
0377     for (auto& prod : qie10_prodAddtl) {
0378       QIE10DigiCollection filtered_qie10 = filter_.filter(*(prod.second), *report);
0379       prod.second->swap(filtered_qie10);
0380     }
0381 
0382     for (auto& prod : qie11_prodAddtl) {
0383       QIE11DigiCollection filtered_qie11 = filter_.filter(*(prod.second), *report);
0384       prod.second->swap(filtered_qie11);
0385     }
0386   }
0387 
0388   // Step D: Put outputs into event
0389   // just until the sorting is proven
0390   hbhe_prod->sort();
0391   ho_prod->sort();
0392   hf_prod->sort();
0393   htp_prod->sort();
0394   hotp_prod->sort();
0395   qie10_prod->sort();
0396   qie10ZDC_prod->sort();
0397   qie10Lasermon_prod->sort();
0398   qie11_prod->sort();
0399 
0400   // sort the additional collections
0401   for (auto& prod : qie10_prodAddtl) {
0402     prod.second->sort();
0403   }
0404   for (auto& prod : qie11_prodAddtl) {
0405     prod.second->sort();
0406   }
0407 
0408   e.put(std::move(hbhe_prod));
0409   e.put(std::move(ho_prod));
0410   e.put(std::move(hf_prod));
0411   e.put(std::move(htp_prod));
0412   e.put(std::move(hotp_prod));
0413   e.put(std::move(qie10_prod));
0414   e.put(std::move(qie10ZDC_prod), "ZDC");
0415   e.put(std::move(qie10Lasermon_prod), "LASERMON");
0416   e.put(std::move(qie11_prod));
0417 
0418   // put the qie10 and qie11 collections into the event
0419   for (auto& prod : qie10_prodAddtl) {
0420     std::string tag = saveQIE10Info_[prod.first];
0421     e.put(std::move(prod.second), tag);
0422   }
0423 
0424   for (auto& prod : qie11_prodAddtl) {
0425     std::string tag = saveQIE11Info_[prod.first];
0426     e.put(std::move(prod.second), tag);
0427   }
0428 
0429   /// calib
0430   if (unpackCalib_) {
0431     auto hc_prod = std::make_unique<HcalCalibDigiCollection>();
0432     hc_prod->swap_contents(hc);
0433 
0434     if (filter_.active()) {
0435       HcalCalibDigiCollection filtered_calib = filter_.filter(*hc_prod, *report);
0436       hc_prod->swap(filtered_calib);
0437     }
0438 
0439     hc_prod->sort();
0440     e.put(std::move(hc_prod));
0441   }
0442 
0443   /// zdc
0444   if (unpackZDC_) {
0445     auto prod = std::make_unique<ZDCDigiCollection>();
0446     prod->swap_contents(zdc);
0447 
0448     if (filter_.active()) {
0449       ZDCDigiCollection filtered_zdc = filter_.filter(*prod, *report);
0450       prod->swap(filtered_zdc);
0451     }
0452 
0453     prod->sort();
0454     e.put(std::move(prod));
0455   }
0456 
0457   if (unpackTTP_) {
0458     auto prod = std::make_unique<HcalTTPDigiCollection>();
0459     prod->swap_contents(ttp);
0460 
0461     prod->sort();
0462     e.put(std::move(prod));
0463   }
0464   e.put(std::move(report));
0465   /// umnio
0466   if (unpackUMNio_) {
0467     if (colls.umnio != nullptr) {
0468       e.put(std::make_unique<HcalUMNioDigi>(umnio));
0469     }
0470   }
0471 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!