#include <L1NtupleProducer.h>

Inheritance diagram for L1NtupleProducer:

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)

virtual void	beginJob (void)

virtual void	endJob ()

	L1NtupleProducer (const edm::ParameterSet &)

virtual	~L1NtupleProducer ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
void	analyzeCSCTF (const edm::Event &e, const edm::EventSetup &)

void	analyzeDTTF (const edm::Event &e)

void	analyzeECAL (const edm::Event &e, const edm::EventSetup &)

void	analyzeEvent (const edm::Event &e)

void	analyzeGCT (const edm::Event &e)

void	analyzeGenerator (const edm::Event &e)

void	analyzeGMT (const edm::Event &e)

void	analyzeGT (const edm::Event &e)

void	analyzeHCAL (const edm::Event &e, const edm::EventSetup &)

void	analyzeRCT (const edm::Event &e)

void	analyzeSimulation (const edm::Event &e)

void	book ()

void	initCSCTF ()

Private Attributes
edm::EDGetTokenT < CSCTriggerContainer < csctf::TrackStub > >	csctfDTStubsSource_

edm::EDGetTokenT < CSCCorrelatedLCTDigiCollection >	csctfLCTSource_

CSCTFPtLUT *	csctfPtLUTs_

edm::ParameterSet	csctfPtLutsPSet

edm::EDGetTokenT < L1CSCStatusDigiCollection >	csctfStatusSource_

edm::EDGetTokenT < L1CSCTrackCollection >	csctfTrkSource_

edm::EDGetTokenT < L1MuDTChambPhContainer >	dttfPhSource_

edm::EDGetTokenT < L1MuDTChambThContainer >	dttfThSource_

edm::EDGetTokenT < L1MuDTTrackContainer >	dttfTrkSource_

unsigned long long	ecalScaleCacheID_

edm::EDGetTokenT < EcalTrigPrimDigiCollection >	ecalSource_

edm::EDGetTokenT < L1GctJetCandCollection >	gctCenJetsSource_

edm::EDGetTokenT < L1GctEtMissCollection >	gctETMSource_

edm::EDGetTokenT < L1GctEtTotalCollection >	gctETTSource_

edm::EDGetTokenT < L1GctJetCandCollection >	gctForJetsSource_

edm::EDGetTokenT < L1GctHFBitCountsCollection >	gctHFBitsSource_

edm::EDGetTokenT < L1GctHFRingEtSumsCollection >	gctHFSumsSource_

edm::EDGetTokenT < L1GctHtMissCollection >	gctHTMSource_

edm::EDGetTokenT < L1GctEtHadCollection >	gctHTTSource_

edm::EDGetTokenT < L1GctEmCandCollection >	gctIsoEmSource_

edm::EDGetTokenT < L1GctJetCandCollection >	gctIsoTauJetsSource_

edm::EDGetTokenT < L1GctEmCandCollection >	gctNonIsoEmSource_

edm::EDGetTokenT < L1GctJetCandCollection >	gctTauJetsSource_

edm::EDGetTokenT < reco::GenParticleCollection >	generatorSource_

edm::EDGetTokenT < L1MuGMTReadoutCollection >	gmtSource_

edm::EDGetTokenT < L1GlobalTriggerEvmReadoutRecord >	gtEvmSource_

edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	gtSource_

unsigned long long	hcalScaleCacheID_

edm::EDGetTokenT < HcalTrigPrimDigiCollection >	hcalSource_

edm::EDGetTokenT < edm::TriggerResults >	hltSource_

bool	initCSCTFPtLutsPSet

unsigned long long	m_csctfptlutCacheID

unsigned long long	m_ptScaleCacheID

unsigned long long	m_scalesCacheID

unsigned int	maxCSC_

unsigned int	maxCSCTFLCTS_

unsigned int	maxCSCTFLCTSTR_

unsigned int	maxCSCTFSPS_

unsigned int	maxCSCTFTR_

unsigned int	maxDTBX_

unsigned int	maxDTPH_

unsigned int	maxDTTH_

unsigned int	maxDTTR_

unsigned int	maxGEN_

unsigned int	maxGMT_

unsigned int	maxGT_

unsigned int	maxRCTREG_

unsigned int	maxRPC_

bool	physVal_

L1Analysis::L1AnalysisCaloTP *	pL1calotp

L1Analysis::L1AnalysisCaloTPDataFormat *	pL1calotp_data

L1Analysis::L1AnalysisCSCTF *	pL1csctf

L1Analysis::L1AnalysisCSCTFDataFormat *	pL1csctf_data

L1Analysis::L1AnalysisDTTF *	pL1dttf

L1Analysis::L1AnalysisDTTFDataFormat *	pL1dttf_data

L1Analysis::L1AnalysisEvent *	pL1evt

L1Analysis::L1AnalysisEventDataFormat *	pL1evt_data

L1Analysis::L1AnalysisGCT *	pL1gct

L1Analysis::L1AnalysisGCTDataFormat *	pL1gct_data

L1Analysis::L1AnalysisGenerator *	pL1generator

L1Analysis::L1AnalysisGeneratorDataFormat *	pL1generator_data

L1Analysis::L1AnalysisGMT *	pL1gmt

L1Analysis::L1AnalysisGMTDataFormat *	pL1gmt_data

L1Analysis::L1AnalysisGT *	pL1gt

L1Analysis::L1AnalysisGTDataFormat *	pL1gt_data

L1Analysis::L1AnalysisRCT *	pL1rct

L1Analysis::L1AnalysisRCTDataFormat *	pL1rct_data

L1Analysis::L1AnalysisSimulation *	pL1simulation

L1Analysis::L1AnalysisSimulationDataFormat *	pL1simulation_data

edm::EDGetTokenT < L1CaloEmCollection >	rctEmSource_

edm::EDGetTokenT < L1CaloRegionCollection >	rctRgnSource_

edm::InputTag	simulationSource_

CSCSectorReceiverLUT *	srLUTs_ [5][2]

edm::Service< TFileService >	tfs_

const L1MuTriggerPtScale *	tpts

TTree *	tree_

const L1MuTriggerScales *	ts

bool	verbose_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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 93 of file L1NtupleProducer.h.

Constructor & Destructor Documentation

L1NtupleProducer::L1NtupleProducer ( const edm::ParameterSet & ps )

explicit

 Description:  This code is designed for l1 prompt analysis

starting point is a GMTTreeMaker By Ivan Mikulec now extended from Lorenzo Agostino.

Definition at line 70 of file L1NtupleProducer.cc.

                                                             : csctfPtLUTs_(NULL), tree_(0) {
 
   hltSource_           = consumes<edm::TriggerResults>(ps.getParameter<edm::InputTag>("hltSource"));
 
 //gt, gmt  
   gmtSource_           = consumes<L1MuGMTReadoutCollection>(ps.getParameter<edm::InputTag>("gmtSource"));
   gtEvmSource_         = consumes<L1GlobalTriggerEvmReadoutRecord>(ps.getParameter<edm::InputTag>("gtEvmSource"));
   gtSource_        = consumes<L1GlobalTriggerReadoutRecord>(ps.getParameter<edm::InputTag>("gtSource"));
   generatorSource_     = consumes<reco::GenParticleCollection>(ps.getParameter<edm::InputTag>("generatorSource"));
   //  simulationSource_    = consumes<CaloTowerBxCollection>(ps.getParameter<edm::InputTag>("simulationSource"));
   physVal_             = ps.getParameter< bool >("physVal");
   
 //gct
   gctCenJetsSource_    = consumes<L1GctJetCandCollection>(ps.getParameter<edm::InputTag>("gctCentralJetsSource"));
   gctForJetsSource_    = consumes<L1GctJetCandCollection>(ps.getParameter<edm::InputTag>("gctForwardJetsSource"));
   gctTauJetsSource_    = consumes<L1GctJetCandCollection>(ps.getParameter<edm::InputTag>("gctTauJetsSource"));
   gctIsoTauJetsSource_ = consumes<L1GctJetCandCollection>(ps.getParameter<edm::InputTag>("gctIsoTauJetsSource"));
   gctETTSource_ = consumes<L1GctEtTotalCollection>(ps.getParameter<edm::InputTag>("gctETTSource"));
   gctETMSource_ = consumes<L1GctEtMissCollection>(ps.getParameter<edm::InputTag>("gctETMSource"));
   gctHTTSource_ = consumes<L1GctEtHadCollection>(ps.getParameter<edm::InputTag>("gctHTTSource"));
   gctHTMSource_ = consumes<L1GctHtMissCollection>(ps.getParameter<edm::InputTag>("gctHTMSource"));
   gctHFSumsSource_ = consumes<L1GctHFRingEtSumsCollection>(ps.getParameter<edm::InputTag>("gctHFSumsSource"));
   gctIsoEmSource_      = consumes<L1GctEmCandCollection>(ps.getParameter<edm::InputTag>("gctIsoEmSource"));
   gctNonIsoEmSource_   = consumes<L1GctEmCandCollection>(ps.getParameter<edm::InputTag>("gctNonIsoEmSource"));
   gctHFBitsSource_ = consumes<L1GctHFBitCountsCollection>(ps.getParameter<edm::InputTag>("gctHFBitsSource"));
 
   verbose_             = ps.getUntrackedParameter< bool >("verbose", false);
 
 //rct
   rctRgnSource_           = consumes<L1CaloRegionCollection>(ps.getParameter<edm::InputTag>("rctRgnSource"));
   rctEmSource_           = consumes<L1CaloEmCollection>(ps.getParameter<edm::InputTag>("rctEmSource"));
 
 //dt  
   dttfPhSource_          = consumes<L1MuDTChambPhContainer>(ps.getParameter<edm::InputTag>("dttfPhSource"));
   dttfThSource_          = consumes<L1MuDTChambThContainer>(ps.getParameter<edm::InputTag>("dttfThSource"));
   dttfTrkSource_          = consumes<L1MuDTTrackContainer>(ps.getParameter<edm::InputTag>("dttfTrkSource"));
   
 //ecal/hcal
   ecalSource_          = consumes<EcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("ecalSource"));
   hcalSource_          = consumes<HcalTrigPrimDigiCollection>(ps.getParameter<edm::InputTag>("hcalSource"));
 
 //csctf
   csctfTrkSource_      = consumes<L1CSCTrackCollection>(ps.getParameter<edm::InputTag>("csctfTrkSource"));  
   csctfLCTSource_      = consumes<CSCCorrelatedLCTDigiCollection>(ps.getParameter<edm::InputTag>("csctfLCTSource")); 
   csctfStatusSource_   = consumes<L1CSCStatusDigiCollection>(ps.getParameter<edm::InputTag>("csctfStatusSource")); 
   csctfDTStubsSource_  = consumes<CSCTriggerContainer<csctf::TrackStub> >(ps.getParameter<edm::InputTag>("csctfDTStubsSource"));
 
   initCSCTFPtLutsPSet  = ps.getParameter< bool >("initCSCTFPtLutsPSet");
   csctfPtLutsPSet      = ps.getParameter<edm::ParameterSet>("csctfPtLutsPSet");
    
 //maximum allowed size of tree vectors
   maxRPC_              = ps.getParameter<unsigned int>("maxRPC");
   maxDTBX_             = ps.getParameter<unsigned int>("maxDTBX");
   maxCSC_              = ps.getParameter<unsigned int>("maxCSC");
   maxGMT_              = ps.getParameter<unsigned int>("maxGMT");
   maxGT_               = ps.getParameter<unsigned int>("maxGT");
   maxRCTREG_           = ps.getParameter<unsigned int>("maxRCTREG");
   maxDTPH_             = ps.getParameter<unsigned int>("maxDTPH");
   maxDTTH_             = ps.getParameter<unsigned int>("maxDTTH");
   maxDTTR_             = ps.getParameter<unsigned int>("maxDTTR");
   maxGEN_              = ps.getParameter<unsigned int>("maxGEN");
   maxCSCTFTR_          = ps.getParameter<unsigned int>("maxCSCTFTR");
   maxCSCTFLCTSTR_      = ps.getParameter<unsigned int>("maxCSCTFLCTSTR");
   maxCSCTFLCTS_        = ps.getParameter<unsigned int>("maxCSCTFLCTS");
   maxCSCTFSPS_         = ps.getParameter<unsigned int>("maxCSCTFSPS");
 
   hcalScaleCacheID_    = 0;
   ecalScaleCacheID_    = 0;
 
   std::string puMCFile   = ps.getUntrackedParameter<std::string>("puMCFile", "");
   std::string puMCHist   = ps.getUntrackedParameter<std::string>("puMCHist", "pileup");
   std::string puDataFile = ps.getUntrackedParameter<std::string>("puDataFile", "");
   std::string puDataHist = ps.getUntrackedParameter<std::string>("puDataHist", "pileup");
 
   bool useAvgVtx          = ps.getUntrackedParameter<bool>("useAvgVtx", true);
   double maxAllowedWeight = ps.getUntrackedParameter<double>("maxAllowedWeight", -1);
 
   pL1evt                = new L1Analysis::L1AnalysisEvent(puMCFile, puMCHist, 
                               puDataFile, puDataHist,
                               useAvgVtx, maxAllowedWeight);
   pL1gmt                = new L1Analysis::L1AnalysisGMT();
   pL1rct                = new L1Analysis::L1AnalysisRCT(maxRCTREG_);
   pL1gt                 = new L1Analysis::L1AnalysisGT();
   pL1gct                = new L1Analysis::L1AnalysisGCT(verbose_);
   pL1dttf               = new L1Analysis::L1AnalysisDTTF();
   pL1csctf              = new L1Analysis::L1AnalysisCSCTF();
   pL1calotp             = new L1Analysis::L1AnalysisCaloTP();
   pL1generator          = new L1Analysis::L1AnalysisGenerator(); 
   pL1simulation         = new L1Analysis::L1AnalysisSimulation();
 
 
   pL1evt_data           = pL1evt->getData();
   pL1gmt_data           = pL1gmt->getData();
   pL1rct_data           = pL1rct->getData();
   pL1gt_data            = pL1gt->getData();
   pL1gct_data           = pL1gct->getData();
   pL1dttf_data          = pL1dttf->getData();
   pL1csctf_data         = pL1csctf->getData();
   pL1calotp_data         = pL1calotp->getData();
   pL1generator_data     = pL1generator->getData();
   pL1simulation_data    = pL1simulation->getData();
   
   initCSCTF(); 
   
   tree_ = tfs_->make<TTree>("L1Tree", "L1Tree");
 
   book();
 }

L1NtupleProducer::~L1NtupleProducer ( )

virtual

Definition at line 182 of file L1NtupleProducer.cc.

References csctfPtLUTs_, i, j, pL1calotp, pL1csctf, pL1dttf, pL1evt, pL1gct, pL1generator, pL1gmt, pL1gt, pL1rct, pL1simulation, and srLUTs_.

                                     { 
   
   //free the CSCTF array of pointers
   for(unsigned int j=0; j<2; j++) 
     for(unsigned int i=0; i<5; i++) 
      delete srLUTs_[i][j]; 
   delete csctfPtLUTs_; 
   
   delete pL1evt;
   delete pL1gmt;
   delete pL1rct;
   delete pL1gct;
   delete pL1gt;
   delete pL1dttf; 
   delete pL1csctf;
   delete pL1calotp;
   delete pL1generator;
   delete pL1simulation;
 }

Member Function Documentation

void L1NtupleProducer::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)

virtual

Implements edm::EDAnalyzer.

Definition at line 213 of file L1NtupleProducer.cc.

References analyzeCSCTF(), analyzeDTTF(), analyzeEvent(), analyzeGCT(), analyzeGenerator(), analyzeGMT(), analyzeGT(), analyzeRCT(), analyzeSimulation(), and tree_.

                                                                          {
   
    //add if "none" ..
   analyzeEvent(e);
   analyzeGenerator(e);
   analyzeSimulation(e);
   analyzeGMT(e);
   analyzeGT(e);
   analyzeGCT(e);
   analyzeRCT(e);
   analyzeDTTF(e);
   analyzeCSCTF(e,es); 
   //  pL1calotp->Reset();
   //  analyzeECAL(e, es);
   //  analyzeHCAL(e, es);                           
 
   tree_->Fill();
 
 }

void L1NtupleProducer::analyzeCSCTF	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)

private

Definition at line 448 of file L1NtupleProducer.cc.

References pL1csctf, and L1Analysis::L1AnalysisCSCTF::Reset().

Referenced by analyze().

 {
  
   pL1csctf->Reset();
 
   //csctf (tracks)
   // if( csctfTrkSource_.label() != "none" )
   // {   
   //    if( es.get< L1MuTriggerScalesRcd > ().cacheIdentifier() != m_scalesCacheID ||
   //        es.get< L1MuTriggerPtScaleRcd >().cacheIdentifier() != m_ptScaleCacheID ){
       
   //     edm::ESHandle< L1MuTriggerScales > scales;
   //     es.get< L1MuTriggerScalesRcd >().get(scales);
   //     ts = scales.product();
   //     edm::ESHandle< L1MuTriggerPtScale > ptscales;
   //     es.get< L1MuTriggerPtScaleRcd >().get(ptscales);
   //     tpts = ptscales.product();
   //     m_scalesCacheID  = es.get< L1MuTriggerScalesRcd  >().cacheIdentifier();
   //     m_ptScaleCacheID = es.get< L1MuTriggerPtScaleRcd >().cacheIdentifier();
       
   //     edm::LogInfo("L1NtupleProducer") << "Changing triggerscales and triggerptscales for CSCTF...\n";
   //    }    
 
   //    // initialize ptLUTs from a PSet if the flag is True
   //    if( initCSCTFPtLutsPSet ) 
   //      {
   //        // set it only if the pointer is empty
   //        if (csctfPtLUTs_ == NULL) {
   //          edm::LogInfo("L1NtupleProducer") << "Initializing csctf pt LUTs from PSet...";
   //          csctfPtLUTs_ = new CSCTFPtLUT(csctfPtLutsPSet, ts, tpts);
   //        }
   //      } 
 
      // otherwise use the O2O mechanism
    //   else if (es.get< L1MuCSCPtLutRcd > ().cacheIdentifier() != m_csctfptlutCacheID )
    //     {
    //       edm::LogInfo("L1NtupleProducer") << "  Initializing the CSCTF ptLUTs via O2O mechanism...";
    //       // initializing the ptLUT from O2O
    //       csctfPtLUTs_ = new CSCTFPtLUT(es);
       
    //       m_csctfptlutCacheID = es.get< L1MuCSCPtLutRcd > ().cacheIdentifier();
    //       edm::LogInfo("L1NtupleProducer") << "  Changed the cache ID for CSCTF ptLUTs...";
    //     }
      
    //   if (csctfPtLUTs_ == NULL)
    //     edm::LogWarning("L1NtupleProducer")<<"  No valid CSCTFPtLUT initialized!";
 
     
    //   edm::Handle<L1CSCTrackCollection> csctfTrks;
    //   e.getByToken(csctfTrkSource_,csctfTrks);
      
    //   if( csctfTrks.isValid() && csctfPtLUTs_) 
    //     pL1csctf->SetTracks(csctfTrks, ts, tpts, srLUTs_, csctfPtLUTs_);
    //   else 
    //     edm::LogInfo("L1NtupleProducer")<<" No valid L1CSCTrackCollection products found"
    //                                     <<" or ptLUT pointer(" << csctfPtLUTs_ <<") null";
        
           
    // } else 
    //  edm::LogInfo("L1NtupleProducer")<<" No valid L1CSCTrackCollection products found";
      
      
       
   //ALL csctf lcts
   // if(!csctfLCTSource_.isUninitialized())
   // {
   //    edm::Handle<CSCCorrelatedLCTDigiCollection> corrlcts;
   //    e.getByToken(csctfLCTSource_,corrlcts);
   //    if( corrlcts.isValid() ) pL1csctf->SetLCTs(corrlcts, srLUTs_);
   //  } else 
   //   edm::LogInfo("L1NtupleProducer")<<"  No valid CSCCorrelatedLCTDigiCollection products found";
 
            
   //csctf status
   // if(!csctfStatusSource_.isUninitialized())
   // {
   //    edm::Handle<L1CSCStatusDigiCollection> status;
   //    e.getByToken(csctfStatusSource_,status);  
   //    if( status.isValid() ) pL1csctf->SetStatus(status);
   //  } else 
   //    edm::LogInfo("L1NtupleProducer")<<"  No valid L1CSCTrackCollection products found";  
 
   //dt stubs
   // if(!csctfDTStubsSource_.isUninitialized()) {
   //   edm::Handle<CSCTriggerContainer<csctf::TrackStub> > dtStubs;
   //   e.getByToken(csctfDTStubsSource_,dtStubs);  
   //   if( dtStubs.isValid() ) {
   //     pL1csctf->SetDTStubs(dtStubs);
   //   } else {
   //     edm::LogInfo("L1NtupleProducer")<<"  No valid DT TrackStub products found";    
   //   }
   // } else
   //   edm::LogInfo("L1NtupleProducer")<<"  Label for DTStubsSource is set to none"
       ;
 }  

void L1NtupleProducer::analyzeDTTF ( const edm::Event & e )

private

Definition at line 323 of file L1NtupleProducer.cc.

References pL1dttf, and L1Analysis::L1AnalysisDTTF::Reset().

Referenced by analyze().

 {
   
   pL1dttf->Reset();
 
   // edm::Handle<L1MuDTChambPhContainer > myL1MuDTChambPhContainer;  
   // e.getByToken(dttfSource_,myL1MuDTChambPhContainer);
   // if (myL1MuDTChambPhContainer.isValid()) {
   //  pL1dttf->SetDTPH(myL1MuDTChambPhContainer, maxDTPH_);
   // }
   // edm::Handle<L1MuDTChambThContainer > myL1MuDTChambThContainer;  
   // e.getByToken(dttfSource_,myL1MuDTChambThContainer);
   // if (myL1MuDTChambThContainer.isValid()) {
   //   pL1dttf->SetDTTH(myL1MuDTChambThContainer, maxDTTH_);
   // }
 
   // edm::Handle<L1MuDTTrackContainer > myL1MuDTTrackContainer;
   // edm::InputTag trInputTag(trstring);
   // e.getByToken(trInputTag,myL1MuDTTrackContainer);
   // if (myL1MuDTTrackContainer.isValid()) {
   //   pL1dttf->SetDTTR(myL1MuDTTrackContainer, maxDTTR_);
   // }
   // else {
   //   e.getByToken(trInputTag,myL1MuDTTrackContainer);
   //   if (myL1MuDTTrackContainer.isValid()) {
   //     pL1dttf->SetDTTR(myL1MuDTTrackContainer, maxDTTR_);
   //   }
   //   else {
   //     edm::LogInfo("L1Prompt") << "can't find L1MuDTTrackContainer " << dttfSource_.label();
   //   }
   // }
 
 }

void L1NtupleProducer::analyzeECAL	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)

private

Definition at line 544 of file L1NtupleProducer.cc.

References edm::eventsetup::EventSetupRecord::cacheIdentifier(), ecalScaleCacheID_, ecalSource_, edm::EventSetup::get(), edm::Event::getByToken(), edm::HandleBase::isValid(), pL1calotp, edm::Handle< T >::product(), edm::ESHandle< class >::product(), L1Analysis::L1AnalysisCaloTP::SetECAL(), and L1Analysis::L1AnalysisCaloTP::setEcalScale().

                                                                              {
 
   if( es.get< L1CaloEcalScaleRcd > ().cacheIdentifier() != ecalScaleCacheID_ ) {
     edm::ESHandle<L1CaloEcalScale> ecalScale;
     es.get<L1CaloEcalScaleRcd>().get(ecalScale);
     pL1calotp->setEcalScale( ecalScale.product() );
     ecalScaleCacheID_ = es.get< L1CaloEcalScaleRcd > ().cacheIdentifier();
   }
 
   if(!ecalSource_.isUninitialized()) {
     
     edm::Handle< EcalTrigPrimDigiCollection > ecalTPs;
     e.getByToken(ecalSource_,ecalTPs);
 
     if( ecalTPs.isValid() ) {
       pL1calotp->SetECAL( *ecalTPs.product());
     } else {
       edm::LogInfo("L1NtupleProducer")<<"  No valid ECAL trigger primitives found";
     }
   } else
     edm::LogInfo("L1NtupleProducer")<<"  Label for ECAL trig prims is set to none";
 
 }

void L1NtupleProducer::analyzeEvent ( const edm::Event & e )

private

Definition at line 234 of file L1NtupleProducer.cc.

References hltSource_, edm::EDGetTokenT< T >::isUninitialized(), pL1evt, L1Analysis::L1AnalysisEvent::Reset(), and L1Analysis::L1AnalysisEvent::Set().

Referenced by analyze().

                                                      { 
   
   if(!hltSource_.isUninitialized()) {
     pL1evt->Reset();
     pL1evt->Set(e,hltSource_); 
   }
 }

void L1NtupleProducer::analyzeGCT ( const edm::Event & e )

private

Definition at line 359 of file L1NtupleProducer.cc.

References pL1gct, and L1Analysis::L1AnalysisGCT::Reset().

Referenced by analyze().

 {
  
   pL1gct->Reset();
   
     
   // edm::Handle < L1GctEmCandCollection > l1IsoEm;
   // e.getByToken(gctIsoEmSource_, l1IsoEm);
   // if (!l1IsoEm.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1IsoEm "" elements, label was " << gctIsoEmSource_ ;
   
   // edm::Handle < L1GctEmCandCollection > l1NonIsoEm;
   // e.getByToken(gctNonIsoEmSource_, l1NonIsoEm);
   // if (!l1NonIsoEm.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1NonIsoEm "" elements, label was " << gctNonIsoEmSource_ ;
     
   // if (l1IsoEm.isValid() && l1NonIsoEm.isValid())
   //   pL1gct->SetEm(l1IsoEm, l1NonIsoEm);
   // else 
   //   pL1gct_data->Init();
   
   
   // edm::Handle < L1GctJetCandCollection > l1CenJets;
   // e.getByToken(gctCenJetsSource_, l1CenJets);
   // if (!l1CenJets.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1CenJets"", label was " << gctCenJetsSource_ ;
     
   // edm::Handle < L1GctJetCandCollection > l1ForJets;
   // e.getByToken(gctForJetsSource_, l1ForJets);
   // if (!l1ForJets.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1ForJets"", label was " << gctForJetsSource_ ;  
   
   // edm::Handle < L1GctJetCandCollection > l1TauJets;
   // e.getByToken(gctTauJetsSource_, l1TauJets);
   // if (!l1TauJets.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1TauJets"", label was " << gctTauJetsSource_;
 
   // edm::Handle < L1GctJetCandCollection > l1IsoTauJets;
   // e.getByToken(gctIsoTauJetsSource_, l1IsoTauJets);
   // if (!l1IsoTauJets.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1IsoTauJets"", label was " << gctIsoTauJetsSource_;
   
   // if (l1CenJets.isValid() && l1ForJets.isValid() && l1TauJets.isValid()) 
   //   pL1gct->SetJet(l1CenJets, l1ForJets, l1TauJets, l1IsoTauJets);
   
   
   // edm::Handle < L1GctHFRingEtSumsCollection > l1HFSums; 
   // e.getByToken(gctHFSumsSource_, l1HFSums); 
   // if (!l1HFSums.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1HFSums"", label was " << gctEnergySumsSource_ ;
     
   // edm::Handle < L1GctHFBitCountsCollection > l1HFCounts;
   // e.getByToken(gctHFBitsSource_, l1HFCounts);
   // if (!l1HFCounts.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1HFCounts"", label was " << gctEnergySumsSource_ ;
  
   // if (l1HFSums.isValid() && l1HFCounts.isValid()) 
   // pL1gct->SetHFminbias(l1HFSums, l1HFCounts);    
   
   
   // edm::Handle < L1GctEtMissCollection >  l1EtMiss;
   // e.getByToken(gctETMSource_, l1EtMiss);
   // if (!l1EtMiss.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1EtMiss"", label was " << gctEnergySumsSource_ ;
 
   // edm::Handle < L1GctHtMissCollection >  l1HtMiss;
   // e.getByToken(gctHTMSource_, l1HtMiss);
   // if (!l1HtMiss.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1HtMiss"", label was " << gctEnergySumsSource_ ;
   
   // edm::Handle < L1GctEtHadCollection >   l1EtHad;
   // e.getByToken(gctHTTSource_, l1EtHad);
   // if (!l1EtHad.isValid())
   //   edm::LogWarning("DataNotFound") << " Could not find l1EtHad"", label was " << gctEnergySumsSource_ ;
   
   // edm::Handle < L1GctEtTotalCollection > l1EtTotal;
   // e.getByToken(gctETTSource_, l1EtTotal);
   // if (!l1EtTotal.isValid())  
   //   edm::LogWarning("DataNotFound") << " Could not find l1EtTotal"", label was " << gctEnergySumsSource_ ;
  
   // if (l1EtMiss.isValid() && l1HtMiss.isValid() && l1EtHad.isValid() && l1EtTotal.isValid())
   //   pL1gct->SetES(l1EtMiss, l1HtMiss, l1EtHad, l1EtTotal);
 
 }

void L1NtupleProducer::analyzeGenerator ( const edm::Event & e )

private

Definition at line 242 of file L1NtupleProducer.cc.

References generatorSource_, edm::EDGetTokenT< T >::isUninitialized(), pL1generator, and L1Analysis::L1AnalysisGenerator::Reset().

Referenced by analyze().

                                                          {
 
   if(!generatorSource_.isUninitialized()) {
     pL1generator->Reset();
     //    pL1generator->Set(e);
   }  
 
 }

void L1NtupleProducer::analyzeGMT ( const edm::Event & e )

private

Definition at line 259 of file L1NtupleProducer.cc.

References gmtSource_, edm::EDGetTokenT< T >::isUninitialized(), pL1gmt, and L1Analysis::L1AnalysisGMT::Reset().

Referenced by analyze().

                                                    {
   
   pL1gmt->Reset();
   
   if (!gmtSource_.isUninitialized()) {
     // edm::Handle<L1MuGMTReadoutCollection> gmtrc_handle; 
     // e.getByToken(gmtSource_,gmtrc_handle);
     // L1MuGMTReadoutCollection const* gmtrc = gmtrc_handle.product();
     
     // pL1gmt->Set(gmtrc, maxDTBX_, maxCSC_, maxRPC_, maxGMT_, physVal_);
   }
 }

