#include <PixelLumi/PixelLumiDQM/plugins/PixelLumiDQM.h>

Inheritance diagram for PixelLumiDQM:

Classes
class	PixelClusterCount

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

	~PixelLumiDQM ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

	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)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Static Public Attributes
static double	CM2_TO_NANOBARN = 1.0/1.e-33

static double	FREQ_ORBIT = 11245.5

static const unsigned int	lastBunchCrossing = 3564

static double	rXSEC_PIXEL_CLUSTER = 9.4e-24

static double	rXSEC_PIXEL_CLUSTER_UNC = 0.119e-24

static double	SECONDS_PER_LS = double(0x40000)/double(FREQ_ORBIT)

static double	XSEC_PIXEL_CLUSTER = 10.08e-24

static double	XSEC_PIXEL_CLUSTER_UNC = 0.17e-24

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

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

virtual void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

unsigned int	calculateBunchMask (MonitorElement *, std::vector< bool > &)

unsigned int	calculateBunchMask (std::vector< float > &, unsigned int, std::vector< bool > &)

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

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

Private Attributes
std::vector< bool >	bunchTriggerMask

UInt_t	fBXNo

Double_t	fChi2

std::vector< uint32_t >	fDeadModules

UInt_t	fEvtNo

unsigned int	fFillNumber

MonitorElement *	fHistBunchCrossings

MonitorElement *	fHistBunchCrossingsLastLumi

MonitorElement *	fHistClusByLS

MonitorElement *	fHistClusterCountByBxCumulative

MonitorElement *	fHistClusterCountByBxLastLumi

std::map< std::string, MonitorElement * >	fHistContainerThisRun

MonitorElement *	fHistnBClusVsLS [3]

MonitorElement *	fHistnFMClusVsLS [2]

MonitorElement *	fHistnFPClusVsLS [2]

MonitorElement *	fHistRecordedByBxCumulative

MonitorElement *	fHistRecordedByBxLastLumi

MonitorElement *	fHistTotalRecordedLumiByLS

unsigned int	filledAndUnmaskedBunches

bool	fIncludePixelClusterInfo

bool	fIncludePixelQualCheckHistos

bool	fIncludeVertexInfo

MonitorElement *	fIntActiveCrossingsFromDB

std::string	fLogFileName_

UInt_t	fLSNo

double	fMinClusterCharge

int	fMinPixelsPerCluster

Double_t	fNdof

std::map< int, PixelClusterCount >	fNumPixelClusters

UInt_t	fNumTrkPerVtx

UInt_t	fNumVtx

UInt_t	fNumVtxGood

edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > >	fPixelClusterLabel

int	fResetIntervalInLumiSections

UInt_t	fRunNo

UInt_t	fTimestamp

Double_t	fVtxX

Double_t	fVtxY

Double_t	fVtxZ

std::ofstream	logFile_

bool	useInnerBarrelLayer

Static Private Attributes
static size_t const	kNumDisks = 2

static size_t const	kNumLayers = 3

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
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::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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: DQM Module producing Pixel Cluster Count Luminosity

Implementation notes: 1) Filling scheme is put in by 'hand' for now. Can obtain it from the cluster count but need higher rate in trigger; Best would be to have filling scheme in the DB. 2) Afterglow correction is put in by hand. 3) Currently barrel layer 0 is excluded, but a version using all pixel layers and disks is also in place. 4) A stable beam flag should be obtained from the DB to turn on actual checks. (Pixel Lumi does not make sense outside stable beams.) 5) Need a top module to correlate the info from the three trigger categories. NB: at present the module only uses the ZeroBias trigger providing about 85 Hz.

Definition at line 38 of file PixelLumiDQM.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 48 of file PixelLumiDQM.cc.

References fDeadModules, fIncludePixelClusterInfo, fIncludePixelQualCheckHistos, fMinClusterCharge, fMinPixelsPerCluster, and edm::ParameterSet::getUntrackedParameter().

                                                         :
   fPixelClusterLabel(consumes<edmNew::DetSetVector<SiPixelCluster> >(iConfig.getUntrackedParameter<edm::InputTag>("pixelClusterLabel",
                        edm::InputTag("siPixelClusters")))),
   fIncludePixelClusterInfo(iConfig.getUntrackedParameter<bool>("includePixelClusterInfo", true)),
   fIncludePixelQualCheckHistos(iConfig.getUntrackedParameter<bool>("includePixelQualCheckHistos", true)),
   fResetIntervalInLumiSections(iConfig.getUntrackedParameter<int>("resetEveryNLumiSections", 1)),
   fDeadModules(iConfig.getUntrackedParameter<std::vector<uint32_t> >("deadModules", std::vector<uint32_t>())),
   fMinPixelsPerCluster(iConfig.getUntrackedParameter<int>("minNumPixelsPerCluster", 0)),
   fMinClusterCharge(iConfig.getUntrackedParameter<double>("minChargePerCluster", 0)),
   bunchTriggerMask(lastBunchCrossing+1,false),
   filledAndUnmaskedBunches(0),
   useInnerBarrelLayer(iConfig.getUntrackedParameter<bool>("useInnerBarrelLayer", false)),
   fLogFileName_(iConfig.getUntrackedParameter<std::string>("logFileName","/tmp/pixel_lumi.txt"))
 {
   edm::LogInfo("Configuration")
     << "PixelLumiDQM looking for pixel clusters in '"
     << iConfig.getUntrackedParameter<edm::InputTag>("pixelClusterLabel",
                        edm::InputTag("siPixelClusters")) << "'";
   edm::LogInfo("Configuration")
     << "PixelLumiDQM storing pixel cluster info? "
     << fIncludePixelClusterInfo;
   edm::LogInfo("Configuration")
     << "PixelLumiDQM storing pixel cluster quality check histograms? "
     << fIncludePixelQualCheckHistos;
 
   if (!fDeadModules.size()) {
     edm::LogInfo("Configuration")
       << "No pixel modules specified to be ignored";
   } else {
     edm::LogInfo("Configuration")
       << fDeadModules.size() << " pixel modules specified to be ignored:";
     for (std::vector<uint32_t>::const_iterator it = fDeadModules.begin();
          it != fDeadModules.end(); ++it) {
       edm::LogInfo("Configuration")
         << "  " << *it;
     }
   }
   edm::LogInfo("Configuration")
     << "Ignoring pixel clusters with less than "
     << fMinPixelsPerCluster << " pixels";
   edm::LogInfo("Configuration")
     << "Ignoring pixel clusters with charge less than "
     << fMinClusterCharge;
 }

