#include <CSCTFUnpacker.h>

Inheritance diagram for CSCTFUnpacker:

Public Member Functions
	CSCTFUnpacker (const edm::ParameterSet &pset)

void	produce (edm::Event &e, const edm::EventSetup &c) override

	~CSCTFUnpacker (void) override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
int	m_maxBX

int	m_minBX

CSCTriggerMapping *	mapping

edm::InputTag	producer

edm::EDGetTokenT< FEDRawDataCollection >	Raw_token

std::vector< int >	slot2sector

bool	swapME1strips

CSCTFEvent	tfEvent

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 23 of file CSCTFUnpacker.h.

Constructor & Destructor Documentation

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

Definition at line 34 of file CSCTFUnpacker.cc.

References CSCTriggerMapping::addRecord(), makeMuonMisalignmentScenario::endcap, Exception, lumiContext::fill, edm::ParameterSet::getParameter(), LogDebug, m_maxBX, m_minBX, mapping, producer, Raw_token, slot2sector, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and swapME1strips.

                                                        :edm::stream::EDProducer<>(),mapping(nullptr){
     LogDebug("CSCTFUnpacker|ctor")<<"Started ...";
 
     // Edges of the time window, which LCTs are put into (unlike tracks, which are always centred around 0):
     m_minBX = pset.getParameter<int>("MinBX"); //3
     m_maxBX = pset.getParameter<int>("MaxBX"); //9
 
     // Swap: if(swapME1strips && me1b && !zplus) strip = 65 - strip; // 1-64 -> 64-1 :
     swapME1strips = pset.getParameter<bool>("swapME1strips");
 
     // Initialize slot<->sector assignment
     slot2sector = pset.getParameter< std::vector<int> >("slot2sector");
     LogDebug("CSCTFUnpacker|ctor")<<"Verifying slot<->sector map from 'vint32 slot2sector'";
     for(int slot=0; slot<22; slot++)
         if( slot2sector[slot]<0 || slot2sector[slot]>12 )
             throw cms::Exception("Invalid configuration")<<"CSCTFUnpacker: sector index is set out of range (slot2sector["<<slot<<"]="<<slot2sector[slot]<<", should be [0-12])";
     // Just for safety (in case of bad data):
     slot2sector.resize(32);
 
     // As we use standard CSC digi containers, we have to initialize mapping:
     std::string mappingFile = pset.getParameter<std::string>("mappingFile");
     if( mappingFile.length() ){
         LogDebug("CSCTFUnpacker|ctor") << "Define ``mapping'' only if you want to screw up real geometry";
         mapping = new CSCTriggerMappingFromFile(mappingFile);
     } else {
         LogDebug("CSCTFUnpacker|ctor") << "Generating default hw<->geometry mapping";
         class M: public CSCTriggerSimpleMapping{ void fill(void) override{} };
         mapping = new M();
         for(int endcap=1; endcap<=2; endcap++)
             for(int station=1; station<=4; station++)
                 for(int sector=1; sector<=6; sector++)
                     for(int csc=1; csc<=9; csc++){
                         if( station==1 ){
                             mapping->addRecord(endcap,station,sector,1,csc,endcap,station,sector,1,csc);
                             mapping->addRecord(endcap,station,sector,2,csc,endcap,station,sector,2,csc);
                         } else
                             mapping->addRecord(endcap,station,sector,0,csc,endcap,station,sector,0,csc);
                     }
     }
 
     producer = pset.getParameter<edm::InputTag>("producer");
 
     produces<CSCCorrelatedLCTDigiCollection>();
     produces<L1CSCTrackCollection>();
     produces<L1CSCStatusDigiCollection>();
     produces<CSCTriggerContainer<csctf::TrackStub> >("DT");
 
     Raw_token = consumes<FEDRawDataCollection>(producer);
 
 }

CSCTFUnpacker::~CSCTFUnpacker ( void )

override

