#include <CSCValidation.h>

Inheritance diagram for CSCValidation:

Classes
struct	ltrh

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &eventSetup) override
	Perform the analysis. More...

	CSCValidation (const edm::ParameterSet &pset)
	Constructor. More...

void	endJob () override

	~CSCValidation () override
	Destructor. More...

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
int	chamberSerial (CSCDetId id)

void	doADCTiming (const CSCRecHit2DCollection &)

void	doAFEBTiming (const CSCWireDigiCollection &)

void	doCalibrations (const edm::EventSetup &eventSetup)

void	doCompTiming (const CSCComparatorDigiCollection &)

void	doEfficiencies (edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)

void	doGasGain (const CSCWireDigiCollection &, const CSCStripDigiCollection &, const CSCRecHit2DCollection &)

bool	doHLT (edm::Handle< edm::TriggerResults > hltResults)

void	doNoiseHits (edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom, edm::Handle< CSCStripDigiCollection > strips)

void	doOccupancies (edm::Handle< CSCStripDigiCollection > strips, edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments)

void	doPedestalNoise (edm::Handle< CSCStripDigiCollection > strips)

void	doRecHits (edm::Handle< CSCRecHit2DCollection > recHits, edm::ESHandle< CSCGeometry > cscGeom)

void	doResolution (edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)

void	doSegments (edm::Handle< CSCSegmentCollection > cscSegments, edm::ESHandle< CSCGeometry > cscGeom)

void	doSimHits (edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< edm::PSimHitContainer > simHits)

void	doStandalone (edm::Handle< reco::TrackCollection > saMuons)

void	doStripDigis (edm::Handle< CSCStripDigiCollection > strips)

void	doTimeMonitoring (edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::Handle< CSCALCTDigiCollection > alcts, edm::Handle< CSCCLCTDigiCollection > clcts, edm::Handle< CSCCorrelatedLCTDigiCollection > correlatedlcts, edm::Handle< L1MuGMTReadoutCollection > pCollection, edm::ESHandle< CSCGeometry > cscGeom, const edm::EventSetup &eventSetup, const edm::Event &event)

bool	doTrigger (edm::Handle< L1MuGMTReadoutCollection > pCollection)

void	doWireDigis (edm::Handle< CSCWireDigiCollection > wires)

double	extrapolate1D (double initPosition, double initDirection, double parameterOfTheLine)

void	fillEfficiencyHistos (int bin, int flag)

bool	filterEvents (edm::Handle< CSCRecHit2DCollection > recHits, edm::Handle< CSCSegmentCollection > cscSegments, edm::Handle< reco::TrackCollection > saMuons)

void	findNonAssociatedRecHits (edm::ESHandle< CSCGeometry > cscGeom, edm::Handle< CSCStripDigiCollection > strips)

float	fitX (const CLHEP::HepMatrix &sp, const CLHEP::HepMatrix &ep)

void	getEfficiency (float bin, float Norm, std::vector< float > &eff)

float	getSignal (const CSCStripDigiCollection &stripdigis, CSCDetId idRH, int centerStrip)

float	getthisSignal (const CSCStripDigiCollection &stripdigis, CSCDetId idRH, int centerStrip)

int	getWidth (const CSCStripDigiCollection &stripdigis, CSCDetId idRH, int centerStrip)

void	histoEfficiency (TH1F readHisto, TH1F writeHisto)

double	lineParametrization (double z1Position, double z2Position, double z1Direction)

int	ringSerial (CSCDetId id)

int	typeIndex (CSCDetId id)

bool	withinSensitiveRegion (LocalPoint localPos, const std::array< const float, 4 > &layerBounds, int station, int ring, float shiftFromEdge, float shiftFromDeadZone)

Private Attributes
edm::EDGetTokenT< CSCALCTDigiCollection >	al_token

std::multimap< CSCDetId, CSCRecHit2D >	AllRechits

edm::EDGetTokenT< CSCComparatorDigiCollection >	cd_token

double	chisqMax

edm::EDGetTokenT< CSCCLCTDigiCollection >	cl_token

bool	cleanEvent

edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	co_token

double	deltaPhiMax

bool	detailedAnalysis

std::map< CSCRecHit2D, float, ltrh >	distRHmap

bool	firstEvent

TH2F *	hEffDenominator

CSCValHists *	histos

TH2I *	hORecHits

TH2I *	hOSegments

TH2I *	hOStrips

TH2I *	hOWires

TH1F *	hRHEff

TH2F *	hRHEff2

TH1F *	hRHSTE

TH2F *	hRHSTE2

TH1F *	hSEff

TH2F *	hSEff2

TH2F *	hSensitiveAreaEvt

TH1F *	hSSTE

TH2F *	hSSTE2

TH2F *	hStripEff2

TH2F *	hStripSTE2

TH2F *	hWireEff2

TH2F *	hWireSTE2

bool	isSimulation

edm::EDGetTokenT< L1MuGMTReadoutCollection >	l1_token

double	lengthMax

double	lengthMin

std::map< int, int >	m_single_wire_layer

std::map< int, std::vector< int > >	m_wire_hvsegm

bool	makeADCTimingPlots

bool	makeAFEBTimingPlots

bool	makeCalibPlots

bool	makeComparisonPlots

bool	makeCompTimingPlots

bool	makeEfficiencyPlots

bool	makeGasGainPlots

bool	makeHLTPlots

bool	makeOccupancyPlots

bool	makePedNoisePlots

bool	makePlots

bool	makeRecHitPlots

bool	makeResolutionPlots

bool	makeRHNoisePlots

bool	makeSegmentPlots

bool	makeSimHitPlots

bool	makeStandalonePlots

bool	makeStripPlots

bool	makeTimeMonitorPlots

bool	makeTriggerPlots

bool	makeWirePlots

int	nCSCHitsMax

int	nCSCHitsMin

int	nEventsAnalyzed

std::vector< int >	nmbhvsegm
	Maps and vectors for module doGasGain() More...

std::multimap< CSCDetId, CSCRecHit2D >	NonAssociatedRechits

double	pMin

double	polarMax

double	polarMin

edm::EDGetTokenT< FEDRawDataCollection >	rd_token

std::string	refRootFile

edm::EDGetTokenT< CSCRecHit2DCollection >	rh_token

int	rhTreeCount

std::string	rootFileName

edm::EDGetTokenT< reco::TrackCollection >	sa_token

edm::EDGetTokenT< CSCStripDigiCollection >	sd_token

edm::EDGetTokenT< CSCSegmentCollection >	se_token

std::multimap< CSCDetId, CSCRecHit2D >	SegRechits

int	segTreeCount

edm::EDGetTokenT< edm::PSimHitContainer >	sh_token

TFile *	theFile

edm::EDGetTokenT< edm::TriggerResults >	tr_token

bool	useDigis

bool	useQualityFilter

bool	useTriggerFilter

edm::EDGetTokenT< CSCWireDigiCollection >	wd_token

bool	writeTreeToFile

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 &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

Package to validate local CSC reconstruction: DIGIS recHits segments L1 trigger CSC STA muons Various efficiencies

Responsible: Andy Kubik, Northwestern University

Definition at line 119 of file CSCValidation.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 17 of file CSCValidation.cc.

References objects.autophobj::float, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), plotFactory::histos, ALCARECOTkAlMinBias_cff::pMin, DTAnalyzerDetailed_cfi::rootFileName, AlCaHLTBitMon_QueryRunRegistry::string, and interactiveExample::theFile.

                                                     { 
 
   // Get the various input parameters
   rootFileName         = pset.getUntrackedParameter<std::string>("rootFileName","valHists.root");
   isSimulation         = pset.getUntrackedParameter<bool>("isSimulation",false);
   writeTreeToFile      = pset.getUntrackedParameter<bool>("writeTreeToFile",true);
   detailedAnalysis     = pset.getUntrackedParameter<bool>("detailedAnalysis",false);
   useDigis             = pset.getUntrackedParameter<bool>("useDigis",true);
 
   // event quality filter
   useQualityFilter     = pset.getUntrackedParameter<bool>("useQualityFilter",false);
   pMin                 = pset.getUntrackedParameter<double>("pMin",4.);
   chisqMax             = pset.getUntrackedParameter<double>("chisqMax",20.);
   nCSCHitsMin          = pset.getUntrackedParameter<int>("nCSCHitsMin",10);
   nCSCHitsMax          = pset.getUntrackedParameter<int>("nCSCHitsMax",25);
   lengthMin            = pset.getUntrackedParameter<double>("lengthMin",140.);
   lengthMax            = pset.getUntrackedParameter<double>("lengthMax",600.);
   deltaPhiMax          = pset.getUntrackedParameter<double>("deltaPhiMax",0.2);
   polarMax             = pset.getUntrackedParameter<double>("polarMax",0.7);
   polarMin             = pset.getUntrackedParameter<double>("polarMin",0.3);
 
   // trigger filter
   useTriggerFilter     = pset.getUntrackedParameter<bool>("useTriggerFilter",false);
 
   // input tags for collections
   rd_token = consumes<FEDRawDataCollection>( pset.getParameter<edm::InputTag>("rawDataTag") );
   sd_token = consumes<CSCStripDigiCollection>( pset.getParameter<edm::InputTag>("stripDigiTag") );
   wd_token = consumes<CSCWireDigiCollection>( pset.getParameter<edm::InputTag>("wireDigiTag") );
   cd_token = consumes<CSCComparatorDigiCollection>( pset.getParameter<edm::InputTag>("compDigiTag") );
   al_token = consumes<CSCALCTDigiCollection>( pset.getParameter<edm::InputTag>("alctDigiTag") );
   cl_token = consumes<CSCCLCTDigiCollection>( pset.getParameter<edm::InputTag>("clctDigiTag") );
   co_token = consumes<CSCCorrelatedLCTDigiCollection>( pset.getParameter<edm::InputTag>("corrlctDigiTag") );
   rh_token = consumes<CSCRecHit2DCollection>( pset.getParameter<edm::InputTag>("cscRecHitTag") );
   se_token = consumes<CSCSegmentCollection>( pset.getParameter<edm::InputTag>("cscSegTag") );
   sa_token = consumes<reco::TrackCollection>( pset.getParameter<edm::InputTag>("saMuonTag") );
   l1_token = consumes<L1MuGMTReadoutCollection>( pset.getParameter<edm::InputTag>("l1aTag") );
   tr_token = consumes<TriggerResults>( pset.getParameter<edm::InputTag>("hltTag") );
   sh_token = consumes<PSimHitContainer>( pset.getParameter<edm::InputTag>("simHitTag") );
 
   // flags to switch on/off individual modules
   makeOccupancyPlots   = pset.getUntrackedParameter<bool>("makeOccupancyPlots",true);
   makeTriggerPlots     = pset.getUntrackedParameter<bool>("makeTriggerPlots",false);
   makeStripPlots       = pset.getUntrackedParameter<bool>("makeStripPlots",true);
   makeWirePlots        = pset.getUntrackedParameter<bool>("makeWirePlots",true);
   makeRecHitPlots      = pset.getUntrackedParameter<bool>("makeRecHitPlots",true);
   makeSimHitPlots      = pset.getUntrackedParameter<bool>("makeSimHitPlots",true);
   makeSegmentPlots     = pset.getUntrackedParameter<bool>("makeSegmentPlots",true);
   makeResolutionPlots  = pset.getUntrackedParameter<bool>("makeResolutionPlots",true);
   makePedNoisePlots    = pset.getUntrackedParameter<bool>("makePedNoisePlots",true);
   makeEfficiencyPlots  = pset.getUntrackedParameter<bool>("makeEfficiencyPlots",true);
   makeGasGainPlots     = pset.getUntrackedParameter<bool>("makeGasGainPlots",true);
   makeAFEBTimingPlots  = pset.getUntrackedParameter<bool>("makeAFEBTimingPlots",true);
   makeCompTimingPlots  = pset.getUntrackedParameter<bool>("makeCompTimingPlots",true);
   makeADCTimingPlots   = pset.getUntrackedParameter<bool>("makeADCTimingPlots",true);
   makeRHNoisePlots     = pset.getUntrackedParameter<bool>("makeRHNoisePlots",false);
   makeCalibPlots       = pset.getUntrackedParameter<bool>("makeCalibPlots",false);
   makeStandalonePlots  = pset.getUntrackedParameter<bool>("makeStandalonePlots",false);
   makeTimeMonitorPlots = pset.getUntrackedParameter<bool>("makeTimeMonitorPlots",false);
   makeHLTPlots         = pset.getUntrackedParameter<bool>("makeHLTPlots",false);
 
   // set counters to zero
   nEventsAnalyzed = 0;
   rhTreeCount = 0;
   segTreeCount = 0;
   firstEvent = true; 
  
   // Create the root file for the histograms
   theFile = new TFile(rootFileName.c_str(), "RECREATE");
   theFile->cd();
 
   // Create object of class CSCValHists to manage histograms
   histos = new CSCValHists();
 
   // book Occupancy Histos
   hOWires    = new TH2I("hOWires","Wire Digi Occupancy",36,0.5,36.5,20,0.5,20.5);
   hOStrips   = new TH2I("hOStrips","Strip Digi Occupancy",36,0.5,36.5,20,0.5,20.5);
   hORecHits  = new TH2I("hORecHits","RecHit Occupancy",36,0.5,36.5,20,0.5,20.5);
   hOSegments = new TH2I("hOSegments","Segments Occupancy",36,0.5,36.5,20,0.5,20.5);
 
   // book Eff histos
   hSSTE = new TH1F("hSSTE","hSSTE",40,0,40);
   hRHSTE = new TH1F("hRHSTE","hRHSTE",40,0,40);
   hSEff = new TH1F("hSEff","Segment Efficiency",20,0.5,20.5);
   hRHEff = new TH1F("hRHEff","recHit Efficiency",20,0.5,20.5);
 
   const int nChambers = 36; 
   const int nTypes = 18;
   float nCH_min = 0.5;
   float nCh_max = float(nChambers) + 0.5;
   float nT_min = 0.5;
   float nT_max = float(nTypes) + 0.5;
 
   hSSTE2 = new TH2F("hSSTE2","hSSTE2",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   hRHSTE2 = new TH2F("hRHSTE2","hRHSTE2",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   hStripSTE2 = new TH2F("hStripSTE2","hStripSTE2",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   hWireSTE2 = new TH2F("hWireSTE2","hWireSTE2",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   
 
   hEffDenominator = new TH2F("hEffDenominator","hEffDenominator",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   hSEff2 = new TH2F("hSEff2","Segment Efficiency 2D",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   hRHEff2 = new TH2F("hRHEff2","recHit Efficiency 2D",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
 
   hStripEff2 = new TH2F("hStripEff2","strip Efficiency 2D",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
   hWireEff2 = new TH2F("hWireEff2","wire Efficiency 2D",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
 
   hSensitiveAreaEvt = new TH2F("hSensitiveAreaEvt","events in sensitive area",nChambers,nCH_min,nCh_max, nTypes, nT_min, nT_max);
  
   // setup trees to hold global position data for rechits and segments
   if (writeTreeToFile) histos->setupTrees();
 
 
 }

CSCValidation::~CSCValidation ( )

override

Destructor.

Definition at line 133 of file CSCValidation.cc.

References plotFactory::histos, and interactiveExample::theFile.

                              {
 
   // produce final efficiency histograms
   histoEfficiency(hRHSTE,hRHEff);
   histoEfficiency(hSSTE,hSEff);
   hSEff2->Divide(hSSTE2,hEffDenominator,1.,1.,"B");
   hRHEff2->Divide(hRHSTE2,hEffDenominator,1.,1.,"B");
   hStripEff2->Divide(hStripSTE2,hEffDenominator,1.,1.,"B");
   hWireEff2->Divide(hWireSTE2,hEffDenominator,1.,1.,"B");
 
   histos->insertPlot(hRHSTE,"hRHSTE","Efficiency");
   histos->insertPlot(hSSTE,"hSSTE","Efficiency");
   histos->insertPlot(hSSTE2,"hSSTE2","Efficiency");
   histos->insertPlot(hEffDenominator,"hEffDenominator","Efficiency");
   histos->insertPlot(hRHSTE2,"hRHSTE2","Efficiency");
   histos->insertPlot(hStripSTE2,"hStripSTE2","Efficiency");
   histos->insertPlot(hWireSTE2,"hWireSTE2","Efficiency");
 
   //moving this to post job macros
   histos->insertPlot(hSEff,"hSEff","Efficiency");
   histos->insertPlot(hRHEff,"hRHEff","Efficiency");
 
   histos->insertPlot(hSEff2,"hSEff2","Efficiency");
   histos->insertPlot(hRHEff2,"hRHEff2","Efficiency");
   histos->insertPlot(hStripEff2,"hStripff2","Efficiency");
   histos->insertPlot(hWireEff2,"hWireff2","Efficiency");
   
   histos->insertPlot(hSensitiveAreaEvt,"","Efficiency");
 
   // throw in occupancy plots so they're saved
   histos->insertPlot(hOWires,"hOWires","Digis");
   histos->insertPlot(hOStrips,"hOStrips","Digis");
   histos->insertPlot(hORecHits,"hORecHits","recHits");
   histos->insertPlot(hOSegments,"hOSegments","Segments");
 
   
   // write histos to the specified file
   histos->writeHists(theFile);
   if (writeTreeToFile) histos->writeTrees(theFile);
   theFile->Close();
 
 }

Member Function Documentation

void CSCValidation::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

Perform the analysis.

Definition at line 179 of file CSCValidation.cc.

References cscSegments_cfi::cscSegments, ecalTB2006H4_GenSimDigiReco_cfg::doSimHits, edm::EventSetup::get(), ValidationMatrix::hlt, trackerHits::simHits, RecoTauPiZeroBuilderPlugins_cfi::strips, and muonCSCDigis_cfi::wires.

                                                                             {
   // increment counter
   nEventsAnalyzed++;
 
   //int iRun   = event.id().run();
   //int iEvent = event.id().event();
 
   // Get the Digis
   edm::Handle<CSCWireDigiCollection> wires;
   edm::Handle<CSCStripDigiCollection> strips;
   edm::Handle<CSCComparatorDigiCollection> compars;
   edm::Handle<CSCALCTDigiCollection> alcts;
   edm::Handle<CSCCLCTDigiCollection> clcts;
   edm::Handle<CSCCorrelatedLCTDigiCollection> correlatedlcts;
   if (useDigis){
     event.getByToken( sd_token, strips );
     event.getByToken( wd_token, wires );
     event.getByToken( cd_token, compars );
     event.getByToken( al_token, alcts );
     event.getByToken( cl_token, clcts );
     event.getByToken( co_token, correlatedlcts );
  }
 
   // Get the CSC Geometry :
   edm::ESHandle<CSCGeometry> cscGeom;
   eventSetup.get<MuonGeometryRecord>().get(cscGeom);
 
   // Get the RecHits collection :
   edm::Handle<CSCRecHit2DCollection> recHits;
   event.getByToken( rh_token, recHits );
 
   //CSCRecHit2DCollection::const_iterator recIt;
   //for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
   //  recIt->print();
   // }
 
 
   // Get the SimHits (if applicable)
   edm::Handle<PSimHitContainer> simHits;
   if ( isSimulation ) event.getByToken( sh_token, simHits );
 
   // get CSC segment collection
   edm::Handle<CSCSegmentCollection> cscSegments;
   event.getByToken( se_token, cscSegments );
 
   // get the trigger collection
   edm::Handle<L1MuGMTReadoutCollection> pCollection;
   if (makeTriggerPlots || useTriggerFilter || (useDigis && makeTimeMonitorPlots)){
     event.getByToken( l1_token, pCollection );
   }
   edm::Handle<TriggerResults> hlt;
   if (makeHLTPlots) {
       event.getByToken( tr_token, hlt );
   }
 
   // get the standalone muon collection
   edm::Handle<reco::TrackCollection> saMuons;
   if (makeStandalonePlots || useQualityFilter) {
      event.getByToken( sa_token, saMuons );
   }
 
 
   // Run the modules //
 
   // Only do this for the first event
   // this is probably outdated and needs to be looked at
   if (nEventsAnalyzed == 1 && makeCalibPlots) doCalibrations(eventSetup);
 
 
   // Look at the l1a trigger info (returns true if csc L1A present)
   bool CSCL1A = false;
   if (makeTriggerPlots || useTriggerFilter) CSCL1A = doTrigger(pCollection);
   if (!useTriggerFilter) CSCL1A = true;  // always true if not filtering on trigger
 
 
   cleanEvent = false;
   if (makeStandalonePlots || useQualityFilter) cleanEvent = filterEvents(recHits,cscSegments,saMuons);
   if (!useQualityFilter) cleanEvent = true; // always true if not filtering on event quality
 
   
   // look at various chamber occupancies
   // keep this outside of filter for diagnostics???
   if (makeOccupancyPlots && CSCL1A) doOccupancies(strips,wires,recHits,cscSegments);
 
 
   if (makeHLTPlots) doHLT(hlt);
 
 
   if (cleanEvent && CSCL1A){
 
     // general look at strip digis
     if (makeStripPlots && useDigis) doStripDigis(strips);
 
     // general look at wire digis
     if (makeWirePlots && useDigis) doWireDigis(wires);
 
 
     // general look at rechits
     if (makeRecHitPlots) doRecHits(recHits,cscGeom);
 
     // look at simHits
     if (isSimulation && makeSimHitPlots) doSimHits(recHits,simHits);
 
     // general look at Segments
     if (makeSegmentPlots) doSegments(cscSegments,cscGeom);
 
     // look at hit resolution
     if (makeResolutionPlots) doResolution(cscSegments,cscGeom);
 
 
     // look at Pedestal Noise
     if (makePedNoisePlots && useDigis) doPedestalNoise(strips);
   
     // look at recHit and segment efficiencies
     if (makeEfficiencyPlots) doEfficiencies(wires,strips, recHits, cscSegments,cscGeom);
 
     // gas gain
     if (makeGasGainPlots && useDigis) doGasGain(*wires,*strips,*recHits);
 
 
     // AFEB timing
     if (makeAFEBTimingPlots && useDigis) doAFEBTiming(*wires);
 
     // Comparators timing
     if (makeCompTimingPlots && useDigis) doCompTiming(*compars);
 
     // strip ADC timing
     if (makeADCTimingPlots) doADCTiming(*recHits);
 
 
 
     // recHit Noise
     if (makeRHNoisePlots && useDigis) doNoiseHits(recHits,cscSegments,cscGeom,strips);
 
     // look at standalone muons (not implemented yet)
     if (makeStandalonePlots) doStandalone(saMuons);
 
     // make plots for monitoring the trigger and offline timing
     if (makeTimeMonitorPlots) doTimeMonitoring(recHits,cscSegments, alcts, clcts, correlatedlcts, pCollection,cscGeom, eventSetup, event);
 
     firstEvent = false;
 
   }
 
 }

int CSCValidation::chamberSerial ( CSCDetId id )

private

Definition at line 1231 of file CSCValidation.cc.

References RecoEcal_EventContent_cff::ec.

Referenced by CSCValidation::ltrh::operator()().

                                               {
   int st = id.station();
   int ri = id.ring();
   int ch = id.chamber();
   int ec = id.endcap();
   int kSerial = ch;
   if (st == 1 && ri == 1) kSerial = ch;
   if (st == 1 && ri == 2) kSerial = ch + 36;
   if (st == 1 && ri == 3) kSerial = ch + 72;
   if (st == 1 && ri == 4) kSerial = ch;
   if (st == 2 && ri == 1) kSerial = ch + 108;
   if (st == 2 && ri == 2) kSerial = ch + 126;
   if (st == 3 && ri == 1) kSerial = ch + 162;
   if (st == 3 && ri == 2) kSerial = ch + 180;
   if (st == 4 && ri == 1) kSerial = ch + 216;
   if (st == 4 && ri == 2) kSerial = ch + 234;  // one day...
   if (ec == 2) kSerial = kSerial + 300;
   return kSerial;
 }

void CSCValidation::doADCTiming ( const CSCRecHit2DCollection & rechitcltn )

private

Definition at line 2556 of file CSCValidation.cc.

References CSCIndexer::dbIndex(), makeMuonMisalignmentScenario::endcap, RemoveAddSevLevel::flag, plotFactory::histos, mps_fire::i, dataset::name, relativeConstraints::ring, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and runGCPTkAlMap::title.

Referenced by CSCValidation::ltrh::operator()().

                                                                        {
   float  adc_3_3_sum,adc_3_3_wtbin,x,y;
      int cfeb,idchamber,ring;
 
      std::string name,title,endcapstr;
      ostringstream ss;
      std::vector<float> zer(6,0.0);
 
      CSCIndexer indexer;
      std::map<int,int>::iterator intIt;
 
      if(rechitcltn.begin() != rechitcltn.end()) {
 
   //   std::cout<<"Event "<<nEventsAnalyzed <<std::endl;
 
        // Looping thru rechit collection
        CSCRecHit2DCollection::const_iterator recIt;
        CSCRecHit2D::ADCContainer m_adc;
        for(recIt = rechitcltn.begin(); recIt != rechitcltn.end(); ++recIt) {
           CSCDetId id = (CSCDetId)(*recIt).cscDetId();
           // getting strips comprising rechit
           if(recIt->nStrips()==3) {
             // get 3X3 ADC Sum
               // get 3X3 ADC Sum
               unsigned int binmx=0;
               float adcmax=0.0;
  
               for(unsigned int i=0;i<recIt->nStrips();i++) 
                 for(unsigned int j=0;j<recIt->nTimeBins();j++)
                   if(recIt->adcs(i,j)>adcmax) {
                     adcmax=recIt->adcs(i,j); 
                     binmx=j;
                   }
 
                adc_3_3_sum=0.0;
                //well, this really only works for 3 strips in readout - not sure the right fix for general case
                for(unsigned int i=0;i<recIt->nStrips();i++) 
                   for(unsigned int j=binmx-1;j<=binmx+1;j++) 
                        adc_3_3_sum+=recIt->adcs(i,j);
       
       
                   // ADC weighted time bin
                if(adc_3_3_sum > 100.0) {
                            
       
                  int centerStrip=recIt->channels(1); //take central from 3 strips;
                  // temporary fix
                  int flag=0;
                  if(id.station()==1 && id.ring()==4 &&  centerStrip>16) flag=1;
                  // end of temporary fix
                  if(flag==0) {
                       adc_3_3_wtbin=(*recIt).tpeak()/50;   //getTiming(strpcltn, id, centerStrip);
                       idchamber=indexer.dbIndex(id, centerStrip)/10; //strips 1-16 ME1/1a
                                                   // become strips 65-80 ME1/1 !!!
                       /*
                       if(id.station()==1 && (id.ring()==1 || id.ring()==4))
                       std::cout<<idchamber<<" "<<id.station()<<" "<<id.ring()<<" "<<m_strip[1]<<" "<<
                           "      "<<centerStrip<<
                              " "<<adc_3_3_wtbin<<"     "<<adc_3_3_sum<<std::endl;    
                       */      
                      ss<<"adc_3_3_weight_time_bin_vs_cfeb_occupancy_ME_"<<idchamber;
                      name=ss.str(); ss.str("");
       
                      std::string endcapstr;
                      if(id.endcap() == 1) endcapstr = "+";
                      if(id.endcap() == 2) endcapstr = "-";
                      ring=id.ring(); if(id.ring()==4) ring=1;
                      ss<<"ADC 3X3 Weighted Time Bin vs CFEB Occupancy ME"
                        <<endcapstr<<id.station()<<"/"<<ring<<"/"<<id.chamber();
                      title=ss.str(); ss.str("");
       
                      cfeb=(centerStrip-1)/16+1;
                      x=cfeb; y=adc_3_3_wtbin;
                      histos->fill2DHist(x,y,name,title,5,1.,6.,80,-8.,8.,"ADCTiming");                                     
                      } // end of if flag==0
                  } // end of if (adc_3_3_sum > 100.0)
             } // end of if if(m_strip.size()==3
         } // end of the  pass thru CSCRecHit2DCollection
     }  // end of if (rechitcltn.begin() != rechitcltn.end())
 }

void CSCValidation::doAFEBTiming ( const CSCWireDigiCollection & wirecltn )

private

Definition at line 2430 of file CSCValidation.cc.

References CSCIndexer::dbIndex(), makeMuonMisalignmentScenario::endcap, plotFactory::histos, dataset::name, AlCaHLTBitMon_QueryRunRegistry::string, and runGCPTkAlMap::title.

Referenced by CSCValidation::ltrh::operator()().

                                                                       {
      ostringstream ss;
      std::string name,title,endcapstr;
      float x,y;
      int wire,wiretbin,nmbwiretbin,layer,afeb,idlayer,idchamber;
      int channel=0; // for  CSCIndexer::dbIndex(id, channel); irrelevant here
      CSCIndexer indexer;
 
      if(wirecltn.begin() != wirecltn.end())  {
 
        //std::cout<<std::endl;
        //std::cout<<"Event "<<nEventsAnalyzed<<std::endl;
        //std::cout<<std::endl;
 
        // cycle on wire collection for all CSC
        CSCWireDigiCollection::DigiRangeIterator wiredetUnitIt;
        for(wiredetUnitIt=wirecltn.begin();wiredetUnitIt!=wirecltn.end();
           ++wiredetUnitIt) {
           const CSCDetId id = (*wiredetUnitIt).first;
           idlayer=indexer.dbIndex(id, channel);
           idchamber=idlayer/10;
           layer=id.layer();
 
           if (id.endcap() == 1) endcapstr = "+";
           if (id.endcap() == 2) endcapstr = "-";
 
           // looping in the layer of given CSC
  
           const CSCWireDigiCollection::Range& range = (*wiredetUnitIt).second;
           for(CSCWireDigiCollection::const_iterator digiIt =
              range.first; digiIt!=range.second; ++digiIt){
              wire=(*digiIt).getWireGroup();
              wiretbin=(*digiIt).getTimeBin();
              nmbwiretbin=(*digiIt).getTimeBinsOn().size();
              afeb=3*((wire-1)/8)+(layer+1)/2;
              
              // Anode wire group time bin vs afeb for each CSC
              x=afeb;
              y=wiretbin;
              ss<<"afeb_time_bin_vs_afeb_occupancy_ME_"<<idchamber;
              name=ss.str(); ss.str("");
              ss<<"Time Bin vs AFEB Occupancy ME"<<endcapstr<<id.station()<<"/"<<id.ring()<<"/"<< id.chamber();
              title=ss.str(); ss.str("");
              histos->fill2DHist(x,y,name,title,42,1.,43.,16,0.,16.,"AFEBTiming");
 
              // Number of anode wire group time bin vs afeb for each CSC
              x=afeb;
              y=nmbwiretbin;
              ss<<"nmb_afeb_time_bins_vs_afeb_ME_"<<idchamber;
              name=ss.str(); ss.str("");
              ss<<"Number of Time Bins vs AFEB ME"<<endcapstr<<id.station()<<"/"<<id.ring()<<"/"<< id.chamber();
              title=ss.str(); 
              ss.str("");
              histos->fill2DHist(x,y,name,title,42,1.,43.,16,0.,16.,"AFEBTiming");
              
           }     // end of digis loop in layer
        } // end of wire collection loop
      } // end of      if(wirecltn.begin() != wirecltn.end())
 }

void CSCValidation::doCalibrations ( const edm::EventSetup & eventSetup )

private

Definition at line 655 of file CSCValidation.cc.

References stringResolutionProvider_cfi::bin, CSCDBCrosstalk::crosstalk, CSCDBGains::gains, edm::EventSetup::get(), plotFactory::histos, mps_fire::i, LogDebug, CSCDBNoiseMatrix::matrix, CSCDBPedestals::pedestals, and edm::ESHandle< T >::product().

Referenced by CSCValidation::ltrh::operator()().

                                                                  {
 
   // Only do this for the first event
   if (nEventsAnalyzed == 1){
 
     LogDebug("Calibrations") << "Loading Calibrations...";
 
     // get the gains
     edm::ESHandle<CSCDBGains> hGains;
     eventSetup.get<CSCDBGainsRcd>().get( hGains );
     const CSCDBGains* pGains = hGains.product();
     // get the crosstalks
     edm::ESHandle<CSCDBCrosstalk> hCrosstalk;
     eventSetup.get<CSCDBCrosstalkRcd>().get( hCrosstalk );
     const CSCDBCrosstalk* pCrosstalk = hCrosstalk.product();
     // get the noise matrix
     edm::ESHandle<CSCDBNoiseMatrix> hNoiseMatrix;
     eventSetup.get<CSCDBNoiseMatrixRcd>().get( hNoiseMatrix );
     const CSCDBNoiseMatrix* pNoiseMatrix = hNoiseMatrix.product();
     // get pedestals
     edm::ESHandle<CSCDBPedestals> hPedestals;
     eventSetup.get<CSCDBPedestalsRcd>().get( hPedestals );
     const CSCDBPedestals* pPedestals = hPedestals.product();
 
     LogDebug("Calibrations") << "Calibrations Loaded!";
 
     for (int i = 0; i < 400; i++){
       int bin = i+1;
       histos->fillCalibHist(pGains->gains[i].gain_slope,"hCalibGainsS","Gains Slope",400,0,400,bin,"Calib");
       histos->fillCalibHist(pCrosstalk->crosstalk[i].xtalk_slope_left,"hCalibXtalkSL","Xtalk Slope Left",400,0,400,bin,"Calib");
       histos->fillCalibHist(pCrosstalk->crosstalk[i].xtalk_slope_right,"hCalibXtalkSR","Xtalk Slope Right",400,0,400,bin,"Calib");
       histos->fillCalibHist(pCrosstalk->crosstalk[i].xtalk_intercept_left,"hCalibXtalkIL","Xtalk Intercept Left",400,0,400,bin,"Calib");
       histos->fillCalibHist(pCrosstalk->crosstalk[i].xtalk_intercept_right,"hCalibXtalkIR","Xtalk Intercept Right",400,0,400,bin,"Calib");
       histos->fillCalibHist(pPedestals->pedestals[i].ped,"hCalibPedsP","Peds",400,0,400,bin,"Calib");
       histos->fillCalibHist(pPedestals->pedestals[i].rms,"hCalibPedsR","Peds RMS",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem33,"hCalibNoise33","Noise Matrix 33",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem34,"hCalibNoise34","Noise Matrix 34",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem35,"hCalibNoise35","Noise Matrix 35",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem44,"hCalibNoise44","Noise Matrix 44",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem45,"hCalibNoise45","Noise Matrix 45",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem46,"hCalibNoise46","Noise Matrix 46",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem55,"hCalibNoise55","Noise Matrix 55",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem56,"hCalibNoise56","Noise Matrix 56",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem57,"hCalibNoise57","Noise Matrix 57",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem66,"hCalibNoise66","Noise Matrix 66",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem67,"hCalibNoise67","Noise Matrix 67",400,0,400,bin,"Calib");
       histos->fillCalibHist(pNoiseMatrix->matrix[i].elem77,"hCalibNoise77","Noise Matrix 77",400,0,400,bin,"Calib");
 
  
     }
 
   }
 
 
 }

void CSCValidation::doCompTiming ( const CSCComparatorDigiCollection & compars )

private

Definition at line 2495 of file CSCValidation.cc.

References CSCIndexer::dbIndex(), makeMuonMisalignmentScenario::endcap, plotFactory::histos, dataset::name, AlCaHLTBitMon_QueryRunRegistry::string, digitizers_cfi::strip, and runGCPTkAlMap::title.

Referenced by CSCValidation::ltrh::operator()().

                                                                            {
 
      ostringstream ss;      std::string name,title,endcap;
      float x,y;
      int strip,tbin,cfeb,idlayer,idchamber;
      int channel=0; // for  CSCIndexer::dbIndex(id, channel); irrelevant here
      CSCIndexer indexer;
                                                                                 
      if(compars.begin() != compars.end())  {
                                                                                 
        //std::cout<<std::endl;
        //std::cout<<"Event "<<nEventsAnalyzed<<std::endl;
        //std::cout<<std::endl;
                                                                                 
        // cycle on comparators collection for all CSC
        CSCComparatorDigiCollection::DigiRangeIterator compdetUnitIt;
        for(compdetUnitIt=compars.begin();compdetUnitIt!=compars.end();
           ++compdetUnitIt) {
           const CSCDetId id = (*compdetUnitIt).first;
           idlayer=indexer.dbIndex(id, channel); // channel irrelevant here
           idchamber=idlayer/10;
                                                                                 
           if (id.endcap() == 1) endcap = "+";
           if (id.endcap() == 2) endcap = "-";
           // looping in the layer of given CSC
           const CSCComparatorDigiCollection::Range& range = 
           (*compdetUnitIt).second;
           for(CSCComparatorDigiCollection::const_iterator digiIt =
              range.first; digiIt!=range.second; ++digiIt){
              strip=(*digiIt).getStrip();
           /*
           if(id.station()==1 && (id.ring()==1 || id.ring()==4))
              std::cout<<idchamber<<" "<<id.station()<<" "<<id.ring()<<" "
                       <<strip <<std::endl;  
           */
              indexer.dbIndex(id, strip); // strips 1-16 of ME1/1a 
                                          // become strips 65-80 of ME1/1 
              tbin=(*digiIt).getTimeBin();
              cfeb=(strip-1)/16+1;
                                                                                 
              // time bin vs cfeb for each CSC
 
              x=cfeb;
              y=tbin;
              ss<<"comp_time_bin_vs_cfeb_occupancy_ME_"<<idchamber;
              name=ss.str(); ss.str("");
              ss<<"Comparator Time Bin vs CFEB Occupancy ME"<<endcap<<
                  id.station()<<"/"<< id.ring()<<"/"<< id.chamber();             
              title=ss.str(); ss.str("");
              histos->fill2DHist(x,y,name,title,5,1.,6.,16,0.,16.,"CompTiming");
 
          }     // end of digis loop in layer
        } // end of collection loop
      } // end of      if(compars.begin() !=compars.end())
 }

void CSCValidation::doEfficiencies	(	edm::Handle< CSCWireDigiCollection >	wires,
		edm::Handle< CSCStripDigiCollection >	strips,
		edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::Handle< CSCSegmentCollection >	cscSegments,
		edm::ESHandle< CSCGeometry >	cscGeom
	)

private

Definition at line 1319 of file CSCValidation.cc.

References stringResolutionProvider_cfi::bin, CSCDetId::chamber(), CSCGeometry::chamber(), CSCGeometry::chambers(), CSCChamberSpecs::chamberTypeName(), diffTreeTool::diff, CSCDetId::endcap(), plotBeamSpotDB::first, objects.autophobj::float, CSCLayer::geometry(), CSCChamber::id(), createfilelist::int, CSCChamber::layer(), CSCDetId::layer(), CSCSegment::localDirection(), CSCSegment::localPosition(), TrapezoidalPlaneBounds::parameters(), CSCDetId::ring(), CSCChamber::specs(), CSCDetId::station(), electronIdCutBased_cfi::threshold, GeomDet::toGlobal(), GeomDet::toLocal(), mps_merge::weight, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by CSCValidation::ltrh::operator()().

                                                                     {
 
   bool allWires[2][4][4][36][6];
   bool allStrips[2][4][4][36][6];
   bool AllRecHits[2][4][4][36][6];
   bool AllSegments[2][4][4][36];
   
   //bool MultiSegments[2][4][4][36];
   for(int iE = 0;iE<2;iE++){
     for(int iS = 0;iS<4;iS++){
       for(int iR = 0; iR<4;iR++){
         for(int iC =0;iC<36;iC++){
           AllSegments[iE][iS][iR][iC] = false;
           //MultiSegments[iE][iS][iR][iC] = false;
           for(int iL=0;iL<6;iL++){
         allWires[iE][iS][iR][iC][iL] = false;
         allStrips[iE][iS][iR][iC][iL] = false;
             AllRecHits[iE][iS][iR][iC][iL] = false;
           }
         }
       }
     }
   }
   
   if (useDigis){
     // Wires
     for (CSCWireDigiCollection::DigiRangeIterator dWDiter=wires->begin(); dWDiter!=wires->end(); dWDiter++) {
       CSCDetId idrec = (CSCDetId)(*dWDiter).first;
       std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
       std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
       for( ; wireIter != lWire; ++wireIter) {
         allWires[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber() -1][idrec.layer() -1] = true;
         break;
       }
     }
 
     //---- STRIPS
     for (CSCStripDigiCollection::DigiRangeIterator dSDiter=strips->begin(); dSDiter!=strips->end(); dSDiter++) {
       CSCDetId idrec = (CSCDetId)(*dSDiter).first;
       std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
       std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
       for( ; stripIter != lStrip; ++stripIter) {
         std::vector<int> myADCVals = stripIter->getADCCounts();
         bool thisStripFired = false;
         float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
         float threshold = 13.3 ;
         float diff = 0.;
         for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
           diff = (float)myADCVals[iCount]-thisPedestal;
           if (diff > threshold) {
             thisStripFired = true;
         break;
           }
         }
         if(thisStripFired){
       allStrips[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber() -1][idrec.layer() -1] = true;
           break;
         }
       }
     }
   }
 
   // Rechits
   for (CSCRecHit2DCollection::const_iterator recEffIt = recHits->begin(); recEffIt != recHits->end(); recEffIt++) {
     //CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
     CSCDetId  idrec = (CSCDetId)(*recEffIt).cscDetId();
     AllRecHits[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber() -1][idrec.layer() -1] = true;
 
   }
 
   std::vector <unsigned int> seg_ME2(2,0) ;
   std::vector <unsigned int> seg_ME3(2,0) ;
   std::vector < std::pair <CSCDetId, CSCSegment> > theSegments(4);
   // Segments
   for(CSCSegmentCollection::const_iterator segEffIt=cscSegments->begin(); segEffIt != cscSegments->end(); segEffIt++) {
     CSCDetId idseg  = (CSCDetId)(*segEffIt).cscDetId();
     //if(AllSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()]){
     //MultiSegments[idrec.endcap() -1][idrec.station() -1][idrec.ring() -1][idrec.chamber()] = true;
     //}
     AllSegments[idseg.endcap() -1][idseg.station() -1][idseg.ring() -1][idseg.chamber() -1] = true;
     // "Intrinsic" efficiency measurement relies on "good" segment extrapolation - we need the pre-selection below
     // station 2 "good" segment will be used for testing efficiencies in ME1 and ME3
     // station 3 "good" segment will be used for testing efficiencies in ME2 and ME4
     if(2==idseg.station() || 3==idseg.station()){
       unsigned int seg_tmp ; 
       if(2==idseg.station()){
     ++seg_ME2[idseg.endcap() -1];
     seg_tmp = seg_ME2[idseg.endcap() -1];
       }
       else{
     ++seg_ME3[idseg.endcap() -1];
     seg_tmp = seg_ME3[idseg.endcap() -1];
       }
       // is the segment good
       if(1== seg_tmp&& 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
     std::pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
     theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
       }
     }
     /*
     if(2==idseg.station()){
     ++seg_ME2[idseg.endcap() -1];
        if(1==seg_ME2[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
            std::pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
            theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
        }
     }
     else if(3==idseg.station()){
     ++seg_ME3[idseg.endcap() -1];
     if(1==seg_ME3[idseg.endcap() -1] && 6==(*segEffIt).nRecHits() && (*segEffIt).chi2()/(*segEffIt).degreesOfFreedom()<3.){
          std::pair <CSCDetId, CSCSegment> specSeg = make_pair( (CSCDetId)(*segEffIt).cscDetId(),*segEffIt);
      theSegments[2*(idseg.endcap()-1)+(idseg.station() -2)] = specSeg;
        }
     }
     */
     
   }
   // Simple efficiency calculations
   for(int iE = 0;iE<2;iE++){
     for(int iS = 0;iS<4;iS++){
       for(int iR = 0; iR<4;iR++){
         for(int iC =0;iC<36;iC++){
           int NumberOfLayers = 0;
           for(int iL=0;iL<6;iL++){
             if(AllRecHits[iE][iS][iR][iC][iL]){
               NumberOfLayers++;
             }
           }
           int bin = 0;
           if (iS==0) bin = iR+1+(iE*10);
           else bin = (iS+1)*2 + (iR+1) + (iE*10);
           if(NumberOfLayers>1){
             //if(!(MultiSegments[iE][iS][iR][iC])){
             if(AllSegments[iE][iS][iR][iC]){
               //---- Efficient segment evenents
               hSSTE->AddBinContent(bin);
             }
             //---- All segment events (normalization)
             hSSTE->AddBinContent(20+bin);
             //}
           }
           if(AllSegments[iE][iS][iR][iC]){
             if(NumberOfLayers==6){
               //---- Efficient rechit events
               hRHSTE->AddBinContent(bin);;
             }
             //---- All rechit events (normalization)
             hRHSTE->AddBinContent(20+bin);;
           }
         }
       }
     }
   }
 
 // pick a segment only if there are no others in the station
   std::vector < std::pair <CSCDetId, CSCSegment> * > theSeg;
   if(1==seg_ME2[0]) theSeg.push_back(&theSegments[0]);
   if(1==seg_ME3[0]) theSeg.push_back(&theSegments[1]);
   if(1==seg_ME2[1]) theSeg.push_back(&theSegments[2]);
   if(1==seg_ME3[1]) theSeg.push_back(&theSegments[3]);
 
   // Needed for plots
   // at the end the chamber types will be numbered as 1 to 18 
   // (ME-4/1, -ME3/2, -ME3/1, ..., +ME3/1, +ME3/2, ME+4/1 ) 
   std::map <std::string, float> chamberTypes;
   chamberTypes["ME1/a"] = 0.5;
   chamberTypes["ME1/b"] = 1.5;
   chamberTypes["ME1/2"] = 2.5;
   chamberTypes["ME1/3"] = 3.5;
   chamberTypes["ME2/1"] = 4.5;
   chamberTypes["ME2/2"] = 5.5;
   chamberTypes["ME3/1"] = 6.5;
   chamberTypes["ME3/2"] = 7.5;
   chamberTypes["ME4/1"] = 8.5;
 
   if(!theSeg.empty()){
     std::map <int , GlobalPoint> extrapolatedPoint;
     std::map <int , GlobalPoint>::iterator it;
     const CSCGeometry::ChamberContainer& ChamberContainer = cscGeom->chambers();
     // Pick which chamber with which segment to test
     for(size_t nCh=0;nCh<ChamberContainer.size();nCh++){
       const CSCChamber *cscchamber = ChamberContainer[nCh];
       std::pair <CSCDetId, CSCSegment> * thisSegment = nullptr;
       for(size_t iSeg =0;iSeg<theSeg.size();++iSeg ){
         if(cscchamber->id().endcap() == theSeg[iSeg]->first.endcap()){ 
           if(1==cscchamber->id().station() || 3==cscchamber->id().station() ){
         if(2==theSeg[iSeg]->first.station()){
           thisSegment = theSeg[iSeg];
         }
       }
       else if (2==cscchamber->id().station() || 4==cscchamber->id().station()){
         if(3==theSeg[iSeg]->first.station()){
           thisSegment = theSeg[iSeg];
         }
       }
     }
       }
       // this chamber is to be tested with thisSegment
       if(thisSegment){
     CSCSegment * seg = &(thisSegment->second);
     const CSCChamber *segChamber = cscGeom->chamber(thisSegment->first);
     LocalPoint localCenter(0.,0.,0);
     GlobalPoint cscchamberCenter =  cscchamber->toGlobal(localCenter);
     // try to save some time (extrapolate a segment to a certain position only once)
     it = extrapolatedPoint.find(int(cscchamberCenter.z()));
     if(it==extrapolatedPoint.end()){
       GlobalPoint segPos = segChamber->toGlobal(seg->localPosition());
       GlobalVector segDir = segChamber->toGlobal(seg->localDirection());
       double paramaterLine = lineParametrization(segPos.z(),cscchamberCenter.z() , segDir.z());
       double xExtrapolated = extrapolate1D(segPos.x(),segDir.x(), paramaterLine);
       double yExtrapolated = extrapolate1D(segPos.y(),segDir.y(), paramaterLine);
       GlobalPoint globP (xExtrapolated, yExtrapolated, cscchamberCenter.z());
       extrapolatedPoint[int(cscchamberCenter.z())] = globP;
     }
     // Where does the extrapolated point lie in the (tested) chamber local frame? Here: 
     LocalPoint extrapolatedPointLocal = cscchamber->toLocal(extrapolatedPoint[int(cscchamberCenter.z())]);
     const CSCLayer *layer_p = cscchamber->layer(1);//layer 1
     const CSCLayerGeometry *layerGeom = layer_p->geometry ();
     const std::array<const float, 4> & layerBounds = layerGeom->parameters ();
     float shiftFromEdge = 15.;//cm
     float shiftFromDeadZone = 10.;
     // is the extrapolated point within a sensitive region
     bool pass = withinSensitiveRegion(extrapolatedPointLocal, layerBounds, 
                       cscchamber->id().station(), cscchamber->id().ring(), 
                       shiftFromEdge, shiftFromDeadZone);
     if(pass){// the extrapolation point of the segment lies within sensitive region of that chamber
       // how many rechit layers are there in the chamber?
       // 0 - maybe the muon died or is deflected at large angle? do not use that case
       // 1 - could be noise...
       // 2 or more - this is promissing; this is our definition of a reliable signal; use it below
       // is other definition better? 
       int nRHLayers = 0;
       for(int iL =0;iL<6;++iL){
         if(AllRecHits[cscchamber->id().endcap()-1]
            [cscchamber->id().station()-1]
            [cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
           ++nRHLayers;
         }
       }
       //std::cout<<" nRHLayers = "<<nRHLayers<<std::endl;
       float verticalScale = chamberTypes[cscchamber->specs()->chamberTypeName()];
       if(cscchamberCenter.z()<0){
         verticalScale = - verticalScale;
       } 
       verticalScale +=9.5;
       hSensitiveAreaEvt->Fill(float(cscchamber->id().chamber()),verticalScale);
       if(nRHLayers>1){// this chamber contains a reliable signal
         //chamberTypes[cscchamber->specs()->chamberTypeName()];
         // "intrinsic" efficiencies
         //std::cout<<" verticalScale = "<<verticalScale<<" chType = "<<cscchamber->specs()->chamberTypeName()<<std::endl;
         // this is the denominator forr all efficiencies
         hEffDenominator->Fill(float(cscchamber->id().chamber()),verticalScale);
         // Segment efficiency
         if(AllSegments[cscchamber->id().endcap()-1]
            [cscchamber->id().station()-1]
            [cscchamber->id().ring()-1][cscchamber->id().chamber()-1]){
           hSSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale));
         }
       
         for(int iL =0;iL<6;++iL){
           float weight = 1./6.;
           // one shold account for the weight in the efficiency...
           // Rechit efficiency
           if(AllRecHits[cscchamber->id().endcap()-1]
          [cscchamber->id().station()-1]
          [cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
         hRHSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale),weight);
           }
               if (useDigis){
             // Wire efficiency
             if(allWires[cscchamber->id().endcap()-1]
           [cscchamber->id().station()-1]
           [cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
           // one shold account for the weight in the efficiency...
           hWireSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale),weight);
             }
             // Strip efficiency
             if(allStrips[cscchamber->id().endcap()-1]
           [cscchamber->id().station()-1]
           [cscchamber->id().ring()-1][cscchamber->id().chamber()-1][iL]){
           // one shold account for the weight in the efficiency...
           hStripSTE2->Fill(float(cscchamber->id().chamber()),float(verticalScale),weight);
             }
               }
         }
       }
     }
       }
     }
   }
   //
   
   
 }

void CSCValidation::doGasGain	(	const CSCWireDigiCollection &	wirecltn,
		const CSCStripDigiCollection &	strpcltn,
		const CSCRecHit2DCollection &	rechitcltn
	)

private

Definition at line 2195 of file CSCValidation.cc.

References CSCIndexer::dbIndex(), makeMuonMisalignmentScenario::endcap, RemoveAddSevLevel::flag, plotFactory::histos, mps_fire::i, triggerObjects_cff::id, dataset::name, relativeConstraints::ring, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and runGCPTkAlMap::title.

Referenced by CSCValidation::ltrh::operator()().

                                                                        {
      int channel=0,mult,wire,layer,idlayer,idchamber,ring;
      int wire_strip_rechit_present;
      std::string name,title,endcapstr;
      ostringstream ss;
      CSCIndexer indexer;
      std::map<int,int>::iterator intIt;
 
      m_single_wire_layer.clear();
 
   if(firstEvent) {
 
   // HV segments, their # and location in terms of wire groups
 
   m_wire_hvsegm.clear();
   std::map<int,std::vector<int> >::iterator intvecIt;
   //                    ME1a ME1b ME1/2 ME1/3 ME2/1 ME2/2 ME3/1 ME3/2 ME4/1 ME4/2 
   int csctype[10]=     {1,   2,   3,    4,    5,    6,    7,    8,    9,    10};
   int hvsegm_layer[10]={1,   1,   3,    3,    3,    5,    3,    5,    3,    5};
   int id;
   nmbhvsegm.clear();
   for(int i=0;i<10;i++) nmbhvsegm.push_back(hvsegm_layer[i]);
   // For ME1/1a
   std::vector<int> zer_1_1a(49,0);
   id=csctype[0];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_1_1a;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=48;wire++)  intvecIt->second[wire]=1;  // Segment 1
 
   // For ME1/1b
   std::vector<int> zer_1_1b(49,0);
   id=csctype[1];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_1_1b;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=48;wire++)  intvecIt->second[wire]=1;  // Segment 1
  
   // For ME1/2
   std::vector<int> zer_1_2(65,0);
   id=csctype[2];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_1_2;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=24;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=25;wire<=48;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=49;wire<=64;wire++) intvecIt->second[wire]=3;  // Segment 3
  
   // For ME1/3
   std::vector<int> zer_1_3(33,0);
   id=csctype[3];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_1_3;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=12;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=13;wire<=22;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=23;wire<=32;wire++) intvecIt->second[wire]=3;  // Segment 3
  
   // For ME2/1
   std::vector<int> zer_2_1(113,0);
   id=csctype[4];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_2_1;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=44;wire++)   intvecIt->second[wire]=1;  // Segment 1
   for(int wire=45;wire<=80;wire++)  intvecIt->second[wire]=2;  // Segment 2
   for(int wire=81;wire<=112;wire++) intvecIt->second[wire]=3;  // Segment 3
  
   // For ME2/2
   std::vector<int> zer_2_2(65,0);
   id=csctype[5];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_2_2;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=16;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=17;wire<=28;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=29;wire<=40;wire++) intvecIt->second[wire]=3;  // Segment 3
   for(int wire=41;wire<=52;wire++) intvecIt->second[wire]=4;  // Segment 4
   for(int wire=53;wire<=64;wire++) intvecIt->second[wire]=5;  // Segment 5
 
   // For ME3/1
   std::vector<int> zer_3_1(97,0);
   id=csctype[6];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_3_1;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=32;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=33;wire<=64;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=65;wire<=96;wire++) intvecIt->second[wire]=3;  // Segment 3
  
   // For ME3/2
   std::vector<int> zer_3_2(65,0);
   id=csctype[7];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_3_2;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=16;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=17;wire<=28;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=29;wire<=40;wire++) intvecIt->second[wire]=3;  // Segment 3
   for(int wire=41;wire<=52;wire++) intvecIt->second[wire]=4;  // Segment 4
   for(int wire=53;wire<=64;wire++) intvecIt->second[wire]=5;  // Segment 5
 
   // For ME4/1
   std::vector<int> zer_4_1(97,0);
   id=csctype[8];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_4_1;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=32;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=33;wire<=64;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=65;wire<=96;wire++) intvecIt->second[wire]=3;  // Segment 3
 
   // For ME4/2
   std::vector<int> zer_4_2(65,0);
   id=csctype[9];
   if(m_wire_hvsegm.find(id) == m_wire_hvsegm.end()) m_wire_hvsegm[id]=zer_4_2;
   intvecIt=m_wire_hvsegm.find(id);
   for(int wire=1;wire<=16;wire++)  intvecIt->second[wire]=1;  // Segment 1
   for(int wire=17;wire<=28;wire++) intvecIt->second[wire]=2;  // Segment 2
   for(int wire=29;wire<=40;wire++) intvecIt->second[wire]=3;  // Segment 3
   for(int wire=41;wire<=52;wire++) intvecIt->second[wire]=4;  // Segment 4
   for(int wire=53;wire<=64;wire++) intvecIt->second[wire]=5;  // Segment 5
 
   } // end of if(nEventsAnalyzed==1)
 
 
      // do wires, strips and rechits present?
      wire_strip_rechit_present=0;
      if(wirecltn.begin() != wirecltn.end())  
        wire_strip_rechit_present= wire_strip_rechit_present+1;
      if(strpcltn.begin() != strpcltn.end())    
        wire_strip_rechit_present= wire_strip_rechit_present+2;
      if(rechitcltn.begin() != rechitcltn.end())
        wire_strip_rechit_present= wire_strip_rechit_present+4;
 
      if(wire_strip_rechit_present==7) {
 
 //       std::cout<<"Event "<<nEventsAnalyzed<<std::endl;
 //       std::cout<<std::endl;
 
        // cycle on wire collection for all CSC to select single wire hit layers
        CSCWireDigiCollection::DigiRangeIterator wiredetUnitIt;
  
        for(wiredetUnitIt=wirecltn.begin();wiredetUnitIt!=wirecltn.end();
           ++wiredetUnitIt) {
           const CSCDetId id = (*wiredetUnitIt).first;
           idlayer=indexer.dbIndex(id, channel);
           idchamber=idlayer/10;
           layer=id.layer();
           // looping in the layer of given CSC
           mult=0; wire=0; 
           const CSCWireDigiCollection::Range& range = (*wiredetUnitIt).second;
           for(CSCWireDigiCollection::const_iterator digiIt =
              range.first; digiIt!=range.second; ++digiIt){
              wire=(*digiIt).getWireGroup();
              mult++;
           }     // end of digis loop in layer
 
           // select layers with single wire hit
           if(mult==1) {
             if(m_single_wire_layer.find(idlayer) == m_single_wire_layer.end())
               m_single_wire_layer[idlayer]=wire;
           } // end of if(mult==1)
        }   // end of cycle on detUnit
 
        // Looping thru rechit collection
        CSCRecHit2DCollection::const_iterator recIt;
        CSCRecHit2D::ADCContainer m_adc;
 
        for(recIt = rechitcltn.begin(); recIt != rechitcltn.end(); ++recIt) {
           CSCDetId id = (CSCDetId)(*recIt).cscDetId();
           idlayer=indexer.dbIndex(id, channel);
           idchamber=idlayer/10;
           layer=id.layer();
           // select layer with single wire rechit
           if(m_single_wire_layer.find(idlayer) != m_single_wire_layer.end()) {
 
             if(recIt->nStrips()==3)  {        
               // get 3X3 ADC Sum
               unsigned int binmx=0;
               float adcmax=0.0;
  
               for(unsigned int i=0;i<recIt->nStrips();i++) 
         for(unsigned int j=0;j<recIt->nTimeBins();j++)
           if(recIt->adcs(i,j)>adcmax) {
             adcmax=recIt->adcs(i,j); 
             binmx=j;
           }
 
           float adc_3_3_sum=0.0;
           //well, this really only works for 3 strips in readout - not sure the right fix for general case
               for(unsigned int i=0;i<recIt->nStrips();i++) 
         for(unsigned int j=binmx-1;j<=binmx+1;j++) 
           adc_3_3_sum+=recIt->adcs(i,j);
         
 
                if(adc_3_3_sum > 0.0 &&  adc_3_3_sum < 2000.0) {
 
                  // temporary fix for ME1/1a to avoid triple entries
                  int flag=0;
                  if(id.station()==1 && id.ring()==4 &&  recIt->channels(1)>16)  flag=1;
                  // end of temporary fix
                  if(flag==0) {
 
                  wire= m_single_wire_layer[idlayer];
                  int chambertype=id.iChamberType(id.station(),id.ring());
                  int hvsgmtnmb=m_wire_hvsegm[chambertype][wire];
                  int nmbofhvsegm=nmbhvsegm[chambertype-1];
                  int location= (layer-1)*nmbofhvsegm+hvsgmtnmb;
                 
                  ss<<"gas_gain_rechit_adc_3_3_sum_location_ME_"<<idchamber;
                  name=ss.str(); ss.str("");
                  if(id.endcap()==1) endcapstr = "+";
                  ring=id.ring();
                  if(id.station()==1 && id.ring()==4) ring=1;
                  if(id.endcap()==2) endcapstr = "-"; 
                  ss<<"Gas Gain Rechit ADC3X3 Sum ME"<<endcapstr<<
                    id.station()<<"/"<<ring<<"/"<<id.chamber();
                  title=ss.str(); ss.str("");
                  float x=location;
                  float y=adc_3_3_sum;
                  histos->fill2DHist(x,y,name,title,30,1.0,31.0,50,0.0,2000.0,"GasGain");
 
                  /*
                    std::cout<<idchamber<<"   "<<id.station()<<" "<<id.ring()<<" "
                    <<id.chamber()<<"    "<<layer<<" "<< wire<<" "<<m_strip[1]<<" "<<
                    chambertype<<" "<< hvsgmtnmb<<" "<< nmbofhvsegm<<" "<< 
                    location<<"   "<<adc_3_3_sum<<std::endl;
                  */
                } // end of if flag==0
                } // end if(adcsum>0.0 && adcsum<2000.0)
             } // end of if if(m_strip.size()==3
           } // end of if single wire
         } // end of looping thru rechit collection
      }   // end of if wire and strip and rechit present 
 }

bool CSCValidation::doHLT ( edm::Handle< edm::TriggerResults > hltResults )

private

Definition at line 637 of file CSCValidation.cc.

References edm::HLTGlobalStatus::accept(), plotFactory::histos, mps_fire::i, and edm::HLTGlobalStatus::size().

Referenced by CSCValidation::ltrh::operator()().

                                                    {
 
   // HLT stuff
   int hltSize = hlt->size();
   for (int i = 0; i < hltSize; ++i){
     if (hlt->accept(i)) histos->fill1DHist(i,"hltBits","HLT Trigger Bits",hltSize+1,-0.5,(float)hltSize+0.5,"Trigger");
   }
 
   return true;
 }

void CSCValidation::doNoiseHits	(	edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::Handle< CSCSegmentCollection >	cscSegments,
		edm::ESHandle< CSCGeometry >	cscGeom,
		edm::Handle< CSCStripDigiCollection >	strips
	)

private

Definition at line 1823 of file CSCValidation.cc.

References plotFactory::histos, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                             {
 
   CSCRecHit2DCollection::const_iterator recIt;
   for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
 
     CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
 
     //Store the Rechits into a Map
     AllRechits.insert(std::pair<CSCDetId , CSCRecHit2D>(idrec,*recIt));
 
     // Find the strip containing this hit
     int centerid     =  recIt->nStrips()/2;
     int centerStrip =  recIt->channels(centerid);
 
     float  rHsignal = getthisSignal(*strips, idrec, centerStrip);
     histos->fill1DHist(rHsignal,"hrHSignal", "Signal in the 4th time bin for centre strip",1100,-99,1000,"recHits");
 
   }
 
   for(CSCSegmentCollection::const_iterator it=cscSegments->begin(); it != cscSegments->end(); it++) {
 
     std::vector<CSCRecHit2D> theseRecHits = (*it).specificRecHits();
     for ( std::vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
       CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
       LocalPoint lpRH = (*iRH).localPosition();
       float xrec = lpRH.x();
       float yrec = lpRH.y();
       float zrec = lpRH.z();
       bool RHalreadyinMap = false;
       //Store the rechits associated with segments into a Map
       multimap<CSCDetId , CSCRecHit2D>::iterator segRHit;
       segRHit = SegRechits.find(idRH);
       if (segRHit != SegRechits.end()){
     for( ; segRHit != SegRechits.upper_bound(idRH); ++segRHit){
       //for( segRHit = SegRechits.begin(); segRHit != SegRechits.end() ;++segRHit){
       LocalPoint lposRH = (segRHit->second).localPosition();
       float xpos = lposRH.x();
       float ypos = lposRH.y();
       float zpos = lposRH.z();
       if ( xrec == xpos && yrec == ypos && zrec == zpos){
       RHalreadyinMap = true;
       //std::cout << " Already exists " <<std ::endl;
       break;}
     }
       }
       if(!RHalreadyinMap){ SegRechits.insert(std::pair<CSCDetId , CSCRecHit2D>(idRH,*iRH));}
     }
   }
 
   findNonAssociatedRecHits(cscGeom,strips);
 
 }

void CSCValidation::doOccupancies	(	edm::Handle< CSCStripDigiCollection >	strips,
		edm::Handle< CSCWireDigiCollection >	wires,
		edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::Handle< CSCSegmentCollection >	cscSegments
	)

private

Definition at line 412 of file CSCValidation.cc.

References EnergyCorrector::c, CSCDetId::chamber(), diffTreeTool::diff, MillePedeFileConverter_cfg::e, CSCDetId::endcap(), objects.autophobj::float, plotFactory::histos, alignCSCRings::r, CSCDetId::ring(), alignCSCRings::s, CSCDetId::station(), and electronIdCutBased_cfi::threshold.

Referenced by CSCValidation::ltrh::operator()().

                                                                                                                         {
 
   bool wireo[2][4][4][36];
   bool stripo[2][4][4][36];
   bool rechito[2][4][4][36];
   bool segmento[2][4][4][36];
 
   bool hasWires = false;
   bool hasStrips = false;
   bool hasRecHits = false;
   bool hasSegments = false;
 
   for (int e = 0; e < 2; e++){
     for (int s = 0; s < 4; s++){
       for (int r = 0; r < 4; r++){
         for (int c = 0; c < 36; c++){
           wireo[e][s][r][c] = false;
           stripo[e][s][r][c] = false;
           rechito[e][s][r][c] = false;
           segmento[e][s][r][c] = false;
         }
       }
     }
   }
 
   if (useDigis){
     //wires
     for (CSCWireDigiCollection::DigiRangeIterator wi=wires->begin(); wi!=wires->end(); wi++) {
       CSCDetId id = (CSCDetId)(*wi).first;
       int kEndcap  = id.endcap();
       int kRing    = id.ring();
       int kStation = id.station();
       int kChamber = id.chamber();
       std::vector<CSCWireDigi>::const_iterator wireIt = (*wi).second.first;
       std::vector<CSCWireDigi>::const_iterator lastWire = (*wi).second.second;
       for( ; wireIt != lastWire; ++wireIt){
         if (!wireo[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
           wireo[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
           hOWires->Fill(kChamber,typeIndex(id));
           histos->fill1DHist(chamberSerial(id),"hOWireSerial","Wire Occupancy by Chamber Serial",601,-0.5,600.5,"Digis");
           hasWires = true;
         }
       }
     }
   
     //strips
     for (CSCStripDigiCollection::DigiRangeIterator si=strips->begin(); si!=strips->end(); si++) {
       CSCDetId id = (CSCDetId)(*si).first;
       int kEndcap  = id.endcap();
       int kRing    = id.ring();
       int kStation = id.station();
       int kChamber = id.chamber();
       std::vector<CSCStripDigi>::const_iterator stripIt = (*si).second.first;
       std::vector<CSCStripDigi>::const_iterator lastStrip = (*si).second.second;
       for( ; stripIt != lastStrip; ++stripIt) {
         std::vector<int> myADCVals = stripIt->getADCCounts();
         bool thisStripFired = false;
         float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
         float threshold = 13.3 ;
         float diff = 0.;
         for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
           diff = (float)myADCVals[iCount]-thisPedestal;
           if (diff > threshold) { thisStripFired = true; }
         }
         if (thisStripFired) {
           if (!stripo[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
             stripo[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
             hOStrips->Fill(kChamber,typeIndex(id));
             histos->fill1DHist(chamberSerial(id),"hOStripSerial","Strip Occupancy by Chamber Serial",601,-0.5,600.5,"Digis");
             hasStrips = true;
           }
         }
       }
     }
   }
 
   //rechits
   CSCRecHit2DCollection::const_iterator recIt;
   for (recIt = recHits->begin(); recIt != recHits->end(); recIt++) {
     CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
     int kEndcap  = idrec.endcap();
     int kRing    = idrec.ring();
     int kStation = idrec.station();
     int kChamber = idrec.chamber();
     if (!rechito[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
       rechito[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
       histos->fill1DHist(chamberSerial(idrec),"hORecHitsSerial","RecHit Occupancy by Chamber Serial",601,-0.5,600.5,"recHits");
       hORecHits->Fill(kChamber,typeIndex(idrec));
       hasRecHits = true;
     }
   }
 
   //segments
   for(CSCSegmentCollection::const_iterator segIt=cscSegments->begin(); segIt != cscSegments->end(); segIt++) {
     CSCDetId id  = (CSCDetId)(*segIt).cscDetId();
     int kEndcap  = id.endcap();
     int kRing    = id.ring();
     int kStation = id.station();
     int kChamber = id.chamber();
     if (!segmento[kEndcap-1][kStation-1][kRing-1][kChamber-1]){
       segmento[kEndcap-1][kStation-1][kRing-1][kChamber-1] = true;
       histos->fill1DHist(chamberSerial(id),"hOSegmentsSerial","Segment Occupancy by Chamber Serial",601,-0.5,600.5,"Segments");
       hOSegments->Fill(kChamber,typeIndex(id));
       hasSegments = true;
     }
   }
 
   // overall CSC occupancy (events with CSC data compared to total)
   histos->fill1DHist(1,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
   if (hasWires) histos->fill1DHist(3,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
   if (hasStrips) histos->fill1DHist(5,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
   if (hasWires && hasStrips) histos->fill1DHist(7,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
   if (hasRecHits) histos->fill1DHist(9,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
   if (hasSegments) histos->fill1DHist(11,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
   if (!cleanEvent) histos->fill1DHist(13,"hCSCOccupancy","overall CSC occupancy",15,-0.5,14.5,"GeneralHists");
 
 }

void CSCValidation::doPedestalNoise ( edm::Handle< CSCStripDigiCollection > strips )

private

Definition at line 793 of file CSCValidation.cc.

References objects.autophobj::float, plotFactory::histos, relativeConstraints::station, and electronIdCutBased_cfi::threshold.

Referenced by CSCValidation::ltrh::operator()().

                                                                            {
 
   for (CSCStripDigiCollection::DigiRangeIterator dPNiter=strips->begin(); dPNiter!=strips->end(); dPNiter++) {
     CSCDetId id = (CSCDetId)(*dPNiter).first;
     std::vector<CSCStripDigi>::const_iterator pedIt = (*dPNiter).second.first;
     std::vector<CSCStripDigi>::const_iterator lStrip = (*dPNiter).second.second;
     for( ; pedIt != lStrip; ++pedIt) {
       int myStrip = pedIt->getStrip();
       std::vector<int> myADCVals = pedIt->getADCCounts();
       float TotalADC = getSignal(*strips, id, myStrip);
       bool thisStripFired = false;
       float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float thisSignal = (1./6)*(myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
       float threshold = 13.3;
       if(id.station() == 1 && id.ring() == 4)
     {
       if(myStrip <= 16) myStrip += 64; // no trapping for any bizarreness
     }
       if (TotalADC > threshold) { thisStripFired = true;}
       if (!thisStripFired){
     float ADC = thisSignal - thisPedestal;
         histos->fill1DHist(ADC,"hStripPed","Pedestal Noise Distribution",50,-25.,25.,"PedestalNoise");
         histos->fill1DHistByType(ADC,"hStripPedME","Pedestal Noise Distribution",id,50,-25.,25.,"PedestalNoise");
         histos->fillProfile(chamberSerial(id),ADC,"hStripPedMEProfile","Wire TimeBin Fired",601,-0.5,600.5,-25,25,"PedestalNoise");
         if (detailedAnalysis){
           histos->fill1DHistByLayer(ADC,"hStripPedME","Pedestal Noise Distribution",id,50,-25.,25.,"PedestalNoiseByLayer");
         }
       }
     }
   }
 
 }

void CSCValidation::doRecHits	(	edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::ESHandle< CSCGeometry >	cscGeom
	)

private

Definition at line 833 of file CSCValidation.cc.

References CSCDetId::chamber(), CSCDetId::endcap(), plotFactory::histos, mps_fire::i, kLayer(), CSCDetId::layer(), CSCGeometry::layer(), CSCDetId::ring(), mathSSE::sqrt(), CSCDetId::station(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), and LocalError::yy().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                        {
 
   // Get the RecHits collection :
   int nRecHits = recHits->size();
  
   // ---------------------
   // Loop over rechits 
   // ---------------------
   int iHit = 0;
 
   // Build iterator for rechits and loop :
   CSCRecHit2DCollection::const_iterator dRHIter;
   for (dRHIter = recHits->begin(); dRHIter != recHits->end(); dRHIter++) {
     iHit++;
 
     // Find chamber with rechits in CSC 
     CSCDetId idrec = (CSCDetId)(*dRHIter).cscDetId();
     int kEndcap  = idrec.endcap();
     int kRing    = idrec.ring();
     int kStation = idrec.station();
     int kChamber = idrec.chamber();
     int kLayer   = idrec.layer();
 
     // Store rechit as a Local Point:
     LocalPoint rhitlocal = (*dRHIter).localPosition();  
     float xreco = rhitlocal.x();
     float yreco = rhitlocal.y();
     LocalError rerrlocal = (*dRHIter).localPositionError();  
     //these errors are squared!
     float xxerr = rerrlocal.xx();
     float yyerr = rerrlocal.yy();
     float xyerr = rerrlocal.xy();
     // errors in strip units
     float stpos = (*dRHIter).positionWithinStrip();
     float sterr = (*dRHIter).errorWithinStrip();
 
     // Find the charge associated with this hit
     float rHSumQ = 0;
     float sumsides=0.;
     int adcsize=dRHIter->nStrips()*dRHIter->nTimeBins();
     for ( unsigned int i=0; i< dRHIter->nStrips(); i++) {
       for ( unsigned int j=0; j< dRHIter->nTimeBins()-1; j++) {
     rHSumQ+=dRHIter->adcs(i,j); 
     if (i!=1) sumsides+=dRHIter->adcs(i,j);
       }
     }
 
     float rHratioQ = sumsides/rHSumQ;
     if (adcsize != 12) rHratioQ = -99;
 
     // Get the signal timing of this hit
     float rHtime = 0;
     rHtime = (*dRHIter).tpeak()/50.;
 
     // Get pointer to the layer:
     const CSCLayer* csclayer = cscGeom->layer( idrec );
 
     // Transform hit position from local chamber geometry to global CMS geom
     GlobalPoint rhitglobal= csclayer->toGlobal(rhitlocal);
     float grecx   =  rhitglobal.x();
     float grecy   =  rhitglobal.y();
 
     // Fill the rechit position branch
     if (writeTreeToFile && rhTreeCount < 1500000){
       histos->fillRechitTree(xreco, yreco, grecx, grecy, kEndcap, kStation, kRing, kChamber, kLayer);
       rhTreeCount++;
     }    
 
     // Fill some histograms
     // only fill if 3 strips were used in the hit
     histos->fill2DHistByStation(grecx,grecy,"hRHGlobal","recHit Global Position",idrec,100,-800.,800.,100,-800.,800.,"recHits");
     if (kStation == 1 && (kRing == 1 || kRing == 4)) histos->fill1DHistByType(rHSumQ,"hRHSumQ","Sum 3x3 recHit Charge",idrec,125,0,4000,"recHits");
     else histos->fill1DHistByType(rHSumQ,"hRHSumQ","Sum 3x3 recHit Charge",idrec,125,0,2000,"recHits");
     histos->fill1DHistByType(rHratioQ,"hRHRatioQ","Charge Ratio (Ql+Qr)/Qt",idrec,120,-0.1,1.1,"recHits");
     histos->fill1DHistByType(rHtime,"hRHTiming","recHit Timing",idrec,200,-10,10,"recHits");
     histos->fill1DHistByType(sqrt(xxerr),"hRHxerr","RecHit Error on Local X",idrec,100,-0.1,2,"recHits");
     histos->fill1DHistByType(sqrt(yyerr),"hRHyerr","RecHit Error on Local Y",idrec,100,-0.1,2,"recHits");
     histos->fill1DHistByType(xyerr,"hRHxyerr","Corr. RecHit XY Error",idrec,100,-1,2,"recHits");
     if (adcsize == 12) histos->fill1DHistByType(stpos,"hRHstpos","Reconstructed Position on Strip",idrec,120,-0.6,0.6,"recHits");
     histos->fill1DHistByType(sterr,"hRHsterr","Estimated Error on Strip Measurement",idrec,120,-0.05,0.25,"recHits");
     histos->fillProfile(chamberSerial(idrec),rHSumQ,"hRHSumQProfile","Sum 3x3 recHit Charge",601,-0.5,600.5,0,4000,"recHits");
     histos->fillProfile(chamberSerial(idrec),rHtime,"hRHTimingProfile","recHit Timing",601,-0.5,600.5,-11,11,"recHits");
     if (detailedAnalysis){
       if (kStation == 1 && (kRing == 1 || kRing == 4)) histos->fill1DHistByLayer(rHSumQ,"hRHSumQ","Sum 3x3 recHit Charge",idrec,125,0,4000,"RHQByLayer");
       else histos->fill1DHistByLayer(rHSumQ,"hRHSumQ","Sum 3x3 recHit Charge",idrec,125,0,2000,"RHQByLayer");
       histos->fill1DHistByLayer(rHratioQ,"hRHRatioQ","Charge Ratio (Ql+Qr)/Qt",idrec,120,-0.1,1.1,"RHQByLayer");
       histos->fill1DHistByLayer(rHtime,"hRHTiming","recHit Timing",idrec,200,-10,10,"RHTimingByLayer");
       histos->fill2DHistByLayer(xreco,yreco,"hRHLocalXY","recHit Local Position",idrec,50,-100.,100.,75,-150.,150.,"RHLocalXYByLayer");
       histos->fill1DHistByLayer(sqrt(xxerr),"hRHxerr","RecHit Error on Local X",idrec,100,-0.1,2,"RHErrorsByLayer");
       histos->fill1DHistByLayer(sqrt(yyerr),"hRHyerr","RecHit Error on Local Y",idrec,100,-0.1,2,"RHErrorsByLayer");
       histos->fill1DHistByType(stpos,"hRHstpos","Reconstructed Position on Strip",idrec,120,-0.6,0.6,"RHStripPosByLayer");
       histos->fill1DHistByType(sterr,"hRHsterr","Estimated Error on Strip Measurement",idrec,120,-0.05,0.25,"RHStripPosByLayer");
     }
 
   } //end rechit loop
 
   if (nRecHits == 0) nRecHits = -1;
 
   histos->fill1DHist(nRecHits,"hRHnrechits","recHits per Event (all chambers)",151,-0.5,150.5,"recHits");
 
 }

void CSCValidation::doResolution	(	edm::Handle< CSCSegmentCollection >	cscSegments,
		edm::ESHandle< CSCGeometry >	cscGeom
	)

private

Definition at line 1076 of file CSCValidation.cc.

References plotFactory::histos, kLayer(), CSCDetId::layer(), CSCDetId::ring(), and CSCDetId::station().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                              {
 
 
   for(CSCSegmentCollection::const_iterator dSiter=cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
 
     CSCDetId id  = (CSCDetId)(*dSiter).cscDetId();
 
     //
     // try to get the CSC recHits that contribute to this segment.
     std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
     int nRH = (*dSiter).nRecHits();
     int jRH = 0;
     CLHEP::HepMatrix sp(6,1);
     CLHEP::HepMatrix se(6,1);
     for ( std::vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
       jRH++;
       CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
       int kRing    = idRH.ring();
       int kStation = idRH.station();
       int kLayer   = idRH.layer();
 
       // Find the strip containing this hit
       int centerid     =  iRH->nStrips()/2;
       int centerStrip =  iRH->channels(centerid);
 
       // If this segment has 6 hits, find the position of each hit on the strip in units of stripwidth and store values
       if (nRH == 6){
         float stpos = (*iRH).positionWithinStrip();
         se(kLayer,1) = (*iRH).errorWithinStrip();
         // Take into account half-strip staggering of layers (ME1/1 has no staggering)
         if (kStation == 1 && (kRing == 1 || kRing == 4)) sp(kLayer,1) = stpos + centerStrip;
         else{
           if (kLayer == 1 || kLayer == 3 || kLayer == 5) sp(kLayer,1) = stpos + centerStrip;
           if (kLayer == 2 || kLayer == 4 || kLayer == 6) sp(kLayer,1) = stpos - 0.5 + centerStrip;
         }
       }
 
     }
 
     float residual = -99;
     float pull = -99;
     // Fit all points except layer 3, then compare expected value for layer 3 to reconstructed value
     if (nRH == 6){
       float expected = fitX(sp,se);
       residual = expected - sp(3,1);
       pull = residual/se(3,1);
     }
 
     // Fill histos
     histos->fill1DHistByType(residual,"hSResid","Fitted Position on Strip - Reconstructed for Layer 3",id,100,-0.5,0.5,"Resolution");
     histos->fill1DHistByType(pull,"hSStripPosPull","Strip Measurement Pulls",id,100,-5.0,5.0,"Resolution");
     histos->fillProfile(chamberSerial(id),residual,"hSResidProfile","Fitted Position on Strip - Reconstructed for Layer 3",601,-0.5,600.5,-0.5,0.5,"Resolution");
     if (detailedAnalysis){
       histos->fill1DHistByChamber(residual,"hSResid","Fitted Position on Strip - Reconstructed for Layer 3",id,100,-0.5,0.5,"DetailedResolution");
       histos->fill1DHistByChamber(pull,"hSStripPosPull","Strip Measurement Pulls",id,100,-5.0,5.0,"Resolution");
     }
 
 
   }
 
 }

void CSCValidation::doSegments	(	edm::Handle< CSCSegmentCollection >	cscSegments,
		edm::ESHandle< CSCGeometry >	cscGeom
	)

private

Definition at line 995 of file CSCValidation.cc.

References CSCGeometry::chamber(), ChiSquaredProbability(), CSCDetId::endcap(), plotFactory::histos, nhits, PV3DBase< T, PVType, FrameType >::phi(), PV3DBase< T, PVType, FrameType >::theta(), theta(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                            {
 
   // get CSC segment collection
   int nSegments = cscSegments->size();
 
   // -----------------------
   // loop over segments
   // -----------------------
   int iSegment = 0;
   for(CSCSegmentCollection::const_iterator dSiter=cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
     iSegment++;
     //
     CSCDetId id  = (CSCDetId)(*dSiter).cscDetId();
     int kEndcap  = id.endcap();
     int kRing    = id.ring();
     int kStation = id.station();
     int kChamber = id.chamber();
 
     //
     float chisq    = (*dSiter).chi2();
     int nhits      = (*dSiter).nRecHits();
     int nDOF       = 2*nhits-4;
     double chisqProb = ChiSquaredProbability( (double)chisq, nDOF );
     LocalPoint localPos = (*dSiter).localPosition();
     float segX     = localPos.x();
     float segY     = localPos.y();
     LocalVector segDir = (*dSiter).localDirection();
     double theta   = segDir.theta();
 
     // global transformation
     float globX = 0.;
     float globY = 0.;
     float globTheta = 0.;
     float globPhi   = 0.;
     const CSCChamber* cscchamber = cscGeom->chamber(id);
     if (cscchamber) {
       GlobalPoint globalPosition = cscchamber->toGlobal(localPos);
       globX = globalPosition.x();
       globY = globalPosition.y();
       GlobalVector globalDirection = cscchamber->toGlobal(segDir);
       globTheta = globalDirection.theta();
       globPhi   = globalDirection.phi();
     }
 
 
     // Fill segment position branch
     if (writeTreeToFile && segTreeCount < 1500000){
       histos->fillSegmentTree(segX, segY, globX, globY, kEndcap, kStation, kRing, kChamber);
       segTreeCount++;
     }
 
     // Fill histos
     histos->fill2DHistByStation(globX,globY,"hSGlobal","Segment Global Positions;global x (cm)",id,100,-800.,800.,100,-800.,800.,"Segments");
     histos->fill1DHistByType(nhits,"hSnHits","N hits on Segments",id,8,-0.5,7.5,"Segments");
     histos->fill1DHistByType(theta,"hSTheta","local theta segments",id,128,-3.2,3.2,"Segments");
     histos->fill1DHistByType((chisq/nDOF),"hSChiSq","segments chi-squared/ndof",id,110,-0.05,10.5,"Segments");
     histos->fill1DHistByType(chisqProb,"hSChiSqProb","segments chi-squared probability",id,110,-0.05,1.05,"Segments");
     histos->fill1DHist(globTheta,"hSGlobalTheta","segment global theta",128,0,3.2,"Segments");
     histos->fill1DHist(globPhi,"hSGlobalPhi","segment global phi",128,-3.2,3.2,"Segments");
     histos->fillProfile(chamberSerial(id),nhits,"hSnHitsProfile","N hits on Segments",601,-0.5,600.5,-0.5,7.5,"Segments");
     if (detailedAnalysis){
       histos->fill1DHistByChamber(nhits,"hSnHits","N hits on Segments",id,8,-0.5,7.5,"HitsOnSegmentByChamber");
       histos->fill1DHistByChamber(theta,"hSTheta","local theta segments",id,128,-3.2,3.2,"DetailedSegments");
       histos->fill1DHistByChamber((chisq/nDOF),"hSChiSq","segments chi-squared/ndof",id,110,-0.05,10.5,"SegChi2ByChamber");
       histos->fill1DHistByChamber(chisqProb,"hSChiSqProb","segments chi-squared probability",id,110,-0.05,1.05,"SegChi2ByChamber");
     }
 
   } // end segment loop
 
   if (nSegments == 0) nSegments = -1;
 
   histos->fill1DHist(nSegments,"hSnSegments","Segments per Event",31,-0.5,30.5,"Segments");
 
 }

void CSCValidation::doSimHits	(	edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::Handle< edm::PSimHitContainer >	simHits
	)

private

Definition at line 941 of file CSCValidation.cc.

References funct::abs(), plotFactory::histos, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                           {
 
   CSCRecHit2DCollection::const_iterator dSHrecIter;
   for (dSHrecIter = recHits->begin(); dSHrecIter != recHits->end(); dSHrecIter++) {
 
     CSCDetId idrec = (CSCDetId)(*dSHrecIter).cscDetId();
     LocalPoint rhitlocal = (*dSHrecIter).localPosition();
     float xreco = rhitlocal.x();
     float yreco = rhitlocal.y();
     float xError = sqrt((*dSHrecIter).localPositionError().xx());
     float yError = sqrt((*dSHrecIter).localPositionError().yy());
     float simHitXres = -99;
     float simHitYres = -99;
     float xPull      = -99;
     float yPull      = -99;
     float mindiffX   = 99;
     float mindiffY   = 10;
     // If MC, find closest muon simHit to check resolution:
     PSimHitContainer::const_iterator dSHsimIter;
     for (dSHsimIter = simHits->begin(); dSHsimIter != simHits->end(); dSHsimIter++){
       // Get DetID for this simHit:
       CSCDetId sId = (CSCDetId)(*dSHsimIter).detUnitId();
       // Check if the simHit detID matches that of current recHit
       // and make sure it is a muon hit:
       if (sId == idrec && abs((*dSHsimIter).particleType()) == 13){
         // Get the position of this simHit in local coordinate system:
         LocalPoint sHitlocal = (*dSHsimIter).localPosition();
         // Now we need to make reasonably sure that this simHit is
         // responsible for this recHit:
         if ((sHitlocal.x() - xreco) < mindiffX && (sHitlocal.y() - yreco) < mindiffY){
           simHitXres = (sHitlocal.x() - xreco);
           simHitYres = (sHitlocal.y() - yreco);
           mindiffX = (sHitlocal.x() - xreco);
           xPull = simHitXres/xError;
           yPull = simHitYres/yError;
         }
       }
     }
 
     histos->fill1DHistByType(simHitXres,"hSimXResid","SimHitX - Reconstructed X",idrec,100,-1.0,1.0,"Resolution");
     histos->fill1DHistByType(simHitYres,"hSimYResid","SimHitY - Reconstructed Y",idrec,100,-5.0,5.0,"Resolution");
     histos->fill1DHistByType(xPull,"hSimXPull","Local X Pulls",idrec,100,-5.0,5.0,"Resolution");
     histos->fill1DHistByType(yPull,"hSimYPull","Local Y Pulls",idrec,100,-5.0,5.0,"Resolution");
 
   }
 
 }

void CSCValidation::doStandalone ( edm::Handle< reco::TrackCollection > saMuons )

private

Definition at line 1144 of file CSCValidation.cc.

References vertices_cff::chi2, MuonSubdetId::CSC, hiPixelPairStep_cff::deltaPhi, MuonSubdetId::DT, plotFactory::histos, PV3DBase< T, PVType, FrameType >::mag(), DetId::Muon, metsig::muon, gen::n, np, and MuonSubdetId::RPC.

Referenced by CSCValidation::ltrh::operator()().

                                                                    {
 
   int nSAMuons = saMuons->size();
   histos->fill1DHist(nSAMuons,"trNSAMuons","N Standalone Muons per Event",6,-0.5,5.5,"STAMuons");
 
   for(reco::TrackCollection::const_iterator muon = saMuons->begin(); muon != saMuons->end(); ++ muon ) {
     float preco  = muon->p();
     float ptreco = muon->pt();
     int   n = muon->recHitsSize();
     float chi2 = muon->chi2();
     float normchi2 = muon->normalizedChi2();
 
     // loop over hits
     int nDTHits = 0;
     int nCSCHits = 0;
     int nCSCHitsp = 0;
     int nCSCHitsm = 0;
     int nRPCHits = 0;
     int nRPCHitsp = 0;
     int nRPCHitsm = 0;
     int np = 0;
     int nm = 0;
     std::vector<CSCDetId> staChambers;
     for (trackingRecHit_iterator hit = muon->recHitsBegin(); hit != muon->recHitsEnd(); ++hit ) {
       const DetId detId( (*hit)->geographicalId() );
       if (detId.det() == DetId::Muon) {
         if (detId.subdetId() == MuonSubdetId::RPC) {
           RPCDetId rpcId(detId.rawId());
           nRPCHits++;
           if (rpcId.region() == 1){ nRPCHitsp++; np++;}
           if (rpcId.region() == -1){ nRPCHitsm++; nm++;}
         }
         if (detId.subdetId() == MuonSubdetId::DT) {
           nDTHits++;
         }
         else if (detId.subdetId() == MuonSubdetId::CSC) {
           CSCDetId cscId(detId.rawId());
           staChambers.push_back(detId.rawId());
           nCSCHits++;
           if (cscId.endcap() == 1){ nCSCHitsp++; np++;}
           if (cscId.endcap() == 2){ nCSCHitsm++; nm++;}
         }
       }
     }
 
     GlobalPoint  innerPnt(muon->innerPosition().x(),muon->innerPosition().y(),muon->innerPosition().z());
     GlobalPoint  outerPnt(muon->outerPosition().x(),muon->outerPosition().y(),muon->outerPosition().z());
     GlobalVector innerKin(muon->innerMomentum().x(),muon->innerMomentum().y(),muon->innerMomentum().z());
     GlobalVector outerKin(muon->outerMomentum().x(),muon->outerMomentum().y(),muon->outerMomentum().z());
     GlobalVector deltaPnt = innerPnt - outerPnt;
     double crudeLength = deltaPnt.mag();
     double deltaPhi = innerPnt.phi() - outerPnt.phi();
     double innerGlobalPolarAngle = innerKin.theta();
     double outerGlobalPolarAngle = outerKin.theta();
 
 
     // fill histograms
     histos->fill1DHist(n,"trN","N hits on a STA Muon Track",51,-0.5,50.5,"STAMuons");
     if (np != 0) histos->fill1DHist(np,"trNp","N hits on a STA Muon Track (plus endcap)",51,-0.5,50.5,"STAMuons");
     if (nm != 0) histos->fill1DHist(nm,"trNm","N hits on a STA Muon Track (minus endcap)",51,-0.5,50.5,"STAMuons");
     histos->fill1DHist(nDTHits,"trNDT","N DT hits on a STA Muon Track",51,-0.5,50.5,"STAMuons");
     histos->fill1DHist(nCSCHits,"trNCSC","N CSC hits on a STA Muon Track",51,-0.5,50.5,"STAMuons");
     if (nCSCHitsp != 0) histos->fill1DHist(nCSCHitsp,"trNCSCp","N CSC hits on a STA Muon Track (+ endcap)",51,-0.5,50.5,"STAMuons");
     if (nCSCHitsm != 0) histos->fill1DHist(nCSCHitsm,"trNCSCm","N CSC hits on a STA Muon Track (- endcap)",51,-0.5,50.5,"STAMuons");
     histos->fill1DHist(nRPCHits,"trNRPC","N RPC hits on a STA Muon Track",51,-0.5,50.5,"STAMuons");
     if (nRPCHitsp != 0) histos->fill1DHist(nRPCHitsp,"trNRPCp","N RPC hits on a STA Muon Track (+ endcap)",51,-0.5,50.5,"STAMuons");
     if (nRPCHitsm != 0) histos->fill1DHist(nRPCHitsm,"trNRPCm","N RPC hits on a STA Muon Track (- endcap)",51,-0.5,50.5,"STAMuons");
     histos->fill1DHist(preco,"trP","STA Muon Momentum",100,0,300,"STAMuons");
     histos->fill1DHist(ptreco,"trPT","STA Muon pT",100,0,40,"STAMuons");
     histos->fill1DHist(chi2,"trChi2","STA Muon Chi2",100,0,200,"STAMuons");
     histos->fill1DHist(normchi2,"trNormChi2","STA Muon Normalized Chi2",100,0,10,"STAMuons");
     histos->fill1DHist(crudeLength,"trLength","Straight Line Length of STA Muon",120,0.,2400.,"STAMuons");
     histos->fill1DHist(deltaPhi,"trDeltaPhi","Delta-Phi Between Inner and Outer STA Muon Pos.",100,-0.5,0.5,"STAMuons");
     histos->fill1DHist(innerGlobalPolarAngle,"trInnerPolar","Polar Angle of Inner P Vector (STA muons)",128,0,3.2,"STAMuons");
     histos->fill1DHist(outerGlobalPolarAngle,"trOuterPolar","Polar Angle of Outer P Vector (STA muons)",128,0,3.2,"STAMuons");
     histos->fill1DHist(innerPnt.phi(),"trInnerPhi","Phi of Inner Position (STA muons)",256,-3.2,3.2,"STAMuons");
     histos->fill1DHist(outerPnt.phi(),"trOuterPhi","Phi of Outer Position (STA muons)",256,-3.2,3.2,"STAMuons");
 
   }
 
 }

void CSCValidation::doStripDigis ( edm::Handle< CSCStripDigiCollection > strips )

private

Definition at line 752 of file CSCValidation.cc.

References diffTreeTool::diff, objects.autophobj::float, plotFactory::histos, and electronIdCutBased_cfi::threshold.

Referenced by CSCValidation::ltrh::operator()().

                                                                         {
 
   int nStripsFired = 0;
   for (CSCStripDigiCollection::DigiRangeIterator dSDiter=strips->begin(); dSDiter!=strips->end(); dSDiter++) {
     CSCDetId id = (CSCDetId)(*dSDiter).first;
     std::vector<CSCStripDigi>::const_iterator stripIter = (*dSDiter).second.first;
     std::vector<CSCStripDigi>::const_iterator lStrip = (*dSDiter).second.second;
     for( ; stripIter != lStrip; ++stripIter) {
       int myStrip = stripIter->getStrip();
       std::vector<int> myADCVals = stripIter->getADCCounts();
       bool thisStripFired = false;
       float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float threshold = 13.3 ;
       float diff = 0.;
       for (unsigned int iCount = 0; iCount < myADCVals.size(); iCount++) {
     diff = (float)myADCVals[iCount]-thisPedestal;
     if (diff > threshold) { thisStripFired = true; }
       } 
       if (thisStripFired) {
         nStripsFired++;
         // fill strip histos
         histos->fill1DHistByType(myStrip,"hStripStrip","Strip Number",id,81,-0.5,80.5,"Digis");
         if (detailedAnalysis){
           histos->fill1DHistByLayer(myStrip,"hStripStrip","Strip Number",id,81,-0.5,80.5,"StripNumberByLayer");
         }
       }
     }
   } // end strip loop
 
   if (nStripsFired == 0) nStripsFired = -1;
 
   histos->fill1DHist(nStripsFired,"hStripNFired","Fired Strips per Event",251,-0.5,250.5,"Digis");
 
 }

void CSCValidation::doTimeMonitoring	(	edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::Handle< CSCSegmentCollection >	cscSegments,
		edm::Handle< CSCALCTDigiCollection >	alcts,
		edm::Handle< CSCCLCTDigiCollection >	clcts,
		edm::Handle< CSCCorrelatedLCTDigiCollection >	correlatedlcts,
		edm::Handle< L1MuGMTReadoutCollection >	pCollection,
		edm::ESHandle< CSCGeometry >	cscGeom,
		const edm::EventSetup &	eventSetup,
		const edm::Event &	event
	)

private

Get a handle to the FED data collection

uncomment this for regional unpacking if (id!=SOME_ID) continue;

Take a reference to this FED's data

if fed has data then unpack it

examine event for integrity

get a pointer to data and pass it to constructor for unpacking

get a reference to dduData

set default detid to that for E=+z, S=1, R=1, C=1, L=1

skip the DDU if its data has serious errors define a mask for serious errors

get a reference to chamber data

adjust crate numbers for MTCC data

default value for all digis not related to cfebs

layer=0 flags entire chamber

check alct data integrity

check tmb data integrity

Definition at line 2642 of file CSCValidation.cc.

References CSCTMBHeader::ALCTMatchTime(), CSCTMBHeader::BXNCount(), relativeConstraints::chamber, CSCDetId::chamber(), CSCGeometry::chamber(), CSCDetId::chamberId(), trackerTree::check(), CSCDCCExaminer::check(), CSCDCCExaminer::crcALCT(), CSCDCCExaminer::crcCFEB(), CSCDCCExaminer::crcTMB(), FEDRawData::data(), data, CSCDCCEventData::dduData(), CSCCrateMap::detId(), CSCDetId::endcap(), CSCDCCExaminer::errors(), FEDRawDataCollection::FEDData(), edm::EventSetup::get(), L1MuGMTReadoutCollection::getRecords(), plotFactory::histos, triggerObjects_cff::id, LogTrace, FEDNumbering::MAXCSCFEDID, FEDNumbering::MINCSCFEDID, edm::ESHandle< T >::product(), matplotRender::rawdata, CSCDetId::ring(), CSCDCCExaminer::setMask(), FEDRawData::size(), jetUpdater_cfi::sort, mathSSE::sqrt(), CSCDetId::station(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by CSCValidation::ltrh::operator()().

                                                                             {
 
   map<CSCDetId, float > segment_median_map; //structure for storing the median time for segments in a chamber 
   map<CSCDetId, GlobalPoint > segment_position_map; //structure for storing the global position for segments in a chamber 
   
   // -----------------------
   // loop over segments
   // -----------------------
   int iSegment = 0; 
   for(CSCSegmentCollection::const_iterator dSiter=cscSegments->begin(); dSiter != cscSegments->end(); dSiter++) {
     iSegment++;
     
     CSCDetId id  = (CSCDetId)(*dSiter).cscDetId();
     LocalPoint localPos = (*dSiter).localPosition();
     GlobalPoint globalPosition = GlobalPoint(0.0, 0.0, 0.0);
     const CSCChamber* cscchamber = cscGeom->chamber(id);
     if (cscchamber) {
       globalPosition = cscchamber->toGlobal(localPos);
     }
     
     // try to get the CSC recHits that contribute to this segment.
     std::vector<CSCRecHit2D> theseRecHits = (*dSiter).specificRecHits();
     int nRH = (*dSiter).nRecHits();
     if (nRH < 4 ) continue;
     
     //Store the recHit times of a segment in a vector for later sorting
     vector<float> non_zero;
     
     for ( vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
       non_zero.push_back( iRH->tpeak());
       
     }// end rechit loop
     
     //Sort the vector of hit times for this segment and average the center two
     sort(non_zero.begin(),non_zero.end());
     int middle_index = non_zero.size()/2;
     float average_two = (non_zero.at(middle_index-1) + non_zero.at(middle_index))/2.;
     if(non_zero.size()%2)
       average_two = non_zero.at(middle_index);
 
     //If we've vetoed events with multiple segments per chamber, this should never overwrite informations
     segment_median_map[id]=average_two;
     segment_position_map[id]=globalPosition;
     
     double distToIP = sqrt(globalPosition.x()*globalPosition.x()+globalPosition.y()*globalPosition.y()+globalPosition.z()*globalPosition.z());
      
     histos->fillProfile(chamberSerial(id),average_two,"timeChamber","Segment mean time",601,-0.5,600.5,-400.,400.,"TimeMonitoring");
     histos->fillProfileByType(id.chamber(),average_two,"timeChamberByType","Segment mean time by chamber",id,36,0.5,36.5,-400,400.,"TimeMonitoring");
     histos->fill2DHist(distToIP,average_two,"seg_time_vs_distToIP","Segment time vs. Distance to IP",80,600.,1400.,800,-400,400.,"TimeMonitoring");
     histos->fill2DHist(globalPosition.z(),average_two,"seg_time_vs_globZ","Segment time vs. z position",240,-1200,1200,800,-400.,400.,"TimeMonitoring");
     histos->fill2DHist(fabs(globalPosition.z()),average_two,"seg_time_vs_absglobZ","Segment time vs. abs(z position)",120,0.,1200.,800,-400.,400.,"TimeMonitoring");
     
   }//end segment loop
   
    //Now that the information for each segment we're interest in is stored, it is time to go through the pairs and make plots
   map<CSCDetId, float >::const_iterator it_outer; //for the outer loop 
   map<CSCDetId, float >::const_iterator it_inner; //for the nested inner loop
   for (it_outer = segment_median_map.begin(); it_outer != segment_median_map.end(); it_outer++){
     
     CSCDetId id_outer =  it_outer->first;
     float t_outer = it_outer->second;
     
     //begin the inner loop
     for (it_inner = segment_median_map.begin(); it_inner != segment_median_map.end(); it_inner++){
       
       CSCDetId id_inner =  it_inner->first;
       float t_inner = it_inner->second;
       
       // we're looking at ordered pairs, so combinations will be double counted 
       // (chamber a, chamber b) will be counted as well as (chamber b, chamber a)
       // We will avoid (chamber a, chamber a) with the following line
       if (chamberSerial(id_outer) == chamberSerial(id_inner)) continue;
       
       // Calculate expected TOF (in ns units)
       // GlobalPoint gp_outer = segment_position_map.find(id_outer)->second;
       // GlobalPoint gp_inner = segment_position_map.find(id_inner)->second;
       // GlobalVector flight = gp_outer - gp_inner; //in cm
       // float TOF = flight.mag()/30.0;             //to ns
       
       //Plot t(ME+) - t(ME-) for chamber pairs in the same stations and rings but opposite endcaps
       if (id_outer.endcap() ==1 && id_inner.endcap() == 2 && id_outer.station() == id_inner.station() && id_outer.ring() == id_inner.ring() ){
     histos->fill1DHist(t_outer-t_inner,"diff_opposite_endcaps","#Delta t [ME+]-[ME-] for chambers in same station and ring",800,-400.,400.,"TimeMonitoring");
     histos->fill1DHistByType(t_outer-t_inner,"diff_opposite_endcaps_byType","#Delta t [ME+]-[ME-] for chambers in same station and ring",id_outer,800,-400.,400.,"TimeMonitoring");
       }
 
     }//end inner loop of segment pairs
   }//end outer loop of segment pairs
 
   //if the digis, return here
   if( !useDigis ) return;
 
   //looking for the global trigger number 
   vector<L1MuGMTReadoutRecord> L1Mrec = pCollection->getRecords();
   vector<L1MuGMTReadoutRecord>::const_iterator igmtrr;
   int L1GMT_BXN = -100;
   bool has_CSCTrigger = false;
   bool has_beamHaloTrigger = false;
   for(igmtrr=L1Mrec.begin(); igmtrr!=L1Mrec.end(); igmtrr++) {
     std::vector<L1MuRegionalCand>::const_iterator iter1;
     std::vector<L1MuRegionalCand> rmc;
     // CSC
     int icsc = 0;
     rmc = igmtrr->getCSCCands();
     for(iter1=rmc.begin(); iter1!=rmc.end(); iter1++) {
       if ( !(*iter1).empty() ) {
         icsc++;
         int kQuality = (*iter1).quality();   // kQuality = 1 means beam halo
         if (kQuality == 1) has_beamHaloTrigger = true;
       }
     }
     if (igmtrr->getBxInEvent() == 0 && icsc>0){
       //printf("L1 CSCCands exist.  L1MuGMTReadoutRecord BXN = %d \n", igmtrr->getBxNr());
       L1GMT_BXN = igmtrr->getBxNr();
       has_CSCTrigger = true;
     }
     else if (igmtrr->getBxInEvent() == 0 ) { 
       //printf("L1 CSCCands do not exist.  L1MuGMTReadoutRecord BXN = %d \n", igmtrr->getBxNr());
       L1GMT_BXN = igmtrr->getBxNr();
     }
   }
 
   // *************************************************
   // *** ALCT Digis **********************************
   // *************************************************
   
   int n_alcts = 0;
   map<CSCDetId, int > ALCT_KeyWG_map; //structure for storing the key wire group for the first ALCT for each chamber
   for (CSCALCTDigiCollection::DigiRangeIterator j=alcts->begin(); j!=alcts->end(); j++) {
     const CSCALCTDigiCollection::Range& range =(*j).second;
     const CSCDetId& idALCT = (*j).first;
     for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt!=range.second; ++digiIt){
       // Valid digi in the chamber (or in neighbouring chamber)  
       if((*digiIt).isValid()){
     n_alcts++;
     histos->fill1DHist( (*digiIt).getBX(), "ALCT_getBX","ALCT.getBX()",11,-0.5,10.5,"TimeMonitoring");
     histos->fill1DHist( (*digiIt).getFullBX(), "ALCT_getFullBX","ALCT.getFullBX()",3601,-0.5,3600.5,"TimeMonitoring");
     //if we don't already have digi information stored for this chamber, then we fill it
     if (ALCT_KeyWG_map.find(idALCT.chamberId()) == ALCT_KeyWG_map.end()){
       ALCT_KeyWG_map[idALCT.chamberId()] = (*digiIt).getKeyWG();
       //printf("I did fill ALCT info for Chamber %d %d %d %d \n",idALCT.chamberId().endcap(), idALCT.chamberId().station(), idALCT.chamberId().ring(), idALCT.chamberId().chamber());
     }
 
       }
     }
   }
    
   // *************************************************
   // *** CLCT Digis **********************************
   // *************************************************
   int n_clcts = 0;
   map<CSCDetId, int > CLCT_getFullBx_map; //structure for storing the pretrigger bxn for the first CLCT for each chamber
   for (CSCCLCTDigiCollection::DigiRangeIterator j=clcts->begin(); j!=clcts->end(); j++) {
     const CSCCLCTDigiCollection::Range& range =(*j).second;
     const CSCDetId& idCLCT = (*j).first;
     for (CSCCLCTDigiCollection::const_iterator digiIt = range.first; digiIt!=range.second; ++digiIt){
       // Valid digi in the chamber (or in neighbouring chamber) 
       if((*digiIt).isValid()){
     n_clcts++;
     histos->fill1DHist( (*digiIt).getBX(), "CLCT_getBX","CLCT.getBX()",11,-0.5,10.5,"TimeMonitoring");
     histos->fill1DHist( (*digiIt).getFullBX(), "CLCT_getFullBX","CLCT.getFullBX()",3601,-0.5,3600.5,"TimeMonitoring");
     //if we don't already have digi information stored for this chamber, then we fill it
     if (CLCT_getFullBx_map.find(idCLCT.chamberId()) == CLCT_getFullBx_map.end()){
       CLCT_getFullBx_map[idCLCT.chamberId()] = (*digiIt).getFullBX();
       //printf("I did fill CLCT info for Chamber %d %d %d %d \n",idCLCT.chamberId().endcap(), idCLCT.chamberId().station(), idCLCT.chamberId().ring(), idCLCT.chamberId().chamber());
     }
       }
     }
   }
   
   // *************************************************
   // *** CorrelatedLCT Digis *************************
   // *************************************************
   int n_correlatedlcts = 0;
   for (CSCCorrelatedLCTDigiCollection::DigiRangeIterator j=correlatedlcts->begin(); j!=correlatedlcts->end(); j++) {
     const CSCCorrelatedLCTDigiCollection::Range& range =(*j).second;
     for (CSCCorrelatedLCTDigiCollection::const_iterator digiIt = range.first; digiIt!=range.second; ++digiIt){
       if((*digiIt).isValid()){
     n_correlatedlcts++;
     histos->fill1DHist( (*digiIt).getBX(), "CorrelatedLCTS_getBX","CorrelatedLCT.getBX()",11,-0.5,10.5,"TimeMonitoring");
       }
     }
   }
 
 
   int nRecHits = recHits->size();
   int nSegments = cscSegments->size();
   if (has_CSCTrigger){
     histos->fill1DHist(L1GMT_BXN,"BX_L1CSCCand","BX of L1 CSC Cand",4001,-0.5,4000.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,n_alcts,"n_ALCTs_v_BX_L1CSCCand","Number of ALCTs vs. BX of L1 CSC Cand",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,n_clcts,"n_CLCTs_v_BX_L1CSCCand","Number of CLCTs vs. BX of L1 CSC Cand",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,n_correlatedlcts,"n_CorrelatedLCTs_v_BX_L1CSCCand","Number of CorrelatedLCTs vs. BX of L1 CSC Cand",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,nRecHits,"n_RecHits_v_BX_L1CSCCand","Number of RecHits vs. BX of L1 CSC Cand",4001,-0.5,4000.5,101,-0.5,100.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,nSegments,"n_Segments_v_BX_L1CSCCand","Number of Segments vs. BX of L1 CSC Cand",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
   }
   if (has_CSCTrigger && has_beamHaloTrigger){
     histos->fill1DHist(L1GMT_BXN,"BX_L1CSCCand_w_beamHalo","BX of L1 CSC (w beamHalo bit)",4001,-0.5,4000.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,n_alcts,"n_ALCTs_v_BX_L1CSCCand_w_beamHalo","Number of ALCTs vs. BX of L1 CSC Cand (w beamHalo bit)",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,n_clcts,"n_CLCTs_v_BX_L1CSCCand_w_beamHalo","Number of CLCTs vs. BX of L1 CSC Cand (w beamHalo bit)",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,n_correlatedlcts,"n_CorrelatedLCTs_v_BX_L1CSCCand_w_beamHalo","Number of CorrelatedLCTs vs. BX of L1 CSC Cand (w beamHalo bit)",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,nRecHits,"n_RecHits_v_BX_L1CSCCand_w_beamHalo","Number of RecHits vs. BX of L1 CSC Cand (w beamHalo bit)",4001,-0.5,4000.5,101,-0.5,100.5,"TimeMonitoring");
     histos->fill2DHist(L1GMT_BXN,nSegments,"n_Segments_v_BX_L1CSCCand_w_beamHalo","Number of Segments vs. BX of L1 CSC Cand (w beamHalo bit)",4001,-0.5,4000.5,51,-0.5,50.5,"TimeMonitoring");
   }
   
   // *******************************************************************
   // Get information from the TMB header.  
   // Can this eventually come out of the digis?
   // Taking code from EventFilter/CSCRawToDigis/CSCDCCUnpacker.cc
   // *******************************************************************
   
   edm::ESHandle<CSCCrateMap> hcrate;
   eventSetup.get<CSCCrateMapRcd>().get(hcrate); 
   const CSCCrateMap* pcrate = hcrate.product();
   
   edm::Handle<FEDRawDataCollection> rawdata;
   event.getByToken( rd_token, rawdata);
   bool goodEvent = false;
   // If set selective unpacking mode 
   // hardcoded examiner mask below to check for DCC and DDU level errors will be used first
   // then examinerMask for CSC level errors will be used during unpacking of each CSC block
   unsigned long dccBinCheckMask = 0x06080016;
   unsigned int examinerMask = 0x1FEBF3F6; 
   unsigned int errorMask = 0x0;
 
   for (int id=FEDNumbering::MINCSCFEDID; id<=FEDNumbering::MAXCSCFEDID; ++id) {
     // loop over DCCs
     
     const FEDRawData& fedData = rawdata->FEDData(id);
     unsigned long length =  fedData.size();
     
     if (length>=32){ 
       CSCDCCExaminer* examiner = nullptr;
       std::stringstream examiner_out, examiner_err;
       goodEvent = true;
       //CSCDCCExaminer examiner;
       examiner = new CSCDCCExaminer();
       if( examinerMask&0x40000 ) examiner->crcCFEB(true);
       if( examinerMask&0x8000  ) examiner->crcTMB (true);
       if( examinerMask&0x0400  ) examiner->crcALCT(true);
       examiner->setMask(examinerMask);
       const short unsigned int *data = (short unsigned int *)fedData.data();
      
       if( examiner->check(data,long(fedData.size()/2)) < 0 )    {
     goodEvent=false;
       } 
       else {      
     goodEvent=!(examiner->errors()&dccBinCheckMask);
       }  
       
       if (goodEvent) {
     CSCDCCExaminer * ptrExaminer = examiner;
     CSCDCCEventData dccData((short unsigned int *) fedData.data(),ptrExaminer);
         
     const std::vector<CSCDDUEventData> & dduData = dccData.dduData();
         
     CSCDetId layer(1, 1, 1, 1, 1);
     
     for (unsigned int iDDU=0; iDDU<dduData.size(); ++iDDU) {  // loop over DDUs
       if (dduData[iDDU].trailer().errorstat()&errorMask) {
         LogTrace("CSCDCCUnpacker|CSCRawToDigi") << "DDU# " << iDDU << " has serious error - no digis unpacked! " <<
           std::hex << dduData[iDDU].trailer().errorstat();
         continue; // to next iteration of DDU loop
       }
       
       const std::vector<CSCEventData> & cscData = dduData[iDDU].cscData();
       for (unsigned int iCSC=0; iCSC<cscData.size(); ++iCSC) { // loop over CSCs
         
         int vmecrate = cscData[iCSC].dmbHeader()->crateID();
         int dmb = cscData[iCSC].dmbHeader()->dmbID();
         
         // SKIPPING MTCC redefinition of vmecrate
         
         int icfeb = 0;  
         int ilayer = 0; 
         
         if ((vmecrate>=1)&&(vmecrate<=60) && (dmb>=1)&&(dmb<=10)&&(dmb!=6)) {
           layer = pcrate->detId(vmecrate, dmb,icfeb,ilayer );
         } 
         else{
           LogTrace ("CSCTimingAlignment|CSCDCCUnpacker|CSCRawToDigi") << " detID input out of range!!! ";
               LogTrace ("CSCTimingAlignment|CSCDCCUnpacker|CSCRawToDigi")
                 << " skipping chamber vme= " << vmecrate << " dmb= " << dmb;
           continue; // to next iteration of iCSC loop
         }
         
         int nalct = cscData[iCSC].dmbHeader()->nalct();
         bool goodALCT=false;
         //if (nalct&&(cscData[iCSC].dataPresent>>6&0x1)==1) {
         if (nalct&&cscData[iCSC].alctHeader()) {  
           if (cscData[iCSC].alctHeader()->check()){
         goodALCT=true;
           }
         }
         
         int nclct = cscData[iCSC].dmbHeader()->nclct();
         bool goodTMB=false;
         if (nclct&&cscData[iCSC].tmbData()) {
           if (cscData[iCSC].tmbHeader()->check()){
         if (cscData[iCSC].clctData()->check()) goodTMB=true; 
           }
         }  
               
         if (goodTMB && goodALCT) { 
 
           if (ALCT_KeyWG_map.find(layer) == ALCT_KeyWG_map.end()) {
         printf("no ALCT info for Chamber %d %d %d %d \n",layer.endcap(), layer.station(), layer.ring(), layer.chamber());
         continue;
           }
           if (CLCT_getFullBx_map.find(layer) == CLCT_getFullBx_map.end()) {
         printf("no CLCT info for Chamber %d %d %d %d \n",layer.endcap(), layer.station(), layer.ring(), layer.chamber());
         continue;
           }
           int ALCT0Key = ALCT_KeyWG_map.find(layer)->second;
           int CLCTPretrigger = CLCT_getFullBx_map.find(layer)->second;
 
 
 
           const CSCTMBHeader *tmbHead = cscData[iCSC].tmbHeader();
 
           histos->fill1DHistByStation(tmbHead->BXNCount(),     "TMB_BXNCount"     ,"TMB_BXNCount"     , layer.chamberId(),3601,-0.5,3600.5,"TimeMonitoring");
           histos->fill1DHistByStation(tmbHead->ALCTMatchTime(),"TMB_ALCTMatchTime","TMB_ALCTMatchTime", layer.chamberId(),7,-0.5,6.5,"TimeMonitoring");
 
           histos->fill1DHist(tmbHead->BXNCount(),     "TMB_BXNCount"     ,"TMB_BXNCount"     , 3601,-0.5,3600.5,"TimeMonitoring");
           histos->fill1DHist(tmbHead->ALCTMatchTime(),"TMB_ALCTMatchTime","TMB_ALCTMatchTime", 7,-0.5,6.5,"TimeMonitoring");
 
           histos->fill1DHistByType(tmbHead->ALCTMatchTime(),"TMB_ALCTMatchTime","TMB_ALCTMatchTime",layer.chamberId(), 7,-0.5,6.5,"TimeMonitoring");
 
           histos->fillProfile( chamberSerial(layer.chamberId()),tmbHead->ALCTMatchTime(),"prof_TMB_ALCTMatchTime","prof_TMB_ALCTMatchTime", 601,-0.5,600.5,-0.5,7.5,"TimeMonitoring");
           histos->fillProfile(ALCT0Key,tmbHead->ALCTMatchTime(),"prof_TMB_ALCTMatchTime_v_ALCT0KeyWG","prof_TMB_ALCTMatchTime_v_ALCT0KeyWG",128,-0.5,127.5,0,7,"TimeMonitoring");
           histos->fillProfileByType(ALCT0Key,tmbHead->ALCTMatchTime(),"prf_TMB_ALCTMatchTime_v_ALCT0KeyWG","prf_TMB_ALCTMatchTime_v_ALCT0KeyWG",layer.chamberId(),128,-0.5,127.5,0,7,"TimeMonitoring");
 
           //Attempt to make a few sum plots
 
           int TMB_ALCT_rel_L1A = tmbHead->BXNCount()-(CLCTPretrigger+2+tmbHead->ALCTMatchTime());
           if (TMB_ALCT_rel_L1A > 3563)
         TMB_ALCT_rel_L1A = TMB_ALCT_rel_L1A - 3564;
           if (TMB_ALCT_rel_L1A < 0)
         TMB_ALCT_rel_L1A = TMB_ALCT_rel_L1A + 3564;
 
           //Plot TMB_ALCT_rel_L1A
           histos->fill1DHist(TMB_ALCT_rel_L1A,"h1D_TMB_ALCT_rel_L1A","h1D_TMB_ALCT_rel_L1A",11,144.5,155.5,"TimeMonitoring");
           histos->fill2DHist( chamberSerial(layer.chamberId()),TMB_ALCT_rel_L1A,"h2D_TMB_ALCT_rel_L1A","h2D_TMB_ALCT_rel_L1A", 601,-0.5,600.5,11,144.5,155.5,"TimeMonitoring");
           histos->fill2DHist( ringSerial(layer.chamberId()),TMB_ALCT_rel_L1A,"h2D_TMB_ALCT_rel_L1A_by_ring","h2D_TMB_ALCT_rel_L1A_by_ring",19,-9.5,9.5,11,144.5,155.5,"TimeMonitoring");
           histos->fillProfile( chamberSerial(layer.chamberId()),TMB_ALCT_rel_L1A,"prof_TMB_ALCT_rel_L1A","prof_TMB_ALCT_rel_L1A", 601,-0.5,600.5,145,155,"TimeMonitoring");
           histos->fillProfile( ringSerial(layer.chamberId()),TMB_ALCT_rel_L1A,"prof_TMB_ALCT_rel_L1A_by_ring","prof_TMB_ALCT_rel_L1A_by_ring",19,-9.5,9.5,145,155,"TimeMonitoring");
 
           histos->fill2DHist (ALCT0Key,TMB_ALCT_rel_L1A,"h2D_TMB_ALCT_rel_L1A_v_ALCT0KeyWG","h2D_TMB_ALCT_rel_L1A_v_ALCT0KeyWG",  128,-0.5,127.5,11,144.5,155.5,"TimeMonitoring");
           histos->fillProfile(ALCT0Key,TMB_ALCT_rel_L1A,"prof_TMB_ALCT_rel_L1A_v_ALCT0KeyWG","prof_TMB_ALCT_rel_L1A_v_ALCT0KeyWG",128,-0.5,127.5,145,155,"TimeMonitoring");
           histos->fillProfileByType(ALCT0Key,TMB_ALCT_rel_L1A,"prf_TMB_ALCT_rel_L1A_v_ALCT0KeyWG","prf_TMB_ALCT_rel_L1A_v_ALCT0KeyWG",layer.chamberId(),128,-0.5,127.5,145,155,"TimeMonitoring");
         }
 
       } // end CSCData loop
     } // end ddu data loop
       } // end if goodEvent
       if (examiner!=nullptr) delete examiner;
     }// end if non-zero fed data
   } // end DCC loop for NON-REFERENCE
 
 }

bool CSCValidation::doTrigger ( edm::Handle< L1MuGMTReadoutCollection > pCollection )

private

Definition at line 537 of file CSCValidation.cc.

References L1MuGMTReadoutCollection::getRecords(), and plotFactory::histos.

Referenced by CSCValidation::ltrh::operator()().

                                                                             {
 
   std::vector<L1MuGMTReadoutRecord> L1Mrec = pCollection->getRecords();
   std::vector<L1MuGMTReadoutRecord>::const_iterator igmtrr;
 
   bool csc_l1a  = false;
   bool dt_l1a   = false;
   bool rpcf_l1a = false;
   bool rpcb_l1a = false;
   bool beamHaloTrigger = false;
 
   int myBXNumber = -1000;
 
   for(igmtrr=L1Mrec.begin(); igmtrr!=L1Mrec.end(); igmtrr++) {
     std::vector<L1MuRegionalCand>::const_iterator iter1;
     std::vector<L1MuRegionalCand> rmc;
 
     // CSC
     int icsc = 0;
     rmc = igmtrr->getCSCCands();
     for(iter1=rmc.begin(); iter1!=rmc.end(); iter1++) {
       if ( !(*iter1).empty() ) {
         icsc++;
         int kQuality = (*iter1).quality();   // kQuality = 1 means beam halo
         if (kQuality == 1) beamHaloTrigger = true;
       }
     }
     if (igmtrr->getBxInEvent() == 0 && icsc>0) csc_l1a = true;
     if (igmtrr->getBxInEvent() == 0 ) { myBXNumber = igmtrr->getBxNr(); }
 
     // DT
     int idt = 0;
     rmc = igmtrr->getDTBXCands();
     for(iter1=rmc.begin(); iter1!=rmc.end(); iter1++) {
       if ( !(*iter1).empty() ) {
         idt++;
       }
     }
     if(igmtrr->getBxInEvent()==0 && idt>0) dt_l1a = true;
 
     // RPC Barrel
     int irpcb = 0;
     rmc = igmtrr->getBrlRPCCands();
     for(iter1=rmc.begin(); iter1!=rmc.end(); iter1++) {
       if ( !(*iter1).empty() ) {
         irpcb++;
       }
     }
     if(igmtrr->getBxInEvent()==0 && irpcb>0) rpcb_l1a = true;
 
     // RPC Forward
     int irpcf = 0;
     rmc = igmtrr->getFwdRPCCands();
     for(iter1=rmc.begin(); iter1!=rmc.end(); iter1++) {
       if ( !(*iter1).empty() ) {
         irpcf++;
       }
     }
     if(igmtrr->getBxInEvent()==0 && irpcf>0) rpcf_l1a = true;
 
   }
 
   // Fill some histograms with L1A info
   if (csc_l1a)          histos->fill1DHist(myBXNumber,"vtBXNumber","BX Number",4001,-0.5,4000.5,"Trigger");
   if (csc_l1a)          histos->fill1DHist(1,"vtBits","trigger bits",11,-0.5,10.5,"Trigger");
   if (dt_l1a)           histos->fill1DHist(2,"vtBits","trigger bits",11,-0.5,10.5,"Trigger");
   if (rpcb_l1a)         histos->fill1DHist(3,"vtBits","trigger bits",11,-0.5,10.5,"Trigger");
   if (rpcf_l1a)         histos->fill1DHist(4,"vtBits","trigger bits",11,-0.5,10.5,"Trigger");
   if (beamHaloTrigger)  histos->fill1DHist(8,"vtBits","trigger bits",11,-0.5,10.5,"Trigger");
 
   if (csc_l1a) {
     histos->fill1DHist(1,"vtCSCY","trigger bits",11,-0.5,10.5,"Trigger");
     if (dt_l1a)   histos->fill1DHist(2,"vtCSCY","trigger bits",11,-0.5,10.5,"Trigger");
     if (rpcb_l1a) histos->fill1DHist(3,"vtCSCY","trigger bits",11,-0.5,10.5,"Trigger");
     if (rpcf_l1a) histos->fill1DHist(4,"vtCSCY","trigger bits",11,-0.5,10.5,"Trigger");
     if (  dt_l1a || rpcb_l1a || rpcf_l1a)  histos->fill1DHist(5,"vtCSCY","trigger bits",11,-0.5,10.5,"Trigger");
     if (!(dt_l1a || rpcb_l1a || rpcf_l1a)) histos->fill1DHist(6,"vtCSCY","trigger bits",11,-0.5,10.5,"Trigger");
   } else {
     histos->fill1DHist(1,"vtCSCN","trigger bits",11,-0.5,10.5,"Trigger");
     if (dt_l1a)   histos->fill1DHist(2,"vtCSCN","trigger bits",11,-0.5,10.5,"Trigger");
     if (rpcb_l1a) histos->fill1DHist(3,"vtCSCN","trigger bits",11,-0.5,10.5,"Trigger");
     if (rpcf_l1a) histos->fill1DHist(4,"vtCSCN","trigger bits",11,-0.5,10.5,"Trigger");
     if (  dt_l1a || rpcb_l1a || rpcf_l1a)  histos->fill1DHist(5,"vtCSCN","trigger bits",11,-0.5,10.5,"Trigger");
     if (!(dt_l1a || rpcb_l1a || rpcf_l1a)) histos->fill1DHist(6,"vtCSCN","trigger bits",11,-0.5,10.5,"Trigger");
   }
 
   // if valid CSC L1A then return true for possible use elsewhere
 
   if (csc_l1a) return true;
   
   return false;
 
 }

void CSCValidation::doWireDigis ( edm::Handle< CSCWireDigiCollection > wires )

private

Definition at line 718 of file CSCValidation.cc.

References plotFactory::histos.

Referenced by CSCValidation::ltrh::operator()().

                                                                      {
 
   int nWireGroupsTotal = 0;
   for (CSCWireDigiCollection::DigiRangeIterator dWDiter=wires->begin(); dWDiter!=wires->end(); dWDiter++) {
     CSCDetId id = (CSCDetId)(*dWDiter).first;
     std::vector<CSCWireDigi>::const_iterator wireIter = (*dWDiter).second.first;
     std::vector<CSCWireDigi>::const_iterator lWire = (*dWDiter).second.second;
     for( ; wireIter != lWire; ++wireIter) {
       int myWire = wireIter->getWireGroup();
       int myTBin = wireIter->getTimeBin();
       nWireGroupsTotal++;
       histos->fill1DHistByType(myWire,"hWireWire","Wiregroup Numbers Fired",id,113,-0.5,112.5,"Digis");
       histos->fill1DHistByType(myTBin,"hWireTBin","Wire TimeBin Fired",id,17,-0.5,16.5,"Digis");
       histos->fillProfile(chamberSerial(id),myTBin,"hWireTBinProfile","Wire TimeBin Fired",601,-0.5,600.5,-0.5,16.5,"Digis");
       if (detailedAnalysis){
         histos->fill1DHistByLayer(myWire,"hWireWire","Wiregroup Numbers Fired",id,113,-0.5,112.5,"WireNumberByLayer");
         histos->fill1DHistByLayer(myTBin,"hWireTBin","Wire TimeBin Fired",id,17,-0.5,16.5,"WireTimeByLayer");
       }
     }
   } // end wire loop
 
   // this way you can zero suppress but still store info on # events with no digis
   if (nWireGroupsTotal == 0) nWireGroupsTotal = -1;
 
   histos->fill1DHist(nWireGroupsTotal,"hWirenGroupsTotal","Wires Fired Per Event",151,-0.5,150.5,"Digis");
   
 }

void CSCValidation::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 3020 of file CSCValidation.cc.

References gather_cfg::cout, and DEFINE_FWK_MODULE.

                            {
 
      std::cout<<"Events in "<<nEventsAnalyzed<<std::endl;
 }

double CSCValidation::extrapolate1D	(	double	initPosition,
		double	initDirection,
		double	parameterOfTheLine
	)

inlineprivate

Definition at line 196 of file CSCValidation.h.

References relativeConstraints::ring, relativeConstraints::station, and withinSensitiveRegion().

                                                                                             {
     double extrapolatedPosition = initPosition + initDirection*parameterOfTheLine;
     return extrapolatedPosition; 
   }

void CSCValidation::fillEfficiencyHistos	(	int	bin,
		int	flag
	)

private

Referenced by CSCValidation::ltrh::operator()().

bool CSCValidation::filterEvents	(	edm::Handle< CSCRecHit2DCollection >	recHits,
		edm::Handle< CSCSegmentCollection >	cscSegments,
		edm::Handle< reco::TrackCollection >	saMuons
	)

private

Definition at line 333 of file CSCValidation.cc.

Referenced by CSCValidation::ltrh::operator()().

                                                                         {
 
   //int  nGoodSAMuons = 0;
 
   if (recHits->size() < 4 || recHits->size() > 100) return false;
   if (cscSegments->size() < 1 || cscSegments->size() > 15) return false;
   return true;
   //if (saMuons->size() != 1) return false;
   /*
   for(reco::TrackCollection::const_iterator muon = saMuons->begin(); muon != saMuons->end(); ++ muon ) {  
     double p  = muon->p();
     double reducedChisq = muon->normalizedChi2();
 
     GlobalPoint  innerPnt(muon->innerPosition().x(),muon->innerPosition().y(),muon->innerPosition().z());
     GlobalPoint  outerPnt(muon->outerPosition().x(),muon->outerPosition().y(),muon->outerPosition().z());
     GlobalVector innerKin(muon->innerMomentum().x(),muon->innerMomentum().y(),muon->innerMomentum().z());
     GlobalVector outerKin(muon->outerMomentum().x(),muon->outerMomentum().y(),muon->outerMomentum().z());
     GlobalVector deltaPnt = innerPnt - outerPnt;
     double crudeLength = deltaPnt.mag();
     double deltaPhi = innerPnt.phi() - outerPnt.phi();
     double innerGlobalPolarAngle = innerKin.theta();
     double outerGlobalPolarAngle = outerKin.theta();
 
     int nCSCHits = 0;
     for (trackingRecHit_iterator hit = muon->recHitsBegin(); hit != muon->recHitsEnd(); ++hit ) {
       if ( (*hit)->isValid() ) {
         const DetId detId( (*hit)->geographicalId() );
         if (detId.det() == DetId::Muon) {
           if (detId.subdetId() == MuonSubdetId::CSC) {
             nCSCHits++;
           } // this is a CSC hit
         } // this is a muon hit
       } // hit is valid
     } // end loop over rechits
 
     bool goodSAMuon = (p > pMin)
       && ( reducedChisq < chisqMax )
       && ( nCSCHits >= nCSCHitsMin )
       && ( nCSCHits <= nCSCHitsMax )
       && ( crudeLength > lengthMin )
       && ( crudeLength < lengthMax );
 
     
     goodSAMuon = goodSAMuon && ( fabs(deltaPhi) < deltaPhiMax );
     goodSAMuon = goodSAMuon &&
       (
        ( (     innerGlobalPolarAngle > polarMin) && (     innerGlobalPolarAngle < polarMax) ) ||
        ( (M_PI-innerGlobalPolarAngle > polarMin) && (M_PI-innerGlobalPolarAngle < polarMax) )
        );
     goodSAMuon = goodSAMuon &&
       (
        ( (     outerGlobalPolarAngle > polarMin) && (     outerGlobalPolarAngle < polarMax) ) ||
        ( (M_PI-outerGlobalPolarAngle > polarMin) && (M_PI-outerGlobalPolarAngle < polarMax) )
        );
 
    //goodSAMuon = goodSAMuon && (nCSCHits > nCSCHitsMin) && (nCSCHits < 13);  
    //goodSAMuon = goodSAMuon && (nCSCHits > 13) && (nCSCHits < 19);
    //goodSAMuon = goodSAMuon && (nCSCHits > 19) && (nCSCHits < nCSCHitsMax);
 
 
    if (goodSAMuon) nGoodSAMuons++;
    
   } // end loop over stand-alone muon collection
 
 
   histos->fill1DHist(nGoodSAMuons,"hNGoodMuons", "Number of Good STA Muons per Event",11,-0.5,10.5,"STAMuons");
 
   if (nGoodSAMuons == 1) return true;
   return false;
   */
 }

void CSCValidation::findNonAssociatedRecHits	(	edm::ESHandle< CSCGeometry >	cscGeom,
		edm::Handle< CSCStripDigiCollection >	strips
	)

private

Definition at line 1883 of file CSCValidation.cc.

References CSCDetId::chamber(), edmIntegrityCheck::d, CSCDetId::endcap(), plotFactory::histos, mps_fire::i, kLayer(), CSCDetId::layer(), CSCGeometry::layer(), funct::pow(), CSCDetId::ring(), mathSSE::sqrt(), CSCDetId::station(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                                        {
  
   for(std::multimap<CSCDetId , CSCRecHit2D>::iterator allRHiter =  AllRechits.begin();allRHiter != AllRechits.end(); ++allRHiter){
     CSCDetId idRH = allRHiter->first;
     LocalPoint lpRH = (allRHiter->second).localPosition();
     float xrec = lpRH.x();
     float yrec = lpRH.y();
     float zrec = lpRH.z();
     
     bool foundmatch = false;
     multimap<CSCDetId , CSCRecHit2D>::iterator segRHit;
     segRHit = SegRechits.find(idRH);
     if (segRHit != SegRechits.end()){
         for( ; segRHit != SegRechits.upper_bound(idRH); ++segRHit){
             
             LocalPoint lposRH = (segRHit->second).localPosition();
             float xpos = lposRH.x();
             float ypos = lposRH.y();
             float zpos = lposRH.z();
 
             if ( xrec == xpos && yrec == ypos && zrec == zpos){
                 foundmatch = true;}
       
             float d      = 0.;
             float dclose =1000.;
 
             if ( !foundmatch) {
                 
                 d = sqrt(pow(xrec-xpos,2)+pow(yrec-ypos,2)+pow(zrec-zpos,2));
                 if (d < dclose) {
                     dclose = d;
                     if( distRHmap.find((allRHiter->second)) ==  distRHmap.end() ) { // entry for rechit does not yet exist, create one
                         distRHmap.insert(make_pair(allRHiter->second,dclose) );
                     }
                     else {
                         // we already have an entry for the detid.
                         distRHmap.erase(allRHiter->second);
                         distRHmap.insert(make_pair(allRHiter->second,dclose)); // fill rechits for the segment with the given detid
                     }
                 }
             }       
         }
     }
     if(!foundmatch){NonAssociatedRechits.insert(std::pair<CSCDetId , CSCRecHit2D>(idRH,allRHiter->second));}
   }
 
   for(std::map<CSCRecHit2D,float,ltrh>::iterator iter =  distRHmap.begin();iter != distRHmap.end(); ++iter){
     histos->fill1DHist(iter->second,"hdistRH","Distance of Non Associated RecHit from closest Segment RecHit",500,0.,100.,"NonAssociatedRechits");
   }
 
   for(std::multimap<CSCDetId , CSCRecHit2D>::iterator iter =  NonAssociatedRechits.begin();iter != NonAssociatedRechits.end(); ++iter){
     CSCDetId idrec = iter->first;
     int kEndcap  = idrec.endcap();
     int cEndcap  = idrec.endcap();
     if (kEndcap == 2)cEndcap = -1;
     int kRing    = idrec.ring();
     int kStation = idrec.station();
     int kChamber = idrec.chamber();
     int kLayer   = idrec.layer();
 
     // Store rechit as a Local Point:
     LocalPoint rhitlocal = (iter->second).localPosition();  
     float xreco = rhitlocal.x();
     float yreco = rhitlocal.y();
 
     // Find the strip containing this hit
     int centerid    =  (iter->second).nStrips()/2;
     int centerStrip =  (iter->second).channels(centerid);
 
     // Find the charge associated with this hit
     float rHSumQ = 0;
     float sumsides=0.;
     int adcsize=(iter->second).nStrips()*(iter->second).nTimeBins();
     for ( unsigned int i=0; i< (iter->second).nStrips(); i++) {
       for ( unsigned int j=0; j< (iter->second).nTimeBins()-1; j++) {
     rHSumQ+=(iter->second).adcs(i,j);
     if (i!=1) sumsides+=(iter->second).adcs(i,j);
       }
     }
 
     float rHratioQ = sumsides/rHSumQ;
     if (adcsize != 12) rHratioQ = -99;
 
     // Get the signal timing of this hit
     float rHtime = (iter->second).tpeak()/50;
 
     // Get the width of this hit
     int rHwidth = getWidth(*strips, idrec, centerStrip);
 
 
     // Get pointer to the layer:
     const CSCLayer* csclayer = cscGeom->layer( idrec );
 
     // Transform hit position from local chamber geometry to global CMS geom
     GlobalPoint rhitglobal= csclayer->toGlobal(rhitlocal);
     float grecx   =  rhitglobal.x();
     float grecy   =  rhitglobal.y();
 
 
 
    // Simple occupancy variables
     int kCodeBroad  = cEndcap * ( 4*(kStation-1) + kRing) ;
     int kCodeNarrow = cEndcap * ( 100*(kRing-1) + kChamber) ;
 
     //Fill the non-associated rechits parameters in histogram
     histos->fill1DHist(kCodeBroad,"hNARHCodeBroad","broad scope code for recHits",33,-16.5,16.5,"NonAssociatedRechits");
     if (kStation == 1) histos->fill1DHist(kCodeNarrow,"hNARHCodeNarrow1","narrow scope recHit code station 1",801,-400.5,400.5,"NonAssociatedRechits");
     if (kStation == 2) histos->fill1DHist(kCodeNarrow,"hNARHCodeNarrow2","narrow scope recHit code station 2",801,-400.5,400.5,"NonAssociatedRechits");
     if (kStation == 3) histos->fill1DHist(kCodeNarrow,"hNARHCodeNarrow3","narrow scope recHit code station 3",801,-400.5,400.5,"NonAssociatedRechits");
     if (kStation == 4) histos->fill1DHist(kCodeNarrow,"hNARHCodeNarrow4","narrow scope recHit code station 4",801,-400.5,400.5,"NonAssociatedRechits");
     histos->fill1DHistByType(kLayer,"hNARHLayer","RecHits per Layer",idrec,8,-0.5,7.5,"NonAssociatedRechits");
     histos->fill1DHistByType(xreco,"hNARHX","Local X of recHit",idrec,160,-80.,80.,"NonAssociatedRechits");
     histos->fill1DHistByType(yreco,"hNARHY","Local Y of recHit",idrec,60,-180.,180.,"NonAssociatedRechits");
     if (kStation == 1 && (kRing == 1 || kRing == 4)) histos->fill1DHistByType(rHSumQ,"hNARHSumQ","Sum 3x3 recHit Charge",idrec,250,0,4000,"NonAssociatedRechits");
     else histos->fill1DHistByType(rHSumQ,"hNARHSumQ","Sum 3x3 recHit Charge",idrec,250,0,2000,"NonAssociatedRechits");
     histos->fill1DHistByType(rHratioQ,"hNARHRatioQ","Ratio (Ql+Qr)/Qt)",idrec,120,-0.1,1.1,"NonAssociatedRechits");
     histos->fill1DHistByType(rHtime,"hNARHTiming","recHit Timing",idrec,200,-10,10,"NonAssociatedRechits");
     histos->fill2DHistByStation(grecx,grecy,"hNARHGlobal","recHit Global Position",idrec,400,-800.,800.,400,-800.,800.,"NonAssociatedRechits");
     histos->fill1DHistByType(rHwidth,"hNARHwidth","width for Non associated recHit",idrec,21,-0.5,20.5,"NonAssociatedRechits");
     
   }
 
    for(std::multimap<CSCDetId , CSCRecHit2D>::iterator iter =  SegRechits.begin();iter != SegRechits.end(); ++iter){
        CSCDetId idrec = iter->first;
        int kEndcap  = idrec.endcap();
        int cEndcap  = idrec.endcap();
        if (kEndcap == 2)cEndcap = -1;
        int kRing    = idrec.ring();
        int kStation = idrec.station();
        int kChamber = idrec.chamber();
        int kLayer   = idrec.layer();
 
        // Store rechit as a Local Point:
        LocalPoint rhitlocal = (iter->second).localPosition();  
        float xreco = rhitlocal.x();
        float yreco = rhitlocal.y();
 
        // Find the strip containing this hit
        int centerid    =  (iter->second).nStrips()/2;
        int centerStrip =  (iter->second).channels(centerid);
 
        // Find the charge associated with this hit
 
        float rHSumQ = 0;
        float sumsides=0.;
        int adcsize=(iter->second).nStrips()*(iter->second).nTimeBins();
        for ( unsigned int i=0; i< (iter->second).nStrips(); i++) {
          for ( unsigned int j=0; j< (iter->second).nTimeBins()-1; j++) {
            rHSumQ+=(iter->second).adcs(i,j);
                if (i!=1) sumsides+=(iter->second).adcs(i,j);
          }
        }
        
        float rHratioQ = sumsides/rHSumQ;
        if (adcsize != 12) rHratioQ = -99;
        
        // Get the signal timing of this hit
        float rHtime = (iter->second).tpeak()/50;
 
        // Get the width of this hit
        int rHwidth = getWidth(*strips, idrec, centerStrip);
 
 
        // Get pointer to the layer:
        const CSCLayer* csclayer = cscGeom->layer( idrec );
        
        // Transform hit position from local chamber geometry to global CMS geom
        GlobalPoint rhitglobal= csclayer->toGlobal(rhitlocal);
        float grecx   =  rhitglobal.x();
        float grecy   =  rhitglobal.y();
 
        // Simple occupancy variables
        int kCodeBroad  = cEndcap * ( 4*(kStation-1) + kRing) ;
        int kCodeNarrow = cEndcap * ( 100*(kRing-1) + kChamber) ;
 
        //Fill the non-associated rechits global position in histogram
            histos->fill1DHist(kCodeBroad,"hSegRHCodeBroad","broad scope code for recHits",33,-16.5,16.5,"AssociatedRechits");
            if (kStation == 1) histos->fill1DHist(kCodeNarrow,"hSegRHCodeNarrow1","narrow scope recHit code station 1",801,-400.5,400.5,"AssociatedRechits");
            if (kStation == 2) histos->fill1DHist(kCodeNarrow,"hSegRHCodeNarrow2","narrow scope recHit code station 2",801,-400.5,400.5,"AssociatedRechits");
            if (kStation == 3) histos->fill1DHist(kCodeNarrow,"hSegRHCodeNarrow3","narrow scope recHit code station 3",801,-400.5,400.5,"AssociatedRechits");
            if (kStation == 4) histos->fill1DHist(kCodeNarrow,"hSegRHCodeNarrow4","narrow scope recHit code station 4",801,-400.5,400.5,"AssociatedRechits");
            histos->fill1DHistByType(kLayer,"hSegRHLayer","RecHits per Layer",idrec,8,-0.5,7.5,"AssociatedRechits");
            histos->fill1DHistByType(xreco,"hSegRHX","Local X of recHit",idrec,160,-80.,80.,"AssociatedRechits");
            histos->fill1DHistByType(yreco,"hSegRHY","Local Y of recHit",idrec,60,-180.,180.,"AssociatedRechits");
            if (kStation == 1 && (kRing == 1 || kRing == 4)) histos->fill1DHistByType(rHSumQ,"hSegRHSumQ","Sum 3x3 recHit Charge",idrec,250,0,4000,"AssociatedRechits");
            else histos->fill1DHistByType(rHSumQ,"hSegRHSumQ","Sum 3x3 recHit Charge",idrec,250,0,2000,"AssociatedRechits");
            histos->fill1DHistByType(rHratioQ,"hSegRHRatioQ","Ratio (Ql+Qr)/Qt)",idrec,120,-0.1,1.1,"AssociatedRechits");
            histos->fill1DHistByType(rHtime,"hSegRHTiming","recHit Timing",idrec,200,-10,10,"AssociatedRechits");
            histos->fill2DHistByStation(grecx,grecy,"hSegRHGlobal","recHit Global Position",idrec,400,-800.,800.,400,-800.,800.,"AssociatedRechits");
            histos->fill1DHistByType(rHwidth,"hSegRHwidth","width for Non associated recHit",idrec,21,-0.5,20.5,"AssociatedRechits");
        
    }
 
    distRHmap.clear();
    AllRechits.clear();
    SegRechits.clear();
    NonAssociatedRechits.clear();
 }

float CSCValidation::fitX	(	const CLHEP::HepMatrix &	sp,
		const CLHEP::HepMatrix &	ep
	)

private

Definition at line 1276 of file CSCValidation.cc.

References delta, benchmark_cfg::errors, mps_fire::i, hiPixelPairStep_cff::points, and slope.

Referenced by CSCValidation::ltrh::operator()().

                                                                                    {
 
   float S   = 0;
   float Sx  = 0;
   float Sy  = 0;
   float Sxx = 0;
   float Sxy = 0;
   float sigma2 = 0;
 
   for (int i=1;i<7;i++){
     if (i != 3){
       sigma2 = errors(i,1)*errors(i,1);
       S = S + (1/sigma2);
       Sy = Sy + (points(i,1)/sigma2);
       Sx = Sx + ((i)/sigma2);
       Sxx = Sxx + (i*i)/sigma2;
       Sxy = Sxy + (((i)*points(i,1))/sigma2);
     }
   }
 
   float delta = S*Sxx - Sx*Sx;
   float intercept = (Sxx*Sy - Sx*Sxy)/delta;
   float slope = (S*Sxy - Sx*Sy)/delta;
 
   //float chi = 0;
   //float chi2 = 0;
 
   // calculate chi2 (not currently used)
   //for (int i=1;i<7;i++){
   //  chi = (points(i,1) - intercept - slope*i)/(errors(i,1));
   //  chi2 = chi2 + chi*chi;
   //}
 
   return (intercept + slope*3);
 
 }

void CSCValidation::getEfficiency	(	float	bin,
		float	Norm,
		std::vector< float > &	eff
	)

private

Definition at line 1616 of file CSCValidation.cc.

References mathSSE::sqrt().

Referenced by CSCValidation::ltrh::operator()().

                                                                              {
   //---- Efficiency with binomial error
   float Efficiency = 0.;
   float EffError = 0.;
   if(fabs(Norm)>0.000000001){
     Efficiency = bin/Norm;
     if(bin<Norm){
       EffError = sqrt( (1.-Efficiency)*Efficiency/Norm );
     }
   }
   eff[0] = Efficiency;
   eff[1] = EffError;
 }

float CSCValidation::getSignal	(	const CSCStripDigiCollection &	stripdigis,
		CSCDetId	idRH,
		int	centerStrip
	)

private

Definition at line 1757 of file CSCValidation.cc.

References objects.autophobj::float, and plotBeamSpotDB::last.

Referenced by CSCValidation::ltrh::operator()().

                                                                                                       {
 
   float SigADC[5];
   float TotalADC = 0;
   SigADC[0] = 0;
   SigADC[1] = 0;
   SigADC[2] = 0;
   SigADC[3] = 0;
   SigADC[4] = 0;
 
  
   // Loop over strip digis 
   CSCStripDigiCollection::DigiRangeIterator sIt;
   
   for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++){
     CSCDetId id = (CSCDetId)(*sIt).first;
     if (id == idCS){
 
       // First, find the Signal-Pedestal for center strip
       std::vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
       std::vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
       for ( ; digiItr != last; ++digiItr ) {
         int thisStrip = digiItr->getStrip();
         if (thisStrip == (centerStrip)){
       std::vector<int> myADCVals = digiItr->getADCCounts();
           float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
       SigADC[0] = thisSignal - 6*thisPedestal;
     }
      // Now,find the Signal-Pedestal for neighbouring 4 strips
         if (thisStrip == (centerStrip+1)){
       std::vector<int> myADCVals = digiItr->getADCCounts();
           float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
       SigADC[1] = thisSignal - 6*thisPedestal;
     }
         if (thisStrip == (centerStrip+2)){
       std::vector<int> myADCVals = digiItr->getADCCounts();
           float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
       SigADC[2] = thisSignal - 6*thisPedestal;
     }
         if (thisStrip == (centerStrip-1)){
       std::vector<int> myADCVals = digiItr->getADCCounts();
           float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
       SigADC[3] = thisSignal - 6*thisPedestal;
     }
         if (thisStrip == (centerStrip-2)){
       std::vector<int> myADCVals = digiItr->getADCCounts();
           float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
       float thisSignal = (myADCVals[2]+myADCVals[3]+myADCVals[4]+myADCVals[5]+myADCVals[6]+myADCVals[7]);
       SigADC[4] = thisSignal - 6*thisPedestal;
     }
       }
       TotalADC = 0.2*(SigADC[0]+SigADC[1]+SigADC[2]+SigADC[3]+SigADC[4]);
     }
   }
   return TotalADC;
 }

float CSCValidation::getthisSignal	(	const CSCStripDigiCollection &	stripdigis,
		CSCDetId	idRH,
		int	centerStrip
	)

private

Definition at line 2084 of file CSCValidation.cc.

References objects.autophobj::float, plotBeamSpotDB::last, CSCDetId::ring(), and CSCDetId::station().

Referenced by CSCValidation::ltrh::operator()().

                                                                                                           {
     // Loop over strip digis responsible for this recHit
     CSCStripDigiCollection::DigiRangeIterator sIt;
     float thisADC = 0.;
     //bool foundRHid = false;
     // std::cout<<"iD   S/R/C/L = "<<idRH<<"    "<<idRH.station()<<"/"<<idRH.ring()<<"/"<<idRH.chamber()<<"/"<<idRH.layer()<<std::endl;
     for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++){
         CSCDetId id = (CSCDetId)(*sIt).first;
         //std::cout<<"STRIPS: id    S/R/C/L = "<<id<<"     "<<id.station()<<"/"<<id.ring()<<"/"<<id.chamber()<<"/"<<id.layer()<<std::endl;
         if (id == idRH){
             //foundRHid = true;
             vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
             vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
             //if(digiItr == last ) {std::cout << " Attention1 :: Size of digi collection is zero " << std::endl;}
             int St = idRH.station();
             int Rg    = idRH.ring();
             if (St == 1 && Rg == 4){
                 while(centerStrip> 16) centerStrip -= 16;
             }
             for ( ; digiItr != last; ++digiItr ) {
                 int thisStrip = digiItr->getStrip();
                 //std::cout<<" thisStrip = "<<thisStrip<<" centerStrip = "<<centerStrip<<std::endl;
                 std::vector<int> myADCVals = digiItr->getADCCounts();
                 float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
                 float Signal = (float) myADCVals[3];
                 if (thisStrip == (centerStrip)){
                     thisADC = Signal-thisPedestal;
                     //if(thisADC >= 0. && thisADC <2.) {std::cout << " Attention2 :: The Signal is equal to the pedestal " << std::endl;
                     //}
                     //if(thisADC < 0.) {std::cout << " Attention3 :: The Signal is less than the pedestal " << std::endl;
                     //}
                 }
                 if (thisStrip == (centerStrip+1)){
                     std::vector<int> myADCVals = digiItr->getADCCounts();
                 }
                 if (thisStrip == (centerStrip-1)){
                     std::vector<int> myADCVals = digiItr->getADCCounts();
                 }
             }
         }
     }
     //if(!foundRHid){std::cout << " Attention4 :: Did not find a matching RH id in the Strip Digi collection " << std::endl;}
     return thisADC;
 }

int CSCValidation::getWidth	(	const CSCStripDigiCollection &	stripdigis,
		CSCDetId	idRH,
		int	centerStrip
	)

private

Definition at line 2135 of file CSCValidation.cc.

References plotBeamSpotDB::first, objects.autophobj::float, plotBeamSpotDB::last, CSCDetId::ring(), CSCDetId::station(), digitizers_cfi::strip, and ApeEstimator_cff::width.

Referenced by CSCValidation::ltrh::operator()().

                                                                                                    {
 
   int width = 1;
   int widthpos = 0;
   int widthneg = 0;
 
   // Loop over strip digis responsible for this recHit and sum charge
   CSCStripDigiCollection::DigiRangeIterator sIt;
 
   for (sIt = stripdigis.begin(); sIt != stripdigis.end(); sIt++){
       CSCDetId id = (CSCDetId)(*sIt).first;
       if (id == idRH){
           std::vector<CSCStripDigi>::const_iterator digiItr = (*sIt).second.first;
           std::vector<CSCStripDigi>::const_iterator first = (*sIt).second.first;
           std::vector<CSCStripDigi>::const_iterator last = (*sIt).second.second;
           std::vector<CSCStripDigi>::const_iterator it = (*sIt).second.first;
           std::vector<CSCStripDigi>::const_iterator itr = (*sIt).second.first;
           //std::cout << " IDRH " << id <<std::endl;
           int St = idRH.station();
           int Rg    = idRH.ring();
           if (St == 1 && Rg == 4){
               while(centerStrip> 16) centerStrip -= 16;
           }
           for ( ; digiItr != last; ++digiItr ) {
               int thisStrip = digiItr->getStrip();
               if (thisStrip == (centerStrip)){
                   it = digiItr;
                   for( ; it != last; ++it ) {
                       int strip = it->getStrip();
                       std::vector<int> myADCVals = it->getADCCounts();
                       float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
                       if(((float)myADCVals[3]-thisPedestal) < 6 || widthpos == 10 || it==last){break;}
                        if(strip != centerStrip){ widthpos += 1;
                        }
                   }
                   itr = digiItr;
                   for( ; itr != first; --itr) {
                       int strip = itr->getStrip();
                       std::vector<int> myADCVals = itr->getADCCounts();
                       float thisPedestal = 0.5*(float)(myADCVals[0]+myADCVals[1]);
                       if(((float)myADCVals[3]-thisPedestal) < 6 || widthneg == 10 || itr==first){break;}     
                       if(strip != centerStrip) {widthneg += 1 ; 
                       }
                   }
               }
           }
       }
   }
   //std::cout << "Widthneg - " <<  widthneg << "Widthpos + " <<  widthpos << std::endl;
   width =  width + widthneg +  widthpos ;
   //std::cout << "Width " <<  width << std::endl;
   return width;
 }

void CSCValidation::histoEfficiency	(	TH1F *	readHisto,
		TH1F *	writeHisto
	)

private

Definition at line 1630 of file CSCValidation.cc.

References create_public_pileup_plots::bins, mps_fire::i, and writelibraryfile_cfg::Nbins.

Referenced by CSCValidation::ltrh::operator()().

                                                                     {
   std::vector<float> eff(2);
   int Nbins =  readHisto->GetSize()-2;//without underflows and overflows
   std::vector<float> bins(Nbins);
   std::vector<float> Efficiency(Nbins);
   std::vector<float> EffError(Nbins);
   float Num = 1;
   float Den = 1;
   for (int i=0;i<20;i++){
     Num = readHisto->GetBinContent(i+1);
     Den = readHisto->GetBinContent(i+21);
     getEfficiency(Num, Den, eff);
     Efficiency[i] = eff[0];
     EffError[i] = eff[1];
     writeHisto->SetBinContent(i+1, Efficiency[i]);
     writeHisto->SetBinError(i+1, EffError[i]);
   }
 }

double CSCValidation::lineParametrization	(	double	z1Position,
		double	z2Position,
		double	z1Direction
	)

inlineprivate

Definition at line 192 of file CSCValidation.h.

                                                                                       {
     double parameterLine = (z2Position-z1Position)/z1Direction;
     return parameterLine;
   }

int CSCValidation::ringSerial ( CSCDetId id )

private

Definition at line 1255 of file CSCValidation.cc.

References RecoEcal_EventContent_cff::ec.

Referenced by CSCValidation::ltrh::operator()().

                                            {
   int st = id.station();
   int ri = id.ring();
   int ec = id.endcap();
   int kSerial = 0 ;
   if (st == 1 && ri == 1) kSerial = ri;
   if (st == 1 && ri == 2) kSerial = ri ;
   if (st == 1 && ri == 3) kSerial = ri ;
   if (st == 1 && ri == 4) kSerial = 1;
   if (st == 2 ) kSerial = ri + 3;
   if (st == 3 ) kSerial = ri + 5;
   if (st == 4 ) kSerial = ri + 7;
   if (ec == 2) kSerial = kSerial * (-1);
   return kSerial;
 }

int CSCValidation::typeIndex ( CSCDetId id )

inlineprivate

Definition at line 310 of file CSCValidation.h.

References makeMuonMisalignmentScenario::endcap, relativeConstraints::ring, and relativeConstraints::station.

                             {
     // linearlized index bases on endcap, station, and ring
     int index = 0;
     if (id.station() == 1){
       index = id.ring() + 1;
       if (id.ring() == 4) index = 1;
     }
     else index = id.station()*2 + id.ring();
     if (id.endcap() == 1) index = index + 10;
     if (id.endcap() == 2) index = 11 - index;
     return index;
   }

bool CSCValidation::withinSensitiveRegion	(	LocalPoint	localPos,
		const std::array< const float, 4 > &	layerBounds,
		int	station,
		int	ring,
		float	shiftFromEdge,
		float	shiftFromDeadZone
	)

private

Definition at line 1649 of file CSCValidation.cc.

References funct::abs(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by extrapolate1D().

                                                                                                                                                                                {
 //---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded) 
   bool pass = false;
 
   float y_center = 0.;
   double yUp = layerBounds[3] + y_center;
   double yDown = - layerBounds[3] + y_center;
   double xBound1Shifted = layerBounds[0] - shiftFromEdge;//
   double xBound2Shifted = layerBounds[1] - shiftFromEdge;//
   double lineSlope = (yUp - yDown)/(xBound2Shifted-xBound1Shifted);
   double lineConst = yUp - lineSlope*xBound2Shifted;
   double yBorder =  lineSlope*abs(localPos.x()) + lineConst;
       
   //bool withinChamberOnly = false;// false = "good region"; true - boundaries only
   std::vector <float> deadZoneCenter(6);
   float cutZone = shiftFromDeadZone;//cm
   //---- hardcoded... not good
   if(station>1 && station<5){
     if(2==ring){
       deadZoneCenter[0]= -162.48 ;
       deadZoneCenter[1] = -81.8744;
       deadZoneCenter[2] = -21.18165;
       deadZoneCenter[3] = 39.51105;
       deadZoneCenter[4] = 100.2939;
       deadZoneCenter[5] = 160.58;
       
       if(localPos.y() >yBorder &&
      ((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
       (localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
       (localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone) ||
       (localPos.y()> deadZoneCenter[3] + cutZone && localPos.y()< deadZoneCenter[4] - cutZone) ||
       (localPos.y()> deadZoneCenter[4] + cutZone && localPos.y()< deadZoneCenter[5] - cutZone))){
     pass = true;
       }
     }
     else if(1==ring){
       if(2==station){
     deadZoneCenter[0]= -95.80 ;
     deadZoneCenter[1] = -27.47;
     deadZoneCenter[2] = 33.67;
     deadZoneCenter[3] = 90.85;
         }
       else if(3==station){
     deadZoneCenter[0]= -89.305 ;
     deadZoneCenter[1] = -39.705;
     deadZoneCenter[2] = 20.195;
     deadZoneCenter[3] = 77.395;
       }
       else if(4==station){
     deadZoneCenter[0]= -75.645;
     deadZoneCenter[1] = -26.055;
     deadZoneCenter[2] = 23.855;
     deadZoneCenter[3] = 70.575;
       }
       if(localPos.y() >yBorder &&
      ((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
       (localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
       (localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone))){
     pass = true;
       }
     }
   }
   else if(1==station){
     if(3==ring){
       deadZoneCenter[0]= -83.155 ;
       deadZoneCenter[1] = -22.7401;
       deadZoneCenter[2] = 27.86665;
       deadZoneCenter[3] = 81.005;
       if(localPos.y() > yBorder &&
      ((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
       (localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
       (localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone))){
     pass = true;
       }
     }
     else if(2==ring){
       deadZoneCenter[0]= -86.285 ;
       deadZoneCenter[1] = -32.88305;
       deadZoneCenter[2] = 32.867423;
       deadZoneCenter[3] = 88.205;
       if(localPos.y() > (yBorder) &&
      ((localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone) ||
       (localPos.y()> deadZoneCenter[1] + cutZone && localPos.y()< deadZoneCenter[2] - cutZone) ||
       (localPos.y()> deadZoneCenter[2] + cutZone && localPos.y()< deadZoneCenter[3] - cutZone))){
     pass = true;
       }
     }
     else{
       deadZoneCenter[0]= -81.0;
       deadZoneCenter[1] = 81.0;
       if(localPos.y() > (yBorder) &&
      (localPos.y()> deadZoneCenter[0] + cutZone && localPos.y()< deadZoneCenter[1] - cutZone )){
     pass = true;
       }
     }
   }
   return pass;
 }

Classes

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation