CSCValidation Class Reference

#include <CSCValidation.h>

Inheritance diagram for CSCValidation:

Classes
struct	ltrh

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &eventSetup)
	Perform the analysis. More...
	CSCValidation (const edm::ParameterSet &pset)
	Constructor. More...
void	endJob ()
virtual	~CSCValidation ()
	Destructor. More...
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Member Functions
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 &)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

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 create_complex_test_file0_cfg::firstEvent, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mergeVDriftHistosByStation::histos, HLT_FULL_cff::pMin, dtT0Analyzer_cfg::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 ( )

virtual

Destructor.

Definition at line 133 of file CSCValidation.cc.

References mergeVDriftHistosByStation::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  )

virtual

Perform the analysis.

Implements edm::EDAnalyzer.

Definition at line 179 of file CSCValidation.cc.

References HLT_FULL_cff::cscSegments, create_complex_test_file0_cfg::firstEvent, edm::EventSetup::get(), runregparse::hlt, HLT_FULL_cff::recHits, trackerHits::simHits, and RecoTauPiZeroBuilderPlugins_cfi::strips.

                                                                            {
  // 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.

                                              {
  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 2558 of file CSCValidation.cc.

References CSCDetId, CSCIndexer::dbIndex(), Reference_intrackfit_cff::endcap, mergeVDriftHistosByStation::histos, i, j, mergeVDriftHistosByStation::name, relativeConstraints::ring, contentValuesCheck::ss, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, indexGen::title, and x().

                                                                       {
  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.c_str(),title.c_str(),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 2432 of file CSCValidation.cc.

References CSCIndexer::dbIndex(), Reference_intrackfit_cff::endcap, mergeVDriftHistosByStation::histos, mergeVDriftHistosByStation::name, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, indexGen::title, and x().

                                                                      {
     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.c_str(),title.c_str(),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.c_str(),title.c_str(),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 newFWLiteAna::bin, CSCDBCrosstalk::crosstalk, CSCDBGains::gains, edm::EventSetup::get(), mergeVDriftHistosByStation::histos, i, LogDebug, CSCDBNoiseMatrix::matrix, CSCDBPedestals::pedestals, and edm::ESHandle< class >::product().

                                                                 {

  // 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 2497 of file CSCValidation.cc.

References CSCIndexer::dbIndex(), Reference_intrackfit_cff::endcap, mergeVDriftHistosByStation::histos, mergeVDriftHistosByStation::name, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, indexGen::title, and x().

                                                                           {

     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.c_str(),title.c_str(),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 newFWLiteAna::bin, CSCDetId::chamber(), CSCChamberSpecs::chamberTypeName(), CSCDetId, mps_update::diff, CSCDetId::endcap(), plotBeamSpotDB::first, CSCLayer::geometry(), CSCChamber::id(), CSCChamber::layer(), CSCDetId::layer(), CSCSegment::localDirection(), CSCSegment::localPosition(), TrapezoidalPlaneBounds::parameters(), CSCDetId::ring(), CSCChamber::specs(), CSCDetId::station(), dtDQMClient_cfg::threshold, GeomDet::toGlobal(), GeomDet::toLocal(), puppiForMET_cff::weight, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                    {

  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.size()){
    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 = 0;
      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 CSCDetId, CSCIndexer::dbIndex(), Reference_intrackfit_cff::endcap, create_complex_test_file0_cfg::firstEvent, mergeVDriftHistosByStation::histos, i, j, VarParsing::mult, mergeVDriftHistosByStation::name, relativeConstraints::ring, contentValuesCheck::ss, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, indexGen::title, and x().

                                                                       {
     float y;
     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;
                 float x=location;
                
                 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("");
                 x=location;
                 y=adc_3_3_sum;
                 histos->fill2DHist(x,y,name.c_str(),title.c_str(),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 mergeVDriftHistosByStation::histos, and i.

                                                   {

  // 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 CSCDetId, mergeVDriftHistosByStation::histos, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                                            {

  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(), CSCDetId, mps_update::diff, alignCSCRings::e, CSCDetId::endcap(), mergeVDriftHistosByStation::histos, alignCSCRings::r, CSCDetId::ring(), alignCSCRings::s, CSCDetId::station(), and dtDQMClient_cfg::threshold.

                                                                                                                        {

  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 CSCDetId, mergeVDriftHistosByStation::histos, relativeConstraints::station, and dtDQMClient_cfg::threshold.

                                                                           {

  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, CSCDetId::endcap(), mergeVDriftHistosByStation::histos, i, j, kLayer(), CSCDetId::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().

                                                                                                       {

  // 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 CSCDetId, mergeVDriftHistosByStation::histos, kLayer(), CSCDetId::layer(), CSCDetId::ring(), and CSCDetId::station().

                                                                                                             {


  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 ChiSquaredProbability(), CSCDetId, CSCDetId::endcap(), mergeVDriftHistosByStation::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().

                                                                                                           {

  // 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(), CSCDetId, mergeVDriftHistosByStation::histos, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

                                                                                                          {

  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 beam_dqm_sourceclient-live_cfg::chi2, MuonSubdetId::CSC, SiPixelRawToDigiRegional_cfi::deltaPhi, MuonSubdetId::DT, mergeVDriftHistosByStation::histos, PV3DBase< T, PVType, FrameType >::mag(), DetId::Muon, metsig::muon, gen::n, np, and MuonSubdetId::RPC.

                                                                   {

  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 CSCDetId, mps_update::diff, mergeVDriftHistosByStation::histos, and dtDQMClient_cfg::threshold.

                                                                        {

  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 2644 of file CSCValidation.cc.

References CSCTMBHeader::ALCTMatchTime(), CSCTMBHeader::BXNCount(), CSCDetId::chamber(), CSCDetId::chamberId(), DDVectorGetter::check(), CSCDCCExaminer::check(), CSCDCCExaminer::crcALCT(), CSCDCCExaminer::crcCFEB(), CSCDCCExaminer::crcTMB(), CSCDetId, FEDRawData::data(), data, CSCDCCEventData::dduData(), CSCCrateMap::detId(), CSCDetId::endcap(), CSCDCCExaminer::errors(), edm::EventSetup::get(), mergeVDriftHistosByStation::histos, j, LogTrace, FEDNumbering::MAXCSCFEDID, FEDNumbering::MINCSCFEDID, NULL, edm::ESHandle< class >::product(), lumiPlot::rawdata, CSCDetId::ring(), CSCDCCExaminer::setMask(), FEDRawData::size(), mathSSE::sqrt(), CSCDetId::station(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                            {

  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 = NULL;
      std::stringstream examiner_out, examiner_err;
      goodEvent = true;
      //CSCDCCExaminer examiner;
      examiner = new CSCDCCExaminer();
      if( examinerMask&0x40000 ) examiner->crcCFEB(1);
      if( examinerMask&0x8000  ) examiner->crcTMB (1);
      if( examinerMask&0x0400  ) examiner->crcALCT(1);
      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!=NULL) 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 mergeVDriftHistosByStation::histos.

                                                                            {

  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 CSCDetId, and mergeVDriftHistosByStation::histos.

                                                                     {

  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  )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 3022 of file CSCValidation.cc.

References gather_cfg::cout.

                           {

     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.

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

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

private

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.

                                                                        {

  //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(), ztail::d, CSCDetId::endcap(), mergeVDriftHistosByStation::histos, i, j, kLayer(), CSCDetId::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().

                                                                                                                       {
 
  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, i, S(), and slope.

                                                                                   {

  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().

                                                                             {
  //---- 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 CSCDetId, reco::if(), and plotBeamSpotDB::last.

                                                                                                      {

  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 CSCDetId, reco::if(), plotBeamSpotDB::last, CSCDetId::ring(), and CSCDetId::station().

                                                                                                          {
    // 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 CSCDetId, plotBeamSpotDB::first, reco::if(), plotBeamSpotDB::last, CSCDetId::ring(), CSCDetId::station(), and create_public_lumi_plots::width.

                                                                                                   {

  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 i, and SiStripMonitorClusterAlca_cfi::Nbins.

                                                                    {
  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.

                                           {
  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 Reference_intrackfit_cff::endcap, cmsHarvester::index, 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().

                                                                                                                                                                               {
//---- 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;
}

Member Data Documentation

edm::EDGetTokenT<CSCALCTDigiCollection> CSCValidation::al_token

private

Definition at line 244 of file CSCValidation.h.

std::multimap<CSCDetId , CSCRecHit2D> CSCValidation::AllRechits

private

Definition at line 305 of file CSCValidation.h.

edm::EDGetTokenT<CSCComparatorDigiCollection> CSCValidation::cd_token

private

Definition at line 243 of file CSCValidation.h.

double CSCValidation::chisqMax

private

Definition at line 234 of file CSCValidation.h.

edm::EDGetTokenT<CSCCLCTDigiCollection> CSCValidation::cl_token

private

Definition at line 245 of file CSCValidation.h.

bool CSCValidation::cleanEvent

private

Definition at line 208 of file CSCValidation.h.

edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> CSCValidation::co_token

private

Definition at line 246 of file CSCValidation.h.

double CSCValidation::deltaPhiMax

private

Definition at line 237 of file CSCValidation.h.

bool CSCValidation::detailedAnalysis

private

Definition at line 224 of file CSCValidation.h.

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

private

Definition at line 308 of file CSCValidation.h.

bool CSCValidation::firstEvent

private

Definition at line 207 of file CSCValidation.h.

TH2F* CSCValidation::hEffDenominator

private

Definition at line 290 of file CSCValidation.h.

CSCValHists* CSCValidation::histos

private

Definition at line 275 of file CSCValidation.h.

Referenced by cuy.ValElement::__init__(), cuy.additionElement::__init__(), cuy.superimposeElement::__init__(), and cuy.graphElement::__init__().

TH2I* CSCValidation::hORecHits

private

Definition at line 296 of file CSCValidation.h.

TH2I* CSCValidation::hOSegments

private

Definition at line 297 of file CSCValidation.h.

TH2I* CSCValidation::hOStrips

private

Definition at line 295 of file CSCValidation.h.

TH2I* CSCValidation::hOWires

private

Definition at line 294 of file CSCValidation.h.

TH1F* CSCValidation::hRHEff

private

Definition at line 281 of file CSCValidation.h.

TH2F* CSCValidation::hRHEff2

private

Definition at line 287 of file CSCValidation.h.

TH1F* CSCValidation::hRHSTE

private

Definition at line 279 of file CSCValidation.h.

TH2F* CSCValidation::hRHSTE2

private

Definition at line 283 of file CSCValidation.h.

TH1F* CSCValidation::hSEff

private

Definition at line 280 of file CSCValidation.h.

TH2F* CSCValidation::hSEff2

private

Definition at line 286 of file CSCValidation.h.

TH2F* CSCValidation::hSensitiveAreaEvt

private

Definition at line 291 of file CSCValidation.h.

TH1F* CSCValidation::hSSTE

private

Definition at line 278 of file CSCValidation.h.

TH2F* CSCValidation::hSSTE2

private

Definition at line 282 of file CSCValidation.h.

TH2F* CSCValidation::hStripEff2

private

Definition at line 288 of file CSCValidation.h.

TH2F* CSCValidation::hStripSTE2

private

Definition at line 284 of file CSCValidation.h.

TH2F* CSCValidation::hWireEff2

private

Definition at line 289 of file CSCValidation.h.

TH2F* CSCValidation::hWireSTE2

private

Definition at line 285 of file CSCValidation.h.

bool CSCValidation::isSimulation

private

Definition at line 222 of file CSCValidation.h.

edm::EDGetTokenT<L1MuGMTReadoutCollection> CSCValidation::l1_token

private

Definition at line 249 of file CSCValidation.h.

double CSCValidation::lengthMax

private

Definition at line 236 of file CSCValidation.h.

double CSCValidation::lengthMin

private

Definition at line 236 of file CSCValidation.h.

std::map<int, int> CSCValidation::m_single_wire_layer

private

Definition at line 302 of file CSCValidation.h.

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

private

Definition at line 301 of file CSCValidation.h.

bool CSCValidation::makeADCTimingPlots

private

Definition at line 268 of file CSCValidation.h.

bool CSCValidation::makeAFEBTimingPlots

private

Definition at line 266 of file CSCValidation.h.

bool CSCValidation::makeCalibPlots

private

Definition at line 270 of file CSCValidation.h.

bool CSCValidation::makeComparisonPlots

private

Definition at line 219 of file CSCValidation.h.

bool CSCValidation::makeCompTimingPlots

private

Definition at line 267 of file CSCValidation.h.

bool CSCValidation::makeEfficiencyPlots

private

Definition at line 264 of file CSCValidation.h.

bool CSCValidation::makeGasGainPlots

private

Definition at line 265 of file CSCValidation.h.

bool CSCValidation::makeHLTPlots

private

Definition at line 226 of file CSCValidation.h.

bool CSCValidation::makeOccupancyPlots

private

Definition at line 255 of file CSCValidation.h.

bool CSCValidation::makePedNoisePlots

private

Definition at line 263 of file CSCValidation.h.

bool CSCValidation::makePlots

private

Definition at line 218 of file CSCValidation.h.

bool CSCValidation::makeRecHitPlots

private

Definition at line 259 of file CSCValidation.h.

bool CSCValidation::makeResolutionPlots

private

Definition at line 262 of file CSCValidation.h.

bool CSCValidation::makeRHNoisePlots

private

Definition at line 269 of file CSCValidation.h.

bool CSCValidation::makeSegmentPlots

private

Definition at line 261 of file CSCValidation.h.

bool CSCValidation::makeSimHitPlots

private

Definition at line 260 of file CSCValidation.h.

bool CSCValidation::makeStandalonePlots

private

Definition at line 271 of file CSCValidation.h.

bool CSCValidation::makeStripPlots

private

Definition at line 257 of file CSCValidation.h.

bool CSCValidation::makeTimeMonitorPlots

private

Definition at line 272 of file CSCValidation.h.

bool CSCValidation::makeTriggerPlots

private

Definition at line 256 of file CSCValidation.h.

bool CSCValidation::makeWirePlots

private

Definition at line 258 of file CSCValidation.h.

int CSCValidation::nCSCHitsMax

private

Definition at line 235 of file CSCValidation.h.

int CSCValidation::nCSCHitsMin

private

Definition at line 235 of file CSCValidation.h.

int CSCValidation::nEventsAnalyzed

private

Definition at line 204 of file CSCValidation.h.

std::vector<int> CSCValidation::nmbhvsegm

private

Maps and vectors for module doGasGain()

Definition at line 300 of file CSCValidation.h.

std::multimap<CSCDetId , CSCRecHit2D> CSCValidation::NonAssociatedRechits

private

Definition at line 307 of file CSCValidation.h.

double CSCValidation::pMin

private

Definition at line 233 of file CSCValidation.h.

double CSCValidation::polarMax

private

Definition at line 238 of file CSCValidation.h.

double CSCValidation::polarMin

private

Definition at line 238 of file CSCValidation.h.

edm::EDGetTokenT<FEDRawDataCollection> CSCValidation::rd_token

private

Definition at line 240 of file CSCValidation.h.

std::string CSCValidation::refRootFile

private

Definition at line 220 of file CSCValidation.h.

edm::EDGetTokenT<CSCRecHit2DCollection> CSCValidation::rh_token

private

Definition at line 247 of file CSCValidation.h.

int CSCValidation::rhTreeCount

private

Definition at line 205 of file CSCValidation.h.

std::string CSCValidation::rootFileName

private

Definition at line 223 of file CSCValidation.h.

edm::EDGetTokenT<reco::TrackCollection> CSCValidation::sa_token

private

Definition at line 251 of file CSCValidation.h.

edm::EDGetTokenT<CSCStripDigiCollection> CSCValidation::sd_token

private

Definition at line 242 of file CSCValidation.h.

edm::EDGetTokenT<CSCSegmentCollection> CSCValidation::se_token

private

Definition at line 248 of file CSCValidation.h.

std::multimap<CSCDetId , CSCRecHit2D> CSCValidation::SegRechits

private

Definition at line 306 of file CSCValidation.h.

int CSCValidation::segTreeCount

private

Definition at line 206 of file CSCValidation.h.

edm::EDGetTokenT<edm::PSimHitContainer> CSCValidation::sh_token

private

Definition at line 252 of file CSCValidation.h.

TFile* CSCValidation::theFile

private

Definition at line 213 of file CSCValidation.h.

edm::EDGetTokenT<edm::TriggerResults> CSCValidation::tr_token

private

Definition at line 250 of file CSCValidation.h.

bool CSCValidation::useDigis

private

Definition at line 225 of file CSCValidation.h.

bool CSCValidation::useQualityFilter

private

Definition at line 229 of file CSCValidation.h.

bool CSCValidation::useTriggerFilter

private

Definition at line 230 of file CSCValidation.h.

edm::EDGetTokenT<CSCWireDigiCollection> CSCValidation::wd_token

private

Definition at line 241 of file CSCValidation.h.

bool CSCValidation::writeTreeToFile

private

Definition at line 221 of file CSCValidation.h.