File indexing completed on 2024-04-06 12:10:26
0001
0002
0003
0004
0005
0006
0007 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
0008 #include "DataFormats/CSCDigi/interface/CSCConstants.h"
0009 #include "EventFilter/CSCRawToDigi/interface/CSCDigiToRaw.h"
0010 #include "EventFilter/CSCRawToDigi/interface/CSCDigiToRawAccept.h"
0011 #include "EventFilter/CSCRawToDigi/interface/CSCDCCEventData.h"
0012 #include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
0013 #include "DataFormats/FEDRawData/interface/FEDRawData.h"
0014 #include "DataFormats/FEDRawData/interface/FEDNumbering.h"
0015 #include "boost/dynamic_bitset.hpp"
0016 #include "EventFilter/CSCRawToDigi/interface/bitset_append.h"
0017 #include "DataFormats/FEDRawData/interface/FEDHeader.h"
0018 #include "DataFormats/FEDRawData/interface/FEDTrailer.h"
0019 #include "FWCore/Utilities/interface/CRC16.h"
0020 #include "CondFormats/CSCObjects/interface/CSCChamberMap.h"
0021 #include "FWCore/Utilities/interface/Exception.h"
0022 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0023
0024 #include <algorithm>
0025
0026 using namespace edm;
0027 using namespace std;
0028
0029 CSCDigiToRaw::CSCDigiToRaw(const edm::ParameterSet& pset)
0030 : alctWindowMin_(pset.getParameter<int>("alctWindowMin")),
0031 alctWindowMax_(pset.getParameter<int>("alctWindowMax")),
0032 clctWindowMin_(pset.getParameter<int>("clctWindowMin")),
0033 clctWindowMax_(pset.getParameter<int>("clctWindowMax")),
0034 preTriggerWindowMin_(pset.getParameter<int>("preTriggerWindowMin")),
0035 preTriggerWindowMax_(pset.getParameter<int>("preTriggerWindowMax")),
0036
0037 formatVersion_(pset.getParameter<unsigned>("formatVersion")),
0038
0039
0040 packEverything_(pset.getParameter<bool>("packEverything")),
0041 usePreTriggers_(pset.getParameter<bool>("usePreTriggers")),
0042 packByCFEB_(pset.getParameter<bool>("packByCFEB")) {}
0043
0044 CSCEventData& CSCDigiToRaw::findEventData(const CSCDetId& cscDetId, FindEventDataInfo& info) const {
0045 CSCDetId chamberId = CSCDigiToRawAccept::chamberID(cscDetId);
0046
0047 map<CSCDetId, CSCEventData>::iterator chamberMapItr = info.theChamberDataMap.find(chamberId);
0048 if (chamberMapItr == info.theChamberDataMap.end()) {
0049
0050 int chamberType = chamberId.iChamberType();
0051 chamberMapItr = info.theChamberDataMap
0052 .insert(pair<CSCDetId, CSCEventData>(chamberId, CSCEventData(chamberType, info.formatVersion_)))
0053 .first;
0054 }
0055 CSCEventData& cscData = chamberMapItr->second;
0056 cscData.dmbHeader()->setCrateAddress(info.theElectronicsMap->crate(cscDetId), info.theElectronicsMap->dmb(cscDetId));
0057
0058 if (info.formatVersion_ >= 2013) {
0059
0060 bool me11 = ((chamberId.station() == 1) && (chamberId.ring() == 4)) ||
0061 ((chamberId.station() == 1) && (chamberId.ring() == 1));
0062 if (me11) {
0063 cscData.dmbHeader()->setdmbVersion(2);
0064 } else {
0065 cscData.dmbHeader()->setdmbVersion(1);
0066 }
0067 }
0068 return cscData;
0069 }
0070
0071 void CSCDigiToRaw::add(const CSCStripDigiCollection& stripDigis,
0072 const CSCCLCTPreTriggerCollection* preTriggers,
0073 const CSCCLCTPreTriggerDigiCollection* preTriggerDigis,
0074 FindEventDataInfo& fedInfo) const {
0075
0076 for (CSCStripDigiCollection::DigiRangeIterator j = stripDigis.begin(); j != stripDigis.end(); ++j) {
0077 CSCDetId cscDetId = (*j).first;
0078
0079
0080
0081 std::vector<bool> preTriggerInCFEB;
0082 preTriggerInCFEB.resize(CSCConstants::MAX_CFEBS_RUN2);
0083
0084
0085 const bool usePreTriggers = usePreTriggers_ and preTriggers != nullptr;
0086 if (!usePreTriggers || packEverything_ ||
0087 (usePreTriggers && CSCDigiToRawAccept::accept(cscDetId,
0088 *preTriggerDigis,
0089 preTriggerWindowMin_,
0090 preTriggerWindowMax_,
0091 CSCConstants::CLCT_CENTRAL_BX,
0092 preTriggerInCFEB))) {
0093 bool me1a = (cscDetId.station() == 1) && (cscDetId.ring() == 4);
0094 bool zplus = (cscDetId.endcap() == 1);
0095 bool me1b = (cscDetId.station() == 1) && (cscDetId.ring() == 1);
0096
0097 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0098
0099 std::vector<CSCStripDigi>::const_iterator digiItr = (*j).second.first;
0100 std::vector<CSCStripDigi>::const_iterator last = (*j).second.second;
0101 for (; digiItr != last; ++digiItr) {
0102 CSCStripDigi digi = *digiItr;
0103 int strip = digi.getStrip();
0104 int cfeb = digi.getCFEB();
0105
0106
0107 if (me1a)
0108 cfeb += CSCConstants::NUM_CFEBS_ME1B;
0109
0110
0111
0112 if (packByCFEB_ and not preTriggerInCFEB[cfeb])
0113 continue;
0114
0115
0116 if (fedInfo.formatVersion_ >= 2013) {
0117 if (me1a && zplus) {
0118 digi.setStrip(CSCConstants::NUM_STRIPS_ME1A_UNGANGED + 1 - strip);
0119 }
0120 if (me1b && !zplus) {
0121 digi.setStrip(CSCConstants::NUM_STRIPS_ME1B + 1 - strip);
0122 }
0123 if (me1a) {
0124 strip = digi.getStrip();
0125 digi.setStrip(strip + CSCConstants::NUM_STRIPS_ME1B);
0126 }
0127 }
0128
0129 else {
0130 if (me1a && zplus) {
0131 digi.setStrip(CSCConstants::NUM_STRIPS_ME1A_GANGED + 1 - strip);
0132 }
0133 if (me1b && !zplus) {
0134 digi.setStrip(CSCConstants::NUM_STRIPS_ME1B + 1 - strip);
0135 }
0136 if (me1a) {
0137 strip = digi.getStrip();
0138 digi.setStrip(strip + CSCConstants::NUM_STRIPS_ME1B);
0139 }
0140 }
0141 cscData.add(digi, cscDetId.layer());
0142 }
0143 }
0144 }
0145 }
0146
0147 void CSCDigiToRaw::add(const CSCWireDigiCollection& wireDigis,
0148 const CSCALCTDigiCollection& alctDigis,
0149 FindEventDataInfo& fedInfo) const {
0150 add(alctDigis, fedInfo);
0151 for (CSCWireDigiCollection::DigiRangeIterator j = wireDigis.begin(); j != wireDigis.end(); ++j) {
0152 CSCDetId cscDetId = (*j).first;
0153 if (packEverything_ || CSCDigiToRawAccept::accept(
0154 cscDetId, alctDigis, alctWindowMin_, alctWindowMax_, CSCConstants::ALCT_CENTRAL_BX)) {
0155 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0156 std::vector<CSCWireDigi>::const_iterator digiItr = (*j).second.first;
0157 std::vector<CSCWireDigi>::const_iterator last = (*j).second.second;
0158 for (; digiItr != last; ++digiItr) {
0159 cscData.add(*digiItr, cscDetId.layer());
0160 }
0161 }
0162 }
0163 }
0164
0165 void CSCDigiToRaw::add(const CSCComparatorDigiCollection& comparatorDigis,
0166 const CSCCLCTDigiCollection& clctDigis,
0167 FindEventDataInfo& fedInfo) const {
0168 add(clctDigis, fedInfo);
0169 for (auto const& j : comparatorDigis) {
0170 CSCDetId cscDetId = j.first;
0171 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0172 if (packEverything_ || CSCDigiToRawAccept::accept(
0173 cscDetId, clctDigis, clctWindowMin_, clctWindowMax_, CSCConstants::CLCT_CENTRAL_BX)) {
0174 bool me1a = (cscDetId.station() == 1) && (cscDetId.ring() == 4);
0175
0176
0177
0178
0179
0180
0181
0182 for (auto digi = j.second.first; digi != j.second.second; ++digi) {
0183 if (fedInfo.formatVersion_ >= 2013) {
0184
0185 if (me1a && digi->getStrip() <= CSCConstants::NUM_STRIPS_ME1A_UNGANGED) {
0186 CSCComparatorDigi digi_corr(
0187 CSCConstants::NUM_STRIPS_ME1B + digi->getStrip(), digi->getComparator(), digi->getTimeBinWord());
0188 cscData.add(digi_corr, cscDetId);
0189 } else {
0190 cscData.add(*digi, cscDetId);
0191 }
0192 }
0193
0194 else {
0195 if (me1a && digi->getStrip() <= CSCConstants::NUM_STRIPS_ME1A_GANGED) {
0196 CSCComparatorDigi digi_corr(
0197 CSCConstants::NUM_STRIPS_ME1B + digi->getStrip(), digi->getComparator(), digi->getTimeBinWord());
0198 cscData.add(digi_corr, cscDetId.layer());
0199 } else {
0200 cscData.add(*digi, cscDetId.layer());
0201 }
0202 }
0203 }
0204 }
0205 }
0206 }
0207
0208 void CSCDigiToRaw::add(const CSCALCTDigiCollection& alctDigis, FindEventDataInfo& fedInfo) const {
0209 for (CSCALCTDigiCollection::DigiRangeIterator j = alctDigis.begin(); j != alctDigis.end(); ++j) {
0210 CSCDetId cscDetId = (*j).first;
0211 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0212
0213 cscData.add(std::vector<CSCALCTDigi>((*j).second.first, (*j).second.second));
0214 }
0215 }
0216
0217 void CSCDigiToRaw::add(const CSCCLCTDigiCollection& clctDigis, FindEventDataInfo& fedInfo) const {
0218 for (CSCCLCTDigiCollection::DigiRangeIterator j = clctDigis.begin(); j != clctDigis.end(); ++j) {
0219 CSCDetId cscDetId = (*j).first;
0220 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0221
0222 bool me11a = cscDetId.station() == 1 && cscDetId.ring() == 4;
0223
0224
0225
0226 if (me11a && fedInfo.formatVersion_ >= 2013) {
0227 std::vector<CSCCLCTDigi> shiftedDigis((*j).second.first, (*j).second.second);
0228 for (std::vector<CSCCLCTDigi>::iterator iC = shiftedDigis.begin(); iC != shiftedDigis.end(); ++iC) {
0229 if (iC->getCFEB() < CSCConstants::NUM_CFEBS_ME1A_UNGANGED) {
0230 (*iC) = CSCCLCTDigi(iC->isValid(),
0231 iC->getQuality(),
0232 iC->getPattern(),
0233 iC->getStripType(),
0234 iC->getBend(),
0235 iC->getStrip(),
0236 iC->getCFEB() + CSCConstants::NUM_CFEBS_ME1B,
0237 iC->getBX(),
0238 iC->getTrknmb(),
0239 iC->getFullBX());
0240 }
0241 }
0242 cscData.add(shiftedDigis);
0243 } else {
0244 cscData.add(std::vector<CSCCLCTDigi>((*j).second.first, (*j).second.second));
0245 }
0246 }
0247 }
0248
0249 void CSCDigiToRaw::add(const CSCCorrelatedLCTDigiCollection& corrLCTDigis, FindEventDataInfo& fedInfo) const {
0250 for (CSCCorrelatedLCTDigiCollection::DigiRangeIterator j = corrLCTDigis.begin(); j != corrLCTDigis.end(); ++j) {
0251 CSCDetId cscDetId = (*j).first;
0252 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0253
0254 bool me11a = cscDetId.station() == 1 && cscDetId.ring() == 4;
0255
0256
0257
0258 if (me11a && fedInfo.formatVersion_ >= 2013) {
0259 std::vector<CSCCorrelatedLCTDigi> shiftedDigis((*j).second.first, (*j).second.second);
0260 for (std::vector<CSCCorrelatedLCTDigi>::iterator iC = shiftedDigis.begin(); iC != shiftedDigis.end(); ++iC) {
0261 if (iC->getStrip() < CSCConstants::NUM_HALF_STRIPS_ME1A_UNGANGED) {
0262 (*iC) = CSCCorrelatedLCTDigi(iC->getTrknmb(),
0263 iC->isValid(),
0264 iC->getQuality(),
0265 iC->getKeyWG(),
0266 iC->getStrip() + CSCConstants::NUM_HALF_STRIPS_ME1B,
0267 iC->getPattern(),
0268 iC->getBend(),
0269 iC->getBX(),
0270 iC->getMPCLink(),
0271 iC->getBX0(),
0272 iC->getSyncErr(),
0273 iC->getCSCID());
0274 }
0275 }
0276 cscData.add(shiftedDigis);
0277 } else {
0278 cscData.add(std::vector<CSCCorrelatedLCTDigi>((*j).second.first, (*j).second.second));
0279 }
0280 }
0281 }
0282
0283 void CSCDigiToRaw::add(const CSCShowerDigiCollection& cscShowerDigis,
0284 FindEventDataInfo& fedInfo,
0285 enum CSCShowerType showerType) const {
0286 for (const auto& shower : cscShowerDigis) {
0287 const CSCDetId& cscDetId = shower.first;
0288 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0289
0290 switch (showerType) {
0291 case CSCShowerType::lctShower:
0292 cscData.addShower(std::vector<CSCShowerDigi>(shower.second.first, shower.second.second));
0293 break;
0294 case CSCShowerType::anodeShower:
0295 cscData.addAnodeShower(std::vector<CSCShowerDigi>(shower.second.first, shower.second.second));
0296 break;
0297 case CSCShowerType::cathodeShower:
0298 cscData.addCathodeShower(std::vector<CSCShowerDigi>(shower.second.first, shower.second.second));
0299 break;
0300 case CSCShowerType::anodeALCTShower:
0301 cscData.addAnodeALCTShower(std::vector<CSCShowerDigi>(shower.second.first, shower.second.second));
0302 break;
0303 default:
0304 cscData.addShower(std::vector<CSCShowerDigi>(shower.second.first, shower.second.second));
0305 }
0306 }
0307 }
0308
0309 void CSCDigiToRaw::add(const GEMPadDigiClusterCollection& gemPadClusters, FindEventDataInfo& fedInfo) const {
0310 for (const auto& jclus : gemPadClusters) {
0311 const GEMDetId& gemDetId = jclus.first;
0312
0313 const int zendcap = gemDetId.region() == 1 ? 1 : 2;
0314 CSCDetId cscDetId(zendcap, gemDetId.station(), 1, gemDetId.chamber(), 0);
0315 CSCEventData& cscData = findEventData(cscDetId, fedInfo);
0316
0317 cscData.add(std::vector<GEMPadDigiCluster>(jclus.second.first, jclus.second.second), gemDetId);
0318 }
0319 }
0320
0321 void CSCDigiToRaw::createFedBuffers(const CSCStripDigiCollection& stripDigis,
0322 const CSCWireDigiCollection& wireDigis,
0323 const CSCComparatorDigiCollection& comparatorDigis,
0324 const CSCALCTDigiCollection& alctDigis,
0325 const CSCCLCTDigiCollection& clctDigis,
0326 const CSCCLCTPreTriggerCollection* preTriggers,
0327 const CSCCLCTPreTriggerDigiCollection* preTriggerDigis,
0328 const CSCCorrelatedLCTDigiCollection& correlatedLCTDigis,
0329 const CSCShowerDigiCollection* cscShowerDigis,
0330 const CSCShowerDigiCollection* anodeShowerDigis,
0331 const CSCShowerDigiCollection* cathodeShowerDigis,
0332 const CSCShowerDigiCollection* anodeALCTShowerDigis,
0333 const GEMPadDigiClusterCollection* gemPadDigiClusters,
0334 FEDRawDataCollection& fed_buffers,
0335 const CSCChamberMap* mapping,
0336 const EventID& eid) const {
0337
0338
0339 FindEventDataInfo fedInfo{mapping, formatVersion_};
0340
0341 add(stripDigis, preTriggers, preTriggerDigis, fedInfo);
0342 add(wireDigis, alctDigis, fedInfo);
0343 add(comparatorDigis, clctDigis, fedInfo);
0344 add(correlatedLCTDigis, fedInfo);
0345
0346
0347
0348
0349
0350
0351 if (cscShowerDigis) {
0352 add(*cscShowerDigis, fedInfo, CSCShowerType::lctShower);
0353 add(*anodeShowerDigis, fedInfo, CSCShowerType::anodeShower);
0354 add(*cathodeShowerDigis, fedInfo, CSCShowerType::cathodeShower);
0355 add(*anodeALCTShowerDigis, fedInfo, CSCShowerType::anodeALCTShower);
0356 }
0357
0358
0359 if (gemPadDigiClusters) {
0360 add(*gemPadDigiClusters, fedInfo);
0361 }
0362 int l1a = eid.event();
0363 int bx = l1a;
0364
0365 if (fedInfo.formatVersion_ == 2005)
0366 {
0367 std::map<int, CSCDCCEventData> dccMap;
0368
0369 for (int idcc = FEDNumbering::MINCSCFEDID; idcc <= FEDNumbering::MAXCSCFEDID; ++idcc) {
0370 dccMap.insert(std::pair<int, CSCDCCEventData>(idcc, CSCDCCEventData(idcc, CSCConstants::NUM_DDUS, bx, l1a)));
0371 }
0372
0373 for (int idcc = FEDNumbering::MINCSCFEDID; idcc <= FEDNumbering::MAXCSCFEDID; ++idcc) {
0374
0375 for (map<CSCDetId, CSCEventData>::iterator chamberItr = fedInfo.theChamberDataMap.begin();
0376 chamberItr != fedInfo.theChamberDataMap.end();
0377 ++chamberItr) {
0378 int indexDCC = mapping->slink(chamberItr->first);
0379 if (indexDCC == idcc) {
0380
0381 std::map<int, CSCDCCEventData>::iterator dccMapItr = dccMap.find(indexDCC);
0382 if (dccMapItr == dccMap.end()) {
0383 throw cms::Exception("CSCDigiToRaw") << "Bad DCC number:" << indexDCC;
0384 }
0385
0386
0387 int dduId = mapping->ddu(chamberItr->first);
0388 int dduSlot = mapping->dduSlot(chamberItr->first);
0389 int dduInput = mapping->dduInput(chamberItr->first);
0390 int dmbId = mapping->dmb(chamberItr->first);
0391 dccMapItr->second.addChamber(chamberItr->second, dduId, dduSlot, dduInput, dmbId, formatVersion_);
0392 }
0393 }
0394 }
0395
0396
0397 for (std::map<int, CSCDCCEventData>::iterator dccMapItr = dccMap.begin(); dccMapItr != dccMap.end(); ++dccMapItr) {
0398 boost::dynamic_bitset<> dccBits = dccMapItr->second.pack();
0399 FEDRawData& fedRawData = fed_buffers.FEDData(dccMapItr->first);
0400 fedRawData.resize(dccBits.size());
0401
0402 bitset_utilities::bitsetToChar(dccBits, fedRawData.data());
0403 FEDTrailer cscFEDTrailer(fedRawData.data() + (fedRawData.size() - 8));
0404 cscFEDTrailer.set(fedRawData.data() + (fedRawData.size() - 8),
0405 fedRawData.size() / 8,
0406 evf::compute_crc(fedRawData.data(), fedRawData.size()),
0407 0,
0408 0);
0409 }
0410 }
0411
0412 else if (formatVersion_ >= 2013) {
0413 std::map<int, CSCDDUEventData> dduMap;
0414 unsigned int ddu_fmt_version = 0x7;
0415 const unsigned postLS1_map[] = {841, 842, 843, 844, 845, 846, 847, 848, 849, 831, 832, 833,
0416 834, 835, 836, 837, 838, 839, 861, 862, 863, 864, 865, 866,
0417 867, 868, 869, 851, 852, 853, 854, 855, 856, 857, 858, 859};
0418
0419
0420 for (unsigned int i = 0; i < 36; i++) {
0421 unsigned int iddu = postLS1_map[i];
0422
0423 CSCDDUHeader newDDUHeader(bx, l1a, iddu, ddu_fmt_version);
0424
0425 dduMap.insert(std::pair<int, CSCDDUEventData>(iddu, CSCDDUEventData(newDDUHeader)));
0426 }
0427
0428
0429 for (unsigned int i = 0; i < 36; i++) {
0430 unsigned int iddu = postLS1_map[i];
0431
0432 for (map<CSCDetId, CSCEventData>::iterator chamberItr = fedInfo.theChamberDataMap.begin();
0433 chamberItr != fedInfo.theChamberDataMap.end();
0434 ++chamberItr) {
0435 unsigned int indexDDU = mapping->slink(chamberItr->first);
0436
0437
0438
0439 if ((indexDDU >= FEDNumbering::MINCSCFEDID) && (indexDDU <= FEDNumbering::MAXCSCFEDID)) {
0440 int dduID = mapping->ddu(chamberItr->first);
0441
0442 if ((dduID >= FEDNumbering::MINCSCDDUFEDID) && (dduID <= FEDNumbering::MAXCSCDDUFEDID)) {
0443 indexDDU = dduID;
0444 } else
0445 {
0446
0447 dduID &= 0xFF;
0448
0449 if ((dduID <= 36) && (dduID > 0))
0450 indexDDU = postLS1_map[dduID - 1];
0451 }
0452 }
0453
0454 if (indexDDU == iddu) {
0455 std::map<int, CSCDDUEventData>::iterator dduMapItr = dduMap.find(indexDDU);
0456 if (dduMapItr == dduMap.end()) {
0457 throw cms::Exception("CSCDigiToRaw") << "Bad DDU number:" << indexDDU;
0458 }
0459
0460
0461 int dduInput = mapping->dduInput(chamberItr->first);
0462 int dmbId = mapping->dmb(chamberItr->first);
0463
0464 dduMapItr->second.add(chamberItr->second, dmbId, dduInput, formatVersion_);
0465 }
0466 }
0467 }
0468
0469
0470 for (std::map<int, CSCDDUEventData>::iterator dduMapItr = dduMap.begin(); dduMapItr != dduMap.end(); ++dduMapItr) {
0471 boost::dynamic_bitset<> dduBits = dduMapItr->second.pack();
0472 FEDRawData& fedRawData = fed_buffers.FEDData(dduMapItr->first);
0473 fedRawData.resize(dduBits.size() / 8);
0474
0475 bitset_utilities::bitsetToChar(dduBits, fedRawData.data());
0476 FEDTrailer cscFEDTrailer(fedRawData.data() + (fedRawData.size() - 8));
0477 cscFEDTrailer.set(fedRawData.data() + (fedRawData.size() - 8),
0478 fedRawData.size() / 8,
0479 evf::compute_crc(fedRawData.data(), fedRawData.size()),
0480 0,
0481 0);
0482 }
0483 }
0484 }