CSCEfficiency Class Reference

#include <CSCEfficiency.h>

Inheritance diagram for CSCEfficiency:

Classes
struct	ChamberHistos
struct	StationHistos

Public Member Functions
	CSCEfficiency (const edm::ParameterSet &pset)
	Constructor. More...
	~CSCEfficiency () override
	Destructor. More...
Public Member Functions inherited from edm::one::EDFilter<>
	EDFilter ()=default
	EDFilter (const EDFilter &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDFilter &	operator= (const EDFilter &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDFilterBase
	EDFilterBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDFilterBase () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
std::vector< bool > const &	recordProvenanceList () const
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...
	~ProducerBase () noexcept(false) override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
bool	applyTrigger (edm::Handle< edm::TriggerResults > &hltR, const edm::TriggerNames &triggerNames)
void	chamberCandidates (int station, int ring, float phi, std::vector< int > &coupleOfChambers)
bool	checkLocal (double yLocal, double yBoundary, int station, int ring)
void	chooseDirection (CLHEP::Hep3Vector &innerPosition, CLHEP::Hep3Vector &outerPosition)
bool	efficienciesPerChamber (CSCDetId &id, const CSCChamber *cscChamber, FreeTrajectoryState &ftsChamber)
double	extrapolate1D (double initPosition, double initDirection, double parameterOfTheLine)
void	fillDigiInfo (edm::Handle< CSCALCTDigiCollection > &alcts, edm::Handle< CSCCLCTDigiCollection > &clcts, edm::Handle< CSCCorrelatedLCTDigiCollection > &correlatedlcts, edm::Handle< CSCWireDigiCollection > &wires, edm::Handle< CSCStripDigiCollection > &strips, edm::Handle< edm::PSimHitContainer > &simhits, edm::Handle< CSCRecHit2DCollection > &rechits, edm::Handle< CSCSegmentCollection > &segments, edm::ESHandle< CSCGeometry > &cscGeom)
void	fillLCT_info (edm::Handle< CSCALCTDigiCollection > &alcts, edm::Handle< CSCCLCTDigiCollection > &clcts, edm::Handle< CSCCorrelatedLCTDigiCollection > &correlatedlcts)
void	fillRechitsSegments_info (edm::Handle< CSCRecHit2DCollection > &rechits, edm::Handle< CSCSegmentCollection > &segments, edm::ESHandle< CSCGeometry > &cscGeom)
void	fillSimhit_info (edm::Handle< edm::PSimHitContainer > &simHits)
void	fillStrips_info (edm::Handle< CSCStripDigiCollection > &strips)
void	fillWG_info (edm::Handle< CSCWireDigiCollection > &wires, edm::ESHandle< CSCGeometry > &cscGeom)
bool	filter (edm::Event &event, const edm::EventSetup &eventSetup) override
FreeTrajectoryState	getFromCLHEP (const CLHEP::Hep3Vector &p3, const CLHEP::Hep3Vector &r3, int charge, const AlgebraicSymMatrix66 &cov, const MagneticField *field)
void	getFromFTS (const FreeTrajectoryState &fts, CLHEP::Hep3Vector &p3, CLHEP::Hep3Vector &r3, int &charge, AlgebraicSymMatrix66 &cov)
bool	inSensitiveLocalRegion (double xLocal, double yLocal, int station, int ring)
void	linearExtrapolation (GlobalPoint initialPosition, GlobalVector initialDirection, float zSurface, std::vector< float > &posZY)
double	lineParameter (double initZPosition, double destZPosition, double initZDirection)
TrajectoryStateOnSurface	propagate (FreeTrajectoryState &ftsStart, const BoundPlane &bp)
const Propagator *	propagator (std::string propagatorName) const
bool	recHitSegment_Efficiencies (CSCDetId &cscDetId, const CSCChamber *cscChamber, FreeTrajectoryState &ftsChamber)
bool	recSimHitEfficiency (CSCDetId &id, FreeTrajectoryState &ftsChamber)
void	returnTypes (CSCDetId &id, int &ec, int &st, int &rg, int &ch, int &secondRing)
void	ringCandidates (int station, float absEta, std::map< std::string, bool > &chamberTypes)
bool	stripWire_Efficiencies (CSCDetId &cscDetId, FreeTrajectoryState &ftsChamber)

Private Attributes
edm::EDGetTokenT< CSCALCTDigiCollection >	al_token
TH1F *	ALCTPerEvent
bool	allALCT [2][4][4][(36 - 1+1)]
bool	allCLCT [2][4][4][(36 - 1+1)]
bool	allCorrLCT [2][4][4][(36 - 1+1)]
std::vector< std::pair< LocalPoint, bool > >	allRechits [2][4][4][(36 - 1+1)][6]
std::vector< std::pair< LocalPoint, LocalVector > >	allSegments [2][4][4][(36 - 1+1)]
std::vector< std::pair< LocalPoint, int > >	allSimhits [2][4][4][(36 - 1+1)][6]
std::vector< std::pair< int, float > >	allStrips [2][4][4][(36 - 1+1)][6]
std::vector< std::pair< std::pair< int, float >, int > >	allWG [2][4][4][(36 - 1+1)][6]
bool	alongZ
bool	andOr
bool	applyIPangleCuts
struct CSCEfficiency::ChamberHistos	ChHist [2][4][3][36 - 1+1]
edm::EDGetTokenT< CSCCLCTDigiCollection >	cl_token
TH1F *	CLCTPerEvent
edm::EDGetTokenT< CSCCorrelatedLCTDigiCollection >	co_token
TH1F *	DataFlow
double	distanceFromDeadZone
bool	emptyChambers [2][4][4][(36 - 1+1)]
edm::ESGetToken< CSCGeometry, MuonGeometryRecord >	geomToken_
bool	getAbsoluteEfficiency
edm::EDGetTokenT< edm::TriggerResults >	ht_token
bool	isBeamdata
bool	isData
bool	isIPdata
double	local_DX_DZ_Max
double	local_DY_DZ_Max
double	local_DY_DZ_Min
bool	magField
double	maxNormChi2
double	maxP
double	minP
unsigned int	minTrackHits
std::vector< std::string >	myTriggers
int	nEventsAnalyzed
bool	passTheEvent
std::vector< int >	pointToTriggers
bool	printalot
unsigned int	printout_NEvents
TH1F *	recHitsPerEvent
edm::EDGetTokenT< CSCRecHit2DCollection >	rh_token
std::string	rootFileName
edm::EDGetTokenT< CSCStripDigiCollection >	sd_token
edm::EDGetTokenT< CSCSegmentCollection >	se_token
TH1F *	segmentsPerEvent
edm::EDGetTokenT< edm::PSimHitContainer >	sh_token
struct CSCEfficiency::StationHistos	StHist [2][4]
TFile *	theFile
MuonServiceProxy *	theService
edm::EDGetTokenT< edm::View< reco::Track > >	tk_token
TH1F *	TriggersFired
bool	useDigis
bool	useTrigger
edm::EDGetTokenT< CSCWireDigiCollection >	wd_token

Additional Inherited Members
Public Types inherited from edm::one::EDFilterBase
typedef EDFilterBase	ModuleType
Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex > >
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::one::EDFilterBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...
template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()
template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()
template<Transition Tr = Transition::Event>
auto	produces () noexcept
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Efficiency calculations Stoyan Stoynev, Northwestern University

Definition at line 95 of file CSCEfficiency.h.

Constructor & Destructor Documentation

CSCEfficiency()

CSCEfficiency::CSCEfficiency

(

const edm::ParameterSet &

pset

)

Constructor.

Definition at line 1639 of file CSCEfficiency.cc.

References PA_MinBiasSkim_cff::andOr, FirstCh, createfilelist::int, HLTBitAnalyser_cfi::isData, MuonMETValueMapProducer_cff::maxNormChi2, RecoMuonValidator_cfi::maxP, alignBH_cfg::minP, HLT_2023v12_cff::minTrackHits, MuonServiceProxy_cff::MuonServiceProxy, NumCh, mps_fire::Path, muonDTDigis_cfi::pset, CSCSkim_cfi::rootFileName, AlCaHLTBitMon_QueryRunRegistry::string, and makeListRunsInFiles::theFile.

                                                        {
  // const float Xmin = -70;
  //const float Xmax = 70;
  //const int nXbins = int(4.*(Xmax - Xmin));
  const float Ymin = -165;
  const float Ymax = 165;
  const int nYbins = int((Ymax - Ymin) / 2);
  const float Layer_min = -0.5;
  const float Layer_max = 9.5;
  const int nLayer_bins = int(Layer_max - Layer_min);
  //

  //---- Get the input parameters
  printout_NEvents = pset.getUntrackedParameter<unsigned int>("printout_NEvents", 0);
  rootFileName = pset.getUntrackedParameter<string>("rootFileName", "cscHists.root");

  isData = pset.getUntrackedParameter<bool>("runOnData", true);                             //
  isIPdata = pset.getUntrackedParameter<bool>("IPdata", false);                             //
  isBeamdata = pset.getUntrackedParameter<bool>("Beamdata", false);                         //
  getAbsoluteEfficiency = pset.getUntrackedParameter<bool>("getAbsoluteEfficiency", true);  //
  useDigis = pset.getUntrackedParameter<bool>("useDigis", true);                            //
  distanceFromDeadZone = pset.getUntrackedParameter<double>("distanceFromDeadZone", 10.);   //
  minP = pset.getUntrackedParameter<double>("minP", 20.);                                   //
  maxP = pset.getUntrackedParameter<double>("maxP", 100.);                                  //
  maxNormChi2 = pset.getUntrackedParameter<double>("maxNormChi2", 3.);                      //
  minTrackHits = pset.getUntrackedParameter<unsigned int>("minTrackHits", 10);              //

  applyIPangleCuts = pset.getUntrackedParameter<bool>("applyIPangleCuts", false);  //
  local_DY_DZ_Max = pset.getUntrackedParameter<double>("local_DY_DZ_Max", -0.1);   //
  local_DY_DZ_Min = pset.getUntrackedParameter<double>("local_DY_DZ_Min", -0.8);   //
  local_DX_DZ_Max = pset.getUntrackedParameter<double>("local_DX_DZ_Max", 0.2);    //

  sd_token = consumes<CSCStripDigiCollection>(pset.getParameter<edm::InputTag>("stripDigiTag"));
  wd_token = consumes<CSCWireDigiCollection>(pset.getParameter<edm::InputTag>("wireDigiTag"));
  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>("rechitTag"));
  se_token = consumes<CSCSegmentCollection>(pset.getParameter<edm::InputTag>("segmentTag"));
  tk_token = consumes<edm::View<reco::Track> >(pset.getParameter<edm::InputTag>("tracksTag"));
  sh_token = consumes<edm::PSimHitContainer>(pset.getParameter<edm::InputTag>("simHitTag"));

  geomToken_ = esConsumes<CSCGeometry, MuonGeometryRecord>();

  edm::ParameterSet serviceParameters = pset.getParameter<edm::ParameterSet>("ServiceParameters");
  // maybe use the service for getting magnetic field, propagators, etc. ...
  theService = new MuonServiceProxy(serviceParameters, consumesCollector());

  // Trigger
  useTrigger = pset.getUntrackedParameter<bool>("useTrigger", false);

  ht_token = consumes<edm::TriggerResults>(pset.getParameter<edm::InputTag>("HLTriggerResults"));

  myTriggers = pset.getParameter<std::vector<std::string> >("myTriggers");
  andOr = pset.getUntrackedParameter<bool>("andOr");
  pointToTriggers.clear();

  //---- set counter to zero
  nEventsAnalyzed = 0;
  //---- set presence of magnetic field
  magField = true;
  //
  std::string Path = "AllChambers/";
  std::string FullName;
  //---- File with output histograms
  theFile = new TFile(rootFileName.c_str(), "RECREATE");
  theFile->cd();
  //---- Book histograms for the analysis
  char SpecName[60];

  sprintf(SpecName, "DataFlow");
  DataFlow = new TH1F(SpecName, "Data flow;condition number;entries", 40, -0.5, 39.5);
  //
  sprintf(SpecName, "TriggersFired");
  TriggersFired = new TH1F(SpecName, "Triggers fired;trigger number;entries", 140, -0.5, 139.5);
  //
  int Chan = 50;
  float minChan = -0.5;
  float maxChan = 49.5;
  //
  sprintf(SpecName, "ALCTPerEvent");
  ALCTPerEvent = new TH1F(SpecName, "ALCTs per event;N digis;entries", Chan, minChan, maxChan);
  //
  sprintf(SpecName, "CLCTPerEvent");
  CLCTPerEvent = new TH1F(SpecName, "CLCTs per event;N digis;entries", Chan, minChan, maxChan);
  //
  sprintf(SpecName, "recHitsPerEvent");
  recHitsPerEvent = new TH1F(SpecName, "RecHits per event;N digis;entries", 150, -0.5, 149.5);
  //
  sprintf(SpecName, "segmentsPerEvent");
  segmentsPerEvent = new TH1F(SpecName, "segments per event;N digis;entries", Chan, minChan, maxChan);
  //
  //---- Book groups of histograms (for any chamber)

  map<std::string, bool>::iterator iter;
  for (int ec = 0; ec < 2; ++ec) {
    for (int st = 0; st < 4; ++st) {
      theFile->cd();
      sprintf(SpecName, "Stations__E%d_S%d", ec + 1, st + 1);
      theFile->mkdir(SpecName);
      theFile->cd(SpecName);

      //
      sprintf(SpecName, "segmentChi2_ndf_St%d", st + 1);
      StHist[ec][st].segmentChi2_ndf = new TH1F(SpecName, "Chi2/ndf of a segment;chi2/ndf;entries", 100, 0., 20.);
      //
      sprintf(SpecName, "hitsInSegment_St%d", st + 1);
      StHist[ec][st].hitsInSegment = new TH1F(SpecName, "Number of hits in a segment;nHits;entries", 7, -0.5, 6.5);
      //
      Chan = 170;
      minChan = 0.85;
      maxChan = 2.55;
      //
      sprintf(SpecName, "AllSegments_eta_St%d", st + 1);
      StHist[ec][st].AllSegments_eta = new TH1F(SpecName, "All segments in eta;eta;entries", Chan, minChan, maxChan);
      //
      sprintf(SpecName, "EfficientSegments_eta_St%d", st + 1);
      StHist[ec][st].EfficientSegments_eta =
          new TH1F(SpecName, "Efficient segments in eta;eta;entries", Chan, minChan, maxChan);
      //
      sprintf(SpecName, "ResidualSegments_St%d", st + 1);
      StHist[ec][st].ResidualSegments = new TH1F(SpecName, "Residual (segments);residual,cm;entries", 75, 0., 15.);
      //
      Chan = 200;
      minChan = -800.;
      maxChan = 800.;
      int Chan2 = 200;
      float minChan2 = -800.;
      float maxChan2 = 800.;

      sprintf(SpecName, "EfficientSegments_XY_St%d", st + 1);
      StHist[ec][st].EfficientSegments_XY =
          new TH2F(SpecName, "Efficient segments in XY;X;Y", Chan, minChan, maxChan, Chan2, minChan2, maxChan2);
      sprintf(SpecName, "InefficientSegments_XY_St%d", st + 1);
      StHist[ec][st].InefficientSegments_XY =
          new TH2F(SpecName, "Inefficient segments in XY;X;Y", Chan, minChan, maxChan, Chan2, minChan2, maxChan2);
      //
      Chan = 80;
      minChan = 0;
      maxChan = 3.2;
      sprintf(SpecName, "EfficientALCT_momTheta_St%d", st + 1);
      StHist[ec][st].EfficientALCT_momTheta =
          new TH1F(SpecName, "Efficient ALCT in theta (momentum);theta, rad;entries", Chan, minChan, maxChan);
      //
      sprintf(SpecName, "InefficientALCT_momTheta_St%d", st + 1);
      StHist[ec][st].InefficientALCT_momTheta =
          new TH1F(SpecName, "Inefficient ALCT in theta (momentum);theta, rad;entries", Chan, minChan, maxChan);
      //
      Chan = 160;
      minChan = -3.2;
      maxChan = 3.2;
      sprintf(SpecName, "EfficientCLCT_momPhi_St%d", st + 1);
      StHist[ec][st].EfficientCLCT_momPhi =
          new TH1F(SpecName, "Efficient CLCT in phi (momentum);phi, rad;entries", Chan, minChan, maxChan);
      //
      sprintf(SpecName, "InefficientCLCT_momPhi_St%d", st + 1);
      StHist[ec][st].InefficientCLCT_momPhi =
          new TH1F(SpecName, "Inefficient CLCT in phi (momentum);phi, rad;entries", Chan, minChan, maxChan);
      //
      theFile->cd();
      for (int rg = 0; rg < 3; ++rg) {
        if (0 != st && rg > 1) {
          continue;
        } else if (1 == rg && 3 == st) {
          continue;
        }
        for (int iChamber = FirstCh; iChamber < FirstCh + NumCh; iChamber++) {
          if (0 != st && 0 == rg && iChamber > 18) {
            continue;
          }
          theFile->cd();
          sprintf(SpecName, "Chambers__E%d_S%d_R%d_Chamber_%d", ec + 1, st + 1, rg + 1, iChamber);
          theFile->mkdir(SpecName);
          theFile->cd(SpecName);
          //

          sprintf(SpecName, "EfficientRechits_inSegment_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientRechits_inSegment = new TH1F(
              SpecName, "Existing RecHit given a segment;layers (1-6);entries", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "InefficientSingleHits_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].InefficientSingleHits = new TH1F(
              SpecName, "Single RecHits not in the segment;layers (1-6);entries ", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "AllSingleHits_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].AllSingleHits = new TH1F(
              SpecName, "Single RecHits given a segment; layers (1-6);entries", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "digiAppearanceCount_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].digiAppearanceCount =
              new TH1F(SpecName,
                       "Digi appearance (no-yes): segment(0,1), ALCT(2,3), CLCT(4,5), CorrLCT(6,7); digi type;entries",
                       8,
                       -0.5,
                       7.5);
          //
          Chan = 100;
          minChan = -1.1;
          maxChan = 0.9;
          sprintf(SpecName, "EfficientALCT_dydz_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientALCT_dydz =
              new TH1F(SpecName, "Efficient ALCT; local dy/dz (ME 3 and 4 flipped);entries", Chan, minChan, maxChan);
          //
          sprintf(SpecName, "InefficientALCT_dydz_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].InefficientALCT_dydz =
              new TH1F(SpecName, "Inefficient ALCT; local dy/dz (ME 3 and 4 flipped);entries", Chan, minChan, maxChan);
          //
          Chan = 100;
          minChan = -1.;
          maxChan = 1.0;
          sprintf(SpecName, "EfficientCLCT_dxdz_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientCLCT_dxdz =
              new TH1F(SpecName, "Efficient CLCT; local dxdz;entries", Chan, minChan, maxChan);
          //
          sprintf(SpecName, "InefficientCLCT_dxdz_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].InefficientCLCT_dxdz =
              new TH1F(SpecName, "Inefficient CLCT; local dxdz;entries", Chan, minChan, maxChan);
          //
          sprintf(SpecName, "EfficientRechits_good_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientRechits_good = new TH1F(
              SpecName, "Existing RecHit - sensitive area only;layers (1-6);entries", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "EfficientStrips_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientStrips =
              new TH1F(SpecName, "Existing strip;layer (1-6); entries", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "EfficientWireGroups_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientWireGroups =
              new TH1F(SpecName, "Existing WireGroups;layer (1-6); entries ", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "StripWiresCorrelations_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].StripWiresCorrelations =
              new TH1F(SpecName, "StripWire correlations;; entries ", 5, 0.5, 5.5);
          //
          Chan = 80;
          minChan = 0;
          maxChan = 3.2;
          sprintf(SpecName, "NoWires_momTheta_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].NoWires_momTheta =
              new TH1F(SpecName,
                       "No wires (all strips present) - in theta (momentum);theta, rad;entries",
                       Chan,
                       minChan,
                       maxChan);
          //
          Chan = 160;
          minChan = -3.2;
          maxChan = 3.2;
          sprintf(SpecName, "NoStrips_momPhi_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].NoStrips_momPhi = new TH1F(
              SpecName, "No strips (all wires present) - in phi (momentum);phi, rad;entries", Chan, minChan, maxChan);
          //
          for (int iLayer = 0; iLayer < 6; iLayer++) {
            sprintf(SpecName, "Y_InefficientRecHits_inSegment_Ch%d_L%d", iChamber, iLayer);
            ChHist[ec][st][rg][iChamber - FirstCh].Y_InefficientRecHits_inSegment.push_back(
                new TH1F(SpecName,
                         "Missing RecHit/layer in a segment (local system, whole chamber);Y, cm; entries",
                         nYbins,
                         Ymin,
                         Ymax));
            //
            sprintf(SpecName, "Y_EfficientRecHits_inSegment_Ch%d_L%d", iChamber, iLayer);
            ChHist[ec][st][rg][iChamber - FirstCh].Y_EfficientRecHits_inSegment.push_back(
                new TH1F(SpecName,
                         "Efficient (extrapolated from the segment) RecHit/layer in a segment (local system, whole "
                         "chamber);Y, cm; entries",
                         nYbins,
                         Ymin,
                         Ymax));
            //
            Chan = 200;
            minChan = -0.2;
            maxChan = 0.2;
            sprintf(SpecName, "Phi_InefficientRecHits_inSegment_Ch%d_L%d", iChamber, iLayer);
            ChHist[ec][st][rg][iChamber - FirstCh].Phi_InefficientRecHits_inSegment.push_back(
                new TH1F(SpecName,
                         "Missing RecHit/layer in a segment (local system, whole chamber);Phi, rad; entries",
                         Chan,
                         minChan,
                         maxChan));
            //
            sprintf(SpecName, "Phi_EfficientRecHits_inSegment_Ch%d_L%d", iChamber, iLayer);
            ChHist[ec][st][rg][iChamber - FirstCh].Phi_EfficientRecHits_inSegment.push_back(
                new TH1F(SpecName,
                         "Efficient (extrapolated from the segment) in a segment (local system, whole chamber);Phi, "
                         "rad; entries",
                         Chan,
                         minChan,
                         maxChan));
          }
          //
          sprintf(SpecName, "Sim_Rechits_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].SimRechits =
              new TH1F(SpecName, "Existing RecHit (Sim);layers (1-6);entries", nLayer_bins, Layer_min, Layer_max);
          //
          sprintf(SpecName, "Sim_Simhits_Ch%d", iChamber);
          ChHist[ec][st][rg][iChamber - FirstCh].SimSimhits =
              new TH1F(SpecName, "Existing SimHit (Sim);layers (1-6);entries", nLayer_bins, Layer_min, Layer_max);
          //
          /*
      sprintf(SpecName,"Sim_Rechits_each_Ch%d",iChamber);
      ChHist[ec][st][rg][iChamber-FirstCh].SimRechits_each =
        new TH1F(SpecName,"Existing RecHit (Sim), each;layers (1-6);entries",nLayer_bins,Layer_min,Layer_max);
      //
      sprintf(SpecName,"Sim_Simhits_each_Ch%d",iChamber);
      ChHist[ec][st][rg][iChamber-FirstCh].SimSimhits_each =
        new TH1F(SpecName,"Existing SimHit (Sim), each;layers (1-6);entries",nLayer_bins,Layer_min,Layer_max);
      */
          theFile->cd();
        }
      }
    }
  }
}

~CSCEfficiency()

CSCEfficiency::~CSCEfficiency ( )

override

Destructor.

Definition at line 1955 of file CSCEfficiency.cc.

References trigObjTnPSource_cfi::bins, gather_cfg::cout, PixelTestBeamValidation_cfi::Efficiency, FirstCh, NumCh, and makeListRunsInFiles::theFile.

                              {
  if (theService)
    delete theService;
  // Write the histos to a file
  theFile->cd();
  //
  char SpecName[60];
  std::vector<float> bins, Efficiency, EffError;
  std::vector<float> eff(2);

  //---- loop over chambers
  std::map<std::string, bool> chamberTypes;
  chamberTypes["ME11"] = false;
  chamberTypes["ME12"] = false;
  chamberTypes["ME13"] = false;
  chamberTypes["ME21"] = false;
  chamberTypes["ME22"] = false;
  chamberTypes["ME31"] = false;
  chamberTypes["ME32"] = false;
  chamberTypes["ME41"] = false;

  map<std::string, bool>::iterator iter;
  std::cout << " Writing proper histogram structure (patience)..." << std::endl;
  for (int ec = 0; ec < 2; ++ec) {
    for (int st = 0; st < 4; ++st) {
      snprintf(SpecName, sizeof(SpecName), "Stations__E%d_S%d", ec + 1, st + 1);
      theFile->cd(SpecName);
      StHist[ec][st].segmentChi2_ndf->Write();
      StHist[ec][st].hitsInSegment->Write();
      StHist[ec][st].AllSegments_eta->Write();
      StHist[ec][st].EfficientSegments_eta->Write();
      StHist[ec][st].ResidualSegments->Write();
      StHist[ec][st].EfficientSegments_XY->Write();
      StHist[ec][st].InefficientSegments_XY->Write();
      StHist[ec][st].EfficientALCT_momTheta->Write();
      StHist[ec][st].InefficientALCT_momTheta->Write();
      StHist[ec][st].EfficientCLCT_momPhi->Write();
      StHist[ec][st].InefficientCLCT_momPhi->Write();
      for (int rg = 0; rg < 3; ++rg) {
        if (0 != st && rg > 1) {
          continue;
        } else if (1 == rg && 3 == st) {
          continue;
        }
        for (int iChamber = FirstCh; iChamber < FirstCh + NumCh; iChamber++) {
          if (0 != st && 0 == rg && iChamber > 18) {
            continue;
          }
          snprintf(SpecName, sizeof(SpecName), "Chambers__E%d_S%d_R%d_Chamber_%d", ec + 1, st + 1, rg + 1, iChamber);
          theFile->cd(SpecName);

          ChHist[ec][st][rg][iChamber - FirstCh].EfficientRechits_inSegment->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].AllSingleHits->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].digiAppearanceCount->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientALCT_dydz->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].InefficientALCT_dydz->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientCLCT_dxdz->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].InefficientCLCT_dxdz->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].InefficientSingleHits->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientRechits_good->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientStrips->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].StripWiresCorrelations->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].NoWires_momTheta->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].NoStrips_momPhi->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].EfficientWireGroups->Write();
          for (unsigned int iLayer = 0; iLayer < 6; iLayer++) {
            ChHist[ec][st][rg][iChamber - FirstCh].Y_InefficientRecHits_inSegment[iLayer]->Write();
            ChHist[ec][st][rg][iChamber - FirstCh].Y_EfficientRecHits_inSegment[iLayer]->Write();
            ChHist[ec][st][rg][iChamber - FirstCh].Phi_InefficientRecHits_inSegment[iLayer]->Write();
            ChHist[ec][st][rg][iChamber - FirstCh].Phi_EfficientRecHits_inSegment[iLayer]->Write();
          }
          ChHist[ec][st][rg][iChamber - FirstCh].SimRechits->Write();
          ChHist[ec][st][rg][iChamber - FirstCh].SimSimhits->Write();
          /*
      ChHist[ec][st][rg][iChamber-FirstCh].SimRechits_each->Write();
      ChHist[ec][st][rg][iChamber-FirstCh].SimSimhits_each->Write();
      */
          //
          theFile->cd(SpecName);
          theFile->cd();
        }
      }
    }
  }
  //
  snprintf(SpecName, sizeof(SpecName), "AllChambers");
  theFile->mkdir(SpecName);
  theFile->cd(SpecName);
  DataFlow->Write();
  TriggersFired->Write();
  ALCTPerEvent->Write();
  CLCTPerEvent->Write();
  recHitsPerEvent->Write();
  segmentsPerEvent->Write();
  //
  theFile->cd(SpecName);
  //---- Close the file
  theFile->Close();
}

Member Function Documentation

applyTrigger()

bool CSCEfficiency::applyTrigger ( edm::Handle< edm::TriggerResults > &  hltR, const edm::TriggerNames &  triggerNames  )

private

Definition at line 1560 of file CSCEfficiency.cc.

References edm::HLTGlobalStatus::accept(), PA_MinBiasSkim_cff::andOr, gather_cfg::cout, edm::HLTGlobalStatus::error(), edm::HandleBase::isValid(), L1TEGammaOffline_cfi::triggerNames, and edm::HLTGlobalStatus::wasrun().

                                                                                                        {
  bool triggerPassed = true;
  std::vector<std::string> hlNames = triggerNames.triggerNames();
  pointToTriggers.clear();
  for (size_t imyT = 0; imyT < myTriggers.size(); ++imyT) {
    for (size_t iT = 0; iT < hlNames.size(); ++iT) {
      //std::cout<<" iT = "<<iT<<" hlNames[iT] = "<<hlNames[iT]<<
      //" : wasrun = "<<hltR->wasrun(iT)<<" accept = "<<
      //     hltR->accept(iT)<<" !error = "<<
      //    !hltR->error(iT)<<std::endl;
      if (!imyT) {
        if (hltR->wasrun(iT) && hltR->accept(iT) && !hltR->error(iT)) {
          TriggersFired->Fill(iT);
        }
      }
      if (hlNames[iT] == myTriggers[imyT]) {
        pointToTriggers.push_back(iT);
        if (imyT) {
          break;
        }
      }
    }
  }
  if (pointToTriggers.size() != myTriggers.size()) {
    pointToTriggers.clear();
    if (printalot) {
      std::cout << " Not all trigger names found - all trigger specifications will be ignored. Check your cfg file!"
                << std::endl;
    }
  } else {
    if (!pointToTriggers.empty()) {
      if (printalot) {
        std::cout << "The following triggers will be required in the event: " << std::endl;
        for (size_t imyT = 0; imyT < pointToTriggers.size(); ++imyT) {
          std::cout << "  " << hlNames[pointToTriggers[imyT]];
        }
        std::cout << std::endl;
        std::cout << " in condition (AND/OR) : " << !andOr << "/" << andOr << std::endl;
      }
    }
  }

  if (hltR.isValid()) {
    if (pointToTriggers.empty()) {
      if (printalot) {
        std::cout
            << " No triggers specified in the configuration or all ignored - no trigger information will be considered"
            << std::endl;
      }
    }
    for (size_t imyT = 0; imyT < pointToTriggers.size(); ++imyT) {
      if (hltR->wasrun(pointToTriggers[imyT]) && hltR->accept(pointToTriggers[imyT]) &&
          !hltR->error(pointToTriggers[imyT])) {
        triggerPassed = true;
        if (andOr) {
          break;
        }
      } else {
        triggerPassed = false;
        if (!andOr) {
          triggerPassed = false;
          break;
        }
      }
    }
  } else {
    if (printalot) {
      std::cout << " TriggerResults handle returns invalid state?! No trigger information will be considered"
                << std::endl;
    }
  }
  if (printalot) {
    std::cout << " Trigger passed: " << triggerPassed << std::endl;
  }
  return triggerPassed;
}

chamberCandidates()

void CSCEfficiency::chamberCandidates ( int  station, int  ring, float  phi, std::vector< int > &  coupleOfChambers  )

private

Definition at line 1010 of file CSCEfficiency.cc.

References gather_cfg::cout, createfilelist::int, M_PI, relativeConstraints::ring, and relativeConstraints::station.

                                                                                                        {
  coupleOfChambers.clear();
  // -pi< phi<+pi
  float phi_zero = 0.;  // check! the phi at the "edge" of Ch 1
  float phi_const = 2. * M_PI / 36.;
  int last_chamber = 36;
  int first_chamber = 1;
  if (1 != station && 1 == ring) {  // 18 chambers in the ring
    phi_const *= 2;
    last_chamber /= 2;
  }
  if (phi < 0.) {
    if (printalot)
      std::cout << " info: negative phi = " << phi << std::endl;
    phi += 2 * M_PI;
  }
  float chamber_float = (phi - phi_zero) / phi_const;
  int chamber_int = int(chamber_float);
  if (chamber_float - float(chamber_int) - 0.5 < 0.) {
    if (0 != chamber_int) {
      coupleOfChambers.push_back(chamber_int);
    } else {
      coupleOfChambers.push_back(last_chamber);
    }
    coupleOfChambers.push_back(chamber_int + 1);

  } else {
    coupleOfChambers.push_back(chamber_int + 1);
    if (last_chamber != chamber_int + 1) {
      coupleOfChambers.push_back(chamber_int + 2);
    } else {
      coupleOfChambers.push_back(first_chamber);
    }
  }
  if (printalot)
    std::cout << " phi = " << phi << " phi_zero = " << phi_zero << " phi_const = " << phi_const
              << " candidate chambers: first ch = " << coupleOfChambers[0] << " second ch = " << coupleOfChambers[1]
              << std::endl;
}

checkLocal()

bool CSCEfficiency::checkLocal ( double  yLocal, double  yBoundary, int  station, int  ring  )

private

Definition at line 604 of file CSCEfficiency.cc.

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

                                                                                     {
  //---- check if it is in a good local region (sensitive area - geometrical and HV boundaries excluded)
  bool pass = false;
  std::vector<float> deadZoneCenter(6);
  const float deadZoneHalf = 0.32 * 7 / 2;              // wire spacing * (wires missing + 1)/2
  float cutZone = deadZoneHalf + distanceFromDeadZone;  //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 (yLocal > yBoundary && ((yLocal > deadZoneCenter[0] + cutZone && yLocal < deadZoneCenter[1] - cutZone) ||
                                 (yLocal > deadZoneCenter[1] + cutZone && yLocal < deadZoneCenter[2] - cutZone) ||
                                 (yLocal > deadZoneCenter[2] + cutZone && yLocal < deadZoneCenter[3] - cutZone) ||
                                 (yLocal > deadZoneCenter[3] + cutZone && yLocal < deadZoneCenter[4] - cutZone) ||
                                 (yLocal > deadZoneCenter[4] + cutZone && yLocal < deadZoneCenter[5] - cutZone))) {
        pass = true;
      }
    } else if (1 == ring) {
      if (2 == station) {
        deadZoneCenter[0] = -95.94;
        deadZoneCenter[1] = -27.47;
        deadZoneCenter[2] = 33.67;
        deadZoneCenter[3] = 93.72;
      } else if (3 == station) {
        deadZoneCenter[0] = -85.97;
        deadZoneCenter[1] = -36.21;
        deadZoneCenter[2] = 23.68;
        deadZoneCenter[3] = 84.04;
      } else if (4 == station) {
        deadZoneCenter[0] = -75.82;
        deadZoneCenter[1] = -26.14;
        deadZoneCenter[2] = 23.85;
        deadZoneCenter[3] = 73.91;
      }
      if (yLocal > yBoundary && ((yLocal > deadZoneCenter[0] + cutZone && yLocal < deadZoneCenter[1] - cutZone) ||
                                 (yLocal > deadZoneCenter[1] + cutZone && yLocal < deadZoneCenter[2] - cutZone) ||
                                 (yLocal > deadZoneCenter[2] + cutZone && yLocal < 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 (yLocal > yBoundary && ((yLocal > deadZoneCenter[0] + cutZone && yLocal < deadZoneCenter[1] - cutZone) ||
                                 (yLocal > deadZoneCenter[1] + cutZone && yLocal < deadZoneCenter[2] - cutZone) ||
                                 (yLocal > deadZoneCenter[2] + cutZone && yLocal < 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 (yLocal > (yBoundary) && ((yLocal > deadZoneCenter[0] + cutZone && yLocal < deadZoneCenter[1] - cutZone) ||
                                   (yLocal > deadZoneCenter[1] + cutZone && yLocal < deadZoneCenter[2] - cutZone) ||
                                   (yLocal > deadZoneCenter[2] + cutZone && yLocal < deadZoneCenter[3] - cutZone))) {
        pass = true;
      }
    } else {
      deadZoneCenter[0] = -81.0;
      deadZoneCenter[1] = 81.0;
      if (yLocal > (yBoundary) && ((yLocal > deadZoneCenter[0] + cutZone && yLocal < deadZoneCenter[1] - cutZone))) {
        pass = true;
      }
    }
  }
  return pass;
}

chooseDirection()

void CSCEfficiency::chooseDirection ( CLHEP::Hep3Vector &  innerPosition, CLHEP::Hep3Vector &  outerPosition  )

private

Definition at line 1506 of file CSCEfficiency.cc.

References PVValHelper::dy, and PVValHelper::dz.

                                                                                                  {
  //---- Be careful with trigger conditions too
  if (!isIPdata) {
    float dy = outerPosition.y() - innerPosition.y();
    float dz = outerPosition.z() - innerPosition.z();
    if (isBeamdata) {
      if (dz > 0) {
        alongZ = true;
      } else {
        alongZ = false;
      }
    } else {  //cosmics
      if (dy / dz > 0) {
        alongZ = false;
      } else {
        alongZ = true;
      }
    }
  }
}

efficienciesPerChamber()

bool CSCEfficiency::efficienciesPerChamber ( CSCDetId &  id, const CSCChamber *  cscChamber, FreeTrajectoryState &  ftsChamber  )

private

Definition at line 1051 of file CSCEfficiency.cc.

References gather_cfg::cout, dxdz, dydz, FreeTrajectoryState::momentum(), MillePedeFileConverter_cfg::out, PV3DBase< T, PVType, FrameType >::phi(), PV3DBase< T, PVType, FrameType >::theta(), GeomDet::toLocal(), funct::true, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                            {
  int ec, st, rg, ch, secondRing;
  returnTypes(id, ec, st, rg, ch, secondRing);

  LocalVector localDir = cscChamber->toLocal(ftsChamber.momentum());
  if (printalot) {
    std::cout << " global dir = " << ftsChamber.momentum() << std::endl;
    std::cout << " local dir = " << localDir << std::endl;
    std::cout << " local theta = " << localDir.theta() << std::endl;
  }
  float dxdz = localDir.x() / localDir.z();
  float dydz = localDir.y() / localDir.z();
  if (2 == st || 3 == st) {
    if (printalot) {
      std::cout << "st 3 or 4 ... flip dy/dz" << std::endl;
    }
    dydz = -dydz;
  }
  if (printalot) {
    std::cout << "dy/dz = " << dydz << std::endl;
  }
  // Apply angle cut
  bool out = true;
  if (applyIPangleCuts) {
    if (dydz > local_DY_DZ_Max || dydz < local_DY_DZ_Min || fabs(dxdz) > local_DX_DZ_Max) {
      out = false;
    }
  }

  // Segments
  bool firstCondition = !allSegments[ec][st][rg][ch].empty() ? true : false;
  bool secondCondition = false;
  //---- ME1 is special as usual - ME1a and ME1b are actually one chamber
  if (secondRing > -1) {
    secondCondition = !allSegments[ec][st][secondRing][ch].empty() ? true : false;
  }
  if (firstCondition || secondCondition) {
    if (out) {
      ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(1);
    }
  } else {
    if (out) {
      ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(0);
    }
  }

  if (useDigis) {
    // ALCTs
    firstCondition = allALCT[ec][st][rg][ch];
    secondCondition = false;
    if (secondRing > -1) {
      secondCondition = allALCT[ec][st][secondRing][ch];
    }
    if (firstCondition || secondCondition) {
      if (out) {
        ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(3);
      }
      // always apply partial angle cuts for this kind of histos
      if (fabs(dxdz) < local_DX_DZ_Max) {
        StHist[ec][st].EfficientALCT_momTheta->Fill(ftsChamber.momentum().theta());
        ChHist[ec][st][rg][ch].EfficientALCT_dydz->Fill(dydz);
      }
    } else {
      if (out) {
        ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(2);
      }
      if (fabs(dxdz) < local_DX_DZ_Max) {
        StHist[ec][st].InefficientALCT_momTheta->Fill(ftsChamber.momentum().theta());
        ChHist[ec][st][rg][ch].InefficientALCT_dydz->Fill(dydz);
      }
      if (printalot) {
        std::cout << " missing ALCT (dy/dz = " << dydz << ")";
        printf("\t\tendcap/station/ring/chamber: %i/%i/%i/%i\n", ec + 1, st + 1, rg + 1, ch + 1);
      }
    }

    // CLCTs
    firstCondition = allCLCT[ec][st][rg][ch];
    secondCondition = false;
    if (secondRing > -1) {
      secondCondition = allCLCT[ec][st][secondRing][ch];
    }
    if (firstCondition || secondCondition) {
      if (out) {
        ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(5);
      }
      if (dydz < local_DY_DZ_Max && dydz > local_DY_DZ_Min) {
        StHist[ec][st].EfficientCLCT_momPhi->Fill(ftsChamber.momentum().phi());  // - phi chamber...
        ChHist[ec][st][rg][ch].EfficientCLCT_dxdz->Fill(dxdz);
      }
    } else {
      if (out) {
        ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(4);
      }
      if (dydz < local_DY_DZ_Max && dydz > local_DY_DZ_Min) {
        StHist[ec][st].InefficientCLCT_momPhi->Fill(ftsChamber.momentum().phi());  // - phi chamber...
        ChHist[ec][st][rg][ch].InefficientCLCT_dxdz->Fill(dxdz);
      }
      if (printalot) {
        std::cout << " missing CLCT  (dx/dz = " << dxdz << ")";
        printf("\t\tendcap/station/ring/chamber: %i/%i/%i/%i\n", ec + 1, st + 1, rg + 1, ch + 1);
      }
    }
    if (out) {
      // CorrLCTs
      firstCondition = allCorrLCT[ec][st][rg][ch];
      secondCondition = false;
      if (secondRing > -1) {
        secondCondition = allCorrLCT[ec][st][secondRing][ch];
      }
      if (firstCondition || secondCondition) {
        ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(7);
      } else {
        ChHist[ec][st][rg][ch].digiAppearanceCount->Fill(6);
      }
    }
  }
  return out;
}

extrapolate1D()

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

private

Definition at line 1496 of file CSCEfficiency.cc.

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

fillDigiInfo()

void CSCEfficiency::fillDigiInfo ( edm::Handle< CSCALCTDigiCollection > &  alcts, edm::Handle< CSCCLCTDigiCollection > &  clcts, edm::Handle< CSCCorrelatedLCTDigiCollection > &  correlatedlcts, edm::Handle< CSCWireDigiCollection > &  wires, edm::Handle< CSCStripDigiCollection > &  strips, edm::Handle< edm::PSimHitContainer > &  simhits, edm::Handle< CSCRecHit2DCollection > &  rechits, edm::Handle< CSCSegmentCollection > &  segments, edm::ESHandle< CSCGeometry > &  cscGeom  )

private

Definition at line 682 of file CSCEfficiency.cc.

References HLTBitAnalyser_cfi::isData, NumCh, HI_PhotonSkim_cff::rechits, HLTBitAnalyser_cfi::simhits, DigiDM_cff::strips, and DigiDM_cff::wires.

                                                                    {
  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 < NumCh; iC++) {
          allSegments[iE][iS][iR][iC].clear();
          allCLCT[iE][iS][iR][iC] = allALCT[iE][iS][iR][iC] = allCorrLCT[iE][iS][iR][iC] = false;
          for (int iL = 0; iL < 6; iL++) {
            allStrips[iE][iS][iR][iC][iL].clear();
            allWG[iE][iS][iR][iC][iL].clear();
            allRechits[iE][iS][iR][iC][iL].clear();
            allSimhits[iE][iS][iR][iC][iL].clear();
          }
        }
      }
    }
  }
  //
  if (useDigis) {
    fillLCT_info(alcts, clcts, correlatedlcts);
    fillWG_info(wires, cscGeom);
    fillStrips_info(strips);
  }
  fillRechitsSegments_info(rechits, segments, cscGeom);
  if (!isData) {
    fillSimhit_info(simhits);
  }
}

fillLCT_info()

void CSCEfficiency::fillLCT_info ( edm::Handle< CSCALCTDigiCollection > &  alcts, edm::Handle< CSCCLCTDigiCollection > &  clcts, edm::Handle< CSCCorrelatedLCTDigiCollection > &  correlatedlcts  )

private

Definition at line 719 of file CSCEfficiency.cc.

References FirstCh, dqmiolumiharvest::j, dqmdumpme::last, and FastTimerService_cff::range.

                                                                                            {
  //---- ALCTDigis
  int nSize = 0;
  for (CSCALCTDigiCollection::DigiRangeIterator j = alcts->begin(); j != alcts->end(); j++) {
    ++nSize;
    const CSCDetId &id = (*j).first;
    const CSCALCTDigiCollection::Range &range = (*j).second;
    for (CSCALCTDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
      // Valid digi in the chamber (or in neighbouring chamber)
      if ((*digiIt).isValid()) {
        allALCT[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh] = true;
      }
    }  // for digis in layer
  }    // end of for (j=...
  ALCTPerEvent->Fill(nSize);
  //---- CLCTDigis
  nSize = 0;
  for (CSCCLCTDigiCollection::DigiRangeIterator j = clcts->begin(); j != clcts->end(); j++) {
    ++nSize;
    const CSCDetId &id = (*j).first;
    std::vector<CSCCLCTDigi>::const_iterator digiIt = (*j).second.first;
    std::vector<CSCCLCTDigi>::const_iterator last = (*j).second.second;
    for (; digiIt != last; ++digiIt) {
      // Valid digi in the chamber (or in neighbouring chamber)
      if ((*digiIt).isValid()) {
        allCLCT[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh] = true;
      }
    }
  }
  CLCTPerEvent->Fill(nSize);
  //---- CorrLCTDigis
  for (CSCCorrelatedLCTDigiCollection::DigiRangeIterator j = correlatedlcts->begin(); j != correlatedlcts->end(); j++) {
    const CSCDetId &id = (*j).first;
    std::vector<CSCCorrelatedLCTDigi>::const_iterator digiIt = (*j).second.first;
    std::vector<CSCCorrelatedLCTDigi>::const_iterator last = (*j).second.second;
    for (; digiIt != last; ++digiIt) {
      // Valid digi in the chamber (or in neighbouring chamber)
      if ((*digiIt).isValid()) {
        allCorrLCT[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh] = true;
      }
    }
  }
}

fillRechitsSegments_info()

void CSCEfficiency::fillRechitsSegments_info ( edm::Handle< CSCRecHit2DCollection > &  rechits, edm::Handle< CSCSegmentCollection > &  segments, edm::ESHandle< CSCGeometry > &  cscGeom  )

private

Definition at line 837 of file CSCEfficiency.cc.

References relativeConstraints::chamber, CSCDetId::chamber(), gather_cfg::cout, relativeConstraints::empty, CSCDetId::endcap(), makeMuonMisalignmentScenario::endcap, FirstCh, CSCDetId::layer(), CSCGeometry::layer(), NumCh, HI_PhotonSkim_cff::rechits, CSCDetId::ring(), relativeConstraints::ring, relativeConstraints::station, CSCDetId::station(), GeomDet::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), LocalError::yy(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                {
  //---- RECHITS AND SEGMENTS
  //---- Loop over rechits
  if (printalot) {
    //printf("\tGet the recHits collection.\t ");
    printf("  The size of the rechit collection is %i\n", int(rechits->size()));
    //printf("\t...start loop over rechits...\n");
  }
  recHitsPerEvent->Fill(rechits->size());
  //---- Build iterator for rechits and loop :
  CSCRecHit2DCollection::const_iterator recIt;
  for (recIt = rechits->begin(); recIt != rechits->end(); recIt++) {
    //---- Find chamber with rechits in CSC
    CSCDetId id = (CSCDetId)(*recIt).cscDetId();
    if (printalot) {
      const CSCLayer *csclayer = cscGeom->layer(id);
      LocalPoint rhitlocal = (*recIt).localPosition();
      LocalError rerrlocal = (*recIt).localPositionError();
      GlobalPoint rhitglobal = csclayer->toGlobal(rhitlocal);
      printf("\t\tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",
             id.endcap(),
             id.station(),
             id.ring(),
             id.chamber(),
             id.layer());
      printf("\t\tx,y,z: %f, %f, %f\texx,eey,exy: %f, %f, %f\tglobal x,y,z: %f, %f, %f \n",
             rhitlocal.x(),
             rhitlocal.y(),
             rhitlocal.z(),
             rerrlocal.xx(),
             rerrlocal.yy(),
             rerrlocal.xy(),
             rhitglobal.x(),
             rhitglobal.y(),
             rhitglobal.z());
    }
    std::pair<LocalPoint, bool> recHitPos((*recIt).localPosition(), false);
    allRechits[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh][id.layer() - 1].push_back(
        recHitPos);
  }
  //---- "Empty" chambers
  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 < NumCh; iC++) {
          int numLayers = 0;
          for (int iL = 0; iL < 6; iL++) {
            if (!allRechits[iE][iS][iR][iC][iL].empty()) {
              ++numLayers;
            }
          }
          if (numLayers > 1) {
            emptyChambers[iE][iS][iR][iC] = false;
          } else {
            emptyChambers[iE][iS][iR][iC] = true;
          }
        }
      }
    }
  }

  //
  if (printalot) {
    printf("  The size of the segment collection is %i\n", int(segments->size()));
    //printf("\t...start loop over segments...\n");
  }
  segmentsPerEvent->Fill(segments->size());
  for (CSCSegmentCollection::const_iterator it = segments->begin(); it != segments->end(); it++) {
    CSCDetId id = (CSCDetId)(*it).cscDetId();
    StHist[id.endcap() - 1][id.station() - 1].segmentChi2_ndf->Fill((*it).chi2() / (*it).degreesOfFreedom());
    StHist[id.endcap() - 1][id.station() - 1].hitsInSegment->Fill((*it).nRecHits());
    if (printalot) {
      printf("\tendcap/station/ring/chamber: %i %i %i %i\n", id.endcap(), id.station(), id.ring(), id.chamber());
      std::cout << "\tposition(loc) = " << (*it).localPosition() << " error(loc) = " << (*it).localPositionError()
                << std::endl;
      std::cout << "\t chi2/ndf = " << (*it).chi2() / (*it).degreesOfFreedom() << " nhits = " << (*it).nRecHits()
                << std::endl;
    }
    allSegments[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh].push_back(
        make_pair((*it).localPosition(), (*it).localDirection()));

    //---- try to get the CSC recHits that contribute to this segment.
    //if (printalot) printf("\tGet the recHits for this segment.\t");
    std::vector<CSCRecHit2D> theseRecHits = (*it).specificRecHits();
    int nRH = (*it).nRecHits();
    if (printalot) {
      printf("\tGet the recHits for this segment.\t");
      printf("    nRH = %i\n", nRH);
    }
    //---- Find which of the rechits in the chamber is in the segment
    int layerRH = 0;
    for (vector<CSCRecHit2D>::const_iterator iRH = theseRecHits.begin(); iRH != theseRecHits.end(); iRH++) {
      ++layerRH;
      CSCDetId idRH = (CSCDetId)(*iRH).cscDetId();
      if (printalot) {
        printf("\t%i RH\tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",
               layerRH,
               idRH.endcap(),
               idRH.station(),
               idRH.ring(),
               idRH.chamber(),
               idRH.layer());
      }
      for (size_t jRH = 0;
           jRH <
           allRechits[idRH.endcap() - 1][idRH.station() - 1][idRH.ring() - 1][idRH.chamber() - FirstCh][idRH.layer() - 1]
               .size();
           ++jRH) {
        float xDiff = iRH->localPosition().x() - allRechits[idRH.endcap() - 1][idRH.station() - 1][idRH.ring() - 1]
                                                           [idRH.chamber() - FirstCh][idRH.layer() - 1][jRH]
                                                               .first.x();
        float yDiff = iRH->localPosition().y() - allRechits[idRH.endcap() - 1][idRH.station() - 1][idRH.ring() - 1]
                                                           [idRH.chamber() - FirstCh][idRH.layer() - 1][jRH]
                                                               .first.y();
        if (fabs(xDiff) < 0.0001 && fabs(yDiff) < 0.0001) {
          std::pair<LocalPoint, bool> recHitPos(allRechits[idRH.endcap() - 1][idRH.station() - 1][idRH.ring() - 1]
                                                          [idRH.chamber() - FirstCh][idRH.layer() - 1][jRH]
                                                              .first,
                                                true);
          allRechits[idRH.endcap() - 1][idRH.station() - 1][idRH.ring() - 1][idRH.chamber() - FirstCh][idRH.layer() - 1]
                    [jRH] = recHitPos;
          if (printalot) {
            std::cout << " number of the rechit (from zero) in the segment = " << jRH << std::endl;
          }
        }
      }
    }
  }
}

fillSimhit_info()

void CSCEfficiency::fillSimhit_info ( edm::Handle< edm::PSimHitContainer > &  simHits )

private

Definition at line 825 of file CSCEfficiency.cc.

References CSCDetId::chamber(), CSCDetId::endcap(), FirstCh, CSCDetId::layer(), CSCDetId::ring(), HLTBitAnalyser_cfi::simhits, and CSCDetId::station().

                                                                           {
  //---- SIMHITS
  edm::PSimHitContainer::const_iterator dSHsimIter;
  for (dSHsimIter = simhits->begin(); dSHsimIter != simhits->end(); dSHsimIter++) {
    // Get DetID for this simHit:
    CSCDetId sId = (CSCDetId)(*dSHsimIter).detUnitId();
    std::pair<LocalPoint, int> simHitPos((*dSHsimIter).localPosition(), (*dSHsimIter).particleType());
    allSimhits[sId.endcap() - 1][sId.station() - 1][sId.ring() - 1][sId.chamber() - FirstCh][sId.layer() - 1].push_back(
        simHitPos);
  }
}

fillStrips_info()

void CSCEfficiency::fillStrips_info ( edm::Handle< CSCStripDigiCollection > &  strips )

private

Definition at line 791 of file CSCEfficiency.cc.

References change_name::diff, nano_mu_digi_cff::float, cms::cuda::for(), dqmiolumiharvest::j, dqmdumpme::last, DigiDM_cff::strips, and remoteMonitoring_LASER_era2018_cfg::threshold.

                                                                             {
  //---- STRIPS
  const float threshold = 13.3;
  for (CSCStripDigiCollection::DigiRangeIterator j = strips->begin(); j != strips->end(); j++) {
    CSCDetId id = (CSCDetId)(*j).first;
    int largestADCValue = -1;
    std::vector<CSCStripDigi>::const_iterator digiItr = (*j).second.first;
    std::vector<CSCStripDigi>::const_iterator last = (*j).second.second;
    for (; digiItr != last; ++digiItr) {
      int maxADC = largestADCValue;
      int myStrip = digiItr->getStrip();
      std::vector<int> myADCVals = digiItr->getADCCounts();
      float thisPedestal = 0.5 * (float)(myADCVals[0] + myADCVals[1]);
      float peakADC = -1000.;
      for (int myADCVal : myADCVals) {
        float diff = (float)myADCVal - thisPedestal;
        if (diff > threshold) {
          if (myADCVal > largestADCValue)
            largestADCValue = myADCVal;
          if (diff > peakADC)
            peakADC = diff;
        }
      }
      if (largestADCValue > maxADC) {  // FIX IT!!!
        std::pair<int, float> LayerSignal(myStrip, peakADC);
        //---- AllStrips contains basic information about strips
        //---- (strip number and peak signal for most significant strip in the layer)
        allStrips[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - 1][id.layer() - 1].clear();
        allStrips[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - 1][id.layer() - 1].push_back(
            LayerSignal);
      }
    }
  }
}

fillWG_info()

void CSCEfficiency::fillWG_info ( edm::Handle< CSCWireDigiCollection > &  wires, edm::ESHandle< CSCGeometry > &  cscGeom  )

private

Definition at line 765 of file CSCEfficiency.cc.

References FirstCh, dqmiolumiharvest::j, dqmdumpme::last, CSCGeometry::layer(), DigiDM_cff::wires, and CSCLayerGeometry::yOfWireGroup().

                                                                                                          {
  //---- WIRE GROUPS
  for (CSCWireDigiCollection::DigiRangeIterator j = wires->begin(); j != wires->end(); j++) {
    CSCDetId id = (CSCDetId)(*j).first;
    const CSCLayer *layer_p = cscGeom->layer(id);
    const CSCLayerGeometry *layerGeom = layer_p->geometry();
    //
    std::vector<CSCWireDigi>::const_iterator digiItr = (*j).second.first;
    std::vector<CSCWireDigi>::const_iterator last = (*j).second.second;
    //
    for (; digiItr != last; ++digiItr) {
      std::pair<int, float> WG_pos(digiItr->getWireGroup(), layerGeom->yOfWireGroup(digiItr->getWireGroup()));
      std::pair<std::pair<int, float>, int> LayerSignal(WG_pos, digiItr->getTimeBin());

      //---- AllWG contains basic information about WG (WG number and Y-position, time bin)
      allWG[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh][id.layer() - 1].push_back(
          LayerSignal);
      if (printalot) {
        //std::cout<<" WG check : "<<std::endl;
        //printf("\t\tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",id.endcap(),id.station(),id.ring(),id.chamber(),id.layer());
        //std::cout<<" WG size = "<<allWG[id.endcap()-1][id.station()-1][id.ring()-1][id.chamber()-FirstCh]
        //[id.layer()-1].size()<<std::endl;
      }
    }
  }
}

filter()

bool CSCEfficiency::filter ( edm::Event &  event, const edm::EventSetup &  eventSetup  )

overrideprivatevirtual

Implements edm::one::EDFilterBase.

Definition at line 22 of file CSCEfficiency.cc.

References muon::caloCompatibility(), relativeConstraints::chamber, CSCGeometry::chamber(), ALCARECOTkAlJpsiMuMu_cff::charge, reco::TrackBase::confirmed, gather_cfg::cout, debug, PbPb_ZMuSkimMuonDPG_cff::deltaR, hcalRecHitTable_cff::detId, PVValHelper::dz, MillePedeFileConverter_cfg::e, makeMuonMisalignmentScenario::endcap, PV3DBase< T, PVType, FrameType >::eta(), options_cfi::eventSetup, JetMETHLTOfflineSource_cfi::feta, FirstCh, TrajectoryStateOnSurface::freeState(), GeomDet::geographicalId(), reco::TrackBase::goodIterative, reco::TrackBase::highPurity, mps_fire::i, CSCGeometry::idToDet(), iEvent, createfilelist::int, HLTBitAnalyser_cfi::isData, TrajectoryStateOnSurface::isValid(), reco::TrackBase::loose, MuonMETValueMapProducer_cff::maxNormChi2, RecoMuonValidator_cfi::maxP, alignBH_cfg::minP, HLT_2023v12_cff::minTrackHits, HLT_2023v12_cff::muon, PDWG_BPHSkim_cff::muons, reco::Track::outerPosition(), PV3DBase< T, PVType, FrameType >::phi(), GloballyPositioned< T >::position(), reco::BeamSpot::position(), FreeTrajectoryState::position(), conifer::pow(), edm::Handle< T >::product(), reco::TrackBase::qualitySize, HI_PhotonSkim_cff::rechits, relativeConstraints::ring, reco::Muon::SegmentAndTrackArbitration, HLTBitAnalyser_cfi::simhits, mathSSE::sqrt(), relativeConstraints::station, DigiDM_cff::strips, GeomDet::surface(), reco::TrackBase::tight, HLT_2023v12_cff::track, JetHT_cfg::trackCollection, L1TEGammaOffline_cfi::triggerNames, reco::TrackBase::undefQuality, DigiDM_cff::wires, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                           {
  passTheEvent = false;
  DataFlow->Fill(0.);
  MuonPatternRecoDumper debug;

  //---- increment counter
  nEventsAnalyzed++;
  // printalot debug output
  printalot = (nEventsAnalyzed < int(printout_NEvents));  //
  edm::RunNumber_t const iRun = event.id().run();
  edm::EventNumber_t const iEvent = event.id().event();
  if (0 == fmod(double(nEventsAnalyzed), double(1000))) {
    if (printalot) {
      printf("\n==enter==CSCEfficiency===== run %u\tevent %llu\tn Analyzed %i\n", iRun, iEvent, nEventsAnalyzed);
    }
  }
  theService->update(eventSetup);
  //---- These declarations create handles to the types of records that you want
  //---- to retrieve from event "e".
  if (printalot)
    printf("\tget handles for digi collections\n");

  //---- Pass the handle to the method "getByType", which is used to retrieve
  //---- one and only one instance of the type in question out of event "e". If
  //---- zero or more than one instance exists in the event an exception is thrown.
  if (printalot)
    printf("\tpass handles\n");
  edm::Handle<CSCALCTDigiCollection> alcts;
  edm::Handle<CSCCLCTDigiCollection> clcts;
  edm::Handle<CSCCorrelatedLCTDigiCollection> correlatedlcts;
  edm::Handle<CSCWireDigiCollection> wires;
  edm::Handle<CSCStripDigiCollection> strips;
  edm::Handle<CSCRecHit2DCollection> rechits;
  edm::Handle<CSCSegmentCollection> segments;
  edm::Handle<edm::View<reco::Track> > trackCollectionH;
  edm::Handle<edm::PSimHitContainer> simhits;

  if (useDigis) {
    event.getByToken(wd_token, wires);
    event.getByToken(sd_token, strips);
    event.getByToken(al_token, alcts);
    event.getByToken(cl_token, clcts);
    event.getByToken(co_token, correlatedlcts);
  }
  if (!isData) {
    event.getByToken(sh_token, simhits);
  }
  event.getByToken(rh_token, rechits);
  event.getByToken(se_token, segments);
  event.getByToken(tk_token, trackCollectionH);
  const edm::View<reco::Track> trackCollection = *(trackCollectionH.product());

  //---- Get the CSC Geometry :
  if (printalot)
    printf("\tget the CSC geometry.\n");
  edm::ESHandle<CSCGeometry> cscGeom = eventSetup.getHandle(geomToken_);

  // use theTrackingGeometry instead of cscGeom?
  //edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry = eventSetup.getHandle(trackingGeomToken_);

  bool triggerPassed = true;
  if (useTrigger) {
    // access the trigger information
    // trigger names can be find in HLTrigger/Configuration/python/HLT_2E30_cff.py (or?)
    // get hold of TriggerResults
    edm::Handle<edm::TriggerResults> hltR;
    event.getByToken(ht_token, hltR);
    const edm::TriggerNames &triggerNames = event.triggerNames(*hltR);
    triggerPassed = applyTrigger(hltR, triggerNames);
  }
  if (!triggerPassed) {
    return triggerPassed;
  }
  DataFlow->Fill(1.);
  GlobalPoint gpZero(0., 0., 0.);
  if (theService->magneticField()->inTesla(gpZero).mag2() < 0.1) {
    magField = false;
  } else {
    magField = true;
  }

  //---- store info from digis
  fillDigiInfo(alcts, clcts, correlatedlcts, wires, strips, simhits, rechits, segments, cscGeom);
  //
  edm::Handle<reco::MuonCollection> muons;
  edm::InputTag muonTag_("muons");
  event.getByLabel(muonTag_, muons);

  edm::Handle<reco::BeamSpot> beamSpotHandle;
  event.getByLabel("offlineBeamSpot", beamSpotHandle);
  reco::BeamSpot vertexBeamSpot = *beamSpotHandle;
  //
  std::vector<reco::MuonCollection::const_iterator> goodMuons_it;
  unsigned int nPositiveZ = 0;
  unsigned int nNegativeZ = 0;
  float muonOuterZPosition = -99999.;
  if (isIPdata) {
    if (printalot)
      std::cout << " muons.size() = " << muons->size() << std::endl;
    for (reco::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
      DataFlow->Fill(31.);
      if (printalot) {
        std::cout << "  iMuon = " << muon - muons->begin() << " charge = " << muon->charge() << " p = " << muon->p()
                  << " pt = " << muon->pt() << " eta = " << muon->eta() << " phi = " << muon->phi()
                  << " matches = " << muon->matches().size()
                  << " matched Seg = " << muon->numberOfMatches(reco::Muon::SegmentAndTrackArbitration)
                  << " GLB/TR/STA = " << muon->isGlobalMuon() << "/" << muon->isTrackerMuon() << "/"
                  << muon->isStandAloneMuon() << std::endl;
      }
      if (!(muon->isTrackerMuon() && muon->isGlobalMuon())) {
        continue;
      }
      DataFlow->Fill(32.);
      double relISO =
          (muon->isolationR03().sumPt + muon->isolationR03().emEt + muon->isolationR03().hadEt) / muon->track()->pt();
      if (printalot) {
        std::cout << " relISO = " << relISO << " emVetoEt = " << muon->isolationR03().emVetoEt
                  << " caloComp = " << muon::caloCompatibility(*(muon))
                  << " dxy = " << fabs(muon->track()->dxy(vertexBeamSpot.position())) << std::endl;
      }
      if (
          //relISO>0.1 || muon::caloCompatibility(*(muon))<.90 ||
          fabs(muon->track()->dxy(vertexBeamSpot.position())) > 0.2 || muon->pt() < 6.) {
        continue;
      }
      DataFlow->Fill(33.);
      if (muon->track()->hitPattern().numberOfValidPixelHits() < 1 ||
          muon->track()->hitPattern().numberOfValidTrackerHits() < 11 ||
          muon->combinedMuon()->hitPattern().numberOfValidMuonHits() < 1 ||
          muon->combinedMuon()->normalizedChi2() > 10. || muon->numberOfMatches() < 2) {
        continue;
      }
      DataFlow->Fill(34.);
      float zOuter = muon->combinedMuon()->outerPosition().z();
      float rhoOuter = muon->combinedMuon()->outerPosition().rho();
      bool passDepth = true;
      // barrel region
      //if ( fabs(zOuter) < 660. && rhoOuter > 400. && rhoOuter < 480.){
      if (fabs(zOuter) < 660. && rhoOuter > 400. && rhoOuter < 540.) {
        passDepth = false;
      }
      // endcap region
      //else if( fabs(zOuter) > 550. && fabs(zOuter) < 650. && rhoOuter < 300.){
      else if (fabs(zOuter) > 550. && fabs(zOuter) < 650. && rhoOuter < 300.) {
        passDepth = false;
      }
      // overlap region
      //else if ( fabs(zOuter) > 680. && fabs(zOuter) < 730. && rhoOuter < 480.){
      else if (fabs(zOuter) > 680. && fabs(zOuter) < 880. && rhoOuter < 540.) {
        passDepth = false;
      }
      if (!passDepth) {
        continue;
      }
      DataFlow->Fill(35.);
      goodMuons_it.push_back(muon);
      if (muon->track()->momentum().z() > 0.) {
        ++nPositiveZ;
      }
      if (muon->track()->momentum().z() < 0.) {
        ++nNegativeZ;
      }
    }
  }

  //

  if (printalot)
    std::cout << "Start track loop over " << trackCollection.size() << " tracks" << std::endl;
  for (edm::View<reco::Track>::size_type i = 0; i < trackCollection.size(); ++i) {
    DataFlow->Fill(2.);
    edm::RefToBase<reco::Track> track(trackCollectionH, i);
    //std::cout<<" iTR = "<<i<<" eta = "<<track->eta()<<" phi = "<<track->phi()<<std::cout<<" pt = "<<track->pt()<<std::endl;
    if (isIPdata) {
      if (printalot) {
        std::cout << " nNegativeZ = " << nNegativeZ << " nPositiveZ = " << nPositiveZ << std::endl;
      }
      if (nNegativeZ > 1 || nPositiveZ > 1) {
        break;
      }
      bool trackOK = false;
      if (printalot) {
        std::cout << " goodMuons_it.size() = " << goodMuons_it.size() << std::endl;
      }
      for (size_t iM = 0; iM < goodMuons_it.size(); ++iM) {
        //std::cout<<" iM = "<<iM<<" eta = "<<goodMuons_it[iM]->track()->eta()<<
        //" phi = "<<goodMuons_it[iM]->track()->phi()<<
        //" pt = "<<goodMuons_it[iM]->track()->pt()<<std::endl;
        float deltaR = pow(track->phi() - goodMuons_it[iM]->track()->phi(), 2) +
                       pow(track->eta() - goodMuons_it[iM]->track()->eta(), 2);
        deltaR = sqrt(deltaR);
        if (printalot) {
          std::cout << " TR mu match to a tr: deltaR = " << deltaR
                    << " dPt = " << track->pt() - goodMuons_it[iM]->track()->pt() << std::endl;
        }
        if (deltaR > 0.01 || fabs(track->pt() - goodMuons_it[iM]->track()->pt()) > 0.1) {
          continue;
        } else {
          trackOK = true;
          if (printalot) {
            std::cout << " trackOK " << std::endl;
          }
          muonOuterZPosition = goodMuons_it[iM]->combinedMuon()->outerPosition().z();
          break;
          //++nChosenTracks;
        }
      }
      if (!trackOK) {
        if (printalot) {
          std::cout << " failed: trackOK " << std::endl;
        }
        continue;
      }
    } else {
      //---- Do we need a better "clean track" definition?
      if (trackCollection.size() > 2) {
        break;
      }
      DataFlow->Fill(3.);
      if (!i && 2 == trackCollection.size()) {
        edm::View<reco::Track>::size_type tType = 1;
        edm::RefToBase<reco::Track> trackTwo(trackCollectionH, tType);
        if (track->outerPosition().z() * trackTwo->outerPosition().z() > 0) {  // in one and the same "endcap"
          break;
        }
      }
    }
    DataFlow->Fill(4.);
    if (printalot) {
      std::cout << "i track = " << i << " P = " << track->p() << " chi2/ndf = " << track->normalizedChi2()
                << " nSeg = " << segments->size() << std::endl;
      std::cout << "quality undef/loose/tight/high/confirmed/goodIt/size " << track->quality(reco::Track::undefQuality)
                << "/" << track->quality(reco::Track::loose) << "/" << track->quality(reco::Track::tight) << "/"
                << track->quality(reco::Track::highPurity) << "/" << track->quality(reco::Track::confirmed) << "/"
                << track->quality(reco::Track::goodIterative) << "/" << track->quality(reco::Track::qualitySize)
                << std::endl;
      std::cout << " pt = " << track->pt() << " +-" << track->ptError() << " q/pt = " << track->qoverp() << " +- "
                << track->qoverpError() << std::endl;
      //std::cout<<" const Pmin = "<<minTrackMomentum<<" pMax = "<<maxTrackMomentum<<" maxNormChi2 = "<<maxNormChi2<<std::endl;
      std::cout << " track inner position = " << track->innerPosition()
                << " outer position = " << track->outerPosition() << std::endl;
      std::cout << "track eta (outer) = " << track->outerPosition().eta()
                << " phi (outer) = " << track->outerPosition().phi() << std::endl;
      if (fabs(track->innerPosition().z()) > 500.) {
        DetId innerDetId(track->innerDetId());
        std::cout << " dump inner state MUON detid  = " << debug.dumpMuonId(innerDetId) << std::endl;
      }
      if (fabs(track->outerPosition().z()) > 500.) {
        DetId outerDetId(track->outerDetId());
        std::cout << " dump outer state MUON detid  = " << debug.dumpMuonId(outerDetId) << std::endl;
      }

      std::cout << " nHits = " << track->found() << std::endl;
      /*
      trackingRecHit_iterator rhbegin = track->recHitsBegin();
      trackingRecHit_iterator rhend = track->recHitsEnd();
      int iRH = 0;
      for(trackingRecHit_iterator recHit = rhbegin; recHit != rhend; ++recHit){
        const GeomDet* geomDet = theTrackingGeometry->idToDet((*recHit)->geographicalId());
    std::cout<<"hit "<<iRH<<" loc pos = " <<(*recHit)->localPosition()<<
      " glob pos = " <<geomDet->toGlobal((*recHit)->localPosition())<<std::endl;
        ++iRH;
      }
      */
    }
    float dpT_ov_pT = 0.;
    if (fabs(track->pt()) > 0.001) {
      dpT_ov_pT = track->ptError() / track->pt();
    }
    //---- These define a "good" track
    if (track->normalizedChi2() > maxNormChi2) {  // quality
      break;
    }
    DataFlow->Fill(5.);
    if (track->found() < minTrackHits) {  // enough data points
      break;
    }
    DataFlow->Fill(6.);
    if (!segments->size()) {  // better have something in the CSC
      break;
    }
    DataFlow->Fill(7.);
    if (magField && (track->p() < minP || track->p() > maxP)) {  // proper energy range
      break;
    }
    DataFlow->Fill(8.);
    if (magField && (dpT_ov_pT > 0.5)) {  // not too crazy uncertainty
      break;
    }
    DataFlow->Fill(9.);

    passTheEvent = true;
    if (printalot)
      std::cout << "good Track" << std::endl;
    CLHEP::Hep3Vector r3T_inner(track->innerPosition().x(), track->innerPosition().y(), track->innerPosition().z());
    CLHEP::Hep3Vector r3T(track->outerPosition().x(), track->outerPosition().y(), track->outerPosition().z());
    chooseDirection(r3T_inner, r3T);  // for non-IP

    CLHEP::Hep3Vector p3T(track->outerMomentum().x(), track->outerMomentum().y(), track->outerMomentum().z());
    CLHEP::Hep3Vector p3_propagated, r3_propagated;
    AlgebraicSymMatrix66 cov_propagated, covT;
    covT *= 1e-20;
    cov_propagated *= 1e-20;
    int charge = track->charge();
    FreeTrajectoryState ftsStart = getFromCLHEP(p3T, r3T, charge, covT, &*(theService->magneticField()));
    if (printalot) {
      std::cout << " p = " << track->p() << " norm chi2 = " << track->normalizedChi2() << std::endl;
      std::cout << " dump the very first FTS  = " << debug.dumpFTS(ftsStart) << std::endl;
    }
    TrajectoryStateOnSurface tSOSDest;
    int endcap = 0;
    //---- which endcap to look at
    if (track->outerPosition().z() > 0) {
      endcap = 1;
    } else {
      endcap = 2;
    }
    int chamber = 1;
    //---- a "refference" CSCDetId for each ring
    std::vector<CSCDetId> refME;
    for (int iS = 1; iS < 5; ++iS) {
      for (int iR = 1; iR < 4; ++iR) {
        if (1 != iS && iR > 2) {
          continue;
        } else if (4 == iS && iR > 1) {
          continue;
        }
        refME.push_back(CSCDetId(endcap, iS, iR, chamber));
      }
    }
    //---- loop over the "refference" CSCDetIds
    for (size_t iSt = 0; iSt < refME.size(); ++iSt) {
      if (printalot) {
        std::cout << "loop iStatation = " << iSt << std::endl;
        std::cout << "refME[iSt]: st = " << refME[iSt].station() << " rg = " << refME[iSt].ring() << std::endl;
      }
      std::map<std::string, bool> chamberTypes;
      chamberTypes["ME11"] = false;
      chamberTypes["ME12"] = false;
      chamberTypes["ME13"] = false;
      chamberTypes["ME21"] = false;
      chamberTypes["ME22"] = false;
      chamberTypes["ME31"] = false;
      chamberTypes["ME32"] = false;
      chamberTypes["ME41"] = false;
      const CSCChamber *cscChamber_base = cscGeom->chamber(refME[iSt].chamberId());
      DetId detId = cscChamber_base->geographicalId();
      if (printalot) {
        std::cout << " base iStation : eta = " << cscGeom->idToDet(detId)->surface().position().eta()
                  << " phi = " << cscGeom->idToDet(detId)->surface().position().phi()
                  << " y = " << cscGeom->idToDet(detId)->surface().position().y() << std::endl;
        std::cout << " dump base iStation detid  = " << debug.dumpMuonId(detId) << std::endl;
        std::cout << " dump FTS start  = " << debug.dumpFTS(ftsStart) << std::endl;
      }
      //---- propagate to this ME
      tSOSDest = propagate(ftsStart, cscGeom->idToDet(detId)->surface());
      if (tSOSDest.isValid()) {
        ftsStart = *tSOSDest.freeState();
        if (printalot)
          std::cout << "  dump FTS end   = " << debug.dumpFTS(ftsStart) << std::endl;
        getFromFTS(ftsStart, p3_propagated, r3_propagated, charge, cov_propagated);
        float feta = fabs(r3_propagated.eta());
        float phi = r3_propagated.phi();
        //---- which rings are (possibly) penetrated
        ringCandidates(refME[iSt].station(), feta, chamberTypes);

        map<std::string, bool>::iterator iter;
        int iterations = 0;
        //---- loop over ring candidates
        for (iter = chamberTypes.begin(); iter != chamberTypes.end(); iter++) {
          ++iterations;
          //---- is this ME a machinig candidate station
          if (iter->second && (iterations - 1) == int(iSt)) {
            if (printalot) {
              std::cout << " Chamber type " << iter->first << " is a candidate..." << std::endl;
              std::cout << " station() = " << refME[iSt].station() << " ring() = " << refME[iSt].ring()
                        << " iSt = " << iSt << std::endl;
            }
            std::vector<int> coupleOfChambers;
            //---- which chamber (and its closes neighbor) is penetrated by the track - candidates
            chamberCandidates(refME[iSt].station(), refME[iSt].ring(), phi, coupleOfChambers);
            //---- loop over the two chamber candidates
            for (size_t iCh = 0; iCh < coupleOfChambers.size(); ++iCh) {
              DataFlow->Fill(11.);
              if (printalot)
                std::cout << " Check chamber N = " << coupleOfChambers.at(iCh) << std::endl;
              ;
              if ((!getAbsoluteEfficiency) &&
                  (true == emptyChambers[refME[iSt].endcap() - 1][refME[iSt].station() - 1][refME[iSt].ring() - 1]
                                        [coupleOfChambers.at(iCh) - FirstCh])) {
                continue;
              }
              CSCDetId theCSCId(refME[iSt].endcap(), refME[iSt].station(), refME[iSt].ring(), coupleOfChambers.at(iCh));
              const CSCChamber *cscChamber = cscGeom->chamber(theCSCId.chamberId());
              const BoundPlane bpCh = cscGeom->idToDet(cscChamber->geographicalId())->surface();
              float zFTS = ftsStart.position().z();
              float dz = fabs(bpCh.position().z() - zFTS);
              float zDistInner = track->innerPosition().z() - bpCh.position().z();
              float zDistOuter = track->outerPosition().z() - bpCh.position().z();
              //---- only detectors between the inner and outer points of the track are considered for non IP-data
              if (printalot) {
                std::cout << " zIn = " << track->innerPosition().z() << " zOut = " << track->outerPosition().z()
                          << " zSurf = " << bpCh.position().z() << std::endl;
              }
              if (!isIPdata && (zDistInner * zDistOuter > 0. || fabs(zDistInner) < 15. ||
                                fabs(zDistOuter) < 15.)) {  // for non IP-data
                if (printalot) {
                  std::cout << " Not an intermediate (as defined) point... Skip." << std::endl;
                }
                continue;
              }
              if (isIPdata && fabs(track->eta()) < 1.8) {
                if (fabs(muonOuterZPosition) - fabs(bpCh.position().z()) < 0 ||
                    fabs(muonOuterZPosition - bpCh.position().z()) < 15.) {
                  continue;
                }
              }
              DataFlow->Fill(13.);
              //---- propagate to the chamber (from this ME) if it is a different surface (odd/even chambers)
              if (dz > 0.1) {  // i.e. non-zero (float 0 check is bad)
                //if(fabs(zChanmber - zFTS ) > 0.1){
                tSOSDest = propagate(ftsStart, cscGeom->idToDet(cscChamber->geographicalId())->surface());
                if (tSOSDest.isValid()) {
                  ftsStart = *tSOSDest.freeState();
                } else {
                  if (printalot)
                    std::cout << "TSOS not valid! Break." << std::endl;
                  break;
                }
              } else {
                if (printalot)
                  std::cout << " info: dz<0.1" << std::endl;
              }
              DataFlow->Fill(15.);
              FreeTrajectoryState ftsInit = ftsStart;
              bool inDeadZone = false;
              //---- loop over the 6 layers
              for (int iLayer = 0; iLayer < 6; ++iLayer) {
                bool extrapolationPassed = true;
                if (printalot) {
                  std::cout << " iLayer = " << iLayer << "   dump FTS init  = " << debug.dumpFTS(ftsInit) << std::endl;
                  std::cout << " dump detid  = " << debug.dumpMuonId(cscChamber->geographicalId()) << std::endl;
                  std::cout << "Surface to propagate to:  pos = " << cscChamber->layer(iLayer + 1)->surface().position()
                            << " eta = " << cscChamber->layer(iLayer + 1)->surface().position().eta()
                            << " phi = " << cscChamber->layer(iLayer + 1)->surface().position().phi() << std::endl;
                }
                //---- propagate to this layer
                tSOSDest = propagate(ftsInit, cscChamber->layer(iLayer + 1)->surface());
                if (tSOSDest.isValid()) {
                  ftsInit = *tSOSDest.freeState();
                  if (printalot)
                    std::cout << " Propagation between layers successful:  dump FTS end  = " << debug.dumpFTS(ftsInit)
                              << std::endl;
                  getFromFTS(ftsInit, p3_propagated, r3_propagated, charge, cov_propagated);
                } else {
                  if (printalot)
                    std::cout << "Propagation between layers not successful - notValid TSOS" << std::endl;
                  extrapolationPassed = false;
                  inDeadZone = true;
                }
                //}
                //---- Extrapolation passed? For each layer?
                if (extrapolationPassed) {
                  GlobalPoint theExtrapolationPoint(r3_propagated.x(), r3_propagated.y(), r3_propagated.z());
                  LocalPoint theLocalPoint = cscChamber->layer(iLayer + 1)->toLocal(theExtrapolationPoint);
                  //std::cout<<" Candidate chamber: extrapolated LocalPoint = "<<theLocalPoint<<std::endl;
                  inDeadZone = (inDeadZone ||
                                !inSensitiveLocalRegion(
                                    theLocalPoint.x(), theLocalPoint.y(), refME[iSt].station(), refME[iSt].ring()));
                  if (printalot) {
                    std::cout << " Candidate chamber: extrapolated LocalPoint = " << theLocalPoint
                              << "inDeadZone = " << inDeadZone << std::endl;
                  }
                  //---- break if in dead zone for any layer ("clean" tracks)
                  if (inDeadZone) {
                    break;
                  }
                } else {
                  break;
                }
              }
              DataFlow->Fill(17.);
              //---- Is a track in a sensitive area for each layer?
              if (!inDeadZone) {  //---- for any layer
                DataFlow->Fill(19.);
                if (printalot)
                  std::cout << "Do efficiencies..." << std::endl;
                //---- Do efficiencies
                // angle cuts applied (if configured)
                bool angle_flag = true;
                angle_flag = efficienciesPerChamber(theCSCId, cscChamber, ftsStart);
                if (useDigis && angle_flag) {
                  stripWire_Efficiencies(theCSCId, ftsStart);
                }
                if (angle_flag) {
                  recHitSegment_Efficiencies(theCSCId, cscChamber, ftsStart);
                  if (!isData) {
                    recSimHitEfficiency(theCSCId, ftsStart);
                  }
                }
              } else {
                if (printalot)
                  std::cout << " Not in active area for all layers" << std::endl;
              }
            }
            if (tSOSDest.isValid()) {
              ftsStart = *tSOSDest.freeState();
            }
          }
        }
      } else {
        if (printalot)
          std::cout << " TSOS not valid..." << std::endl;
      }
    }
  }
  //---- End
  if (printalot)
    printf("==exit===CSCEfficiency===== run %u\tevent %llu\n\n", iRun, iEvent);
  return passTheEvent;
}

getFromCLHEP()

FreeTrajectoryState CSCEfficiency::getFromCLHEP ( const CLHEP::Hep3Vector &  p3, const CLHEP::Hep3Vector &  r3, int  charge, const AlgebraicSymMatrix66 &  cov, const MagneticField *  field  )

private

Definition at line 1470 of file CSCEfficiency.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, and chargedHadronTrackResolutionFilter_cfi::p3.

                                                                            {
  GlobalVector p3GV(p3.x(), p3.y(), p3.z());
  GlobalPoint r3GP(r3.x(), r3.y(), r3.z());
  GlobalTrajectoryParameters tPars(r3GP, p3GV, charge, field);

  CartesianTrajectoryError tCov(cov);

  return cov.kRows == 6 ? FreeTrajectoryState(tPars, tCov) : FreeTrajectoryState(tPars);
}

getFromFTS()

void CSCEfficiency::getFromFTS ( const FreeTrajectoryState &  fts, CLHEP::Hep3Vector &  p3, CLHEP::Hep3Vector &  r3, int &  charge, AlgebraicSymMatrix66 &  cov  )

private

Definition at line 1455 of file CSCEfficiency.cc.

References FreeTrajectoryState::cartesianError(), ALCARECOTkAlJpsiMuMu_cff::charge, FreeTrajectoryState::charge(), FreeTrajectoryState::hasError(), CartesianTrajectoryError::matrix(), FreeTrajectoryState::momentum(), chargedHadronTrackResolutionFilter_cfi::p3, FreeTrajectoryState::position(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                          {
  GlobalVector p3GV = fts.momentum();
  GlobalPoint r3GP = fts.position();

  p3.set(p3GV.x(), p3GV.y(), p3GV.z());
  r3.set(r3GP.x(), r3GP.y(), r3GP.z());

  charge = fts.charge();
  cov = fts.hasError() ? fts.cartesianError().matrix() : AlgebraicSymMatrix66();
}

inSensitiveLocalRegion()

bool CSCEfficiency::inSensitiveLocalRegion ( double  xLocal, double  yLocal, int  station, int  ring  )

private

Definition at line 545 of file CSCEfficiency.cc.

References funct::abs(), relativeConstraints::ring, and relativeConstraints::station.

                                                                                              {
  //---- Good region means sensitive area of a chamber. "Local" stands for the local system
  bool pass = false;
  std::vector<double> chamberBounds(3);  // the sensitive area
  float y_center = 99999.;
  //---- hardcoded... not good
  if (station > 1 && station < 5) {
    if (2 == ring) {
      chamberBounds[0] = 66.46 / 2;   // (+-)x1 shorter
      chamberBounds[1] = 127.15 / 2;  // (+-)x2 longer
      chamberBounds[2] = 323.06 / 2;
      y_center = -0.95;
    } else {
      if (2 == station) {
        chamberBounds[0] = 54.00 / 2;   // (+-)x1 shorter
        chamberBounds[1] = 125.71 / 2;  // (+-)x2 longer
        chamberBounds[2] = 189.66 / 2;
        y_center = -0.955;
      } else if (3 == station) {
        chamberBounds[0] = 61.40 / 2;   // (+-)x1 shorter
        chamberBounds[1] = 125.71 / 2;  // (+-)x2 longer
        chamberBounds[2] = 169.70 / 2;
        y_center = -0.97;
      } else if (4 == station) {
        chamberBounds[0] = 69.01 / 2;   // (+-)x1 shorter
        chamberBounds[1] = 125.65 / 2;  // (+-)x2 longer
        chamberBounds[2] = 149.42 / 2;
        y_center = -0.94;
      }
    }
  } else if (1 == station) {
    if (3 == ring) {
      chamberBounds[0] = 63.40 / 2;  // (+-)x1 shorter
      chamberBounds[1] = 92.10 / 2;  // (+-)x2 longer
      chamberBounds[2] = 164.16 / 2;
      y_center = -1.075;
    } else if (2 == ring) {
      chamberBounds[0] = 51.00 / 2;  // (+-)x1 shorter
      chamberBounds[1] = 83.74 / 2;  // (+-)x2 longer
      chamberBounds[2] = 174.49 / 2;
      y_center = -0.96;
    } else {                        // to be investigated
      chamberBounds[0] = 30. / 2;   //40./2; // (+-)x1 shorter
      chamberBounds[1] = 60. / 2;   //100./2; // (+-)x2 longer
      chamberBounds[2] = 160. / 2;  //142./2;
      y_center = 0.;
    }
  }
  double yUp = chamberBounds[2] + y_center;
  double yDown = -chamberBounds[2] + y_center;
  double xBound1Shifted = chamberBounds[0] - distanceFromDeadZone;  //
  double xBound2Shifted = chamberBounds[1] - distanceFromDeadZone;  //
  double lineSlope = (yUp - yDown) / (xBound2Shifted - xBound1Shifted);
  double lineConst = yUp - lineSlope * xBound2Shifted;
  double yBoundary = lineSlope * abs(xLocal) + lineConst;
  pass = checkLocal(yLocal, yBoundary, station, ring);
  return pass;
}

linearExtrapolation()

void CSCEfficiency::linearExtrapolation ( GlobalPoint  initialPosition, GlobalVector  initialDirection, float  zSurface, std::vector< float > &  posZY  )

private

Definition at line 1484 of file CSCEfficiency.cc.

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

                                                                 {
  double paramLine = lineParameter(initialPosition.z(), zSurface, initialDirection.z());
  double xPosition = extrapolate1D(initialPosition.x(), initialDirection.x(), paramLine);
  double yPosition = extrapolate1D(initialPosition.y(), initialDirection.y(), paramLine);
  posZY.clear();
  posZY.push_back(xPosition);
  posZY.push_back(yPosition);
}

lineParameter()

double CSCEfficiency::lineParameter ( double  initZPosition, double  destZPosition, double  initZDirection  )

private

Definition at line 1501 of file CSCEfficiency.cc.

                                                                                                     {
  double paramLine = (destZPosition - initZPosition) / initZDirection;
  return paramLine;
}

propagate()

TrajectoryStateOnSurface CSCEfficiency::propagate ( FreeTrajectoryState &  ftsStart, const BoundPlane &  bp  )

private

Definition at line 1532 of file CSCEfficiency.cc.

References TrackCandidateProducer_cfi::propagator, HLT_2023v12_cff::propagatorName, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                         {
  TrajectoryStateOnSurface tSOSDest;
  std::string propagatorName;
  /*
// it would work if cosmic muons had properly assigned direction...
  bool dzPositive = bpDest.position().z() - ftsStart.position().z() > 0 ? true : false;
 //---- Be careful with trigger conditions too
  if(!isIPdata){
    bool rightDirection = !(alongZ^dzPositive);
    if(rightDirection){
      if(printalot) std::cout<<" propagate along momentum"<<std::endl;
      propagatorName = "SteppingHelixPropagatorAlong";
    }
    else{
      if(printalot) std::cout<<" propagate opposite momentum"<<std::endl;
      propagatorName = "SteppingHelixPropagatorOpposite";
    }
  }
  else{
    if(printalot) std::cout<<" propagate any (momentum)"<<std::endl;
    propagatorName = "SteppingHelixPropagatorAny";
  }
*/
  propagatorName = "SteppingHelixPropagatorAny";
  tSOSDest = propagator(propagatorName)->propagate(ftsStart, bpDest);
  return tSOSDest;
}

propagator()

const Propagator * CSCEfficiency::propagator ( std::string  propagatorName ) const

private

Definition at line 1527 of file CSCEfficiency.cc.

References HLT_2023v12_cff::propagatorName.

                                                                          {
  return &*theService->propagator(propagatorName);
}

recHitSegment_Efficiencies()

bool CSCEfficiency::recHitSegment_Efficiencies ( CSCDetId &  cscDetId, const CSCChamber *  cscChamber, FreeTrajectoryState &  ftsChamber  )

private

Definition at line 1308 of file CSCEfficiency.cc.

References relativeConstraints::chamber, gather_cfg::cout, makeMuonMisalignmentScenario::endcap, PV3DBase< T, PVType, FrameType >::eta(), dqmdumpme::first, FirstCh, CSCLayer::geometry(), CSCChamber::layer(), M_PI, CSCLayerGeometry::nearestStrip(), FreeTrajectoryState::position(), conifer::pow(), relativeConstraints::ring, edm::second(), findQualityFiles::size, mathSSE::sqrt(), relativeConstraints::station, CSCLayerGeometry::stripAngle(), GeomDet::surface(), GeomDet::toGlobal(), GeomDet::toLocal(), funct::true, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                {
  int ec, st, rg, ch, secondRing;
  returnTypes(id, ec, st, rg, ch, secondRing);
  bool firstCondition, secondCondition;

  std::vector<bool> missingLayers_rh(6);
  std::vector<int> usedInSegment(6);
  // Rechits
  if (printalot)
    std::cout << "RecHits eff" << std::endl;
  for (int iLayer = 0; iLayer < 6; ++iLayer) {
    firstCondition = !allRechits[ec][st][rg][ch][iLayer].empty() ? true : false;
    secondCondition = false;
    int thisRing = rg;
    if (secondRing > -1) {
      secondCondition = !allRechits[ec][st][secondRing][ch][iLayer].empty() ? true : false;
      if (secondCondition) {
        thisRing = secondRing;
      }
    }
    if (firstCondition || secondCondition) {
      ChHist[ec][st][rg][ch].EfficientRechits_good->Fill(iLayer + 1);
      for (size_t iR = 0; iR < allRechits[ec][st][thisRing][ch][iLayer].size(); ++iR) {
        if (allRechits[ec][st][thisRing][ch][iLayer][iR].second) {
          usedInSegment[iLayer] = 1;
          break;
        } else {
          usedInSegment[iLayer] = -1;
        }
      }
    } else {
      missingLayers_rh[iLayer] = true;
      if (printalot) {
        std::cout << "missing rechits ";
        printf("\t\tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",
               id.endcap(),
               id.station(),
               id.ring(),
               id.chamber(),
               iLayer + 1);
      }
    }
  }
  GlobalVector globalDir;
  GlobalPoint globalPos;
  // Segments
  firstCondition = !allSegments[ec][st][rg][ch].empty() ? true : false;
  secondCondition = false;
  int secondSize = 0;
  int thisRing = rg;
  if (secondRing > -1) {
    secondCondition = !allSegments[ec][st][secondRing][ch].empty() ? true : false;
    secondSize = allSegments[ec][st][secondRing][ch].size();
    if (secondCondition) {
      thisRing = secondRing;
    }
  }
  if (firstCondition || secondCondition) {
    if (printalot)
      std::cout << "segments - start ec = " << ec << " st = " << st << " rg = " << rg << " ch = " << ch << std::endl;
    StHist[ec][st].EfficientSegments_XY->Fill(ftsChamber.position().x(), ftsChamber.position().y());
    if (1 == allSegments[ec][st][rg][ch].size() + secondSize) {
      globalDir = cscChamber->toGlobal(allSegments[ec][st][thisRing][ch][0].second);
      globalPos = cscChamber->toGlobal(allSegments[ec][st][thisRing][ch][0].first);
      StHist[ec][st].EfficientSegments_eta->Fill(fabs(ftsChamber.position().eta()));
      double residual =
          sqrt(pow(ftsChamber.position().x() - globalPos.x(), 2) + pow(ftsChamber.position().y() - globalPos.y(), 2) +
               pow(ftsChamber.position().z() - globalPos.z(), 2));
      if (printalot)
        std::cout << " fts.position() = " << ftsChamber.position() << " segPos = " << globalPos << " res = " << residual
                  << std::endl;
      StHist[ec][st].ResidualSegments->Fill(residual);
    }
    for (int iLayer = 0; iLayer < 6; ++iLayer) {
      if (printalot)
        std::cout << " iLayer = " << iLayer << " usedInSegment = " << usedInSegment[iLayer] << std::endl;
      if (0 != usedInSegment[iLayer]) {
        if (-1 == usedInSegment[iLayer]) {
          ChHist[ec][st][rg][ch].InefficientSingleHits->Fill(iLayer + 1);
        }
        ChHist[ec][st][rg][ch].AllSingleHits->Fill(iLayer + 1);
      }
      firstCondition = !allRechits[ec][st][rg][ch][iLayer].empty() ? true : false;
      secondCondition = false;
      if (secondRing > -1) {
        secondCondition = !allRechits[ec][st][secondRing][ch][iLayer].empty() ? true : false;
      }
      float stripAngle = 99999.;
      std::vector<float> posXY(2);
      bool oneSegment = false;
      if (1 == allSegments[ec][st][rg][ch].size() + secondSize) {
        oneSegment = true;
        const BoundPlane bp = cscChamber->layer(iLayer + 1)->surface();
        linearExtrapolation(globalPos, globalDir, bp.position().z(), posXY);
        GlobalPoint gp_extrapol(posXY.at(0), posXY.at(1), bp.position().z());
        const LocalPoint lp_extrapol = cscChamber->layer(iLayer + 1)->toLocal(gp_extrapol);
        posXY.at(0) = lp_extrapol.x();
        posXY.at(1) = lp_extrapol.y();
        int nearestStrip = cscChamber->layer(iLayer + 1)->geometry()->nearestStrip(lp_extrapol);
        stripAngle = cscChamber->layer(iLayer + 1)->geometry()->stripAngle(nearestStrip) - M_PI / 2.;
      }
      if (firstCondition || secondCondition) {
        ChHist[ec][st][rg][ch].EfficientRechits_inSegment->Fill(iLayer + 1);
        if (oneSegment) {
          ChHist[ec][st][rg][ch].Y_EfficientRecHits_inSegment[iLayer]->Fill(posXY.at(1));
          ChHist[ec][st][rg][ch].Phi_EfficientRecHits_inSegment[iLayer]->Fill(stripAngle);
        }
      } else {
        if (oneSegment) {
          ChHist[ec][st][rg][ch].Y_InefficientRecHits_inSegment[iLayer]->Fill(posXY.at(1));
          ChHist[ec][st][rg][ch].Phi_InefficientRecHits_inSegment[iLayer]->Fill(stripAngle);
        }
      }
    }
  } else {
    StHist[ec][st].InefficientSegments_XY->Fill(ftsChamber.position().x(), ftsChamber.position().y());
    if (printalot) {
      std::cout << "missing segment " << std::endl;
      printf("\t\tendcap/station/ring/chamber: %i/%i/%i/%i\n", id.endcap(), id.station(), id.ring(), id.chamber());
      std::cout << " fts.position() = " << ftsChamber.position() << std::endl;
    }
  }
  // Normalization
  ChHist[ec][st][rg][ch].EfficientRechits_good->Fill(8);
  if (allSegments[ec][st][rg][ch].size() + secondSize < 2) {
    StHist[ec][st].AllSegments_eta->Fill(fabs(ftsChamber.position().eta()));
  }
  ChHist[ec][st][rg][id.chamber() - FirstCh].EfficientRechits_inSegment->Fill(9);

  return true;
}

recSimHitEfficiency()

bool CSCEfficiency::recSimHitEfficiency ( CSCDetId &  id, FreeTrajectoryState &  ftsChamber  )

private

Definition at line 1264 of file CSCEfficiency.cc.

References relativeConstraints::empty, edm::second(), and funct::true.

                                                                                     {
  int ec, st, rg, ch, secondRing;
  returnTypes(id, ec, st, rg, ch, secondRing);
  bool firstCondition, secondCondition;
  for (int iLayer = 0; iLayer < 6; iLayer++) {
    firstCondition = !allSimhits[ec][st][rg][ch][iLayer].empty() ? true : false;
    secondCondition = false;
    int thisRing = rg;
    if (secondRing > -1) {
      secondCondition = !allSimhits[ec][st][secondRing][ch][iLayer].empty() ? true : false;
      if (secondCondition) {
        thisRing = secondRing;
      }
    }
    if (firstCondition || secondCondition) {
      for (size_t iSH = 0; iSH < allSimhits[ec][st][thisRing][ch][iLayer].size(); ++iSH) {
        if (13 == fabs(allSimhits[ec][st][thisRing][ch][iLayer][iSH].second)) {
          ChHist[ec][st][rg][ch].SimSimhits->Fill(iLayer + 1);
          if (!allRechits[ec][st][thisRing][ch][iLayer].empty()) {
            ChHist[ec][st][rg][ch].SimRechits->Fill(iLayer + 1);
          }
          break;
        }
      }
      //---- Next is not too usefull...
      /*
      for(unsigned int iSimHits=0;
      iSimHits<allSimhits[id.endcap()-1][id.station()-1][id.ring()-1][id.chamber()-FirstCh][iLayer].size();
      iSimHits++){
    ChHist[ec][st][rg][id.chamber()-FirstCh].SimSimhits_each->Fill(iLayer+1);
      }
      for(unsigned int iRecHits=0;
      iRecHits<allRechits[id.endcap()-1][id.station()-1][id.ring()-1][id.chamber()-FirstCh][iLayer].size();
      iRecHits++){
    ChHist[ec][st][rg][id.chamber()-FirstCh].SimRechits_each->Fill(iLayer+1);
      }
      */
      //
    }
  }
  return true;
}

returnTypes()

void CSCEfficiency::returnTypes ( CSCDetId &  id, int &  ec, int &  st, int &  rg, int &  ch, int &  secondRing  )

private

Definition at line 1442 of file CSCEfficiency.cc.

References FirstCh, relativeConstraints::ring, and relativeConstraints::station.

                                                                                                 {
  ec = id.endcap() - 1;
  st = id.station() - 1;
  rg = id.ring() - 1;
  secondRing = -1;
  if (1 == id.station() && (4 == id.ring() || 1 == id.ring())) {
    rg = 0;
    secondRing = 3;
  }
  ch = id.chamber() - FirstCh;
}

ringCandidates()

void CSCEfficiency::ringCandidates ( int  station, float  absEta, std::map< std::string, bool > &  chamberTypes  )

private

Definition at line 970 of file CSCEfficiency.cc.

References JetMETHLTOfflineSource_cfi::feta, and relativeConstraints::station.

                                                                                                 {
  // yeah, hardcoded again...
  switch (station) {
    case 1:
      if (feta > 0.85 && feta < 1.18) {  //ME13
        chamberTypes["ME13"] = true;
      }
      if (feta > 1.18 && feta < 1.7) {  //ME12
        chamberTypes["ME12"] = true;
      }
      if (feta > 1.5 && feta < 2.45) {  //ME11
        chamberTypes["ME11"] = true;
      }
      break;
    case 2:
      if (feta > 0.95 && feta < 1.6) {  //ME22
        chamberTypes["ME22"] = true;
      }
      if (feta > 1.55 && feta < 2.45) {  //ME21
        chamberTypes["ME21"] = true;
      }
      break;
    case 3:
      if (feta > 1.08 && feta < 1.72) {  //ME32
        chamberTypes["ME32"] = true;
      }
      if (feta > 1.69 && feta < 2.45) {  //ME31
        chamberTypes["ME31"] = true;
      }
      break;
    case 4:
      if (feta > 1.78 && feta < 2.45) {  //ME41
        chamberTypes["ME41"] = true;
      }
      break;
    default:
      break;
  }
}

stripWire_Efficiencies()

bool CSCEfficiency::stripWire_Efficiencies ( CSCDetId &  cscDetId, FreeTrajectoryState &  ftsChamber  )

private

Definition at line 1174 of file CSCEfficiency.cc.

References relativeConstraints::chamber, gather_cfg::cout, makeMuonMisalignmentScenario::endcap, FirstCh, FreeTrajectoryState::momentum(), relativeConstraints::ring, relativeConstraints::station, PV3DBase< T, PVType, FrameType >::theta(), and funct::true.

                                                                                        {
  int ec, st, rg, ch, secondRing;
  returnTypes(id, ec, st, rg, ch, secondRing);

  bool firstCondition, secondCondition;
  int missingLayers_s = 0;
  int missingLayers_wg = 0;
  for (int iLayer = 0; iLayer < 6; iLayer++) {
    //----Strips
    if (printalot) {
      printf("\t%i swEff: \tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",
             iLayer + 1,
             id.endcap(),
             id.station(),
             id.ring(),
             id.chamber(),
             iLayer + 1);
      std::cout << " size S = "
                << allStrips[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh][iLayer].size()
                << "size W = "
                << allWG[id.endcap() - 1][id.station() - 1][id.ring() - 1][id.chamber() - FirstCh][iLayer].size()
                << std::endl;
    }
    firstCondition = !allStrips[ec][st][rg][ch][iLayer].empty() ? true : false;
    //allSegments[ec][st][rg][ch].size() ? true : false;
    secondCondition = false;
    if (secondRing > -1) {
      secondCondition = !allStrips[ec][st][secondRing][ch][iLayer].empty() ? true : false;
    }
    if (firstCondition || secondCondition) {
      ChHist[ec][st][rg][ch].EfficientStrips->Fill(iLayer + 1);
    } else {
      if (printalot) {
        std::cout << "missing strips ";
        printf("\t\tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",
               id.endcap(),
               id.station(),
               id.ring(),
               id.chamber(),
               iLayer + 1);
      }
    }
    // Wires
    firstCondition = !allWG[ec][st][rg][ch][iLayer].empty() ? true : false;
    secondCondition = false;
    if (secondRing > -1) {
      secondCondition = !allWG[ec][st][secondRing][ch][iLayer].empty() ? true : false;
    }
    if (firstCondition || secondCondition) {
      ChHist[ec][st][rg][ch].EfficientWireGroups->Fill(iLayer + 1);
    } else {
      if (printalot) {
        std::cout << "missing wires ";
        printf("\t\tendcap/station/ring/chamber/layer: %i/%i/%i/%i/%i\n",
               id.endcap(),
               id.station(),
               id.ring(),
               id.chamber(),
               iLayer + 1);
      }
    }
  }
  // Normalization
  if (6 != missingLayers_s) {
    ChHist[ec][st][rg][ch].EfficientStrips->Fill(8);
  }
  if (6 != missingLayers_wg) {
    ChHist[ec][st][rg][ch].EfficientWireGroups->Fill(8);
  }
  ChHist[ec][st][rg][ch].EfficientStrips->Fill(9);
  ChHist[ec][st][rg][ch].EfficientWireGroups->Fill(9);
  //
  ChHist[ec][st][rg][ch].StripWiresCorrelations->Fill(1);
  if (missingLayers_s != missingLayers_wg) {
    ChHist[ec][st][rg][ch].StripWiresCorrelations->Fill(2);
    if (6 == missingLayers_wg) {
      ChHist[ec][st][rg][ch].StripWiresCorrelations->Fill(3);
      ChHist[ec][st][rg][ch].NoWires_momTheta->Fill(ftsChamber.momentum().theta());
    }
    if (6 == missingLayers_s) {
      ChHist[ec][st][rg][ch].StripWiresCorrelations->Fill(4);
      ChHist[ec][st][rg][ch].NoStrips_momPhi->Fill(ftsChamber.momentum().theta());
    }
  } else if (6 == missingLayers_s) {
    ChHist[ec][st][rg][ch].StripWiresCorrelations->Fill(5);
  }

  return true;
}

Member Data Documentation

al_token

edm::EDGetTokenT<CSCALCTDigiCollection> CSCEfficiency::al_token

private

Definition at line 115 of file CSCEfficiency.h.

ALCTPerEvent

TH1F* CSCEfficiency::ALCTPerEvent

private

Definition at line 253 of file CSCEfficiency.h.

allALCT

bool CSCEfficiency::allALCT[2][4][4][(36 - 1+1)]

private

Definition at line 170 of file CSCEfficiency.h.

allCLCT

bool CSCEfficiency::allCLCT[2][4][4][(36 - 1+1)]

private

Definition at line 169 of file CSCEfficiency.h.

allCorrLCT

bool CSCEfficiency::allCorrLCT[2][4][4][(36 - 1+1)]

private

Definition at line 171 of file CSCEfficiency.h.

allRechits

std::vector<std::pair<LocalPoint, bool> > CSCEfficiency::allRechits[2][4][4][(36 - 1+1)][6]

private

Definition at line 185 of file CSCEfficiency.h.

allSegments

std::vector<std::pair<LocalPoint, LocalVector> > CSCEfficiency::allSegments[2][4][4][(36 - 1+1)]

private

Definition at line 188 of file CSCEfficiency.h.

allSimhits

std::vector<std::pair<LocalPoint, int> > CSCEfficiency::allSimhits[2][4][4][(36 - 1+1)][6]

private

Definition at line 181 of file CSCEfficiency.h.

allStrips

std::vector<std::pair<int, float> > CSCEfficiency::allStrips[2][4][4][(36 - 1+1)][6]

private

Definition at line 174 of file CSCEfficiency.h.

allWG

std::vector<std::pair<std::pair<int, float>, int> > CSCEfficiency::allWG[2][4][4][(36 - 1+1)][6]

private

Definition at line 177 of file CSCEfficiency.h.

alongZ

bool CSCEfficiency::alongZ

private

Definition at line 163 of file CSCEfficiency.h.

andOr

bool CSCEfficiency::andOr

private

Definition at line 150 of file CSCEfficiency.h.

applyIPangleCuts

bool CSCEfficiency::applyIPangleCuts

private

Definition at line 141 of file CSCEfficiency.h.

ChHist

struct CSCEfficiency::ChamberHistos CSCEfficiency::ChHist[2][4][3][ 36 - 1 + 1]

private

cl_token

edm::EDGetTokenT<CSCCLCTDigiCollection> CSCEfficiency::cl_token

private

Definition at line 116 of file CSCEfficiency.h.

CLCTPerEvent

TH1F* CSCEfficiency::CLCTPerEvent

private

Definition at line 254 of file CSCEfficiency.h.

co_token

edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> CSCEfficiency::co_token

private

Definition at line 117 of file CSCEfficiency.h.

DataFlow

TH1F* CSCEfficiency::DataFlow

private

Definition at line 250 of file CSCEfficiency.h.

distanceFromDeadZone

double CSCEfficiency::distanceFromDeadZone

private

Definition at line 135 of file CSCEfficiency.h.

emptyChambers

bool CSCEfficiency::emptyChambers[2][4][4][(36 - 1+1)]

private

Definition at line 191 of file CSCEfficiency.h.

geomToken_

edm::ESGetToken<CSCGeometry, MuonGeometryRecord> CSCEfficiency::geomToken_

private

Definition at line 126 of file CSCEfficiency.h.

getAbsoluteEfficiency

bool CSCEfficiency::getAbsoluteEfficiency

private

Definition at line 133 of file CSCEfficiency.h.

ht_token

edm::EDGetTokenT<edm::TriggerResults> CSCEfficiency::ht_token

private

Definition at line 124 of file CSCEfficiency.h.

isBeamdata

bool CSCEfficiency::isBeamdata

private

Definition at line 132 of file CSCEfficiency.h.

isData

bool CSCEfficiency::isData

private

Definition at line 130 of file CSCEfficiency.h.

isIPdata

bool CSCEfficiency::isIPdata

private

Definition at line 131 of file CSCEfficiency.h.

local_DX_DZ_Max

double CSCEfficiency::local_DX_DZ_Max

private

Definition at line 144 of file CSCEfficiency.h.

local_DY_DZ_Max

double CSCEfficiency::local_DY_DZ_Max

private

Definition at line 142 of file CSCEfficiency.h.

local_DY_DZ_Min

double CSCEfficiency::local_DY_DZ_Min

private

Definition at line 143 of file CSCEfficiency.h.

magField

bool CSCEfficiency::magField

private

Definition at line 161 of file CSCEfficiency.h.

maxNormChi2

double CSCEfficiency::maxNormChi2

private

Definition at line 138 of file CSCEfficiency.h.

maxP

double CSCEfficiency::maxP

private

Definition at line 137 of file CSCEfficiency.h.

minP

double CSCEfficiency::minP

private

Definition at line 136 of file CSCEfficiency.h.

minTrackHits

unsigned int CSCEfficiency::minTrackHits

private

Definition at line 139 of file CSCEfficiency.h.

myTriggers

std::vector<std::string> CSCEfficiency::myTriggers

private

Definition at line 148 of file CSCEfficiency.h.

nEventsAnalyzed

int CSCEfficiency::nEventsAnalyzed

private

Definition at line 159 of file CSCEfficiency.h.

passTheEvent

bool CSCEfficiency::passTheEvent

private

Definition at line 165 of file CSCEfficiency.h.

pointToTriggers

std::vector<int> CSCEfficiency::pointToTriggers

private

Definition at line 149 of file CSCEfficiency.h.

printalot

bool CSCEfficiency::printalot

private

Definition at line 157 of file CSCEfficiency.h.

printout_NEvents

unsigned int CSCEfficiency::printout_NEvents

private

Definition at line 129 of file CSCEfficiency.h.

recHitsPerEvent

TH1F* CSCEfficiency::recHitsPerEvent

private

Definition at line 255 of file CSCEfficiency.h.

rh_token

edm::EDGetTokenT<CSCRecHit2DCollection> CSCEfficiency::rh_token

private

Definition at line 118 of file CSCEfficiency.h.

rootFileName

std::string CSCEfficiency::rootFileName

private

Definition at line 109 of file CSCEfficiency.h.

sd_token

edm::EDGetTokenT<CSCStripDigiCollection> CSCEfficiency::sd_token

private

Definition at line 114 of file CSCEfficiency.h.

se_token

edm::EDGetTokenT<CSCSegmentCollection> CSCEfficiency::se_token

private

Definition at line 119 of file CSCEfficiency.h.

segmentsPerEvent

TH1F* CSCEfficiency::segmentsPerEvent

private

Definition at line 256 of file CSCEfficiency.h.

sh_token

edm::EDGetTokenT<edm::PSimHitContainer> CSCEfficiency::sh_token

private

Definition at line 122 of file CSCEfficiency.h.

StHist

struct CSCEfficiency::StationHistos CSCEfficiency::StHist[2][4]

private

theFile

TFile* CSCEfficiency::theFile

private

Definition at line 155 of file CSCEfficiency.h.

theService

MuonServiceProxy* CSCEfficiency::theService

private

Definition at line 153 of file CSCEfficiency.h.

tk_token

edm::EDGetTokenT<edm::View<reco::Track> > CSCEfficiency::tk_token

private

Definition at line 121 of file CSCEfficiency.h.

TriggersFired

TH1F* CSCEfficiency::TriggersFired

private

Definition at line 251 of file CSCEfficiency.h.

useDigis

bool CSCEfficiency::useDigis

private

Definition at line 134 of file CSCEfficiency.h.

useTrigger

bool CSCEfficiency::useTrigger

private

Definition at line 147 of file CSCEfficiency.h.

wd_token

edm::EDGetTokenT<CSCWireDigiCollection> CSCEfficiency::wd_token

private

Definition at line 113 of file CSCEfficiency.h.