#include <myTKAnalyses/DigiInvestigator/src/OccupancyPlots.cc>

Inheritance diagram for OccupancyPlots:

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

	~OccupancyPlots () override

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

	~EDAnalyzer () override

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

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

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	endJob () override

void	endRun (const edm::Run &, const edm::EventSetup &) override

Private Attributes
TProfile **	m_avemultiplicity

TProfile **	m_aveoccupancy

TProfile **	m_averadius

TProfile **	m_avex

TProfile **	m_avey

TProfile **	m_avez

edm::FileInPath	m_fp

std::vector< edm::EDGetTokenT< std::map< unsigned int, int > > >	m_multiplicityMapTokens

TH1F **	m_nchannels_ideal

TH1F **	m_nchannels_real

std::vector< edm::EDGetTokenT< std::map< unsigned int, int > > >	m_occupancyMapTokens

RunHistogramManager	m_rhm

std::map< unsigned int, DetIdSelector >	m_wantedsubdets

TProfile **	m_xavedr

TProfile **	m_xavedrphi

TProfile **	m_xavedz

TProfile **	m_yavedr

TProfile **	m_yavedrphi

TProfile **	m_yavedz

TProfile **	m_zavedr

TProfile **	m_zavedrphi

TProfile **	m_zavedz

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

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 67 of file OccupancyPlots.cc.

Constructor & Destructor Documentation

OccupancyPlots::OccupancyPlots ( const edm::ParameterSet & iConfig )

explicit

Definition at line 123 of file OccupancyPlots.cc.

References edm::EDConsumerBase::consumesCollector(), m_avemultiplicity, m_aveoccupancy, m_averadius, m_avex, m_avey, m_avez, m_fp, m_nchannels_ideal, m_nchannels_real, m_occupancyMapTokens, m_rhm, m_wantedsubdets, m_xavedr, m_xavedrphi, m_xavedz, m_yavedr, m_yavedrphi, m_yavedz, m_zavedr, m_zavedrphi, m_zavedz, RunHistogramManager::makeTH1F(), RunHistogramManager::makeTProfile(), GlobalPosition_Frontier_DevDB_cff::tag, and edm::vector_transform().

                                                             :
   m_multiplicityMapTokens(edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag> >("multiplicityMaps"), [this](edm::InputTag const & tag){return consumes<std::map<unsigned int, int> >(tag);})),
   m_occupancyMapTokens(edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag> >("occupancyMaps"), [this](edm::InputTag const & tag){return consumes<std::map<unsigned int, int> >(tag);})),
   m_fp(iConfig.getUntrackedParameter<edm::FileInPath>("file",edm::FileInPath("CalibTracker/SiPixelESProducers/data/PixelSkimmedGeometry.txt"))),
   m_rhm(consumesCollector()), m_wantedsubdets()
 {
    //now do what ever initialization is needed
 
   m_avemultiplicity = m_rhm.makeTProfile("avemult","Average Multiplicty",6000,0.5,6000.5);
   m_aveoccupancy = m_rhm.makeTProfile("aveoccu","Average Occupancy",6000,0.5,6000.5);
 
   m_nchannels_ideal = m_rhm.makeTH1F("nchannels_ideal","Number of channels (ideal)",6000,0.5,6000.5);
   m_nchannels_real = m_rhm.makeTH1F("nchannels_real","Number of channels (real)",6000,0.5,6000.5);
 
   m_averadius = m_rhm.makeTProfile("averadius","Average Module Radius",6000,0.5,6000.5);
   m_avez = m_rhm.makeTProfile("avez","Average Module z coordinate",6000,0.5,6000.5);
   m_avex = m_rhm.makeTProfile("avex","Average Module x coordinate",6000,0.5,6000.5);
   m_avey = m_rhm.makeTProfile("avey","Average Module y coordinate",6000,0.5,6000.5);
 
   m_zavedr = m_rhm.makeTProfile("zavedr","Average z unit vector dr",6000,0.5,6000.5);
   m_zavedz = m_rhm.makeTProfile("zavedz","Average z unit vector dz",6000,0.5,6000.5);
   m_zavedrphi = m_rhm.makeTProfile("zavedrphi","Average z unit vector drphi",6000,0.5,6000.5);
   m_xavedr = m_rhm.makeTProfile("xavedr","Average x unit vector dr",6000,0.5,6000.5);
   m_xavedz = m_rhm.makeTProfile("xavedz","Average x unit vctor dz",6000,0.5,6000.5);
   m_xavedrphi = m_rhm.makeTProfile("xavedrphi","Average Module x unit vector drphi",6000,0.5,6000.5);
   m_yavedr = m_rhm.makeTProfile("yavedr","Average y unit vector dr",6000,0.5,6000.5);
   m_yavedz = m_rhm.makeTProfile("yavedz","Average y unit vector dz",6000,0.5,6000.5);
   m_yavedrphi = m_rhm.makeTProfile("yavedrphi","Average y unit vector drphi",6000,0.5,6000.5);
 
   std::vector<edm::ParameterSet> wantedsubdets_ps = iConfig.getParameter<std::vector<edm::ParameterSet> >("wantedSubDets");
 
   for(std::vector<edm::ParameterSet>::const_iterator wsdps = wantedsubdets_ps.begin();wsdps!=wantedsubdets_ps.end();++wsdps) {
 
     unsigned int detsel = wsdps->getParameter<unsigned int>("detSelection");
     std::vector<std::string> selstr = wsdps->getUntrackedParameter<std::vector<std::string> >("selection");
     m_wantedsubdets[detsel]=DetIdSelector(selstr);
 
   }
 
 
 }

OccupancyPlots::~OccupancyPlots ( )

override

Definition at line 166 of file OccupancyPlots.cc.

 {
 
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 
 }

Member Function Documentation

void OccupancyPlots::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 181 of file OccupancyPlots.cc.

References edm::Event::getByToken(), m_avemultiplicity, m_aveoccupancy, m_multiplicityMapTokens, and m_occupancyMapTokens.

 {
   using namespace edm;
 
 
   for(std::vector<edm::EDGetTokenT<std::map<unsigned int, int> > >::const_iterator mapToken = m_multiplicityMapTokens.begin();mapToken!=m_multiplicityMapTokens.end();++mapToken) {
 
     Handle<std::map<unsigned int, int> > mults;
     iEvent.getByToken(*mapToken,mults);
 
     for(std::map<unsigned int,int>::const_iterator mult=mults->begin();mult!=mults->end();mult++) {
       if(m_avemultiplicity && *m_avemultiplicity) (*m_avemultiplicity)->Fill(mult->first,mult->second);
     }
   }
 
 
 
   for(std::vector<edm::EDGetTokenT<std::map<unsigned int, int> > >::const_iterator mapToken = m_occupancyMapTokens.begin();mapToken!=m_occupancyMapTokens.end();++mapToken) {
 
     Handle<std::map<unsigned int, int> > occus;
     iEvent.getByToken(*mapToken,occus);
 
     for(std::map<unsigned int,int>::const_iterator occu=occus->begin();occu!=occus->end();occu++) {
       if(m_aveoccupancy && *m_aveoccupancy) (*m_aveoccupancy)->Fill(occu->first,occu->second);
     }
   }
 
 }

void OccupancyPlots::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 213 of file OccupancyPlots.cc.

 {
 
 }

void OccupancyPlots::beginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 219 of file OccupancyPlots.cc.

References RunHistogramManager::beginRun(), and m_rhm.

                                                                         {
 
   m_rhm.beginRun(iRun);
 
 }

void OccupancyPlots::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 374 of file OccupancyPlots.cc.

References DEFINE_FWK_MODULE.

374 {

375 }

void OccupancyPlots::endRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 226 of file OccupancyPlots.cc.

                                                                       {
 
 
   //  edm::ESHandle<GlobalTrackingGeometry> trkgeo;
   //  iSetup.get<GlobalTrackingGeometryRecord>().get("",trkgeo);
   edm::ESHandle<TrackerGeometry> trkgeo;
   iSetup.get<TrackerDigiGeometryRecord>().get("",trkgeo);
 
   // Test new TrackerGeometry features
   LogDebug("IsThereTest") << "Test of TrackerGeometry::isThere";
   LogTrace("IsThereTest") << " is there PixelBarrel: " << trkgeo->isThere(GeomDetEnumerators::PixelBarrel);
   LogTrace("IsThereTest") << " is there PixelEndcap: " << trkgeo->isThere(GeomDetEnumerators::PixelEndcap);
   LogTrace("IsThereTest") << " is there P1PXB: " << trkgeo->isThere(GeomDetEnumerators::P1PXB);
   LogTrace("IsThereTest") << " is there P1PXEC: " << trkgeo->isThere(GeomDetEnumerators::P1PXEC);
   LogTrace("IsThereTest") << " is there P2PXB: " << trkgeo->isThere(GeomDetEnumerators::P2PXB);
   LogTrace("IsThereTest") << " is there P2PXEC: " << trkgeo->isThere(GeomDetEnumerators::P2PXEC);
   LogTrace("IsThereTest") << " is there TIB: " << trkgeo->isThere(GeomDetEnumerators::TIB);
   LogTrace("IsThereTest") << " is there TID: " << trkgeo->isThere(GeomDetEnumerators::TID);
   LogTrace("IsThereTest") << " is there TOB: " << trkgeo->isThere(GeomDetEnumerators::TOB);
   LogTrace("IsThereTest") << " is there TEC: " << trkgeo->isThere(GeomDetEnumerators::TEC);
   LogTrace("IsThereTest") << " is there P2OTB: " << trkgeo->isThere(GeomDetEnumerators::P2OTB);
   LogTrace("IsThereTest") << " is there P2OTEC: " << trkgeo->isThere(GeomDetEnumerators::P2OTEC);
 
 
   const Local2DPoint center(0.,0.);
   const Local3DPoint locz(0.,0.,1.);
   const Local3DPoint locx(1.,0.,0.);
   const Local3DPoint locy(0.,1.,0.);
   const GlobalPoint origin(0.,0.,0.);
 
   TrackingGeometry::DetIdContainer detunits = trkgeo->detUnitIds();
 
   for(TrackingGeometry::DetIdContainer::const_iterator det = detunits.begin(); det!=detunits.end(); ++det) {
 
     if(det->det()!=DetId::Tracker) continue;
 
     edm::LogInfo("DetIdFromGeometry") << det->rawId();
 
     GlobalPoint position = trkgeo->idToDet(*det)->toGlobal(center);
     GlobalPoint zpos = trkgeo->idToDet(*det)->toGlobal(locz);
     GlobalPoint xpos = trkgeo->idToDet(*det)->toGlobal(locx);
     GlobalPoint ypos = trkgeo->idToDet(*det)->toGlobal(locy);
     GlobalVector posvect = position - origin;
     GlobalVector dz = zpos - position;
     GlobalVector dx = xpos - position;
     GlobalVector dy = ypos - position;
 
     double dzdr = posvect.perp()>0 ? (dz.x()*posvect.x()+dz.y()*posvect.y())/posvect.perp() : 0. ;
     double dxdr = posvect.perp()>0 ? (dx.x()*posvect.x()+dx.y()*posvect.y())/posvect.perp() : 0. ;
     double dydr = posvect.perp()>0 ? (dy.x()*posvect.x()+dy.y()*posvect.y())/posvect.perp() : 0. ;
 
     double dzdrphi = posvect.perp()>0 ? (dz.y()*posvect.x()-dz.x()*posvect.y())/posvect.perp() : 0. ;
     double dxdrphi = posvect.perp()>0 ? (dx.y()*posvect.x()-dx.x()*posvect.y())/posvect.perp() : 0. ;
     double dydrphi = posvect.perp()>0 ? (dy.y()*posvect.x()-dy.x()*posvect.y())/posvect.perp() : 0. ;
 
      for(std::map<unsigned int,DetIdSelector>::const_iterator sel=m_wantedsubdets.begin();sel!=m_wantedsubdets.end();++sel) {
 
        if(sel->second.isSelected(*det)) {
      edm::LogInfo("SelectedDetId") << sel->first;
      // average positions
      if(m_averadius && *m_averadius) (*m_averadius)->Fill(sel->first,position.perp());
      if(m_avez && *m_avez) (*m_avez)->Fill(sel->first,position.z());
      if(m_avex && *m_avex) (*m_avex)->Fill(sel->first,position.x());
      if(m_avey && *m_avey) (*m_avey)->Fill(sel->first,position.y());
      if(m_zavedr && *m_zavedr) (*m_zavedr)->Fill(sel->first,dzdr);
      if(m_zavedz && *m_zavedz) (*m_zavedz)->Fill(sel->first,dz.z());
      if(m_zavedrphi && *m_zavedrphi) (*m_zavedrphi)->Fill(sel->first,dzdrphi);
      if(m_xavedr && *m_xavedr) (*m_xavedr)->Fill(sel->first,dxdr);
      if(m_xavedz && *m_xavedz) (*m_xavedz)->Fill(sel->first,dx.z());
      if(m_xavedrphi && *m_xavedrphi) (*m_xavedrphi)->Fill(sel->first,dxdrphi);
      if(m_yavedr && *m_yavedr) (*m_yavedr)->Fill(sel->first,dydr);
      if(m_yavedz && *m_yavedz) (*m_yavedz)->Fill(sel->first,dy.z());
      if(m_yavedrphi && *m_yavedrphi) (*m_yavedrphi)->Fill(sel->first,dydrphi);
        }
      }
   }
 
   // counting the number of channels per module subset
 
   // the histograms have to be reset to avoid double counting if endRun is called more than once
 
   if(m_nchannels_ideal && *m_nchannels_ideal) (*m_nchannels_ideal)->Reset();
   if(m_nchannels_real && *m_nchannels_real) (*m_nchannels_real)->Reset();
 
   edm::ESHandle<SiStripQuality> quality;
   iSetup.get<SiStripQualityRcd>().get("",quality);
 
 
    SiStripDetInfoFileReader * reader=edm::Service<SiStripDetInfoFileReader>().operator->();
 
    const std::vector<uint32_t>& detids = reader->getAllDetIds();
 
    for(std::vector<uint32_t>::const_iterator detid=detids.begin();detid!=detids.end();++detid) {
 
      int nchannideal = reader->getNumberOfApvsAndStripLength(*detid).first*128;
      //     int nchannreal = reader->getNumberOfApvsAndStripLength(*detid).first*128;
      int nchannreal = 0;
      for(int strip = 0; strip < nchannideal; ++strip) {
        if(!quality->IsStripBad(*detid,strip)) ++nchannreal;
      }
 
 
      for(std::map<unsigned int,DetIdSelector>::const_iterator sel=m_wantedsubdets.begin();sel!=m_wantedsubdets.end();++sel) {
 
        if(sel->second.isSelected(*detid)) {
      if(m_nchannels_ideal && *m_nchannels_ideal) (*m_nchannels_ideal)->Fill(sel->first,nchannideal);
      if(m_nchannels_real && *m_nchannels_real) (*m_nchannels_real)->Fill(sel->first,nchannreal);
        }
      }
 
    }
 
 
   edm::ESHandle<SiPixelQuality> pxlquality;
   iSetup.get<SiPixelQualityRcd>().get("",pxlquality);
 
 
    SiPixelDetInfoFileReader pxlreader(m_fp.fullPath());
 
    const std::vector<uint32_t>& pxldetids = pxlreader.getAllDetIds();
 
    for(std::vector<uint32_t>::const_iterator detid=pxldetids.begin();detid!=pxldetids.end();++detid) {
 
      int nchannideal = pxlreader.getDetUnitDimensions(*detid).first*pxlreader.getDetUnitDimensions(*detid).second;
      int nchannreal = 0;
      if(!pxlquality->IsModuleBad(*detid)) {
        nchannreal = pxlreader.getDetUnitDimensions(*detid).first*pxlreader.getDetUnitDimensions(*detid).second;
      }
      /*
      int nchannreal = 0;
      for(int strip = 0; strip < nchannideal; ++strip) {
        if(!quality->IsStripBad(*detid,strip)) ++nchannreal;
      }
      */
 
      for(std::map<unsigned int,DetIdSelector>::const_iterator sel=m_wantedsubdets.begin();sel!=m_wantedsubdets.end();++sel) {
 
        if(sel->second.isSelected(*detid)) {
      if(m_nchannels_ideal && *m_nchannels_ideal) (*m_nchannels_ideal)->Fill(sel->first,nchannideal);
      if(m_nchannels_real && *m_nchannels_real) (*m_nchannels_real)->Fill(sel->first,nchannreal);
        }
      }
 
    }
 
 }