#include <CSCDigiToRaw.h>

Classes
struct	FindEventDataInfo

Public Member Functions
void	createFedBuffers (const CSCStripDigiCollection &stripDigis, const CSCWireDigiCollection &wireDigis, const CSCComparatorDigiCollection &comparatorDigis, const CSCALCTDigiCollection &alctDigis, const CSCCLCTDigiCollection &clctDigis, const CSCCLCTPreTriggerCollection preTriggers, const CSCCLCTPreTriggerDigiCollection preTriggerDigis, const CSCCorrelatedLCTDigiCollection &correlatedLCTDigis, const CSCShowerDigiCollection showerDigis, const GEMPadDigiClusterCollection padDigiClusters, FEDRawDataCollection &fed_buffers, const CSCChamberMap *theMapping, const edm::EventID &eid) const
	Take a vector of digis and fill the FEDRawDataCollection. More...

	CSCDigiToRaw (const edm::ParameterSet &pset)
	Constructor. More...

Private Member Functions
void	add (const CSCStripDigiCollection &stripDigis, const CSCCLCTPreTriggerCollection preTriggers, const CSCCLCTPreTriggerDigiCollection preTriggerDigis, FindEventDataInfo &) const

void	add (const CSCWireDigiCollection &wireDigis, const CSCALCTDigiCollection &alctDigis, FindEventDataInfo &) const

void	add (const CSCComparatorDigiCollection &comparatorDigis, const CSCCLCTDigiCollection &clctDigis, FindEventDataInfo &) const

void	add (const CSCALCTDigiCollection &alctDigis, FindEventDataInfo &) const

void	add (const CSCCLCTDigiCollection &clctDigis, FindEventDataInfo &) const

void	add (const CSCCorrelatedLCTDigiCollection &corrLCTDigis, FindEventDataInfo &) const

void	add (const CSCShowerDigiCollection &cscShowerDigis, FindEventDataInfo &) const

void	add (const GEMPadDigiClusterCollection &gemPadClusters, FindEventDataInfo &) const

CSCEventData &	findEventData (const CSCDetId &cscDetId, FindEventDataInfo &) const
	pick out the correct data object for this chamber More...

Private Attributes
const int	alctWindowMax_

const int	alctWindowMin_

const int	clctWindowMax_

const int	clctWindowMin_

uint16_t	formatVersion_

bool	packByCFEB_

bool	packEverything_

const int	preTriggerWindowMax_

const int	preTriggerWindowMin_

bool	usePreTriggers_

Detailed Description

Author: A. Tumanov - Rice

Definition at line 26 of file CSCDigiToRaw.h.

Constructor & Destructor Documentation

CSCDigiToRaw::CSCDigiToRaw ( const edm::ParameterSet & pset )

explicit

Constructor.

Definition at line 29 of file CSCDigiToRaw.cc.

     : alctWindowMin_(pset.getParameter<int>("alctWindowMin")),
       alctWindowMax_(pset.getParameter<int>("alctWindowMax")),
       clctWindowMin_(pset.getParameter<int>("clctWindowMin")),
       clctWindowMax_(pset.getParameter<int>("clctWindowMax")),
       preTriggerWindowMin_(pset.getParameter<int>("preTriggerWindowMin")),
       preTriggerWindowMax_(pset.getParameter<int>("preTriggerWindowMax")),
       // pre-LS1 - '2005'. post-LS1 - '2013'
       formatVersion_(pset.getParameter<unsigned>("formatVersion")),
       // don't check for consistency with trig primitives
       // overrides usePreTriggers
       packEverything_(pset.getParameter<bool>("packEverything")),
       usePreTriggers_(pset.getParameter<bool>("usePreTriggers")),
       packByCFEB_(pset.getParameter<bool>("packByCFEB")) {}

Member Function Documentation