void L1NtupleProducer::analyzeGT ( const edm::Event & e )

private

Definition at line 273 of file L1NtupleProducer.cc.

References gtEvmSource_, gtSource_, edm::EDGetTokenT< T >::isUninitialized(), pL1gt, and L1Analysis::L1AnalysisGT::Reset().

Referenced by analyze().

                                                   {
   
   pL1gt->Reset();
   
   if (!gtEvmSource_.isUninitialized()) {
     // edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtevmrr_handle;
     // e.getByToken(gtEvmSource_, gtevmrr_handle);
     // L1GlobalTriggerEvmReadoutRecord const* gtevmrr = gtevmrr_handle.product();
 
     // L1TcsWord tcsw = gtevmrr->tcsWord();
 
     // pL1evt_data->bx = tcsw.bxNr();
     // pL1evt_data->orbit = tcsw.orbitNr();
     // //pL1evt->lumi = tcsw.luminositySegmentNr();
     // //pL1evt->run = tcsw.partRunNr();
     // //pL1evt->event = tcsw.partTrigNr();
 
     // pL1gt->SetEvm(gtevmrr);
   }
 
    
   if (!gtSource_.isUninitialized()) {
     // edm::Handle<L1GlobalTriggerReadoutRecord> gtrr_handle;
     // e.getByToken(gtSource_, gtrr_handle);
     // L1GlobalTriggerReadoutRecord const* gtrr = gtrr_handle.product();
 
     // pL1gt->Set(gtrr);
   }
 }

void L1NtupleProducer::analyzeHCAL	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)

private

Definition at line 568 of file L1NtupleProducer.cc.

References edm::EventSetup::get(), edm::Event::getByToken(), hcalScaleCacheID_, hcalSource_, edm::HandleBase::isValid(), pL1calotp, edm::Handle< T >::product(), edm::ESHandle< class >::product(), L1Analysis::L1AnalysisCaloTP::SetHCAL(), and L1Analysis::L1AnalysisCaloTP::setHcalScale().

                                                                              {
 
   //  if( es.get< L1CaloHcalScaleRcd > ().cacheIdentifier() != hcalScaleCacheID_ ) {
     edm::ESHandle<L1CaloHcalScale> hcalScale;
     es.get<L1CaloHcalScaleRcd>().get(hcalScale);
     pL1calotp->setHcalScale( hcalScale.product() );
     hcalScaleCacheID_ = es.get< L1CaloHcalScaleRcd > ().cacheIdentifier();
     //  }  
 
     if (!hcalSource_.isUninitialized()) {
 
       edm::Handle< HcalTrigPrimDigiCollection > hcalTPs;
       e.getByToken(hcalSource_,hcalTPs);
       
       if( hcalTPs.isValid() ) {
     pL1calotp->SetHCAL(*hcalTPs.product());
       } else {
     edm::LogInfo("L1NtupleProducer")<<"  No valid HCAL trigger primitives found";
       }
     } else
       edm::LogInfo("L1NtupleProducer")<<"  Label for HCAL trig prims is set to none";
     
 }

void L1NtupleProducer::analyzeRCT ( const edm::Event & e )

private

Definition at line 305 of file L1NtupleProducer.cc.

References pL1rct, and L1Analysis::L1AnalysisRCT::Reset().

Referenced by analyze().

                                                    {
   
   pL1rct->Reset();
   
   // edm::Handle < L1CaloEmCollection > em;
   // e.getByToken(rctSource_,em);
   // if (!em.isValid()) {
   //   pL1rct->SetEmRCT(em);
   // }
   // edm::Handle < L1CaloRegionCollection > rgn;
   // e.getByToken(rctSource_,rgn);
   // if (!rgn.isValid()) { 
   //   pL1rct->SetHdRCT(rgn);
   // }
 
 }

void L1NtupleProducer::analyzeSimulation ( const edm::Event & e )

private

Definition at line 251 of file L1NtupleProducer.cc.

References pL1simulation, and L1Analysis::L1AnalysisSimulation::Reset().

Referenced by analyze().

                                                           {
 
   pL1simulation->Reset();
   //  pL1simulation->Set(e);
 
 }

void L1NtupleProducer::beginJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 202 of file L1NtupleProducer.cc.

202 {

203 }

void L1NtupleProducer::book ( )

private

Definition at line 596 of file L1NtupleProducer.cc.

References csctfDTStubsSource_, csctfLCTSource_, csctfStatusSource_, csctfTrkSource_, dttfPhSource_, dttfThSource_, dttfTrkSource_, ecalSource_, gctCenJetsSource_, gctETMSource_, gctETTSource_, gctForJetsSource_, gctHFBitsSource_, gctHFSumsSource_, gctHTMSource_, gctHTTSource_, gctIsoEmSource_, gctNonIsoEmSource_, gctTauJetsSource_, generatorSource_, gmtSource_, gtSource_, hcalSource_, edm::EDGetTokenT< T >::isUninitialized(), pL1calotp_data, pL1csctf_data, pL1dttf_data, pL1evt_data, pL1gct_data, pL1generator_data, pL1gmt_data, pL1gt_data, pL1rct_data, pL1simulation_data, rctEmSource_, rctRgnSource_, and tree_.

Referenced by L1NtupleProducer().

                             {
 
   tree_->Branch("Event", "L1Analysis::L1AnalysisEventDataFormat", &pL1evt_data, 32000, 3);
 
   tree_->Branch("Simulation", "L1Analysis::L1AnalysisSimulationDataFormat", &pL1simulation_data, 32000, 3);
    
   if (!gctCenJetsSource_.isUninitialized() || 
       !gctForJetsSource_.isUninitialized() || 
       !gctTauJetsSource_.isUninitialized() || 
       !gctETTSource_.isUninitialized() || 
       !gctETMSource_.isUninitialized() || 
       !gctHTTSource_.isUninitialized() || 
       !gctHTMSource_.isUninitialized() || 
       !gctHFSumsSource_.isUninitialized() || 
       !gctHFBitsSource_.isUninitialized() || 
       !gctIsoEmSource_.isUninitialized() || 
       !gctNonIsoEmSource_.isUninitialized())
   tree_->Branch("GCT", "L1Analysis::L1AnalysisGCTDataFormat", &pL1gct_data, 32000, 3);
 
   if (!generatorSource_.isUninitialized()) 
     tree_->Branch("Generator", "L1Analysis::L1AnalysisGeneratorDataFormat", &pL1generator_data, 32000, 3);
   
   if (!gmtSource_.isUninitialized())   
     tree_->Branch("GMT", "L1Analysis::L1AnalysisGMTDataFormat", &pL1gmt_data, 32000, 3);
     
   if (!gtSource_.isUninitialized()) 
     tree_->Branch("GT", "L1Analysis::L1AnalysisGTDataFormat", &pL1gt_data, 32000, 3);
      
   if (!rctRgnSource_.isUninitialized() && !rctEmSource_.isUninitialized()) 
     tree_->Branch("RCT", "L1Analysis::L1AnalysisRCTDataFormat", &pL1rct_data, 32000, 3);
 
   if (!dttfPhSource_.isUninitialized() &&
       !dttfThSource_.isUninitialized() &&
       !dttfTrkSource_.isUninitialized())
   tree_->Branch("DTTF", "L1Analysis::L1AnalysisDTTFDataFormat", &pL1dttf_data, 32000, 3);
   if (!csctfTrkSource_.isUninitialized() ||
       !csctfLCTSource_.isUninitialized() ||
       !csctfStatusSource_.isUninitialized() ||
       !csctfDTStubsSource_.isUninitialized() ) 
   tree_->Branch("CSCTF", "L1Analysis::L1AnalysisCSCTFDataFormat", &pL1csctf_data, 32000, 3);
 
   if (!ecalSource_.isUninitialized() && !hcalSource_.isUninitialized()) {
     tree_->Branch("CALO", "L1Analysis::L1AnalysisCaloTPDataFormat", &pL1calotp_data, 32000, 3);
   }
 
 }

void L1NtupleProducer::endJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 205 of file L1NtupleProducer.cc.

                               {
 
 }

void L1NtupleProducer::initCSCTF ( )

private

Definition at line 643 of file L1NtupleProducer.cc.

References edm::ParameterSet::addUntrackedParameter(), Reference_intrackfit_cff::endcap, srLUTs_, relativeConstraints::station, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by L1NtupleProducer().

                                  {
   
   // csctf does not preserve information about the LCT (stubs) which forms
   // the track so we need to retrieve this information. In order to do so
   // we need to initialize the Sector Receiver LUTs in the software
   
   bzero(srLUTs_ , sizeof(srLUTs_));
   int sector=1;    // assume SR LUTs are all same for every sector
   bool TMB07=true; // specific TMB firmware
   // Create a pset for SR/PT LUTs: if you do not change the value in the 
   // configuration file, it will load the default minitLUTs
   edm::ParameterSet srLUTset;
   srLUTset.addUntrackedParameter<bool>("ReadLUTs", false);
   srLUTset.addUntrackedParameter<bool>("Binary",   false);
   srLUTset.addUntrackedParameter<std::string>("LUTPath", "./");
  
    // positive endcap
   int endcap = 1; 
   for(int station=1,fpga=0; station<=4 && fpga<5; station++)
     {
       if(station==1)
     for(int subSector=0; subSector<2 && fpga<5; subSector++)
       srLUTs_[fpga++][1] = new CSCSectorReceiverLUT(endcap,sector,subSector+1,
                             station, srLUTset, TMB07);
       else
     srLUTs_[fpga++][1]   = new CSCSectorReceiverLUT(endcap,  sector,   0, 
                             station, srLUTset, TMB07);
     }
 
   // negative endcap
   endcap = 2; 
   for(int station=1,fpga=0; station<=4 && fpga<5; station++)
     {
       if(station==1)
     for(int subSector=0; subSector<2 && fpga<5; subSector++)
       srLUTs_[fpga++][0] = new CSCSectorReceiverLUT(endcap,sector,subSector+1,
                             station, srLUTset, TMB07);
       else
     srLUTs_[fpga++][0]   = new CSCSectorReceiverLUT(endcap,  sector,   0, 
                             station, srLUTset, TMB07);
     }
  
 }