#include <MuonCandProducerMon.h>

Inheritance diagram for MuonCandProducerMon:

Public Member Functions
	MuonCandProducerMon (const edm::ParameterSet &)

	~MuonCandProducerMon ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

Private Member Functions
virtual void	beginJob (void)

virtual void	endJob ()

virtual void	produce (edm::Event &, const edm::EventSetup &)

int	verbose ()

Private Attributes
edm::InputTag	CSCinput_

CSCTFPtLUT *	cscPtLUT_

edm::InputTag	DTinput_

unsigned long long	m_ptScaleCacheID

unsigned long long	m_scalesCacheID

int	verbose_

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

typedef WorkerT< EDProducer >	WorkerType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Detailed Description

Definition at line 32 of file MuonCandProducerMon.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 10 of file MuonCandProducerMon.cc.

References CSCinput_, cscPtLUT_, DTinput_, edm::ParameterSet::getUntrackedParameter(), m_ptScaleCacheID, m_scalesCacheID, and verbose_.

                                                                     {
 
     verbose_ = pset.getUntrackedParameter<int>("VerboseFlag", 0);
 
     CSCinput_ = pset.getUntrackedParameter<edm::InputTag>("CSCinput",
             (edm::InputTag) ("csctfdigis"));
     DTinput_ = pset.getUntrackedParameter<edm::InputTag>("DTinput",
             (edm::InputTag) ("dttfdigis"));
 
     cscPtLUT_ = 0;
     m_scalesCacheID = 0;
     m_ptScaleCacheID = 0;
 
     produces<std::vector<L1MuRegionalCand> >("CSC");
     produces<std::vector<L1MuRegionalCand> >("DT");
 }

MuonCandProducerMon::~MuonCandProducerMon ( )

Definition at line 27 of file MuonCandProducerMon.cc.

27 {

28 }

Member Function Documentation

virtual void MuonCandProducerMon::beginJob ( void )

inlineprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 40 of file MuonCandProducerMon.h.

40 {};

void MuonCandProducerMon::endJob ( void )

privatevirtual

Reimplemented from edm::EDProducer.

Definition at line 30 of file MuonCandProducerMon.cc.

References cscPtLUT_.

                                  {
     if (cscPtLUT_)
         delete cscPtLUT_;
 }

void MuonCandProducerMon::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Implements edm::EDProducer.

Definition at line 35 of file MuonCandProducerMon.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::addUntrackedParameter(), edm::eventsetup::EventSetupRecord::cacheIdentifier(), CSCinput_, cscPtLUT_, csc::L1Track::decodeRank(), DTinput_, edm::EventSetup::get(), edm::Event::getByLabel(), edm::HandleBase::isValid(), m_ptScaleCacheID, m_scalesCacheID, edm::ESHandle< class >::product(), CSCTFPtLUT::Pt(), and edm::Event::put().

                                      {
 
     edm::Handle<L1CSCTrackCollection> CSCtracks;
     iEvent.getByLabel(CSCinput_, CSCtracks);
 
     edm::Handle<L1MuDTTrackContainer> DTtracks;
     iEvent.getByLabel(DTinput_, DTtracks);
 
     std::auto_ptr<std::vector<L1MuRegionalCand> > csc_product(
             new std::vector<L1MuRegionalCand>);
 
     std::auto_ptr<std::vector<L1MuRegionalCand> > dt_product(
             new std::vector<L1MuRegionalCand>);
 
     if (!CSCtracks.isValid()) {
 
         csc_product->push_back(L1MuRegionalCand());
 
     } else {
 
         typedef L1CSCTrackCollection::const_iterator ctcIt;
 
         for (ctcIt tcit = CSCtracks->begin(); tcit != CSCtracks->end(); tcit++) {
 
             L1MuRegionalCand cand(tcit->first.getDataWord(), tcit->first.bx());
 
             // set pt value
 
             // Update CSCTFTrackBuilder only if the scales have changed.  Use the
             // EventSetup cacheIdentifier to tell when this has happened.
             if (iSetup.get<L1MuTriggerScalesRcd>().cacheIdentifier()
                     != m_scalesCacheID
                     || iSetup.get<L1MuTriggerPtScaleRcd>().cacheIdentifier()
                             != m_ptScaleCacheID) {
                 if (cscPtLUT_)
                     delete cscPtLUT_;
                 edm::ESHandle<L1MuTriggerScales> scales;
                 iSetup.get<L1MuTriggerScalesRcd>().get(scales);
                 edm::ESHandle<L1MuTriggerPtScale> ptScale;
                 iSetup.get<L1MuTriggerPtScaleRcd>().get(ptScale);
                 // Create a dummy pset for CSC Pt LUTs
 
                 edm::ParameterSet ptLUTset;
                 ptLUTset.addParameter<bool>("ReadPtLUT", false);
                 ptLUTset.addParameter<bool>("isBinary", false);
                 ptLUTset.addUntrackedParameter<std::string>("LUTPath", "./");
 
                 cscPtLUT_ = new CSCTFPtLUT(ptLUTset, scales.product(),
                         ptScale.product());
                 m_scalesCacheID
                         = iSetup.get<L1MuTriggerScalesRcd>().cacheIdentifier();
                 m_ptScaleCacheID
                         = iSetup.get<L1MuTriggerPtScaleRcd>().cacheIdentifier();
             }
 
             ptadd thePtAddress(tcit->first.ptLUTAddress());
             ptdat thePtData = cscPtLUT_->Pt(thePtAddress);
             const unsigned int rank =
                     (thePtAddress.track_fr ? thePtData.front_rank
                             : thePtData.rear_rank);
             unsigned int quality = 0;
             unsigned int pt = 0;
             csc::L1Track::decodeRank(rank, pt, quality);
             cand.setQualityPacked(quality & 0x3);
             cand.setPtPacked(pt & 0x1f);
             csc_product->push_back(cand);
         }
     }
 
     if (!DTtracks.isValid()) {
 
         dt_product->push_back(L1MuRegionalCand());
 
     } else {
 
         typedef std::vector<L1MuDTTrackCand>::const_iterator ctcIt;
 
         std::vector<L1MuDTTrackCand> *dttc = DTtracks->getContainer();
 
         for (ctcIt it = dttc->begin(); it != dttc->end(); it++) {
             dt_product->push_back(L1MuRegionalCand(*it));
         }
     }
 
     iEvent.put(csc_product, "CSC");
     iEvent.put(dt_product, "DT");
 }