Definition at line 85 of file CSCTFUnpacker.cc.

References mapping.

                              {
     if( mapping ) delete mapping;
 }

Member Function Documentation

void CSCTFUnpacker::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

override

Definition at line 89 of file CSCTFUnpacker.cc.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                               {
     // Get a handle to the FED data collection
     edm::Handle<FEDRawDataCollection> rawdata;
     e.getByToken(Raw_token,rawdata);
 
     // create the collection of CSC wire and strip digis as well as of DT stubs, which we receive from DTTF
     auto LCTProduct = std::make_unique<CSCCorrelatedLCTDigiCollection>();
     auto trackProduct = std::make_unique<L1CSCTrackCollection>();
     auto statusProduct = std::make_unique<L1CSCStatusDigiCollection>();
     auto dtProduct = std::make_unique<CSCTriggerContainer<csctf::TrackStub>>();
 
     for(int fedid=FEDNumbering::MINCSCTFFEDID; fedid<=FEDNumbering::MAXCSCTFFEDID; fedid++){
         const FEDRawData& fedData = rawdata->FEDData(fedid);
         if( fedData.size()==0 ) continue;
         //LogDebug("CSCTFUnpacker|produce");
         //if( monitor ) monitor->process((unsigned short*)fedData.data());
         unsigned int unpacking_status = tfEvent.unpack((unsigned short*)fedData.data(),fedData.size()/2);
         if( unpacking_status==0 ){
             // There may be several SPs in event
             std::vector<const CSCSPEvent*> SPs = tfEvent.SPs_fast();
             // Cycle over all of them
             for(std::vector<const CSCSPEvent *>::const_iterator spItr=SPs.begin(); spItr!=SPs.end(); spItr++){
                 const CSCSPEvent *sp = *spItr;
 
                 L1CSCSPStatusDigi status; 
                 status.sp_slot    = sp->header().slot();
                 status.l1a_bxn    = sp->header().BXN();
                 status.fmm_status = sp->header().status();
                 status.track_cnt  = sp->counters().track_counter();
                 status.orbit_cnt  = sp->counters().orbit_counter();
 
                 // Finds central LCT BX
                 // assumes window is odd number of bins
                 int central_lct_bx = (m_maxBX + m_minBX)/2;
 
                 // Find central SP BX
                 // assumes window is odd number of bins
                 int central_sp_bx = int(sp->header().nTBINs()/2);
 
                 for(unsigned int tbin=0; tbin<sp->header().nTBINs(); tbin++){
 
                     status.se |= sp->record(tbin).SEs();
                     status.sm |= sp->record(tbin).SMs();
                     status.bx |= sp->record(tbin).BXs();
                     status.af |= sp->record(tbin).AFs();
                     status.vp |= sp->record(tbin).VPs();
 
                     for(unsigned int FPGA=0; FPGA<5; FPGA++)
                         for(unsigned int MPClink=0; MPClink<3; ++MPClink){
                             std::vector<CSCSP_MEblock> lct = sp->record(tbin).LCT(FPGA,MPClink);
                             if( lct.empty() ) continue;
 
                             status.link_status[lct[0].spInput()] |=
                                 (1<<lct[0].receiver_status_frame1())|
                                 (1<<lct[0].receiver_status_frame2())|
                                 ((lct[0].aligment_fifo()?1:0)<<4);
                             status.mpc_link_id |= (lct[0].link()<<2)|lct[0].mpc();
 
                             int station = ( FPGA ? FPGA : 1 );
                             int endcap=0, sector=0;
                             if( slot2sector[sp->header().slot()] ){
                                 endcap = slot2sector[sp->header().slot()]/7 + 1;
                                 sector = slot2sector[sp->header().slot()];
                                 if( sector>6 ) sector -= 6;
                             } else {
                                 endcap = (sp->header().endcap()?1:2);
                                 sector =  sp->header().sector();
                             }
                             int subsector = ( FPGA>1 ? 0 : FPGA+1 );
                             int cscid   = lct[0].csc() ;
 
                             try{
                                 CSCDetId id = mapping->detId(endcap,station,sector,subsector,cscid,0);
                                 // corrlcts now have no layer associated with them
                                 LCTProduct->insertDigi(id,
                                     CSCCorrelatedLCTDigi(
                                         0,lct[0].vp(),lct[0].quality(),lct[0].wireGroup(),
                                         (swapME1strips && cscid<=3 && station==1 && endcap==2 && lct[0].strip()<65 ? 65 - lct[0].strip() : lct[0].strip() ),
                                         lct[0].pattern(),lct[0].l_r(),
                                         (lct[0].tbin()+(central_lct_bx-central_sp_bx)),
                                         lct[0].link(), lct[0].BXN(), 0, cscid )
                                     );
                             } catch(cms::Exception &e) {
                                 edm::LogInfo("CSCTFUnpacker|produce") << e.what() << "Not adding digi to collection in event "
                                       <<sp->header().L1A()<<" (endcap="<<endcap<<",station="<<station<<",sector="<<sector<<",subsector="<<subsector<<",cscid="<<cscid<<",spSlot="<<sp->header().slot()<<")";
                             }
 
                         }
 
                     std::vector<CSCSP_MBblock> mbStubs = sp->record(tbin).mbStubs();
                     for(std::vector<CSCSP_MBblock>::const_iterator iter=mbStubs.begin(); iter!=mbStubs.end(); iter++){
                         int endcap, sector;
                         if( slot2sector[sp->header().slot()] ){
                             endcap = slot2sector[sp->header().slot()]/7 + 1;
                             sector = slot2sector[sp->header().slot()];
                             if( sector>6 ) sector -= 6;
                         } else {
                             endcap = (sp->header().endcap()?1:2);
                             sector =  sp->header().sector();
                         }
                         const unsigned int csc2dt[6][2] = {{2,3},{4,5},{6,7},{8,9},{10,11},{12,1}};
                         DTChamberId id((endcap==1?2:-2),1, csc2dt[sector-1][iter->id()-1]);
                         CSCCorrelatedLCTDigi base(0,iter->vq(),iter->quality(),iter->cal(),iter->flag(),iter->bc0(),iter->phi_bend(),tbin+(central_lct_bx-central_sp_bx),iter->id(),iter->bxn(),iter->timingError(),iter->BXN());
                         csctf::TrackStub dtStub(base,id,iter->phi(),0);
                         dtProduct->push_back(dtStub);
                     }
 
                     std::vector<CSCSP_SPblock> tracks = sp->record(tbin).tracks();
                     unsigned int trkNumber=0;
                     for(std::vector<CSCSP_SPblock>::const_iterator iter=tracks.begin(); iter!=tracks.end(); iter++,trkNumber++){
                         L1CSCTrack track;
                         if( slot2sector[sp->header().slot()] ){
                             track.first.m_endcap = slot2sector[sp->header().slot()]/7 + 1;
                             track.first.m_sector = slot2sector[sp->header().slot()];
                             if(  track.first.m_sector>6 ) track.first.m_sector -= 6;
                         } else {
                             track.first.m_endcap = (sp->header().endcap()?1:2);
                             track.first.m_sector =  sp->header().sector();
                         }
 
                         track.first.m_lphi      = iter->phi();
                         track.first.m_ptAddress = iter->ptLUTaddress();
                         track.first.m_fr        = iter->f_r();
                         track.first.m_ptAddress|=(iter->f_r() << 21);
 
                         track.first.setStationIds(iter->ME1_id(),iter->ME2_id(),iter->ME3_id(),iter->ME4_id(),iter->MB_id());
                         track.first.setTbins(iter->ME1_tbin(), iter->ME2_tbin(), iter->ME3_tbin(), iter->ME4_tbin(), iter->MB_tbin() );
                         track.first.setBx(iter->tbin()-central_sp_bx);
                         track.first.setBits(iter->syncErr(), iter->bx0(), iter->bc0());
 
                         track.first.setLocalPhi(iter->phi());
                         track.first.setEtaPacked(iter->eta());
                         track.first.setChargePacked(iter->charge());
 
                         track.first.m_output_link = iter->id();
                         if( track.first.m_output_link ){
                             track.first.m_rank = (iter->f_r()?sp->record(tbin).ptSpy()&0x7F:(sp->record(tbin).ptSpy()&0x7F00)>>8);
                             track.first.setChargeValidPacked((iter->f_r()?(sp->record(tbin).ptSpy()&0x80)>>8:(sp->record(tbin).ptSpy()&0x8000)>>15));
                         } else {
                             track.first.m_rank = 0;
                             track.first.setChargeValidPacked(0);
                         }
                         track.first.setFineHaloPacked(iter->halo());
 
                         track.first.m_winner = iter->MS_id()&(1<<trkNumber);
 
                         std::vector<CSCSP_MEblock> lcts = iter->LCTs();
                         for(std::vector<CSCSP_MEblock>::const_iterator lct=lcts.begin(); lct!=lcts.end(); lct++){
                             int station   = ( lct->spInput()>6 ? (lct->spInput()-1)/3 : 1 );
                             int subsector = ( lct->spInput()>6 ? 0 : (lct->spInput()-1)/3 + 1 );
                             try{
                                 CSCDetId id = mapping->detId(track.first.m_endcap,station,track.first.m_sector,subsector,lct->csc(),0);
                                 track.second.insertDigi(id,
                                     CSCCorrelatedLCTDigi(
                                         0,lct->vp(),lct->quality(),lct->wireGroup(),
                                         (swapME1strips && lct->csc()<=3 && station==1 && track.first.m_endcap==2 && lct[0].strip()<65 ? 65 - lct[0].strip() : lct[0].strip() ),
                                         lct->pattern(),lct->l_r(),
                                         (lct->tbin()+(central_lct_bx-central_sp_bx)),
                                         lct->link(), lct->BXN(), 0, lct->csc() )
                                     );
                             } catch(cms::Exception &e) {
                                 edm::LogInfo("CSCTFUnpacker|produce") << e.what() << "Not adding track digi to collection in event"
                                       <<sp->header().L1A()<<" (endcap="<<track.first.m_endcap<<",station="<<station<<",sector="<<track.first.m_sector<<",subsector="<<subsector<<",cscid="<<lct->csc()<<",spSlot="<<sp->header().slot()<<")";
                             }
                         }
 
                         std::vector<CSCSP_MBblock> mbStubs = iter->dtStub();
                         for(std::vector<CSCSP_MBblock>::const_iterator iter=mbStubs.begin(); iter!=mbStubs.end(); iter++){
                             CSCDetId id = mapping->detId(track.first.m_endcap,1,track.first.m_sector,iter->id(),1,0);
                             track.second.insertDigi(id,
                                 CSCCorrelatedLCTDigi(iter->phi(),iter->vq(),iter->quality()+100,iter->cal(),iter->flag(),iter->bc0(),iter->phi_bend(),tbin+(central_lct_bx-central_sp_bx),iter->id(),iter->bxn(),iter->timingError(),iter->BXN())
                             );
                         }
 
                         trackProduct->push_back( track );
                     }
                 }
                 statusProduct->second.push_back( status );
             }
         } else {
             edm::LogError("CSCTFUnpacker|produce")<<" problem of unpacking TF event: 0x"<<std::hex<<unpacking_status<<std::dec<<" code";
         }
 
         statusProduct->first  = unpacking_status;
 
     } //end of fed cycle
     e.put(std::move(dtProduct),"DT");
     e.put(std::move(LCTProduct)); // put processed lcts into the event.
     e.put(std::move(trackProduct));
     e.put(std::move(statusProduct));
 }