PixelLumiDQM::~PixelLumiDQM ( )

Definition at line 94 of file PixelLumiDQM.cc.

95 {

96 }

Member Function Documentation

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

overrideprivatevirtual

Definition at line 108 of file PixelLumiDQM.cc.

References edmNew::DetSetVector< T >::begin(), edm::EventBase::bunchCrossing(), ALCARECOTkAlJpsiMuMu_cff::charge, TrackerGeometry::dets(), edmNew::DetSetVector< T >::end(), edm::EventID::event(), fBXNo, fDeadModules, fEvtNo, fHistBunchCrossings, fHistBunchCrossingsLastLumi, fHistContainerThisRun, MonitorElement::Fill(), fIncludePixelClusterInfo, fIncludePixelQualCheckHistos, spr::find(), fLSNo, fMinClusterCharge, fMinPixelsPerCluster, fNumPixelClusters, fPixelClusterLabel, fRunNo, fTimestamp, edm::EventSetup::get(), edm::Event::getByToken(), edm::Event::getLuminosityBlock(), mps_fire::i, edm::EventBase::id(), TrackerGeometry::idToDet(), GeomDetEnumerators::isTrackerPixel(), PixelBarrelName::layerName(), Topology::localPosition(), edm::LuminosityBlockBase::luminosityBlock(), PixelEndcapName::mI, PixelEndcapName::mO, PV3DBase< T, PVType, FrameType >::phi(), PixelEndcapName::pI, PixelSubdetector::PixelBarrel, hiDetachedTripletStep_cff::pixelClusters, PixelSubdetector::PixelEndcap, PixelEndcapName::pO, edm::EventID::run(), findQualityFiles::size, PixelGeomDetUnit::specificTopology(), mathSSE::sqrt(), DetId::subdetId(), GeomDet::surface(), edm::EventBase::time(), Surface::toGlobal(), edm::Timestamp::unixTime(), x, PV3DBase< T, PVType, FrameType >::x(), y, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

 {
   // Collect all bookkeeping information.
   fRunNo = iEvent.id().run();
   fEvtNo = iEvent.id().event();
   fLSNo = iEvent.getLuminosityBlock().luminosityBlock();
   fBXNo = iEvent.bunchCrossing();
   fTimestamp = iEvent.time().unixTime();
   fHistBunchCrossings->Fill(float(fBXNo)); 
   fHistBunchCrossingsLastLumi->Fill(float(fBXNo)); 
   // This serves as event counter to compute luminosity from cluster counts.
   std::map<int, PixelClusterCount>::iterator it = fNumPixelClusters.find(fBXNo);
   if(it==fNumPixelClusters.end()) fNumPixelClusters[fBXNo] = PixelClusterCount();
 
   if (fIncludePixelClusterInfo) {
     // Find tracker geometry.
     edm::ESHandle<TrackerGeometry> trackerGeo;
     iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeo);
     
     // Find pixel clusters.
     edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
     iEvent.getByToken(fPixelClusterLabel, pixelClusters);
     
     // Loop over entire tracker geometry.
     for (TrackerGeometry::DetContainer::const_iterator
            i = trackerGeo->dets().begin();
          i != trackerGeo->dets().end(); ++i) {
       // See if this is a pixel unit(?).
          
       if ( GeomDetEnumerators::isTrackerPixel((*i)->subDetector())) {
         DetId detId = (*i)->geographicalId();
         // Find all clusters on this detector module.
         edmNew::DetSetVector<SiPixelCluster>::const_iterator iSearch =
           pixelClusters->find(detId);
         if (iSearch != pixelClusters->end()) {
       
           // Count the number of clusters with at least a minimum
           // number of pixels per cluster and at least a minimum charge.
           size_t numClusters = 0;
           for (edmNew::DetSet<SiPixelCluster>::const_iterator
                  itClus = iSearch->begin();
                itClus != iSearch->end(); ++itClus) {
             if ((itClus->size() >= fMinPixelsPerCluster) &&
                 (itClus->charge() >= fMinClusterCharge)) {
               ++numClusters;
             }
           }
             // DEBUG DEBUG DEBUG
           assert(numClusters <= iSearch->size());
           // DEBUG DEBUG DEBUG end
       
           // Add up the cluster count based on the position of this detector element.
           if (detId.subdetId() == PixelSubdetector::PixelBarrel) {
             PixelBarrelName detName = PixelBarrelName(detId);
             int layer = detName.layerName();
             fNumPixelClusters[fBXNo].numB.at(layer - 1) += numClusters;
             fNumPixelClusters[fBXNo].dnumB.at(layer - 1) += sqrt(numClusters);
           } else {
             // DEBUG DEBUG DEBUG
             assert(detId.subdetId() == PixelSubdetector::PixelEndcap);
             // DEBUG DEBUG DEBUG end
         
             PixelEndcapName detName = PixelEndcapName(detId);
             PixelEndcapName::HalfCylinder halfCylinder = detName.halfCylinder();
             int disk = detName.diskName();
             switch (halfCylinder) {
               case PixelEndcapName::mO:
               case PixelEndcapName::mI:
                 fNumPixelClusters[fBXNo].numFM.at(disk - 1) += numClusters;
                 fNumPixelClusters[fBXNo].dnumFM.at(disk - 1) += sqrt(numClusters);
                 break;
               case PixelEndcapName::pO:
               case PixelEndcapName::pI:
                 fNumPixelClusters[fBXNo].numFP.at(disk - 1) += numClusters;
                 fNumPixelClusters[fBXNo].dnumFP.at(disk - 1) += sqrt(numClusters);
                 break;
               default:
                 assert(false);
                 break;
             }
           }
         }
       }
     }
   }
   // ----------
 
   // Fill some pixel cluster quality check histograms if requested.
   if (fIncludePixelQualCheckHistos) {
     
     // Find tracker geometry.
     edm::ESHandle<TrackerGeometry> trackerGeo;
     iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeo);
     
     // Find pixel clusters.
     edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
     iEvent.getByToken(fPixelClusterLabel, pixelClusters);
     
     bool filterDeadModules = (fDeadModules.size() > 0);
     std::vector<uint32_t>::const_iterator deadModulesBegin = fDeadModules.begin();
     std::vector<uint32_t>::const_iterator deadModulesEnd = fDeadModules.end();
     
     // Loop over entire tracker geometry.
     for (TrackerGeometry::DetContainer::const_iterator
            i = trackerGeo->dets().begin();
          i != trackerGeo->dets().end(); ++i) {
       
       // See if this is a pixel module.
       if ( GeomDetEnumerators::isTrackerPixel((*i)->subDetector())) {
         DetId detId = (*i)->geographicalId();
     
         // Skip this module if it's on the list of modules to be ignored.
         if (filterDeadModules &&
             find(deadModulesBegin, deadModulesEnd, detId()) != deadModulesEnd) {
           continue;
         }
     
         // Find all clusters in this module.
         edmNew::DetSetVector<SiPixelCluster>::const_iterator iSearch =
           pixelClusters->find(detId);
     
         // Loop over all clusters in this module.
         if (iSearch != pixelClusters->end()) {
           for (edmNew::DetSet<SiPixelCluster>::const_iterator clus = iSearch->begin();
                clus != iSearch->end(); ++clus) {
         
             if ((clus->size() >= fMinPixelsPerCluster) &&
                 (clus->charge() >= fMinClusterCharge)) {
           
               PixelGeomDetUnit const* theGeomDet =
                 dynamic_cast<PixelGeomDetUnit const*>(trackerGeo->idToDet(detId));
               PixelTopology const* topol = &(theGeomDet->specificTopology());
               double x = clus->x();
               double y = clus->y();
               LocalPoint clustLP = topol->localPosition(MeasurementPoint(x, y));
               GlobalPoint clustGP = theGeomDet->surface().toGlobal(clustLP);
               double charge = clus->charge() / 1.e3;
               int size = clus->size();
           
               if (detId.subdetId() == PixelSubdetector::PixelBarrel) {
                 PixelBarrelName detName = PixelBarrelName(detId);
                 int layer = detName.layerName();
                 switch (layer) {
                 case 1:
                   fHistContainerThisRun["clusPosBarrel1"]->Fill(clustGP.z(), clustGP.phi());
                   fHistContainerThisRun["clusChargeBarrel1"]->Fill(iEvent.bunchCrossing(), charge);
                   fHistContainerThisRun["clusSizeBarrel1"]->Fill(iEvent.bunchCrossing(), size);
                   break;
                 case 2:
                   fHistContainerThisRun["clusPosBarrel2"]->Fill(clustGP.z(), clustGP.phi());
                   fHistContainerThisRun["clusChargeBarrel2"]->Fill(iEvent.bunchCrossing(), charge);
                   fHistContainerThisRun["clusSizeBarrel2"]->Fill(iEvent.bunchCrossing(), size);
                   break;
                 case 3:
                   fHistContainerThisRun["clusPosBarrel3"]->Fill(clustGP.z(), clustGP.phi());
                   fHistContainerThisRun["clusChargeBarrel3"]->Fill(iEvent.bunchCrossing(), charge);
                   fHistContainerThisRun["clusSizeBarrel3"]->Fill(iEvent.bunchCrossing(), size);
                   break;
                 default:
                   assert(false);
                   break;
                 }
               } else {
                 
                 // DEBUG DEBUG DEBUG
                 assert(detId.subdetId() == PixelSubdetector::PixelEndcap);
                 // DEBUG DEBUG DEBUG end
                 
                 PixelEndcapName detName = PixelEndcapName(detId);
                 PixelEndcapName::HalfCylinder halfCylinder = detName.halfCylinder();
                 int disk = detName.diskName();
                 switch (halfCylinder) {
                   case PixelEndcapName::mO:
                   case PixelEndcapName::mI:
                     switch (disk) {
                       case 1:
                         fHistContainerThisRun["clusPosEndCapM1"]->Fill(clustGP.x(), clustGP.y());
                         fHistContainerThisRun["clusChargeEndCapM1"]->Fill(iEvent.bunchCrossing(), charge);
                         fHistContainerThisRun["clusSizeEndCapM1"]->Fill(iEvent.bunchCrossing(), size);
                         break;
                       case 2:
                         fHistContainerThisRun["clusPosEndCapM2"]->Fill(clustGP.x(), clustGP.y());
                         fHistContainerThisRun["clusChargeEndCapM2"]->Fill(iEvent.bunchCrossing(), charge);
                         fHistContainerThisRun["clusSizeEndCapM2"]->Fill(iEvent.bunchCrossing(), size);
                         break;
                       default:
                         assert(false);
                         break;
                     }
                     break;
                   case PixelEndcapName::pO:
                   case PixelEndcapName::pI:
                     switch (disk) {
                       case 1:
                         fHistContainerThisRun["clusPosEndCapP1"]->Fill(clustGP.x(), clustGP.y());
                         fHistContainerThisRun["clusChargeEndCapP1"]->Fill(iEvent.bunchCrossing(), charge);
                         fHistContainerThisRun["clusSizeEndCapP1"]->Fill(iEvent.bunchCrossing(), size);
                         break;
                       case 2:
                         fHistContainerThisRun["clusPosEndCapP2"]->Fill(clustGP.x(), clustGP.y());
                         fHistContainerThisRun["clusChargeEndCapP2"]->Fill(iEvent.bunchCrossing(), charge);
                         fHistContainerThisRun["clusSizeEndCapP2"]->Fill(iEvent.bunchCrossing(), size);
                         break;
                       default:
                         assert(false);
                         break;
                     }
                     break;
                   default:
                     assert(false);
                     break;
                 }
               }
             }
           }
         }
       }
     }
   }
 } 

void PixelLumiDQM::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &
	)

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 491 of file PixelLumiDQM.cc.

References fHistBunchCrossingsLastLumi, fHistClusterCountByBxLastLumi, fHistRecordedByBxLastLumi, fResetIntervalInLumiSections, eostools::ls(), edm::LuminosityBlockAuxiliary::luminosityBlock(), edm::LuminosityBlock::luminosityBlockAuxiliary(), and MonitorElement::Reset().

 {
   // Only reset and fill every fResetIntervalInLumiSections (default is 1 LS)
   // Return unless the PREVIOUS LS was at the right modulo value 
   // (e.g. is resetinterval = 5 the rest will only be executed at LS=6
   // NB: reset is done here so the histograms by LS are sent before resetting.
   // NB: not being used for now since default is 1 LS. There is a bug here.
 
   unsigned int ls = lumiBlock.luminosityBlockAuxiliary().luminosityBlock();
 
   if((ls-1)%fResetIntervalInLumiSections==0){
     fHistBunchCrossingsLastLumi->Reset();
     fHistClusterCountByBxLastLumi->Reset();
     fHistRecordedByBxLastLumi->Reset();
   }
 }

void PixelLumiDQM::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	run,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 331 of file PixelLumiDQM.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), fHistBunchCrossings, fHistBunchCrossingsLastLumi, fHistClusByLS, fHistClusterCountByBxCumulative, fHistClusterCountByBxLastLumi, fHistContainerThisRun, fHistnBClusVsLS, fHistnFMClusVsLS, fHistnFPClusVsLS, fHistRecordedByBxCumulative, fHistRecordedByBxLastLumi, fHistTotalRecordedLumiByLS, fIncludePixelQualCheckHistos, printsummarytable::folder, mps_fire::i, edm::RunBase::id(), crabWrapper::key, kNumDisks, kNumLayers, lastBunchCrossing, dataset::name, Geom::pi(), edm::RunID::run(), edm::RunBase::run(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and fftjetcommon_cfi::title.

 {
   edm::LogInfo("Status") << "Starting processing of run #" << run.id().run();
 
   // Top folder containing high-level information about pixel and HF lumi.  
   std::string folder = "PixelLumi/";
   ibooker.setCurrentFolder(folder);
   
   fHistTotalRecordedLumiByLS = ibooker.book1D("totalPixelLumiByLS","Pixel Lumi in nb vs LS",8000,0.5,8000.5);
   fHistRecordedByBxCumulative = ibooker.book1D("PXLumiByBXsum","Pixel Lumi in nb by BX Cumulative vs LS",lastBunchCrossing,
                          0.5,float(lastBunchCrossing)+0.5);
 
   std::string subfolder = folder + "lastLS/";
   ibooker.setCurrentFolder(subfolder);
   fHistRecordedByBxLastLumi = ibooker.book1D("PXByBXLastLumi","Pixel By BX Last Lumi",lastBunchCrossing+1,
                        -0.5,float(lastBunchCrossing)+0.5);
 
   subfolder = folder+"ClusterCountingDetails/";
   ibooker.setCurrentFolder(subfolder);
 
   fHistnBClusVsLS[0] = ibooker.book1D("nBClusVsLS_0","Fraction of Clusters vs LS Barrel layer 0",8000,0.5,8000.5);
   fHistnBClusVsLS[1] = ibooker.book1D("nBClusVsLS_1","Fraction of Clusters vs LS Barrel layer 1",8000,0.5,8000.5);
   fHistnBClusVsLS[2] = ibooker.book1D("nBClusVsLS_2","Fraction of Clusters vs LS Barrel layer 2",8000,0.5,8000.5);
   fHistnFPClusVsLS[0] = ibooker.book1D("nFPClusVsLS_0","Fraction of Clusters vs LS Barrel layer 0",8000,0.5,8000.5);
   fHistnFPClusVsLS[1] = ibooker.book1D("nFPClusVsLS_1","Fraction of Clusters vs LS Barrel layer 1",8000,0.5,8000.5);
   fHistnFMClusVsLS[0] = ibooker.book1D("nFMClusVsLS_0","Fraction of Clusters vs LS Barrel layer 0",8000,0.5,8000.5);
   fHistnFMClusVsLS[1] = ibooker.book1D("nFMClusVsLS_1","Fraction of Clusters vs LS Barrel layer 1",8000,0.5,8000.5);
   fHistBunchCrossings = ibooker.book1D("BunchCrossings","Cumulative Bunch Crossings",lastBunchCrossing,
                  0.5,float(lastBunchCrossing)+0.5);
   fHistBunchCrossingsLastLumi = ibooker.book1D("BunchCrossingsLL","Bunch Crossings Last Lumi",lastBunchCrossing,
                      0.5,float(lastBunchCrossing)+0.5);
   fHistClusterCountByBxLastLumi = ibooker.book1D("ClusterCountByBxLL","Cluster Count by BX Last Lumi",lastBunchCrossing,
                      0.5,float(lastBunchCrossing)+0.5);
   fHistClusterCountByBxCumulative = ibooker.book1D("ClusterCountByBxSum","Cluster Count by BX Cumulative",lastBunchCrossing,
                      0.5,float(lastBunchCrossing)+0.5);
   fHistClusByLS = ibooker.book1D("totalClusByLS","Number of Clusters all dets vs LS",8000,0.5,8000.5);
 
   // Add some pixel cluster quality check histograms (in a subfolder).
   subfolder = folder+"qualityChecks/";
   ibooker.setCurrentFolder(subfolder);
   
   if (fIncludePixelQualCheckHistos) {
     // Create histograms for this run if not already present in our list.
     edm::LogInfo("Status") << "Creating histograms for run #" << run.id().run();
     
     // Pixel cluster positions in the barrel - (z, phi).
     for (size_t i = 1; i <= kNumLayers; ++i) {
       std::stringstream key;
       key << "clusPosBarrel" << i;
       std::stringstream name;
       name << key.str() << "_" << run.run();
       std::stringstream title;
       title << "Pixel cluster position - barrel layer " << i;
       fHistContainerThisRun[key.str()] = ibooker.book2D(name.str().c_str(),
                         title.str().c_str(),
                         100, -30., 30.,
                         64, -Geom::pi(), Geom::pi());
     }
     
     // Pixel cluster positions in the endcaps (x, y).
     std::vector<std::string> sides;
     sides.push_back("M");
     sides.push_back("P");
     for (std::vector<std::string>::const_iterator side = sides.begin();
          side != sides.end(); ++side) {
       for (size_t i = 1; i <= kNumDisks; ++i) {
         std::stringstream key;
         key << "clusPosEndCap" << *side << i;
         std::stringstream name;
         name << key.str() << "_" << run.run();
         std::stringstream title;
         title << "Pixel cluster position - endcap disk " << i;
         fHistContainerThisRun[key.str()] = ibooker.book2D(name.str().c_str(),
                           title.str().c_str(),
                           100, -20., 20.,
                           100, -20., 20.);
       }
     }
     
     // Pixel cluster charge in the barrel, per bx.
     for (size_t i = 1; i <= kNumLayers; ++i) {
       std::stringstream key;
       key << "clusChargeBarrel" << i;
       std::stringstream name;
       name << key.str() << "_" << run.run();
       std::stringstream title;
       title << "Pixel cluster charge - barrel layer " << i;
       fHistContainerThisRun[key.str()] = ibooker.book2D(name.str().c_str(),
                         title.str().c_str(),
                         3564, .5, 3564.5,
                         100, 0., 100.);
     }
 
     // Pixel cluster charge in the endcaps, per bx.
     for (std::vector<std::string>::const_iterator side = sides.begin();
          side != sides.end(); ++side) {
       for (size_t i = 1; i <= kNumDisks; ++i) {
         std::stringstream key;
         key << "clusChargeEndCap" << *side << i;
         std::stringstream name;
         name << key.str() << "_" << run.run();
         std::stringstream title;
         title << "Pixel cluster charge - endcap disk " << i;
         fHistContainerThisRun[key.str()] = ibooker.book2D(name.str().c_str(),
                                     title.str().c_str(),
                                     3564, .5, 3564.5,
                                     100, 0., 100.);
       }
     }
 
     // Pixel cluster size in the barrel, per bx.
     for (size_t i = 1; i <= kNumLayers; ++i) {
       std::stringstream key;
       key << "clusSizeBarrel" << i;
       std::stringstream name;
       name << key.str() << "_" << run.run();
       std::stringstream title;
       title << "Pixel cluster size - barrel layer " << i;
       fHistContainerThisRun[key.str()] = ibooker.book2D(name.str().c_str(),
                                   title.str().c_str(),
                                   3564, .5, 3564.5,
                                   100, 0., 100.);
     }
 
     // Pixel cluster size in the endcaps, per bx.
     for (std::vector<std::string>::const_iterator side = sides.begin();
          side != sides.end(); ++side) {
       for (size_t i = 1; i <= kNumDisks; ++i) {
         std::stringstream key;
         key << "clusSizeEndCap" << *side << i;
         std::stringstream name;
         name << key.str() << "_" << run.run();
         std::stringstream title;
         title << "Pixel cluster size - endcap disk " << i;
         fHistContainerThisRun[key.str()] = ibooker.book2D(name.str().c_str(),
                                     title.str().c_str(),
                                     3564, .5, 3564.5,
                                     100, 0., 100.);
       }
     }
   }
 }

unsigned int PixelLumiDQM::calculateBunchMask	(	MonitorElement *	e,
		std::vector< bool > &	mask
	)

private

Definition at line 680 of file PixelLumiDQM.cc.

References MonitorElement::getBinContent(), MonitorElement::getNbinsX(), mps_fire::i, and pileupCalc::nbins.

Referenced by endLuminosityBlock().

                                                                                      {
   unsigned int nbins = e->getNbinsX();
   std::vector<float> ar(nbins,0.);
   for(unsigned int i = 1; i<= nbins; i++){
     ar[i] = e->getBinContent(i);
   }
   return calculateBunchMask(ar,nbins,mask);
 }

unsigned int PixelLumiDQM::calculateBunchMask	(	std::vector< float > &	e,
		unsigned int	nbins,
		std::vector< bool > &	mask
	)

private

Definition at line 688 of file PixelLumiDQM.cc.

References funct::abs(), stringResolutionProvider_cfi::bin, gather_cfg::cout, DEFINE_FWK_MODULE, trackingPlots::fit, mps_fire::i, RecoTauDiscriminantConfiguration::mean, pileupCalc::nbins, and ctppsDiamondLocalTracks_cfi::sigma.

                                                                                                            {
   // Take the cumulative cluster count histogram and find max and average of non-empty bins.
   unsigned int active_count = 0;
   double maxc = 0.0;
   double ave = 0.0; // Average of non-empty bins
   unsigned int non_empty_bins = 0;
   
   for(unsigned int i = 1; i<= nbins; i++){
     double bin = e[i];
     if(bin !=0.0){
       if(maxc<bin) maxc = bin;
       ave += bin;
       non_empty_bins++;
     }      
   }
   
   ave /= non_empty_bins;
   std::cout << "Bunch mask finder - non empty bins " << non_empty_bins
         << " average of non empty bins " << ave 
         << " max content of one bin " << maxc << std::endl;
   double mean = 0.;
   double sigma = 0.;
   if(non_empty_bins < 50){
     mean = maxc;
     sigma = (maxc)/20;
   }    
   else{
     TH1F dist("dist","dist",500,0.,maxc+(maxc/500.)*20.);
     for(unsigned int i = 1; i<= nbins; i++){
       double bin = e[i];
       dist.Fill(bin);
     }  
     TF1 fit("plgaus","gaus");
     dist.Fit(&fit,"","",fmax(0.,ave-(maxc-ave)/5.),maxc);
     mean = fit.GetParameter("Mean");
     sigma = fit.GetParameter("Sigma");
   }
   std::cout << "Bunch mask will use mean" << mean << " sigma " << sigma << std::endl;
   // Active BX defined as those which have nclus within fixed standard deviations of peak.
   for(unsigned int i = 1; i<= nbins; i++){
     double bin = e[i];
     if(bin>0. && std::abs(bin-mean)<5.*(sigma)){ mask[i]=true; active_count++;}
   }
   std::cout << "Bunch mask finds " << active_count << " active bunch crossings " << std::endl;
   //   std::cout << "this is the full bx mask " ;
   //   for(unsigned int i = 1; i<= nbins; i++)
   //     std::cout << ((mask[i]) ? 1:0);
   //   std::cout << std::endl;
   return active_count;
 }

void PixelLumiDQM::dqmBeginRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 478 of file PixelLumiDQM.cc.

479 {

480 }

void PixelLumiDQM::endLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	es
	)

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 512 of file PixelLumiDQM.cc.