void CSCDigiToRaw::add	(	const CSCStripDigiCollection &	stripDigis,
		const CSCCLCTPreTriggerCollection *	preTriggers,
		const CSCCLCTPreTriggerDigiCollection *	preTriggerDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 71 of file CSCDigiToRaw.cc.

References CSCDigiToRawAccept::accept(), CSCEventData::add(), CSCConstants::CLCT_CENTRAL_BX, CSCDetId::endcap(), findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, CSCStripDigi::getCFEB(), CSCStripDigi::getStrip(), dqmiolumiharvest::j, dqmdumpme::last, CSCDetId::layer(), CSCConstants::MAX_CFEBS_RUN2, CSCConstants::NUM_CFEBS_ME1B, CSCConstants::NUM_STRIPS_ME1A_GANGED, CSCConstants::NUM_STRIPS_ME1A_UNGANGED, CSCConstants::NUM_STRIPS_ME1B, packByCFEB_, packEverything_, preTriggerWindowMax_, preTriggerWindowMin_, CSCDetId::ring(), CSCStripDigi::setStrip(), CSCDetId::station(), digitizers_cfi::strip, usePreTriggers_, and SurfaceOrientation::zplus.

Referenced by add(), createFedBuffers(), counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                          {
   //iterate over chambers with strip digis in them
   for (CSCStripDigiCollection::DigiRangeIterator j = stripDigis.begin(); j != stripDigis.end(); ++j) {
     CSCDetId cscDetId = (*j).first;
     // only digitize if there are pre-triggers
 
     // determine where the pretriggers are
     std::vector<bool> preTriggerInCFEB;
     preTriggerInCFEB.resize(CSCConstants::MAX_CFEBS_RUN2);
 
     // pretrigger flag must be set and the pretrigger collection must be nonzero!
     const bool usePreTriggers = usePreTriggers_ and preTriggers != nullptr;
     if (!usePreTriggers || packEverything_ ||
         (usePreTriggers && CSCDigiToRawAccept::accept(cscDetId,
                                                       *preTriggerDigis,
                                                       preTriggerWindowMin_,
                                                       preTriggerWindowMax_,
                                                       CSCConstants::CLCT_CENTRAL_BX,
                                                       preTriggerInCFEB))) {
       bool me1a = (cscDetId.station() == 1) && (cscDetId.ring() == 4);
       bool zplus = (cscDetId.endcap() == 1);
       bool me1b = (cscDetId.station() == 1) && (cscDetId.ring() == 1);
 
       CSCEventData& cscData = findEventData(cscDetId, fedInfo);
 
       std::vector<CSCStripDigi>::const_iterator digiItr = (*j).second.first;
       std::vector<CSCStripDigi>::const_iterator last = (*j).second.second;
       for (; digiItr != last; ++digiItr) {
         CSCStripDigi digi = *digiItr;
         int strip = digi.getStrip();
         int cfeb = digi.getCFEB();
         // CSC strip digis in ME1/a have CFEB number 0, 1, or 2
         // But a pretrigger in ME1/a has CFEB number 4, 5, or 6 (+4)
         if (me1a)
           cfeb += CSCConstants::NUM_CFEBS_ME1B;
 
         // At this point, if we are packing by CFEBs and there is no
         // pretrigger in this CFEB, ignore this strip digi
         if (packByCFEB_ and not preTriggerInCFEB[cfeb])
           continue;
 
         // From LS1 on ME1a strips are unganged
         if (fedInfo.formatVersion_ == 2013) {
           if (me1a && zplus) {
             digi.setStrip(CSCConstants::NUM_STRIPS_ME1A_UNGANGED + 1 - strip);  // 1-48 -> 48-1
           }
           if (me1b && !zplus) {
             digi.setStrip(CSCConstants::NUM_STRIPS_ME1B + 1 - strip);  // 1-64 -> 64-1
           }
           if (me1a) {
             strip = digi.getStrip();  // reset back 1-16 to 65-80 digi
             digi.setStrip(strip + CSCConstants::NUM_STRIPS_ME1B);
           }
         }
         // During Run-1 ME1a strips are triple-ganged
         else {
           if (me1a && zplus) {
             digi.setStrip(CSCConstants::NUM_STRIPS_ME1A_GANGED + 1 - strip);  // 1-16 -> 16-1
           }
           if (me1b && !zplus) {
             digi.setStrip(CSCConstants::NUM_STRIPS_ME1B + 1 - strip);  // 1-64 -> 64-1
           }
           if (me1a) {
             strip = digi.getStrip();  // reset back 1-16 to 65-80 digi
             digi.setStrip(strip + CSCConstants::NUM_STRIPS_ME1B);
           }
         }
         cscData.add(digi, cscDetId.layer());
       }
     }
   }
 }

void CSCDigiToRaw::add	(	const CSCWireDigiCollection &	wireDigis,
		const CSCALCTDigiCollection &	alctDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 147 of file CSCDigiToRaw.cc.

References CSCDigiToRawAccept::accept(), add(), CSCEventData::add(), CSCConstants::ALCT_CENTRAL_BX, alctWindowMax_, alctWindowMin_, findEventData(), dqmiolumiharvest::j, dqmdumpme::last, CSCDetId::layer(), and packEverything_.

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                          {
   add(alctDigis, fedInfo);
   for (CSCWireDigiCollection::DigiRangeIterator j = wireDigis.begin(); j != wireDigis.end(); ++j) {
     CSCDetId cscDetId = (*j).first;
     if (packEverything_ || CSCDigiToRawAccept::accept(
                                cscDetId, alctDigis, alctWindowMin_, alctWindowMax_, CSCConstants::ALCT_CENTRAL_BX)) {
       CSCEventData& cscData = findEventData(cscDetId, fedInfo);
       std::vector<CSCWireDigi>::const_iterator digiItr = (*j).second.first;
       std::vector<CSCWireDigi>::const_iterator last = (*j).second.second;
       for (; digiItr != last; ++digiItr) {
         cscData.add(*digiItr, cscDetId.layer());
       }
     }
   }
 }

void CSCDigiToRaw::add	(	const CSCComparatorDigiCollection &	comparatorDigis,
		const CSCCLCTDigiCollection &	clctDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 165 of file CSCDigiToRaw.cc.

References CSCDigiToRawAccept::accept(), add(), CSCEventData::add(), CSCConstants::CLCT_CENTRAL_BX, clctWindowMax_, clctWindowMin_, findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, dqmiolumiharvest::j, CSCDetId::layer(), CSCConstants::NUM_STRIPS_ME1A_GANGED, CSCConstants::NUM_STRIPS_ME1A_UNGANGED, CSCConstants::NUM_STRIPS_ME1B, packEverything_, CSCDetId::ring(), and CSCDetId::station().

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                          {
   add(clctDigis, fedInfo);
   for (auto const& j : comparatorDigis) {
     CSCDetId cscDetId = j.first;
     CSCEventData& cscData = findEventData(cscDetId, fedInfo);
     if (packEverything_ || CSCDigiToRawAccept::accept(
                                cscDetId, clctDigis, clctWindowMin_, clctWindowMax_, CSCConstants::CLCT_CENTRAL_BX)) {
       bool me1a = (cscDetId.station() == 1) && (cscDetId.ring() == 4);
 
       /*
         Add the comparator digi to the fedInfo.
         Move ME1/A comparators from CFEB=0 to CFEB=4 if this has not
         been done already.
         Consider the case for triple-ganged and unganged ME1A strips
        */
       for (auto digi = j.second.first; digi != j.second.second; ++digi) {
         if (fedInfo.formatVersion_ == 2013) {
           // unganged case
           if (me1a && digi->getStrip() <= CSCConstants::NUM_STRIPS_ME1A_UNGANGED) {
             CSCComparatorDigi digi_corr(
                 CSCConstants::NUM_STRIPS_ME1B + digi->getStrip(), digi->getComparator(), digi->getTimeBinWord());
             cscData.add(digi_corr, cscDetId);
           } else {
             cscData.add(*digi, cscDetId);
           }
         }
         // triple-ganged case
         else {
           if (me1a && digi->getStrip() <= CSCConstants::NUM_STRIPS_ME1A_GANGED) {
             CSCComparatorDigi digi_corr(
                 CSCConstants::NUM_STRIPS_ME1B + digi->getStrip(), digi->getComparator(), digi->getTimeBinWord());
             cscData.add(digi_corr, cscDetId.layer());
           } else {
             cscData.add(*digi, cscDetId.layer());
           }
         }
       }
     }
   }
 }

void CSCDigiToRaw::add	(	const CSCALCTDigiCollection &	alctDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 208 of file CSCDigiToRaw.cc.

References CSCEventData::add(), findEventData(), and dqmiolumiharvest::j.

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                                {
   for (CSCALCTDigiCollection::DigiRangeIterator j = alctDigis.begin(); j != alctDigis.end(); ++j) {
     CSCDetId cscDetId = (*j).first;
     CSCEventData& cscData = findEventData(cscDetId, fedInfo);
 
     cscData.add(std::vector<CSCALCTDigi>((*j).second.first, (*j).second.second));
   }
 }

void CSCDigiToRaw::add	(	const CSCCLCTDigiCollection &	clctDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 217 of file CSCDigiToRaw.cc.

References CSCEventData::add(), findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, dqmiolumiharvest::j, CSCConstants::NUM_CFEBS_ME1A_UNGANGED, CSCConstants::NUM_CFEBS_ME1B, CSCDetId::ring(), and CSCDetId::station().

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                                {
   for (CSCCLCTDigiCollection::DigiRangeIterator j = clctDigis.begin(); j != clctDigis.end(); ++j) {
     CSCDetId cscDetId = (*j).first;
     CSCEventData& cscData = findEventData(cscDetId, fedInfo);
 
     bool me11a = cscDetId.station() == 1 && cscDetId.ring() == 4;
     //CLCTs are packed by chamber not by A/B parts in ME11
     //me11a appears only in simulation with SLHC algorithm settings
     //without the shift, it's impossible to distinguish A and B parts
     if (me11a && fedInfo.formatVersion_ == 2013) {
       std::vector<CSCCLCTDigi> shiftedDigis((*j).second.first, (*j).second.second);
       for (std::vector<CSCCLCTDigi>::iterator iC = shiftedDigis.begin(); iC != shiftedDigis.end(); ++iC) {
         if (iC->getCFEB() < CSCConstants::NUM_CFEBS_ME1A_UNGANGED) {  //sanity check, mostly
           (*iC) = CSCCLCTDigi(iC->isValid(),
                               iC->getQuality(),
                               iC->getPattern(),
                               iC->getStripType(),
                               iC->getBend(),
                               iC->getStrip(),
                               iC->getCFEB() + CSCConstants::NUM_CFEBS_ME1B,
                               iC->getBX(),
                               iC->getTrknmb(),
                               iC->getFullBX());
         }
       }
       cscData.add(shiftedDigis);
     } else {
       cscData.add(std::vector<CSCCLCTDigi>((*j).second.first, (*j).second.second));
     }
   }
 }

void CSCDigiToRaw::add	(	const CSCCorrelatedLCTDigiCollection &	corrLCTDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 249 of file CSCDigiToRaw.cc.

References CSCEventData::add(), findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, dqmiolumiharvest::j, CSCConstants::NUM_HALF_STRIPS_ME1A_UNGANGED, CSCConstants::NUM_HALF_STRIPS_ME1B, CSCDetId::ring(), and CSCDetId::station().

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                                            {
   for (CSCCorrelatedLCTDigiCollection::DigiRangeIterator j = corrLCTDigis.begin(); j != corrLCTDigis.end(); ++j) {
     CSCDetId cscDetId = (*j).first;
     CSCEventData& cscData = findEventData(cscDetId, fedInfo);
 
     bool me11a = cscDetId.station() == 1 && cscDetId.ring() == 4;
     //LCTs are packed by chamber not by A/B parts in ME11
     //me11a appears only in simulation with SLHC algorithm settings
     //without the shift, it's impossible to distinguish A and B parts
     if (me11a && fedInfo.formatVersion_ == 2013) {
       std::vector<CSCCorrelatedLCTDigi> shiftedDigis((*j).second.first, (*j).second.second);
       for (std::vector<CSCCorrelatedLCTDigi>::iterator iC = shiftedDigis.begin(); iC != shiftedDigis.end(); ++iC) {
         if (iC->getStrip() < CSCConstants::NUM_HALF_STRIPS_ME1A_UNGANGED) {  //sanity check, mostly
           (*iC) = CSCCorrelatedLCTDigi(iC->getTrknmb(),
                                        iC->isValid(),
                                        iC->getQuality(),
                                        iC->getKeyWG(),
                                        iC->getStrip() + CSCConstants::NUM_HALF_STRIPS_ME1B,
                                        iC->getPattern(),
                                        iC->getBend(),
                                        iC->getBX(),
                                        iC->getMPCLink(),
                                        iC->getBX0(),
                                        iC->getSyncErr(),
                                        iC->getCSCID());
         }
       }
       cscData.add(shiftedDigis);
     } else {
       cscData.add(std::vector<CSCCorrelatedLCTDigi>((*j).second.first, (*j).second.second));
     }
   }
 }

void CSCDigiToRaw::add	(	const CSCShowerDigiCollection &	cscShowerDigis,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 283 of file CSCDigiToRaw.cc.

References CSCEventData::add(), and findEventData().

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                                       {
   for (const auto& shower : cscShowerDigis) {
     const CSCDetId& cscDetId = shower.first;
     CSCEventData& cscData = findEventData(cscDetId, fedInfo);
 
     cscData.add(std::vector<CSCShowerDigi>(shower.second.first, shower.second.second));
   }
 }

void CSCDigiToRaw::add	(	const GEMPadDigiClusterCollection &	gemPadClusters,
		FindEventDataInfo &	fedInfo
	)		const

private

Definition at line 292 of file CSCDigiToRaw.cc.

References GEMDetId::chamber(), findEventData(), GEMDetId::region(), and GEMDetId::station().

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                                           {
   for (const auto& jclus : gemPadClusters) {
     const GEMDetId& gemDetId = jclus.first;
 
     const int zendcap = gemDetId.region() == 1 ? 1 : 2;
     CSCDetId cscDetId(zendcap, gemDetId.station(), 1, gemDetId.chamber(), 0);
     CSCEventData& cscData = findEventData(cscDetId, fedInfo);
 
     cscData.add(std::vector<GEMPadDigiCluster>(jclus.second.first, jclus.second.second), gemDetId);
   }
 }

void CSCDigiToRaw::createFedBuffers	(	const CSCStripDigiCollection &	stripDigis,
		const CSCWireDigiCollection &	wireDigis,
		const CSCComparatorDigiCollection &	comparatorDigis,
		const CSCALCTDigiCollection &	alctDigis,
		const CSCCLCTDigiCollection &	clctDigis,
		const CSCCLCTPreTriggerCollection *	preTriggers,
		const CSCCLCTPreTriggerDigiCollection *	preTriggerDigis,
		const CSCCorrelatedLCTDigiCollection &	correlatedLCTDigis,
		const CSCShowerDigiCollection *	showerDigis,
		const GEMPadDigiClusterCollection *	padDigiClusters,
		FEDRawDataCollection &	fed_buffers,
		const CSCChamberMap *	theMapping,
		const edm::EventID &	eid
	)		const

Take a vector of digis and fill the FEDRawDataCollection.

Handle pre-LS1 format data

Handle post-LS1 format data

2013 Format

Create dummy DDU buffers

Loop over post-LS1 DDU FEDs

Lets handle possible mapping issues

Definition at line 304 of file CSCDigiToRaw.cc.

References add(), bitset_utilities::bitsetToChar(), makePileupJSON::bx, evf::compute_crc(), FEDRawData::data(), CSCChamberMap::ddu(), CSCChamberMap::dduInput(), CSCChamberMap::dduSlot(), CSCChamberMap::dmb(), edm::EventID::event(), Exception, FEDRawDataCollection::FEDData(), formatVersion_, mps_fire::i, FEDNumbering::MAXCSCDDUFEDID, FEDNumbering::MAXCSCFEDID, FEDNumbering::MINCSCDDUFEDID, FEDNumbering::MINCSCFEDID, CSCConstants::NUM_DDUS, FEDRawData::resize(), FEDRawData::size(), and CSCChamberMap::slink().

                                                               {
   //get fed object from fed_buffers
   // make a map from the index of a chamber to the event data from it
   FindEventDataInfo fedInfo{mapping, formatVersion_};
   add(stripDigis, preTriggers, preTriggerDigis, fedInfo);
   add(wireDigis, alctDigis, fedInfo);
   add(comparatorDigis, clctDigis, fedInfo);
   add(correlatedLCTDigis, fedInfo);
 
   // Starting Run-3, the CSC DAQ will pack/unpack CSC showers
   if (cscShowerDigis) {
     add(*cscShowerDigis, fedInfo);
   }
 
   // Starting Run-3, the CSC DAQ will pack/unpack GEM clusters
   if (gemPadDigiClusters) {
     add(*gemPadDigiClusters, fedInfo);
   }
   int l1a = eid.event();  //need to add increments or get it from lct digis
   int bx = l1a;           //same as above
 
   if (fedInfo.formatVersion_ == 2005)  
   {
     std::map<int, CSCDCCEventData> dccMap;
     //idcc goes from startingFed to startingFED+7
     for (int idcc = FEDNumbering::MINCSCFEDID; idcc <= FEDNumbering::MAXCSCFEDID; ++idcc) {
       dccMap.insert(std::pair<int, CSCDCCEventData>(idcc, CSCDCCEventData(idcc, CSCConstants::NUM_DDUS, bx, l1a)));
     }
 
     for (int idcc = FEDNumbering::MINCSCFEDID; idcc <= FEDNumbering::MAXCSCFEDID; ++idcc) {
       // for every chamber with data, add to a DDU in this DCC Event
       for (map<CSCDetId, CSCEventData>::iterator chamberItr = fedInfo.theChamberDataMap.begin();
            chamberItr != fedInfo.theChamberDataMap.end();
            ++chamberItr) {
         int indexDCC = mapping->slink(chamberItr->first);
         if (indexDCC == idcc) {
           //FIXME (What does this mean? Is something wrong?)
           std::map<int, CSCDCCEventData>::iterator dccMapItr = dccMap.find(indexDCC);
           if (dccMapItr == dccMap.end()) {
             throw cms::Exception("CSCDigiToRaw") << "Bad DCC number:" << indexDCC;
           }
           // get id's based on ChamberId from mapping
 
           int dduId = mapping->ddu(chamberItr->first);
           int dduSlot = mapping->dduSlot(chamberItr->first);
           int dduInput = mapping->dduInput(chamberItr->first);
           int dmbId = mapping->dmb(chamberItr->first);
           dccMapItr->second.addChamber(chamberItr->second, dduId, dduSlot, dduInput, dmbId, formatVersion_);
         }
       }
     }
 
     // FIXME: FEDRawData size set to 2*64 to add FED header and trailer
     for (std::map<int, CSCDCCEventData>::iterator dccMapItr = dccMap.begin(); dccMapItr != dccMap.end(); ++dccMapItr) {
       boost::dynamic_bitset<> dccBits = dccMapItr->second.pack();
       FEDRawData& fedRawData = fed_buffers.FEDData(dccMapItr->first);
       fedRawData.resize(dccBits.size());
       //fill data with dccEvent
       bitset_utilities::bitsetToChar(dccBits, fedRawData.data());
       FEDTrailer cscFEDTrailer(fedRawData.data() + (fedRawData.size() - 8));
       cscFEDTrailer.set(fedRawData.data() + (fedRawData.size() - 8),
                         fedRawData.size() / 8,
                         evf::compute_crc(fedRawData.data(), fedRawData.size()),
                         0,
                         0);
     }
   }
   else if (formatVersion_ == 2013) {
     std::map<int, CSCDDUEventData> dduMap;
     unsigned int ddu_fmt_version = 0x7;  
     const unsigned postLS1_map[] = {841, 842, 843, 844, 845, 846, 847, 848, 849, 831, 832, 833,
                                     834, 835, 836, 837, 838, 839, 861, 862, 863, 864, 865, 866,
                                     867, 868, 869, 851, 852, 853, 854, 855, 856, 857, 858, 859};
 
     for (unsigned int i = 0; i < 36; i++) {
       unsigned int iddu = postLS1_map[i];
       // make a new one
       CSCDDUHeader newDDUHeader(bx, l1a, iddu, ddu_fmt_version);
 
       dduMap.insert(std::pair<int, CSCDDUEventData>(iddu, CSCDDUEventData(newDDUHeader)));
     }
 
     for (unsigned int i = 0; i < 36; i++) {
       unsigned int iddu = postLS1_map[i];
       // for every chamber with data, add to a DDU in this DCC Event
       for (map<CSCDetId, CSCEventData>::iterator chamberItr = fedInfo.theChamberDataMap.begin();
            chamberItr != fedInfo.theChamberDataMap.end();
            ++chamberItr) {
         unsigned int indexDDU = mapping->slink(chamberItr->first);
 
         // Still preLS1 DCC FEDs mapping
         if ((indexDDU >= FEDNumbering::MINCSCFEDID) && (indexDDU <= FEDNumbering::MAXCSCFEDID)) {
           int dduID = mapping->ddu(chamberItr->first);  // try to switch to DDU ID mapping
           // DDU ID is in expectedi post-LS1 FED ID range
           if ((dduID >= FEDNumbering::MINCSCDDUFEDID) && (dduID <= FEDNumbering::MAXCSCDDUFEDID)) {
             indexDDU = dduID;
           } else  // Messy
           {
             // Lets try to change pre-LS1 1-36 ID range to post-LS1 MINCSCDDUFEDID - MAXCSCDDUFEDID range
             dduID &= 0xFF;
             // indexDDU = FEDNumbering::MINCSCDDUFEDID + dduID-1;
             if ((dduID <= 36) && (dduID > 0))
               indexDDU = postLS1_map[dduID - 1];
           }
         }
 
         if (indexDDU == iddu) {
           std::map<int, CSCDDUEventData>::iterator dduMapItr = dduMap.find(indexDDU);
           if (dduMapItr == dduMap.end()) {
             throw cms::Exception("CSCDigiToRaw") << "Bad DDU number:" << indexDDU;
           }
           // get id's based on ChamberId from mapping
 
           int dduInput = mapping->dduInput(chamberItr->first);
           int dmbId = mapping->dmb(chamberItr->first);
           // int crateId  = mapping->crate(chamberItr->first);
           dduMapItr->second.add(chamberItr->second, dmbId, dduInput, formatVersion_);
         }
       }
     }
 
     // FIXME: FEDRawData size set to 2*64 to add FED header and trailer
     for (std::map<int, CSCDDUEventData>::iterator dduMapItr = dduMap.begin(); dduMapItr != dduMap.end(); ++dduMapItr) {
       boost::dynamic_bitset<> dduBits = dduMapItr->second.pack();
       FEDRawData& fedRawData = fed_buffers.FEDData(dduMapItr->first);
       fedRawData.resize(dduBits.size() / 8);
       //fill data with dduEvent
       bitset_utilities::bitsetToChar(dduBits, fedRawData.data());
       FEDTrailer cscFEDTrailer(fedRawData.data() + (fedRawData.size() - 8));
       cscFEDTrailer.set(fedRawData.data() + (fedRawData.size() - 8),
                         fedRawData.size() / 8,
                         evf::compute_crc(fedRawData.data(), fedRawData.size()),
                         0,
                         0);
     }
   }
 }

CSCEventData & CSCDigiToRaw::findEventData	(	const CSCDetId &	cscDetId,
		FindEventDataInfo &	info
	)		const

private

pick out the correct data object for this chamber

Definition at line 44 of file CSCDigiToRaw.cc.

References CSCDigiToRawAccept::chamberID(), CSCChamberMap::crate(), CSCChamberMap::dmb(), CSCEventData::dmbHeader(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, CSCDetId::iChamberType(), CSCDetId::ring(), CSCDMBHeader::setCrateAddress(), CSCDMBHeader::setdmbVersion(), CSCDetId::station(), CSCDigiToRaw::FindEventDataInfo::theChamberDataMap, and CSCDigiToRaw::FindEventDataInfo::theElectronicsMap.

Referenced by add().

                                                                                                  {
   CSCDetId chamberId = CSCDigiToRawAccept::chamberID(cscDetId);
   // find the entry into the map
   map<CSCDetId, CSCEventData>::iterator chamberMapItr = info.theChamberDataMap.find(chamberId);
   if (chamberMapItr == info.theChamberDataMap.end()) {
     // make an entry, telling it the correct chamberType
     int chamberType = chamberId.iChamberType();
     chamberMapItr = info.theChamberDataMap
                         .insert(pair<CSCDetId, CSCEventData>(chamberId, CSCEventData(chamberType, info.formatVersion_)))
                         .first;
   }
   CSCEventData& cscData = chamberMapItr->second;
   cscData.dmbHeader()->setCrateAddress(info.theElectronicsMap->crate(cscDetId), info.theElectronicsMap->dmb(cscDetId));
 
   if (info.formatVersion_ == 2013) {
     // Set DMB version field to distinguish between ME11s and other chambers (ME11 - 2, others - 1)
     bool me11 = ((chamberId.station() == 1) && (chamberId.ring() == 4)) ||
                 ((chamberId.station() == 1) && (chamberId.ring() == 1));
     if (me11) {
       cscData.dmbHeader()->setdmbVersion(2);
     } else {
       cscData.dmbHeader()->setdmbVersion(1);
     }
   }
   return cscData;
 }

Member Data Documentation

const int CSCDigiToRaw::alctWindowMax_

private

Definition at line 75 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::alctWindowMin_

private

Definition at line 74 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::clctWindowMax_

private

Definition at line 77 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::clctWindowMin_

private

Definition at line 76 of file CSCDigiToRaw.h.

Referenced by add().

uint16_t CSCDigiToRaw::formatVersion_

private

Definition at line 81 of file CSCDigiToRaw.h.

Referenced by createFedBuffers().

bool CSCDigiToRaw::packByCFEB_

private

Definition at line 84 of file CSCDigiToRaw.h.

Referenced by add().

bool CSCDigiToRaw::packEverything_

private

Definition at line 82 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::preTriggerWindowMax_

private

Definition at line 79 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::preTriggerWindowMin_

private

Definition at line 78 of file CSCDigiToRaw.h.

Referenced by add().

bool CSCDigiToRaw::usePreTriggers_

private

Definition at line 83 of file CSCDigiToRaw.h.

Referenced by add().

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation