#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 CSCCorrelatedLCTDigiCollection &correlatedLCTDigis, FEDRawDataCollection &fed_buffers, const CSCChamberMap *theMapping, edm::Event &e, uint16_t theFormatVersion=2005, bool usePreTriggers=true, bool packEverything=false) 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, FindEventDataInfo &, bool usePreTriggers, bool packEverything) const

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

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

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

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

void	add (const CSCCorrelatedLCTDigiCollection &corrLCTDigis, 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_

const int	preTriggerWindowMax_

const int	preTriggerWindowMin_

Detailed Description

Author: A. Tumanov - Rice

Definition at line 23 of file CSCDigiToRaw.h.

Constructor & Destructor Documentation

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

explicit

Constructor.

Definition at line 123 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"))
 {}

Member Function Documentation

void CSCDigiToRaw::add	(	const CSCStripDigiCollection &	stripDigis,
		const CSCCLCTPreTriggerCollection &	preTriggers,
		FindEventDataInfo &	fedInfo,
		bool	usePreTriggers,
		bool	packEverything
	)		const

private

Definition at line 165 of file CSCDigiToRaw.cc.

References cscd2r::accept(), CSCEventData::add(), CSCDetId::endcap(), findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, CSCStripDigi::getStrip(), plotBeamSpotDB::last, CSCDetId::layer(), preTriggerWindowMax_, preTriggerWindowMin_, CSCDetId::ring(), CSCStripDigi::setStrip(), CSCDetId::station(), digitizers_cfi::strip, 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
       
       bool me1abCheck = fedInfo.formatVersion_ == 2013;
       /* !!! Testing. Uncomment for production */
      if (!usePreTriggers || packEverything ||
     (usePreTriggers && cscd2r::accept(cscDetId, preTriggers, preTriggerWindowMin_, preTriggerWindowMax_, me1abCheck)) )
         {
           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();
               if (fedInfo.formatVersion_ == 2013)
                 {
                   if ( me1a && zplus )
                     {
                       digi.setStrip(49-strip);  // 1-48 -> 48-1
                     }
                   if ( me1b && !zplus)
                     {
                       digi.setStrip(65-strip);  // 1-64 -> 64-1
                     }
                   if ( me1a )
                     {
                       strip = digi.getStrip();  // reset back 1-16 to 65-80 digi
                       digi.setStrip(strip+64);
                     }
 
                 }
               else
                 {
                   if ( me1a && zplus )
                     {
                       digi.setStrip(17-strip);  // 1-16 -> 16-1
                     }
                   if ( me1b && !zplus)
                     {
                       digi.setStrip(65-strip);  // 1-64 -> 64-1
                     }
                   if ( me1a )
                     {
                       strip = digi.getStrip();  // reset back 1-16 to 65-80 digi
                       digi.setStrip(strip+64);
                     }
                 }
               cscData.add(digi, cscDetId.layer() );
             }
         }
     }
 }

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

private

Definition at line 233 of file CSCDigiToRaw.cc.

References cscd2r::accept(), add(), CSCEventData::add(), alctWindowMax_, alctWindowMin_, findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, plotBeamSpotDB::last, and CSCDetId::layer().

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;
       bool me1abCheck = fedInfo.formatVersion_ == 2013;
       if (packEverything || cscd2r::accept(cscDetId, alctDigis, alctWindowMin_, alctWindowMax_, me1abCheck))
         {
           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,
		bool	packEverything
	)		const

private

Definition at line 257 of file CSCDigiToRaw.cc.

References cscd2r::accept(), add(), CSCEventData::add(), clctWindowMax_, clctWindowMin_, findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, CSCComparatorDigi::getComparator(), CSCComparatorDigi::getStrip(), CSCComparatorDigi::getTimeBinWord(), CSCDetId::layer(), CSCDetId::ring(), and CSCDetId::station().

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

 {
   add(clctDigis,fedInfo);
   for (CSCComparatorDigiCollection::DigiRangeIterator j=comparatorDigis.begin(); j!=comparatorDigis.end(); ++j)
     {
       CSCDetId cscDetId=(*j).first;
       CSCEventData & cscData = findEventData(cscDetId, fedInfo);
       bool me1abCheck = fedInfo.formatVersion_ == 2013;
       if (packEverything || cscd2r::accept(cscDetId, clctDigis, clctWindowMin_, clctWindowMax_, me1abCheck))
         {
           bool me1a = (cscDetId.station()==1) && (cscDetId.ring()==4);
       
 
       BOOST_FOREACH(CSCComparatorDigi digi, (*j).second)
           {
             if (fedInfo.formatVersion_ == 2013)
               {
                 // Move ME1/A comparators from CFEB=0 to CFEB=4 if this has not
                 // been done already.
                 if (me1a && digi.getStrip() <= 48)
                   {
                     CSCComparatorDigi digi_corr(64+digi.getStrip(),
                                                 digi.getComparator(),
                                                 digi.getTimeBinWord());
                     cscData.add(digi_corr, cscDetId);           // This version does ME11 strips swapping
             // cscData.add(digi_corr, cscDetId.layer());        // This one doesn't
                   }
                 else
                   {
             cscData.add(digi, cscDetId);                    // This version does ME11 strips swapping
                     // cscData.add(digi, cscDetId.layer());        // This one doesn't
                   }
               }
             else
               {
                 // Move ME1/A comparators from CFEB=0 to CFEB=4 if this has not
                 // been done already.
                 if (me1a && digi.getStrip() <= 16)
                   {
                     CSCComparatorDigi digi_corr(64+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 314 of file CSCDigiToRaw.cc.

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

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 326 of file CSCDigiToRaw.cc.

References CSCEventData::add(), findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, 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() >= 0 && iC->getCFEB() < 3){//sanity check, mostly
         (*iC) = CSCCLCTDigi(iC->isValid(), iC->getQuality(), iC->getPattern(), iC->getStripType(),
                  iC->getBend(), iC->getStrip(), iC->getCFEB()+4, 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 354 of file CSCDigiToRaw.cc.

References CSCEventData::add(), findEventData(), CSCDigiToRaw::FindEventDataInfo::formatVersion_, 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() >= 0 && iC->getStrip() < 96){//sanity check, mostly
             (*iC) = CSCCorrelatedLCTDigi(iC->getTrknmb(), iC->isValid(), iC->getQuality(), 
                      iC->getKeyWG(), iC->getStrip() + 128, 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::createFedBuffers	(	const CSCStripDigiCollection &	stripDigis,
		const CSCWireDigiCollection &	wireDigis,
		const CSCComparatorDigiCollection &	comparatorDigis,
		const CSCALCTDigiCollection &	alctDigis,
		const CSCCLCTDigiCollection &	clctDigis,
		const CSCCLCTPreTriggerCollection &	preTriggers,
		const CSCCorrelatedLCTDigiCollection &	correlatedLCTDigis,
		FEDRawDataCollection &	fed_buffers,
		const CSCChamberMap *	theMapping,
		edm::Event &	e,
		uint16_t	theFormatVersion = `2005`,
		bool	usePreTriggers = `true`,
		bool	packEverything = `false`
	)		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 384 of file CSCDigiToRaw.cc.

References add(), bitset_utilities::bitsetToChar(), evf::compute_crc(), FEDRawData::data(), CSCChamberMap::ddu(), CSCChamberMap::dduInput(), CSCChamberMap::dduSlot(), CSCChamberMap::dmb(), edm::EventID::event(), Exception, FEDRawDataCollection::FEDData(), mps_fire::i, edm::EventBase::id(), taus_updatedMVAIds_cff::mapping, FEDNumbering::MAXCSCDDUFEDID, FEDNumbering::MAXCSCFEDID, FEDNumbering::MINCSCDDUFEDID, FEDNumbering::MINCSCFEDID, FEDRawData::resize(), FEDRawData::size(), and CSCChamberMap::slink().

 {
 
   //bits of code from ORCA/Muon/METBFormatter - thanks, Rick:)!
 
   //get fed object from fed_buffers
   // make a map from the index of a chamber to the event data from it
   FindEventDataInfo fedInfo{mapping, format_version};
   add(stripDigis, preTriggers,fedInfo, use_pre_triggers, packEverything);
   add(wireDigis, alctDigis,fedInfo, packEverything);
   add(comparatorDigis, clctDigis,fedInfo, packEverything);
   add(correlatedLCTDigis,fedInfo);
 
   int l1a=e.id().event(); //need to add increments or get it from lct digis
   int bx = l1a;//same as above
   //int startingFED = FEDNumbering::MINCSCFEDID;
 
   if (fedInfo.formatVersion_ == 2005) 
     {
       std::map<int, CSCDCCEventData> dccMap;
       for (int idcc=FEDNumbering::MINCSCFEDID;
            idcc<=FEDNumbering::MAXCSCFEDID; ++idcc)
         {
           //idcc goes from startingFed to startingFED+7
           // @@ if ReadoutMapping changes, this'll have to change
           // DCCs 1,2,4,5 have 5 DDUs.  Otherwise, 4
           //int nDDUs = (idcc < 2) || (idcc ==4) || (idcc ==5)
           //          ? 5 : 4;
           //@@ WARNING some DCCs only have 4 DDUs, but I'm giving them all 5, for now
           int nDDUs = 5;
           dccMap.insert(std::pair<int, CSCDCCEventData>(idcc, CSCDCCEventData(idcc, nDDUs, 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, format_version);
                 }
             }
         }
 
       // 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 (format_version == 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);
 
               if ( (indexDDU >= FEDNumbering::MINCSCFEDID) && (indexDDU <= FEDNumbering::MAXCSCFEDID) ) // Still preLS1 DCC FEDs mapping
                 {
 
                   int dduID    = mapping->ddu(chamberItr->first); // try to switch to DDU ID mapping
                   if ((dduID >= FEDNumbering::MINCSCDDUFEDID) && (dduID <= FEDNumbering::MAXCSCDDUFEDID) ) // DDU ID is in expectedi post-LS1 FED ID range
                     {
                       indexDDU = dduID;
                     }
                   else // Messy
                     {
                       // Lets try to change pre-LS1 1-36 ID range to post-LS1 MINCSCDDUFEDID - MAXCSCDDUFEDID range
                       dduID &= 0xFF;
                       if ((dduID <= 36) && (dduID > 0)) indexDDU = postLS1_map[dduID -1]; // indexDDU = FEDNumbering::MINCSCDDUFEDID + 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, format_version );
                 }
             }
         }
 
       // 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 132 of file CSCDigiToRaw.cc.

References cscd2r::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 = cscd2r::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 81 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::alctWindowMin_

private

Definition at line 80 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::clctWindowMax_

private

Definition at line 83 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::clctWindowMin_

private

Definition at line 82 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::preTriggerWindowMax_

private

Definition at line 85 of file CSCDigiToRaw.h.

Referenced by add().

const int CSCDigiToRaw::preTriggerWindowMin_

private

Definition at line 84 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