References bunchTriggerMask, calculateBunchMask(), CM2_TO_NANOBARN, gather_cfg::cout, fHistBunchCrossingsLastLumi, fHistClusByLS, fHistClusterCountByBxCumulative, fHistClusterCountByBxLastLumi, fHistnBClusVsLS, fHistnFMClusVsLS, fHistnFPClusVsLS, fHistRecordedByBxCumulative, fHistRecordedByBxLastLumi, fHistTotalRecordedLumiByLS, filledAndUnmaskedBunches, fLogFileName_, fNumPixelClusters, FREQ_ORBIT, fResetIntervalInLumiSections, fRunNo, MonitorElement::getBinContent(), MonitorElement::getBinError(), mps_fire::i, lastBunchCrossing, logFile_, eostools::ls(), edm::LuminosityBlockAuxiliary::luminosityBlock(), edm::LuminosityBlock::luminosityBlockAuxiliary(), rXSEC_PIXEL_CLUSTER, rXSEC_PIXEL_CLUSTER_UNC, SECONDS_PER_LS, MonitorElement::setBinContent(), MonitorElement::setBinError(), mathSSE::sqrt(), pileupDistInMC::total, estimatePileup_makeJSON::trunc, useInnerBarrelLayer, XSEC_PIXEL_CLUSTER, and XSEC_PIXEL_CLUSTER_UNC.

 {
   
   unsigned int ls = lumiBlock.luminosityBlockAuxiliary().luminosityBlock();
   
   // Only fill every fResetIntervalInLumiSections (default is 1 LS)
   if(ls%fResetIntervalInLumiSections!=0) return;
   
   printf("Lumi Block = %d\n",ls);
 
   if((ls-1)%fResetIntervalInLumiSections==0){
   }
   
   unsigned int nBClus[3] = {0,0,0};
   unsigned int nFPClus[2] = {0, 0};
   unsigned int nFMClus[2] = {0, 0};
   
   double total_recorded = 0.;
   double total_recorded_unc_square = 0.;
   
   // Obtain bunch-by-bunch cluster counts and compute totals for lumi calculation.
   double totalcounts = 0.0;
   double etotalcounts = 0.0;
   double totalevents = 0.0;
   double lumi_factor_per_bx = 0.0;
   if(useInnerBarrelLayer) 
     lumi_factor_per_bx = FREQ_ORBIT * SECONDS_PER_LS * fResetIntervalInLumiSections / XSEC_PIXEL_CLUSTER  ;
   else
     lumi_factor_per_bx = FREQ_ORBIT * SECONDS_PER_LS * fResetIntervalInLumiSections / rXSEC_PIXEL_CLUSTER  ;
   
   for(std::map<int, PixelClusterCount>::iterator it = fNumPixelClusters.begin();
       it != fNumPixelClusters.end(); it++) {
     
     // Sum all clusters for this BX.
     unsigned int total = (*it).second.numB.at(1)+
       (*it).second.numB.at(2)+(*it).second.numFP.at(0)+(*it).second.numFP.at(1)+
       (*it).second.numFM.at(0)+(*it).second.numFM.at(1);
     if(useInnerBarrelLayer) total+=(*it).second.numB.at(0);
     totalcounts += total;
     double etotal = (*it).second.dnumB.at(1)+
       (*it).second.dnumB.at(2)+(*it).second.dnumFP.at(0)+(*it).second.dnumFP.at(1)+
       (*it).second.dnumFM.at(0)+(*it).second.dnumFM.at(1);
     if(useInnerBarrelLayer) etotal = (*it).second.dnumB.at(0);
     etotalcounts += etotal;
     etotal = sqrt(etotal);
 
     fHistClusterCountByBxLastLumi->setBinContent((*it).first,total);
     fHistClusterCountByBxLastLumi->setBinError((*it).first,etotal);
     fHistClusterCountByBxCumulative->setBinContent((*it).first,fHistClusterCountByBxCumulative->getBinContent((*it).first)+total);
     
     unsigned int events_per_bx = fHistBunchCrossingsLastLumi->getBinContent((*it).first);
     totalevents += events_per_bx;
     double average_cluster_count = events_per_bx !=0 ? double(total)/events_per_bx : 0.;
     double average_cluster_count_unc = events_per_bx!=0 ? etotal/events_per_bx : 0.;
     double pixel_bx_lumi_per_ls =  lumi_factor_per_bx * average_cluster_count / CM2_TO_NANOBARN ;
     double pixel_bx_lumi_per_ls_unc = 0.0;
     if(useInnerBarrelLayer) 
       pixel_bx_lumi_per_ls_unc = sqrt(lumi_factor_per_bx*lumi_factor_per_bx *
                       (average_cluster_count_unc*average_cluster_count_unc +
                        (average_cluster_count*  XSEC_PIXEL_CLUSTER_UNC /
                     XSEC_PIXEL_CLUSTER )*
                        (average_cluster_count*  XSEC_PIXEL_CLUSTER / 
                     XSEC_PIXEL_CLUSTER ))
                       ) / CM2_TO_NANOBARN ;
     else
       pixel_bx_lumi_per_ls_unc = sqrt(lumi_factor_per_bx*lumi_factor_per_bx *
                       (average_cluster_count_unc*average_cluster_count_unc +
                        (average_cluster_count*  rXSEC_PIXEL_CLUSTER_UNC /
                     rXSEC_PIXEL_CLUSTER )*
                        (average_cluster_count*  rXSEC_PIXEL_CLUSTER / 
                     rXSEC_PIXEL_CLUSTER ))
                       ) / CM2_TO_NANOBARN ;
     
     fHistRecordedByBxLastLumi->setBinContent((*it).first,pixel_bx_lumi_per_ls);
     fHistRecordedByBxLastLumi->setBinError((*it).first,pixel_bx_lumi_per_ls_unc);
     
     fHistRecordedByBxCumulative->setBinContent((*it).first,
                            fHistRecordedByBxCumulative->getBinContent((*it).first)+
                            pixel_bx_lumi_per_ls);
     
     /*
       if(fHistRecordedByBxLastLumi->getBinContent((*it).first)!=0.)
       fHistRecordedByBxLastLumi->getBinContent((*it).first));
       if(fHistRecordedByBxCumulative->getBinContent((*it).first)!=0.)
       fHistRecordedByBxCumulative->getBinContent((*it).first));
     */
 
     nBClus[0] +=(*it).second.numB.at(0);
     nBClus[1] +=(*it).second.numB.at(1);
     nBClus[2] +=(*it).second.numB.at(2);
     nFPClus[0] +=(*it).second.numFP.at(0);
     nFPClus[1] +=(*it).second.numFP.at(1);
     nFMClus[0] +=(*it).second.numFM.at(0);
     nFMClus[1] +=(*it).second.numFM.at(1);
     
     // Reset counters 
     (*it).second.Reset();
 
     // std::cout << "bx="<< (*it).first << " clusters=" << (*it).second.numB.at(0)) << std::endl; 
   }
 
   if((filledAndUnmaskedBunches = calculateBunchMask(fHistClusterCountByBxCumulative,bunchTriggerMask))!=0){
     for(unsigned int i = 0; i<= lastBunchCrossing; i++){
       if(bunchTriggerMask[i]){ 
         double err = fHistRecordedByBxLastLumi->getBinError(i);
         total_recorded += fHistRecordedByBxLastLumi->getBinContent(i);
         total_recorded_unc_square += err*err;
       }
     }
     
     // Replace the total obtained by summing over BXs with the average per BX from the total cluster count and rescale 
     
     if(totalevents > 10){
       total_recorded = lumi_factor_per_bx * totalcounts / totalevents / CM2_TO_NANOBARN ;
     }
     else total_recorded = 0.0;
     
     std::cout << " Total recorded " << total_recorded  << std::endl;
     fHistTotalRecordedLumiByLS->setBinContent(ls,total_recorded);
     fHistTotalRecordedLumiByLS->setBinError(ls,
                         sqrt(total_recorded_unc_square));
   }
   // fill cluster counts by detector regions for sanity checks
   unsigned int all_detectors_counts = 0;
   for(unsigned int i = 0; i < 3; i++){
     all_detectors_counts+=nBClus[i];
   }
   for(unsigned int i = 0; i < 2; i++){
     all_detectors_counts+=nFPClus[i];
   }
   for(unsigned int i = 0; i < 2; i++){
     all_detectors_counts+=nFMClus[i];
   }
   
   fHistClusByLS->setBinContent(ls, all_detectors_counts);
   
   for(unsigned int i = 0; i < 3; i++){
     fHistnBClusVsLS[i]->setBinContent(ls, 
                       float(nBClus[i])/float(all_detectors_counts));
   }
   for(unsigned int i = 0; i < 2; i++){
     fHistnFPClusVsLS[i]->setBinContent(ls, 
                        float(nFPClus[i])/float(all_detectors_counts));
   }
   for(unsigned int i = 0; i < 2; i++){
     fHistnFMClusVsLS[i]->setBinContent(ls, 
                        float(nFMClus[i])/float(all_detectors_counts));
   }
   
   logFile_.open(fLogFileName_.c_str(),std::ios_base::trunc);        
 
   timeval tv;
   gettimeofday(&tv,0);
   tm *ts = gmtime(&tv.tv_sec);
   char datestring[256];
   strftime(datestring, sizeof(datestring),"%Y.%m.%d %T GMT %s",ts);
   logFile_ << "RunNumber "<< fRunNo << std::endl;
   logFile_ << "EndTimeOfFit " << datestring << std::endl;
   logFile_ << "LumiRange "<< ls << "-" << ls << std::endl;
   logFile_ << "Fill "<< -99 << std::endl;
   logFile_ << "ActiveBunchCrossings "<< filledAndUnmaskedBunches << std::endl;
   logFile_ << "PixelLumi "<< fHistTotalRecordedLumiByLS->getBinContent(ls) * 0.98 << std::endl;
   logFile_ << "HFLumi "<< -99 << std::endl;
   logFile_ << "Ratio " << -99 << std::endl;
   logFile_.close();
 }

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

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 484 of file PixelLumiDQM.cc.

485 {

486 }

void PixelLumiDQM::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 100 of file PixelLumiDQM.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                          {
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }