CSCSkim Class Reference

#include <RecoLocalMuon/CSCSkim/src/CSCSkim.cc>

Inheritance diagram for CSCSkim:

Public Member Functions
void	beginJob () override
	CSCSkim (const edm::ParameterSet &pset)
void	endJob () override
bool	filter (edm::Event &event, const edm::EventSetup &eventSetup) override
	~CSCSkim () override
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 noexcept final
bool	wantsGlobalRuns () const noexcept final
bool	wantsInputProcessBlocks () const noexcept final
bool	wantsProcessBlocks () const noexcept final
Public Member Functions inherited from edm::one::EDFilterBase
	EDFilterBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const noexcept
bool	wantsStreamRuns () const noexcept
	~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
int	chamberSerial (int kE, int kS, int kR, int kCh)
bool	doBFieldStudySelection (edm::Handle< reco::TrackCollection > saTracks, edm::Handle< reco::TrackCollection > Tracks, edm::Handle< reco::MuonCollection > gMuons)
bool	doCertainChamberSelection (edm::Handle< CSCWireDigiCollection > wires, edm::Handle< CSCStripDigiCollection > strips)
bool	doCSCSkimming (edm::Handle< CSCRecHit2DCollection > cscRecHits, edm::Handle< CSCSegmentCollection > cscSegments)
bool	doDTOverlap (edm::Handle< CSCSegmentCollection > cscSegments)
bool	doHaloLike (edm::Handle< CSCSegmentCollection > cscSegments)
bool	doLongSATrack (edm::Handle< reco::TrackCollection > saTracks)
bool	doMessyEventSkimming (edm::Handle< CSCRecHit2DCollection > cscRecHits, edm::Handle< CSCSegmentCollection > cscSegments)
bool	doOverlapSkimming (edm::Handle< CSCSegmentCollection > cscSegments)

Private Attributes
bool	demandChambersBothSides
edm::EDGetTokenT< reco::MuonCollection >	glm_token
std::string	histogramFileName
TH1F *	hxnHitChambers
TH1F *	hxnRecHits
TH1F *	hxnRecHitsSel
TH1F *	hxnSegments
int	iEvent
int	iRun
bool	isSimulation
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord >	m_CSCGeomToken
bool	makeHistograms
bool	makeHistogramsForMessyEvents
TH1F *	mevnChambers0
TH1F *	mevnChambers1
TH1F *	mevnRecHits0
TH1F *	mevnRecHits1
TH1F *	mevnSegments0
TH1F *	mevnSegments1
int	minimumHitChambers
int	minimumSegments
int	nCSCHitsMin
int	nEventsAnalyzed
int	nEventsCertainChamber
int	nEventsChambersBothSides
int	nEventsDTOverlap
int	nEventsForBFieldStudies
int	nEventsHaloLike
int	nEventsLongSATrack
int	nEventsMessy
int	nEventsOverlappingChambers
int	nEventsSelected
int	nLayersWithHitsMinimum
int	nTrHitsMin
int	nValidHitsMin
std::string	outputFileName
float	pMin
float	redChiSqMax
float	rExtMax
edm::EDGetTokenT< CSCRecHit2DCollection >	rh_token
edm::EDGetTokenT< reco::TrackCollection >	sam_token
edm::EDGetTokenT< CSCStripDigiCollection >	sdr_token
edm::EDGetTokenT< CSCStripDigiCollection >	sds_token
edm::EDGetTokenT< CSCSegmentCollection >	seg_token
TFile *	theHistogramFile
edm::EDGetTokenT< reco::TrackCollection >	trk_token
int	typeOfSkim
edm::EDGetTokenT< CSCWireDigiCollection >	wdr_token
edm::EDGetTokenT< CSCWireDigiCollection >	wds_token
int	whichChamber
int	whichEndcap
int	whichRing
int	whichStation
TH1F *	xxnCSCHits
TH1F *	xxnTrackerHits
TH1F *	xxnValidHits
TH1F *	xxP
TH1F *	xxredChiSq
float	zInnerMax
float	zLengthMin
float	zLengthTrMin

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

This simple program selects minimal CSC events for output.

Michael Schmitt, Northwestern University, July 2008

Description: Offline skim module for CSC cosmic ray data

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

Definition at line 71 of file CSCSkim.h.

Constructor & Destructor Documentation

CSCSkim()

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

explicit

Definition at line 51 of file CSCSkim.cc.

References demandChambersBothSides, glm_token, histogramFileName, ProducerED_cfi::InputTag, makeHistograms, makeHistogramsForMessyEvents, minimumHitChambers, minimumSegments, nCSCHitsMin, nLayersWithHitsMinimum, nTrHitsMin, nValidHitsMin, outputFileName, pMin, muonDTDigis_cfi::pset, redChiSqMax, rExtMax, rh_token, sam_token, sdr_token, sds_token, seg_token, AlCaHLTBitMon_QueryRunRegistry::string, trk_token, typeOfSkim, wdr_token, wds_token, whichChamber, whichEndcap, whichRing, whichStation, zInnerMax, zLengthMin, and zLengthTrMin.

                                            : m_CSCGeomToken(esConsumes()) {
  // tokens from tags

  // Really should define the wire and digi tags in config, but for now, to avoid having to modify
  // multiple config files, just hard-code those tags, to be equivalent to the pre-consumes code

  //  wds_token = consumes<CSCWireDigiCollection>(pset.getParameter<InputTag>("simWireDigiTag"));
  //  sds_token = consumes<CSCStripDigiCollection>(pset.getParameter<InputTag>("simStripDigiTag"));
  //  wdr_token = consumes<CSCWireDigiCollection>(pset.getParameter<InputTag>("wireDigiTag"));
  //  sdr_token = consumes<CSCStripDigiCollection>(pset.getParameter<InputTag>("stripDigiTag"));

  wds_token = consumes<CSCWireDigiCollection>(edm::InputTag("simMuonCSCDigis", "MuonCSCWireDigi"));
  sds_token = consumes<CSCStripDigiCollection>(edm::InputTag("simMuonCSCDigis", "MuonCSCStripDigi"));
  wdr_token = consumes<CSCWireDigiCollection>(edm::InputTag("muonCSCDigis", "MuonCSCWireDigi"));
  sdr_token = consumes<CSCStripDigiCollection>(edm::InputTag("muonCSCDigis", "MuonCSCStripDigi"));

  rh_token = consumes<CSCRecHit2DCollection>(pset.getParameter<InputTag>("cscRecHitTag"));
  seg_token = consumes<CSCSegmentCollection>(pset.getParameter<InputTag>("cscSegmentTag"));

  sam_token = consumes<reco::TrackCollection>(pset.getParameter<InputTag>("SAMuonTag"));
  trk_token = consumes<reco::TrackCollection>(pset.getParameter<InputTag>("trackTag"));
  glm_token = consumes<reco::MuonCollection>(pset.getParameter<InputTag>("GLBMuonTag"));

  // Get the various input parameters
  outputFileName = pset.getUntrackedParameter<std::string>("outputFileName", "outputSkim.root");
  histogramFileName = pset.getUntrackedParameter<std::string>("histogramFileName", "histos.root");
  typeOfSkim = pset.getUntrackedParameter<int>("typeOfSkim", 1);
  nLayersWithHitsMinimum = pset.getUntrackedParameter<int>("nLayersWithHitsMinimum", 3);
  minimumHitChambers = pset.getUntrackedParameter<int>("minimumHitChambers", 1);
  minimumSegments = pset.getUntrackedParameter<int>("minimumSegments", 3);
  demandChambersBothSides = pset.getUntrackedParameter<bool>("demandChambersBothSides", false);
  makeHistograms = pset.getUntrackedParameter<bool>("makeHistograms", false);
  makeHistogramsForMessyEvents = pset.getUntrackedParameter<bool>("makeHistogramsForMessyEvebts", false);
  whichEndcap = pset.getUntrackedParameter<int>("whichEndcap", 2);
  whichStation = pset.getUntrackedParameter<int>("whichStation", 3);
  whichRing = pset.getUntrackedParameter<int>("whichRing", 2);
  whichChamber = pset.getUntrackedParameter<int>("whichChamber", 24);

  // for BStudy selection (skim type 9)
  pMin = pset.getUntrackedParameter<double>("pMin", 3.);
  zLengthMin = pset.getUntrackedParameter<double>("zLengthMin", 200.);
  nCSCHitsMin = pset.getUntrackedParameter<int>("nCSCHitsMin", 9);
  zInnerMax = pset.getUntrackedParameter<double>("zInnerMax", 9000.);
  nTrHitsMin = pset.getUntrackedParameter<int>("nTrHitsMin", 8);
  zLengthTrMin = pset.getUntrackedParameter<double>("zLengthTrMin", 180.);
  rExtMax = pset.getUntrackedParameter<double>("rExtMax", 3000.);
  redChiSqMax = pset.getUntrackedParameter<double>("redChiSqMax", 20.);
  nValidHitsMin = pset.getUntrackedParameter<int>("nValidHitsMin", 8);

  LogInfo("[CSCSkim] Setup") << "\n\t===== CSCSkim =====\n"
                             << "\t\ttype of skim ...............................\t" << typeOfSkim
                             << "\t\tminimum number of layers with hits .........\t" << nLayersWithHitsMinimum
                             << "\n\t\tminimum number of chambers w/ hit layers..\t" << minimumHitChambers
                             << "\n\t\tminimum number of segments ...............\t" << minimumSegments
                             << "\n\t\tdemand chambers on both sides.............\t" << demandChambersBothSides
                             << "\n\t\tmake histograms...........................\t" << makeHistograms
                             << "\n\t\t..for messy events........................\t" << makeHistogramsForMessyEvents
                             << "\n\t===================\n\n";
}

~CSCSkim()

CSCSkim::~CSCSkim ( )

override

Definition at line 114 of file CSCSkim.cc.

{}

Member Function Documentation

beginJob()

void CSCSkim::beginJob ( )

overridevirtual

Reimplemented from edm::one::EDFilterBase.

Definition at line 119 of file CSCSkim.cc.

References histogramFileName, hxnHitChambers, hxnRecHits, hxnRecHitsSel, hxnSegments, iEvent, iRun, makeHistograms, makeHistogramsForMessyEvents, mevnChambers0, mevnChambers1, mevnRecHits0, mevnRecHits1, mevnSegments0, mevnSegments1, nEventsAnalyzed, nEventsCertainChamber, nEventsChambersBothSides, nEventsDTOverlap, nEventsForBFieldStudies, nEventsHaloLike, nEventsLongSATrack, nEventsMessy, nEventsOverlappingChambers, nEventsSelected, theHistogramFile, xxnCSCHits, xxnTrackerHits, xxnValidHits, xxP, and xxredChiSq.

                       {
  // set counters to zero
  nEventsAnalyzed = 0;
  nEventsSelected = 0;
  nEventsChambersBothSides = 0;
  nEventsOverlappingChambers = 0;
  nEventsMessy = 0;
  nEventsCertainChamber = 0;
  nEventsDTOverlap = 0;
  nEventsHaloLike = 0;
  nEventsLongSATrack = 0;
  nEventsForBFieldStudies = 0;
  iRun = 0;
  iEvent = 0;

  if (makeHistograms || makeHistogramsForMessyEvents) {
    // Create the root file for the histograms
    theHistogramFile = new TFile(histogramFileName.c_str(), "RECREATE");
    theHistogramFile->cd();

    if (makeHistograms) {
      // book histograms for the skimming module
      hxnRecHits = new TH1F("hxnRecHits", "n RecHits", 61, -0.5, 60.5);
      hxnSegments = new TH1F("hxnSegments", "n Segments", 11, -0.5, 10.5);
      hxnHitChambers = new TH1F("hxnHitsChambers", "n chambers with hits", 11, -0.5, 10.5);
      hxnRecHitsSel = new TH1F("hxnRecHitsSel", "n RecHits selected", 61, -0.5, 60.5);

      xxP = new TH1F("xxP", "P global", 100, 0., 200.);
      xxnValidHits = new TH1F("xxnValidHits", "n valid hits global", 61, -0.5, 60.5);
      xxnTrackerHits = new TH1F("xxnTrackerHits", "n tracker hits global", 61, -0.5, 60.5);
      xxnCSCHits = new TH1F("xxnCSCHits", "n CSC hits global", 41, -0.5, 40.5);
      xxredChiSq = new TH1F("xxredChiSq", "red chisq global", 100, 0., 100.);
    }
    if (makeHistogramsForMessyEvents) {
      // book histograms for the messy event skimming module
      mevnRecHits0 = new TH1F("mevnRecHits0", "n RecHits", 121, -0.5, 120.5);
      mevnChambers0 = new TH1F("mevnChambers0", "n chambers with hits", 21, -0.5, 20.5);
      mevnSegments0 = new TH1F("mevnSegments0", "n Segments", 21, -0.5, 20.5);
      mevnRecHits1 = new TH1F("mevnRecHits1", "n RecHits", 100, 0., 300.);
      mevnChambers1 = new TH1F("mevnChambers1", "n chambers with hits", 50, 0., 50.);
      mevnSegments1 = new TH1F("mevnSegments1", "n Segments", 30, 0., 30.);
    }
  }
}

chamberSerial()

int CSCSkim::chamberSerial ( int  kE, int  kS, int  kR, int  kCh  )

private

Definition at line 1280 of file CSCSkim.cc.

Referenced by doCSCSkimming(), doMessyEventSkimming(), and doOverlapSkimming().

                                                                             {
  int kSerial = kChamber;
  if (kStation == 1 && kRing == 1) {
    kSerial = kChamber;
  }
  if (kStation == 1 && kRing == 2) {
    kSerial = kChamber + 36;
  }
  if (kStation == 1 && kRing == 3) {
    kSerial = kChamber + 72;
  }
  if (kStation == 1 && kRing == 4) {
    kSerial = kChamber;
  }
  if (kStation == 2 && kRing == 1) {
    kSerial = kChamber + 108;
  }
  if (kStation == 2 && kRing == 2) {
    kSerial = kChamber + 126;
  }
  if (kStation == 3 && kRing == 1) {
    kSerial = kChamber + 162;
  }
  if (kStation == 3 && kRing == 2) {
    kSerial = kChamber + 180;
  }
  if (kStation == 4 && kRing == 1) {
    kSerial = kChamber + 216;
  }
  if (kStation == 4 && kRing == 2) {
    kSerial = kChamber + 234;
  }  // one day...
  if (kEndcap == 2) {
    kSerial = kSerial + 300;
  }
  return kSerial;
}

doBFieldStudySelection()

bool CSCSkim::doBFieldStudySelection ( edm::Handle< reco::TrackCollection >  saTracks, edm::Handle< reco::TrackCollection >  Tracks, edm::Handle< reco::MuonCollection >  gMuons  )

private

Definition at line 1104 of file CSCSkim.cc.

References funct::abs(), MuonSubdetId::CSC, l1tTrackerHTMiss_cfi::deltaZ, hcalRecHitTable_cff::detId, spr::goodTrack(), trackingPlots::hp, DetId::Muon, HLT_2024v14_cff::muon, create_idmaps::n, nCSCHitsMin, nTrHitsMin, nValidHitsMin, pMin, redChiSqMax, rExtMax, mathSSE::sqrt(), HLT_2024v14_cff::track, DiMuonV_cfg::tracks, zInnerMax, zLengthMin, and zLengthTrMin.

Referenced by filter().

                                                                           {
  bool acceptThisEvent = false;

  //-----------------------------------
  // examine the stand-alone tracks
  //-----------------------------------
  int nGoodSAMuons = 0;
  for (reco::TrackCollection::const_iterator muon = saMuons->begin(); muon != saMuons->end(); ++muon) {
    float preco = muon->p();

    math::XYZPoint innerPo = muon->innerPosition();
    GlobalPoint iPnt(innerPo.x(), innerPo.y(), innerPo.z());
    math::XYZPoint outerPo = muon->outerPosition();
    GlobalPoint oPnt(outerPo.x(), outerPo.y(), outerPo.z());
    float zLength = abs(iPnt.z() - oPnt.z());

    math::XYZVector innerMom = muon->innerMomentum();
    GlobalVector iP(innerMom.x(), innerMom.y(), innerMom.z());
    math::XYZVector outerMom = muon->outerMomentum();
    GlobalVector oP(outerMom.x(), outerMom.y(), outerMom.z());

    const float zRef = 300.;
    float xExt = 10000.;
    float yExt = 10000.;
    if (abs(oPnt.z()) < abs(iPnt.z())) {
      float deltaZ = 0.;
      if (oPnt.z() > 0) {
        deltaZ = zRef - oPnt.z();
      } else {
        deltaZ = -zRef - oPnt.z();
      }
      xExt = oPnt.x() + deltaZ * oP.x() / oP.z();
      yExt = oPnt.y() + deltaZ * oP.y() / oP.z();
    } else {
      float deltaZ = 0.;
      if (iPnt.z() > 0) {
        deltaZ = zRef - iPnt.z();
      } else {
        deltaZ = -zRef - iPnt.z();
      }
      xExt = iPnt.x() + deltaZ * iP.x() / iP.z();
      yExt = iPnt.y() + deltaZ * iP.y() / iP.z();
    }
    float rExt = sqrt(xExt * xExt + yExt * yExt);

    int nCSCHits = 0;
    for (trackingRecHit_iterator hit = muon->recHitsBegin(); hit != muon->recHitsEnd(); ++hit) {
      const DetId detId((*hit)->geographicalId());
      if (detId.det() == DetId::Muon) {
        if (detId.subdetId() == MuonSubdetId::CSC) {
          nCSCHits++;
        }
      }
    }  // end loop over hits

    float zInner = -1.;
    if (nCSCHits >= nCSCHitsMin) {
      if (abs(iPnt.z()) < abs(iPnt.z())) {
        zInner = iPnt.z();
      } else {
        zInner = oPnt.z();
      }
    }

    bool goodSAMuon = (preco > pMin) && (zLength > zLengthMin) && (nCSCHits >= nCSCHitsMin) && (zInner < zInnerMax) &&
                      (rExt < rExtMax);

    if (goodSAMuon) {
      nGoodSAMuons++;
    }

  }  // end loop over stand-alone muon collection

  //-----------------------------------
  // examine the tracker tracks
  //-----------------------------------
  int nGoodTracks = 0;
  for (reco::TrackCollection::const_iterator track = tracks->begin(); track != tracks->end(); ++track) {
    float preco = track->p();
    int n = track->recHitsSize();

    math::XYZPoint innerPo = track->innerPosition();
    GlobalPoint iPnt(innerPo.x(), innerPo.y(), innerPo.z());
    math::XYZPoint outerPo = track->outerPosition();
    GlobalPoint oPnt(outerPo.x(), outerPo.y(), outerPo.z());
    float zLength = abs(iPnt.z() - oPnt.z());

    math::XYZVector innerMom = track->innerMomentum();
    GlobalVector iP(innerMom.x(), innerMom.y(), innerMom.z());
    math::XYZVector outerMom = track->outerMomentum();
    GlobalVector oP(outerMom.x(), outerMom.y(), outerMom.z());

    const float zRef = 300.;
    float xExt = 10000.;
    float yExt = 10000.;
    if (abs(oPnt.z()) > abs(iPnt.z())) {
      float deltaZ = 0.;
      if (oPnt.z() > 0) {
        deltaZ = zRef - oPnt.z();
      } else {
        deltaZ = -zRef - oPnt.z();
      }
      xExt = oPnt.x() + deltaZ * oP.x() / oP.z();
      yExt = oPnt.y() + deltaZ * oP.y() / oP.z();
    } else {
      float deltaZ = 0.;
      if (iPnt.z() > 0) {
        deltaZ = zRef - iPnt.z();
      } else {
        deltaZ = -zRef - iPnt.z();
      }
      xExt = iPnt.x() + deltaZ * iP.x() / iP.z();
      yExt = iPnt.y() + deltaZ * iP.y() / iP.z();
    }
    float rExt = sqrt(xExt * xExt + yExt * yExt);

    bool goodTrack = (preco > pMin) && (n >= nTrHitsMin) && (zLength > zLengthTrMin) && (rExt < rExtMax);

    if (goodTrack) {
      nGoodTracks++;
    }

  }  // end loop over tracker tracks

  //-----------------------------------
  // examine the global muons
  //-----------------------------------
  int nGoodGlobalMuons = 0;
  for (reco::MuonCollection::const_iterator global = gMuons->begin(); global != gMuons->end(); ++global) {
    if (global->isGlobalMuon()) {
      float pDef = global->p();
      float redChiSq = global->globalTrack()->normalizedChi2();
      const reco::HitPattern& hp = (global->globalTrack())->hitPattern();
      // int nTotalHits = hp.numberOfHits();
      //    int nValidHits = hp.numberOfValidHits();
      int nTrackerHits = hp.numberOfValidTrackerHits();
      // int nPixelHits   = hp.numberOfValidPixelHits();
      // int nStripHits   = hp.numberOfValidStripHits();

      int nCSCHits = 0;
      for (trackingRecHit_iterator hit = (global->globalTrack())->recHitsBegin();
           hit != (global->globalTrack())->recHitsEnd();
           ++hit) {
        const DetId detId((*hit)->geographicalId());
        if (detId.det() == DetId::Muon) {
          if (detId.subdetId() == MuonSubdetId::CSC) {
            nCSCHits++;
          }
        }
      }  // end loop over hits

      bool goodGlobalMuon =
          (pDef > pMin) && (nTrackerHits >= nValidHitsMin) && (nCSCHits >= nCSCHitsMin) && (redChiSq < redChiSqMax);

      if (goodGlobalMuon) {
        nGoodGlobalMuons++;
      }

    }  // this is a global muon
  }  // end loop over stand-alone muon collection

  //-----------------------------------
  // do we accept this event?
  //-----------------------------------

  acceptThisEvent = ((nGoodSAMuons > 0) && (nGoodTracks > 0)) || (nGoodGlobalMuons > 0);

  return acceptThisEvent;
}

doCertainChamberSelection()

bool CSCSkim::doCertainChamberSelection ( edm::Handle< CSCWireDigiCollection >  wires, edm::Handle< CSCStripDigiCollection >  strips  )

private

Definition at line 728 of file CSCSkim.cc.

References CSCDetId::endcap(), DigiDM_cff::strips, whichChamber, whichEndcap, whichRing, whichStation, and DigiDM_cff::wires.

Referenced by filter().

                                                                                  {
  // Loop through the wire DIGIs, looking for a match
  bool certainChamberIsPresentInWires = false;
  for (CSCWireDigiCollection::DigiRangeIterator jw = wires->begin(); jw != wires->end(); jw++) {
    CSCDetId id = (CSCDetId)(*jw).first;
    int kEndcap = id.endcap();
    int kRing = id.ring();
    int kStation = id.station();
    int kChamber = id.chamber();
    if ((kEndcap == whichEndcap) && (kStation == whichStation) && (kRing == whichRing) && (kChamber == whichChamber)) {
      certainChamberIsPresentInWires = true;
    }
  }  // end wire loop

  // Loop through the strip DIGIs, looking for a match
  bool certainChamberIsPresentInStrips = false;
  for (CSCStripDigiCollection::DigiRangeIterator js = strips->begin(); js != strips->end(); js++) {
    CSCDetId id = (CSCDetId)(*js).first;
    int kEndcap = id.endcap();
    int kRing = id.ring();
    int kStation = id.station();
    int kChamber = id.chamber();
    if ((kEndcap == whichEndcap) && (kStation == whichStation) && (kRing == whichRing) && (kChamber == whichChamber)) {
      certainChamberIsPresentInStrips = true;
    }
  }

  bool certainChamberIsPresent = certainChamberIsPresentInWires || certainChamberIsPresentInStrips;

  return certainChamberIsPresent;
}

doCSCSkimming()

bool CSCSkim::doCSCSkimming ( edm::Handle< CSCRecHit2DCollection >  cscRecHits, edm::Handle< CSCSegmentCollection >  cscSegments  )

private

Definition at line 375 of file CSCSkim.cc.

References CSCDetId::chamber(), chamberSerial(), dtChamberEfficiency_cfi::cscSegments, CSCDetId::endcap(), ALCARECOEcalPhiSym_cff::float, hxnHitChambers, hxnRecHits, hxnRecHitsSel, hxnSegments, mps_fire::i, createfilelist::int, dqmiolumiharvest::j, kLayer(), CSCDetId::layer(), LogDebug, makeHistograms, minimumHitChambers, minimumSegments, nEventsChambersBothSides, nLayersWithHitsMinimum, funct::pow(), CSCDetId::ring(), CSCDetId::station(), and typeOfSkim.

Referenced by filter().

                                                                         {
  // how many RecHits in the collection?
  int nRecHits = cscRecHits->size();

  // zero the recHit counter
  int cntRecHit[600];
  for (int i = 0; i < 600; i++) {
    cntRecHit[i] = 0;
  }

  // ---------------------
  // Loop over rechits
  // ---------------------

  CSCRecHit2DCollection::const_iterator recIt;
  for (recIt = cscRecHits->begin(); recIt != cscRecHits->end(); recIt++) {
    // which chamber is it?
    CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
    int kEndcap = idrec.endcap();
    int kRing = idrec.ring();
    int kStation = idrec.station();
    int kChamber = idrec.chamber();
    int kLayer = idrec.layer();

    // compute chamber serial number
    int kSerial = chamberSerial(kEndcap, kStation, kRing, kChamber);

    // increment recHit counter
    //     (each layer is represented by a different power of 10)
    int kDigit = (int)pow((float)10., (float)(kLayer - 1));
    cntRecHit[kSerial] += kDigit;

  }  //end rechit loop

  // ------------------------------------------------------
  // Are there chambers with the minimum number of hits?
  // ------------------------------------------------------

  int nChambersWithMinimalHits = 0;
  int nChambersWithMinimalHitsPOS = 0;
  int nChambersWithMinimalHitsNEG = 0;
  if (nRecHits > 0) {
    for (int i = 0; i < 600; i++) {
      if (cntRecHit[i] > 0) {
        int nLayersWithHits = 0;
        float dummy = (float)cntRecHit[i];
        for (int j = 5; j > -1; j--) {
          float digit = dummy / pow((float)10., (float)j);
          int kCount = (int)digit;
          if (kCount > 0)
            nLayersWithHits++;
          dummy = dummy - ((float)kCount) * pow((float)10., (float)j);
        }
        if (nLayersWithHits > nLayersWithHitsMinimum) {
          if (i < 300) {
            nChambersWithMinimalHitsPOS++;
          } else {
            nChambersWithMinimalHitsNEG++;
          }
        }
      }
    }
    nChambersWithMinimalHits = nChambersWithMinimalHitsPOS + nChambersWithMinimalHitsNEG;
  }

  // how many Segments?
  int nSegments = cscSegments->size();

  // ----------------------
  // fill histograms
  // ----------------------

  if (makeHistograms) {
    hxnRecHits->Fill(nRecHits);
    if (nRecHits > 0) {
      hxnSegments->Fill(nSegments);
      hxnHitChambers->Fill(nChambersWithMinimalHits);
    }
    if (nChambersWithMinimalHits > 0) {
      hxnRecHitsSel->Fill(nRecHits);
    }
  }

  // ----------------------
  // set the filter flag
  // ----------------------
  bool basicEvent = (nChambersWithMinimalHits >= minimumHitChambers) && (nSegments >= minimumSegments);

  bool chambersOnBothSides =
      ((nChambersWithMinimalHitsPOS >= minimumHitChambers) && (nChambersWithMinimalHitsNEG >= minimumHitChambers));

  if (chambersOnBothSides) {
    nEventsChambersBothSides++;
  }

  bool selectEvent = false;
  if (typeOfSkim == 1) {
    selectEvent = basicEvent;
  }
  if (typeOfSkim == 2) {
    selectEvent = chambersOnBothSides;
  }

  // debug
  LogDebug("[CSCSkim]") << "----- nRecHits = " << nRecHits
                        << "\tnChambersWithMinimalHits = " << nChambersWithMinimalHits << "\tnSegments = " << nSegments
                        << "\tselect? " << selectEvent << std::endl;

  /*
  if ((nChambersWithMinimalHitsPOS >= minimumHitChambers) && (nChambersWithMinimalHitsNEG >= minimumHitChambers)) {
    std::cout << "\n==========================================================================\n"
     << "\tinteresting event - chambers hit on both sides\n"
     << "\t  " <<  nEventsAnalyzed
     << "\trun " << iRun << "\tevent " << iEvent << std::endl;
    std::cout << "----- nRecHits = " << nRecHits
     << "\tnChambersWithMinimalHits = " << nChambersWithMinimalHits
     << "\tnSegments = " << nSegments 
     << "\tselect? " << selectEvent << std::endl;
    for (int i = 0; i < 600; i++) {
      if (cntRecHit[i] > 0) {
    cout << "\t\t" << i << "\tcntRecHit= " << cntRecHit[i] << std::endl;
      }
    }
    std::cout << "==========================================================================\n\n" ;
  }
  */

  return selectEvent;
}

doDTOverlap()

bool CSCSkim::doDTOverlap ( edm::Handle< CSCSegmentCollection >  cscSegments )

private

Definition at line 766 of file CSCSkim.cc.

References dtChamberEfficiency_cfi::cscSegments, CSCDetId::endcap(), mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and TrackingDataMCValidation_Standalone_cff::nhits.

Referenced by filter().

                                                                  {
  const float chisqMax = 100.;
  const int nhitsMin = 5;
  const int maxNSegments = 3;

  // initialize
  bool DTOverlapCandidate = false;
  int cntMEP13[36];
  int cntMEN13[36];
  int cntMEP22[36];
  int cntMEN22[36];
  int cntMEP32[36];
  int cntMEN32[36];
  for (int i = 0; i < 36; ++i) {
    cntMEP13[i] = 0;
    cntMEN13[i] = 0;
    cntMEP22[i] = 0;
    cntMEN22[i] = 0;
    cntMEP32[i] = 0;
    cntMEN32[i] = 0;
  }

  // -----------------------
  // loop over segments
  // -----------------------

  int nSegments = cscSegments->size();
  if (nSegments < 2)
    return DTOverlapCandidate;

  for (CSCSegmentCollection::const_iterator it = cscSegments->begin(); it != cscSegments->end(); it++) {
    // which chamber?
    CSCDetId id = (CSCDetId)(*it).cscDetId();
    int kEndcap = id.endcap();
    int kStation = id.station();
    int kRing = id.ring();
    int kChamber = id.chamber();
    // segment information
    float chisq = (*it).chi2();
    int nhits = (*it).nRecHits();
    bool goodSegment = (chisq < chisqMax) && (nhits >= nhitsMin);
    if (goodSegment) {
      if ((kStation == 1) && (kRing == 3)) {
        if (kEndcap == 1) {
          cntMEP13[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN13[kChamber - 1]++;
        }
      }
      if ((kStation == 2) && (kRing == 2)) {
        if (kEndcap == 1) {
          cntMEP22[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN22[kChamber - 1]++;
        }
      }
      if ((kStation == 3) && (kRing == 2)) {
        if (kEndcap == 1) {
          cntMEP32[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN32[kChamber - 1]++;
        }
      }
    }  // this is a good segment
  }  // end loop over segments

  // ---------------------------------------------
  // veto messy events
  // ---------------------------------------------
  bool tooManySegments = false;
  for (int i = 0; i < 36; ++i) {
    if ((cntMEP13[i] > maxNSegments) || (cntMEN13[i] > maxNSegments) || (cntMEP22[i] > maxNSegments) ||
        (cntMEN22[i] > maxNSegments) || (cntMEP32[i] > maxNSegments) || (cntMEN32[i] > maxNSegments))
      tooManySegments = true;
  }
  if (tooManySegments) {
    return DTOverlapCandidate;
  }

  // ---------------------------------------------
  // check for relevant matchup of segments
  // ---------------------------------------------
  bool matchup = false;
  for (int i = 0; i < 36; ++i) {
    if ((cntMEP13[i] > 0) && (cntMEP22[i] + cntMEP32[i] > 0)) {
      matchup = true;
    }
    if ((cntMEN13[i] > 0) && (cntMEN22[i] + cntMEN32[i] > 0)) {
      matchup = true;
    }
  }
  /*
  if (matchup) {
    std::cout << "\tYYY looks like a good event.  Select!\n";
    std::cout << "-- pos endcap --\n"
     << "ME1/3: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP13[k];}
    std::cout << "\nME2/2: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP22[k];}
    std::cout << "\nME3/2: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP32[k];}
    std::cout << std::endl;
  }
  */

  // set the selection flag
  DTOverlapCandidate = matchup;
  return DTOverlapCandidate;
}

doHaloLike()

bool CSCSkim::doHaloLike ( edm::Handle< CSCSegmentCollection >  cscSegments )

private

Definition at line 885 of file CSCSkim.cc.

References dtChamberEfficiency_cfi::cscSegments, CSCDetId::endcap(), mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and TrackingDataMCValidation_Standalone_cff::nhits.

Referenced by filter().

                                                                 {
  const float chisqMax = 100.;
  const int nhitsMin = 5;      // on a segment
  const int maxNSegments = 3;  // in a chamber

  // initialize
  bool HaloLike = false;
  int cntMEP11[36];
  int cntMEN11[36];
  int cntMEP12[36];
  int cntMEN12[36];
  int cntMEP21[36];
  int cntMEN21[36];
  int cntMEP31[36];
  int cntMEN31[36];
  int cntMEP41[36];
  int cntMEN41[36];
  for (int i = 0; i < 36; ++i) {
    cntMEP11[i] = 0;
    cntMEN11[i] = 0;
    cntMEP12[i] = 0;
    cntMEN12[i] = 0;
    cntMEP21[i] = 0;
    cntMEN21[i] = 0;
    cntMEP31[i] = 0;
    cntMEN31[i] = 0;
    cntMEP41[i] = 0;
    cntMEN41[i] = 0;
  }

  // -----------------------
  // loop over segments
  // -----------------------
  int nSegments = cscSegments->size();
  if (nSegments < 4)
    return HaloLike;

  for (CSCSegmentCollection::const_iterator it = cscSegments->begin(); it != cscSegments->end(); it++) {
    // which chamber?
    CSCDetId id = (CSCDetId)(*it).cscDetId();
    int kEndcap = id.endcap();
    int kStation = id.station();
    int kRing = id.ring();
    int kChamber = id.chamber();
    // segment information
    float chisq = (*it).chi2();
    int nhits = (*it).nRecHits();
    bool goodSegment = (chisq < chisqMax) && (nhits >= nhitsMin);
    if (goodSegment) {
      if ((kStation == 1) && (kRing == 1)) {
        if (kEndcap == 1) {
          cntMEP11[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN11[kChamber - 1]++;
        }
      }
      if ((kStation == 1) && (kRing == 2)) {
        if (kEndcap == 1) {
          cntMEP12[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN12[kChamber - 1]++;
        }
      }
      if ((kStation == 2) && (kRing == 1)) {
        if (kEndcap == 1) {
          cntMEP21[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN21[kChamber - 1]++;
        }
      }
      if ((kStation == 3) && (kRing == 1)) {
        if (kEndcap == 1) {
          cntMEP31[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN31[kChamber - 1]++;
        }
      }
      if ((kStation == 4) && (kRing == 1)) {
        if (kEndcap == 1) {
          cntMEP41[kChamber - 1]++;
        }
        if (kEndcap == 2) {
          cntMEN41[kChamber - 1]++;
        }
      }
    }  // this is a good segment
  }  // end loop over segments

  // ---------------------------------------------
  // veto messy events
  // ---------------------------------------------
  bool tooManySegments = false;
  for (int i = 0; i < 36; ++i) {
    if ((cntMEP11[i] > 3 * maxNSegments) || (cntMEN11[i] > 3 * maxNSegments) || (cntMEP12[i] > maxNSegments) ||
        (cntMEN12[i] > maxNSegments) || (cntMEP21[i] > maxNSegments) || (cntMEN21[i] > maxNSegments) ||
        (cntMEP31[i] > maxNSegments) || (cntMEN31[i] > maxNSegments) || (cntMEP41[i] > maxNSegments) ||
        (cntMEN41[i] > maxNSegments))
      tooManySegments = true;
  }
  if (tooManySegments) {
    return HaloLike;
  }

  // ---------------------------------------------
  // check for relevant matchup of segments
  // ---------------------------------------------
  bool matchup = false;
  for (int i = 0; i < 36; ++i) {
    if ((cntMEP11[i] + cntMEP12[i] > 0) && (cntMEP21[i] > 0) && (cntMEP31[i] > 0) && (cntMEP41[i] > 0)) {
      matchup = true;
    }
    if ((cntMEN11[i] + cntMEN12[i] > 0) && (cntMEN21[i] > 0) && (cntMEN31[i] > 0) && (cntMEN41[i] > 0)) {
      matchup = true;
    }
  }
  /*
  if (matchup) {
    std::cout << "\tYYY looks like a good event.  Select!\n";
    std::cout << "-- pos endcap --\n"
     << "ME1/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP11[k];}
    std::cout << "\nME1/2: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP12[k];}
    std::cout << "\nME2/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP21[k];}
    std::cout << "\nME3/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP31[k];}
    std::cout << "\nME4/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEP41[k];}
    std::cout << std::endl;
    std::cout << "-- neg endcap --\n"
     << "ME1/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEN11[k];}
    std::cout << "\nME1/2: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEN12[k];}
    std::cout << "\nME2/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEN21[k];}
    std::cout << "\nME3/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEN31[k];}
    std::cout << "\nME4/1: ";
    for (int k=0; k<36; ++k) {std::cout << " " << setw(3) << cntMEN41[k];}
    std::cout << std::endl;
    std::cout << "\tn Analyzed = " << nEventsAnalyzed << "\tn Halo-like = " << nEventsHaloLike << std::endl;
  }
  */

  // set the selection flag
  HaloLike = matchup;
  return HaloLike;
}

doLongSATrack()

bool CSCSkim::doLongSATrack ( edm::Handle< reco::TrackCollection >  saTracks )

private

Definition at line 1043 of file CSCSkim.cc.

References MuonSubdetId::CSC, hcalRecHitTable_cff::detId, SiStripPI::min, DetId::Muon, HLT_2024v14_cff::muon, nCSCHitsMin, findAndChange::op, singleTopDQM_cfi::select, and zInnerMax.

Referenced by filter().

                                                                  {
  const float zDistanceMax = 2500.;
  const float zDistanceMin = 700.;
  const int nCSCHitsMin = 25;
  const int nCSCHitsMax = 50;
  const float zInnerMax = 80000.;

  const int nNiceMuonsMin = 1;

  //
  // Loop through the track collection and test each one
  //

  int nNiceMuons = 0;

  for (reco::TrackCollection::const_iterator muon = saMuons->begin(); muon != saMuons->end(); ++muon) {
    // basic information
    math::XYZVector innerMo = muon->innerMomentum();
    GlobalVector im(innerMo.x(), innerMo.y(), innerMo.z());
    math::XYZPoint innerPo = muon->innerPosition();
    GlobalPoint ip(innerPo.x(), innerPo.y(), innerPo.z());
    math::XYZPoint outerPo = muon->outerPosition();
    GlobalPoint op(outerPo.x(), outerPo.y(), outerPo.z());
    float zInner = ip.z();
    float zOuter = op.z();
    float zDistance = fabs(zOuter - zInner);

    // loop over hits
    int nCSCHits = 0;
    for (trackingRecHit_iterator hit = muon->recHitsBegin(); hit != muon->recHitsEnd(); ++hit) {
      const DetId detId((*hit)->geographicalId());
      if (detId.det() == DetId::Muon) {
        if (detId.subdetId() == MuonSubdetId::CSC) {
          //CSCDetId cscId(detId.rawId());
          //int chamberId = cscId.chamber();
          nCSCHits++;
        }
      }
    }

    // is this a nice muon?
    if ((zDistance < zDistanceMax) && (zDistance > zDistanceMin) && (nCSCHits > nCSCHitsMin) &&
        (nCSCHits < nCSCHitsMax) && (min(fabs(zInner), fabs(zOuter)) < zInnerMax) &&
        (fabs(innerMo.z()) > 0.000000001)) {
      nNiceMuons++;
    }
  }

  bool select = (nNiceMuons >= nNiceMuonsMin);

  return select;
}

doMessyEventSkimming()

bool CSCSkim::doMessyEventSkimming ( edm::Handle< CSCRecHit2DCollection >  cscRecHits, edm::Handle< CSCSegmentCollection >  cscSegments  )

private

Definition at line 592 of file CSCSkim.cc.

References CSCDetId::chamber(), chamberSerial(), dtChamberEfficiency_cfi::cscSegments, CSCDetId::endcap(), ALCARECOEcalPhiSym_cff::float, mps_fire::i, createfilelist::int, dqmiolumiharvest::j, kLayer(), CSCDetId::layer(), LogDebug, makeHistogramsForMessyEvents, mevnChambers0, mevnChambers1, mevnRecHits0, mevnRecHits1, mevnSegments0, mevnSegments1, nLayersWithHitsMinimum, funct::pow(), CSCDetId::ring(), and CSCDetId::station().

Referenced by filter().

                                                                                {
  // how many RecHits in the collection?
  int nRecHits = cscRecHits->size();

  // zero the recHit counter
  int cntRecHit[600];
  for (int i = 0; i < 600; i++) {
    cntRecHit[i] = 0;
  }

  // ---------------------
  // Loop over rechits
  // ---------------------

  CSCRecHit2DCollection::const_iterator recIt;
  for (recIt = cscRecHits->begin(); recIt != cscRecHits->end(); recIt++) {
    // which chamber is it?
    CSCDetId idrec = (CSCDetId)(*recIt).cscDetId();
    int kEndcap = idrec.endcap();
    int kRing = idrec.ring();
    int kStation = idrec.station();
    int kChamber = idrec.chamber();
    int kLayer = idrec.layer();

    // compute chamber serial number
    int kSerial = chamberSerial(kEndcap, kStation, kRing, kChamber);

    // increment recHit counter
    //     (each layer is represented by a different power of 10)
    int kDigit = (int)pow((float)10., (float)(kLayer - 1));
    cntRecHit[kSerial] += kDigit;

  }  //end rechit loop

  // ------------------------------------------------------
  // Are there chambers with the minimum number of hits?
  // ------------------------------------------------------

  int nChambersWithMinimalHits = 0;
  int nChambersWithMinimalHitsPOS = 0;
  int nChambersWithMinimalHitsNEG = 0;
  if (nRecHits > 0) {
    for (int i = 0; i < 600; i++) {
      if (cntRecHit[i] > 0) {
        int nLayersWithHits = 0;
        float dummy = (float)cntRecHit[i];
        for (int j = 5; j > -1; j--) {
          float digit = dummy / pow((float)10., (float)j);
          int kCount = (int)digit;
          if (kCount > 0)
            nLayersWithHits++;
          dummy = dummy - ((float)kCount) * pow((float)10., (float)j);
        }
        if (nLayersWithHits > nLayersWithHitsMinimum) {
          if (i < 300) {
            nChambersWithMinimalHitsPOS++;
          } else {
            nChambersWithMinimalHitsNEG++;
          }
        }
      }
    }
    nChambersWithMinimalHits = nChambersWithMinimalHitsPOS + nChambersWithMinimalHitsNEG;
  }

  // how many Segments?
  int nSegments = cscSegments->size();

  // ----------------------
  // fill histograms
  // ----------------------

  if (makeHistogramsForMessyEvents) {
    if (nRecHits > 8) {
      mevnRecHits0->Fill(nRecHits);
      mevnChambers0->Fill(nChambersWithMinimalHits);
      mevnSegments0->Fill(nSegments);
    }
    if (nRecHits > 54) {
      double dummy = (double)nRecHits;
      if (dummy > 299.9)
        dummy = 299.9;
      mevnRecHits1->Fill(dummy);
      dummy = (double)nChambersWithMinimalHits;
      if (dummy > 49.9)
        dummy = 49.9;
      mevnChambers1->Fill(dummy);
      dummy = (double)nSegments;
      if (dummy > 29.9)
        dummy = 29.9;
      mevnSegments1->Fill(dummy);
    }
  }

  // ----------------------
  // set the filter flag
  // ----------------------

  bool selectEvent = false;
  if ((nRecHits > 54) && (nChambersWithMinimalHits > 5)) {
    selectEvent = true;
  }

  // debug
  LogDebug("[CSCSkim]") << "----- nRecHits = " << nRecHits
                        << "\tnChambersWithMinimalHits = " << nChambersWithMinimalHits << "\tnSegments = " << nSegments
                        << "\tselect? " << selectEvent << std::endl;

  /*
  if (selectEvent) {
    std::cout << "\n==========================================================================\n"
     << "\tmessy event!\n"
     << "\t  " <<  nEventsAnalyzed
     << "\trun " << iRun << "\tevent " << iEvent << std::endl;
    std::cout << "----- nRecHits = " << nRecHits
     << "\tnChambersWithMinimalHits = " << nChambersWithMinimalHits
     << "\tnSegments = " << nSegments 
     << "\tselect? " << selectEvent << std::endl;
    for (int i = 0; i < 600; i++) {
      if (cntRecHit[i] > 0) {
    cout << "\t\t" << i << "\tcntRecHit= " << cntRecHit[i] << std::endl;
      }
    }
    std::cout << "==========================================================================\n\n" ;
  }
  */

  return selectEvent;
}

doOverlapSkimming()

bool CSCSkim::doOverlapSkimming ( edm::Handle< CSCSegmentCollection >  cscSegments )

private

Definition at line 510 of file CSCSkim.cc.

References chamberSerial(), dtChamberEfficiency_cfi::cscSegments, CSCDetId::endcap(), mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and TrackingDataMCValidation_Standalone_cff::nhits.

Referenced by filter().

                                                                           {
  const int nhitsMinimum = 4;
  const float chisqMaximum = 100.;
  const int nAllMaximum = 3;

  // how many Segments?
  //  int nSegments = cscSegments->size();

  // zero arrays
  int nAll[600];
  int nGood[600];
  for (int i = 0; i < 600; i++) {
    nAll[i] = 0;
    nGood[i] = 0;
  }

  // -----------------------
  // loop over segments
  // -----------------------
  for (CSCSegmentCollection::const_iterator it = cscSegments->begin(); it != cscSegments->end(); it++) {
    // which chamber?
    CSCDetId id = (CSCDetId)(*it).cscDetId();
    int kEndcap = id.endcap();
    int kStation = id.station();
    int kRing = id.ring();
    int kChamber = id.chamber();
    int kSerial = chamberSerial(kEndcap, kStation, kRing, kChamber);

    // segment information
    float chisq = (*it).chi2();
    int nhits = (*it).nRecHits();

    // is this a good segment?
    bool goodSegment = (nhits >= nhitsMinimum) && (chisq < chisqMaximum);

    /*
    LocalPoint localPos = (*it).localPosition();
    float segX     = localPos.x();
    float segY     = localPos.y();
    std::cout << "E/S/R/Ch: " << kEndcap << "/" << kStation << "/" << kRing << "/" << kChamber
     << "\tnhits/chisq: " << nhits << "/" << chisq
     << "\tX/Y: " << segX << "/" << segY
     << "\tgood? " << goodSegment << std::endl;
    */

    // count
    nAll[kSerial - 1]++;
    if (goodSegment)
      nGood[kSerial]++;

  }  // end loop over segments

  //----------------------
  // select the event
  //----------------------

  // does any chamber have too many segments?
  bool messyChamber = false;
  for (int i = 0; i < 600; i++) {
    if (nAll[i] > nAllMaximum)
      messyChamber = true;
  }

  // are there consecutive chambers with good segments
  // (This is a little sloppy but is probably fine for skimming...)
  bool consecutiveChambers = false;
  for (int i = 0; i < 599; i++) {
    if ((nGood[i] > 0) && (nGood[i + 1] > 0))
      consecutiveChambers = true;
  }

  bool selectThisEvent = !messyChamber && consecutiveChambers;

  return selectThisEvent;
}

endJob()

void CSCSkim::endJob ( void  )

overridevirtual

Reimplemented from edm::one::EDFilterBase.

Definition at line 167 of file CSCSkim.cc.

References ALCARECOEcalPhiSym_cff::float, HLT_2024v14_cff::fraction, hxnHitChambers, hxnRecHits, hxnRecHitsSel, hxnSegments, LogDebug, makeHistograms, makeHistogramsForMessyEvents, mevnChambers0, mevnChambers1, mevnRecHits0, mevnRecHits1, mevnSegments0, mevnSegments1, nEventsAnalyzed, nEventsCertainChamber, nEventsChambersBothSides, nEventsDTOverlap, nEventsForBFieldStudies, nEventsHaloLike, nEventsLongSATrack, nEventsMessy, nEventsOverlappingChambers, nEventsSelected, theHistogramFile, and typeOfSkim.

                     {
  // Write out results

  float fraction = 0.;
  if (nEventsAnalyzed > 0) {
    fraction = (float)nEventsSelected / (float)nEventsAnalyzed;
  }

  LogInfo("[CSCSkim] Summary") << "\n\n\t====== CSCSkim ==========================================================\n"
                               << "\t\ttype of skim ...............................\t" << typeOfSkim << "\n"
                               << "\t\tevents analyzed ..............\t" << nEventsAnalyzed << "\n"
                               << "\t\tevents selected ..............\t" << nEventsSelected
                               << "\tfraction= " << fraction << std::endl
                               << "\t\tevents chambers both sides ...\t" << nEventsChambersBothSides << "\n"
                               << "\t\tevents w/ overlaps .......... \t" << nEventsOverlappingChambers << "\n"
                               << "\t\tevents lots of hit chambers . \t" << nEventsMessy << "\n"
                               << "\t\tevents from certain chamber . \t" << nEventsCertainChamber << "\n"
                               << "\t\tevents in DT-CSC overlap .... \t" << nEventsDTOverlap << "\n"
                               << "\t\tevents halo-like ............ \t" << nEventsHaloLike << "\n"
                               << "\t\tevents w/ long SA track ..... \t" << nEventsLongSATrack << "\n"
                               << "\t\tevents good for BField  ..... \t" << nEventsForBFieldStudies << "\n"
                               << "\t=========================================================================\n\n";

  if (makeHistograms || makeHistogramsForMessyEvents) {
    // Write the histos to file
    LogDebug("[CSCSkim]") << "======= write out my histograms ====\n";
    theHistogramFile->cd();
    if (makeHistograms) {
      hxnRecHits->Write();
      hxnSegments->Write();
      hxnHitChambers->Write();
      hxnRecHitsSel->Write();
    }
    if (makeHistogramsForMessyEvents) {
      mevnRecHits0->Write();
      mevnChambers0->Write();
      mevnSegments0->Write();
      mevnRecHits1->Write();
      mevnChambers1->Write();
      mevnSegments1->Write();
    }
    theHistogramFile->Close();
  }
}

filter()

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

overridevirtual

Implements edm::one::EDFilterBase.

Definition at line 215 of file CSCSkim.cc.

References dtChamberEfficiency_cfi::cscSegments, doBFieldStudySelection(), doCertainChamberSelection(), doCSCSkimming(), doDTOverlap(), doHaloLike(), doLongSATrack(), doMessyEventSkimming(), doOverlapSkimming(), options_cfi::eventSetup, glm_token, iEvent, iRun, LogDebug, m_CSCGeomToken, nEventsAnalyzed, nEventsCertainChamber, nEventsDTOverlap, nEventsForBFieldStudies, nEventsHaloLike, nEventsLongSATrack, nEventsMessy, nEventsOverlappingChambers, nEventsSelected, rh_token, sam_token, sdr_token, sds_token, seg_token, DigiDM_cff::strips, DiMuonV_cfg::tracks, trk_token, typeOfSkim, wdr_token, wds_token, and DigiDM_cff::wires.

                                                                     {
  // increment counter
  nEventsAnalyzed++;

  iRun = event.id().run();
  iEvent = event.id().event();

  LogDebug("[CSCSkim] EventInfo") << "Run: " << iRun << "\tEvent: " << iEvent << "\tn Analyzed: " << nEventsAnalyzed;

  // Get the CSC Geometry :
  ESHandle<CSCGeometry> cscGeom = eventSetup.getHandle(m_CSCGeomToken);

  // Get the DIGI collections
  edm::Handle<CSCWireDigiCollection> wires;
  edm::Handle<CSCStripDigiCollection> strips;

  if (event.eventAuxiliary().isRealData()) {
    event.getByToken(wdr_token, wires);
    event.getByToken(sdr_token, strips);
  } else {
    event.getByToken(wds_token, wires);
    event.getByToken(sds_token, strips);
  }

  // Get the RecHits collection :
  Handle<CSCRecHit2DCollection> cscRecHits;
  event.getByToken(rh_token, cscRecHits);

  // get CSC segment collection
  Handle<CSCSegmentCollection> cscSegments;
  event.getByToken(seg_token, cscSegments);

  // get the cosmic muons collection
  Handle<reco::TrackCollection> saMuons;
  if (typeOfSkim == 8) {
    event.getByToken(sam_token, saMuons);
  }

  // get the stand-alone muons collection
  Handle<reco::TrackCollection> tracks;
  Handle<reco::MuonCollection> gMuons;
  if (typeOfSkim == 9) {
    event.getByToken(sam_token, saMuons);
    event.getByToken(trk_token, tracks);
    event.getByToken(glm_token, gMuons);
  }

  //======================================
  // evaluate the skimming routines
  //======================================

  // basic skimming
  bool basicEvent = false;
  if (typeOfSkim == 1 || typeOfSkim == 2) {
    basicEvent = doCSCSkimming(cscRecHits, cscSegments);
  }

  // overlapping chamber skim
  bool goodOverlapEvent = false;
  if (typeOfSkim == 3) {
    goodOverlapEvent = doOverlapSkimming(cscSegments);
    if (goodOverlapEvent) {
      nEventsOverlappingChambers++;
    }
  }

  // messy events skim
  bool messyEvent = false;
  if (typeOfSkim == 4) {
    messyEvent = doMessyEventSkimming(cscRecHits, cscSegments);
    if (messyEvent) {
      nEventsMessy++;
    }
  }

  // select events with DIGIs in a certain chamber
  bool hasChamber = false;
  if (typeOfSkim == 5) {
    hasChamber = doCertainChamberSelection(wires, strips);
    if (hasChamber) {
      nEventsCertainChamber++;
    }
  }

  // select events in the DT-CSC overlap region
  bool DTOverlapCandidate = false;
  if (typeOfSkim == 6) {
    DTOverlapCandidate = doDTOverlap(cscSegments);
    if (DTOverlapCandidate) {
      nEventsDTOverlap++;
    }
  }

  // select halo-like events
  bool HaloLike = false;
  if (typeOfSkim == 7) {
    HaloLike = doHaloLike(cscSegments);
    if (HaloLike) {
      nEventsHaloLike++;
    }
  }

  // select long cosmic tracks
  bool LongSATrack = false;
  if (typeOfSkim == 8) {
    LongSATrack = doLongSATrack(saMuons);
    if (LongSATrack) {
      nEventsLongSATrack++;
    }
  }

  // select events suitable for a B-field study.  They have tracks in the tracker.
  bool GoodForBFieldStudy = false;
  if (typeOfSkim == 9) {
    GoodForBFieldStudy = doBFieldStudySelection(saMuons, tracks, gMuons);
    if (GoodForBFieldStudy) {
      nEventsForBFieldStudies++;
    }
  }

  // set filter flag
  bool selectThisEvent = false;
  if (typeOfSkim == 1 || typeOfSkim == 2) {
    selectThisEvent = basicEvent;
  }
  if (typeOfSkim == 3) {
    selectThisEvent = goodOverlapEvent;
  }
  if (typeOfSkim == 4) {
    selectThisEvent = messyEvent;
  }
  if (typeOfSkim == 5) {
    selectThisEvent = hasChamber;
  }
  if (typeOfSkim == 6) {
    selectThisEvent = DTOverlapCandidate;
  }
  if (typeOfSkim == 7) {
    selectThisEvent = HaloLike;
  }
  if (typeOfSkim == 8) {
    selectThisEvent = LongSATrack;
  }
  if (typeOfSkim == 9) {
    selectThisEvent = GoodForBFieldStudy;
  }

  if (selectThisEvent) {
    nEventsSelected++;
  }

  return selectThisEvent;
}

Member Data Documentation

demandChambersBothSides

bool CSCSkim::demandChambersBothSides

private

Definition at line 160 of file CSCSkim.h.

Referenced by CSCSkim().

glm_token

edm::EDGetTokenT<reco::MuonCollection> CSCSkim::glm_token

private

Definition at line 152 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

histogramFileName

std::string CSCSkim::histogramFileName

private

Definition at line 137 of file CSCSkim.h.

Referenced by beginJob(), and CSCSkim().

hxnHitChambers

TH1F* CSCSkim::hxnHitChambers

private

Definition at line 181 of file CSCSkim.h.

Referenced by beginJob(), doCSCSkimming(), and endJob().

hxnRecHits

TH1F* CSCSkim::hxnRecHits

private

Definition at line 179 of file CSCSkim.h.

Referenced by beginJob(), doCSCSkimming(), and endJob().

hxnRecHitsSel

TH1F* CSCSkim::hxnRecHitsSel

private

Definition at line 182 of file CSCSkim.h.

Referenced by beginJob(), doCSCSkimming(), and endJob().

hxnSegments

TH1F* CSCSkim::hxnSegments

private

Definition at line 180 of file CSCSkim.h.

Referenced by beginJob(), doCSCSkimming(), and endJob().

iEvent

int CSCSkim::iEvent

private

Definition at line 130 of file CSCSkim.h.

Referenced by beginJob(), and filter().

iRun

int CSCSkim::iRun

private

Definition at line 129 of file CSCSkim.h.

Referenced by beginJob(), and filter().

isSimulation

bool CSCSkim::isSimulation

private

Definition at line 155 of file CSCSkim.h.

m_CSCGeomToken

const edm::ESGetToken<CSCGeometry, MuonGeometryRecord> CSCSkim::m_CSCGeomToken

private

Definition at line 140 of file CSCSkim.h.

Referenced by filter().

makeHistograms

bool CSCSkim::makeHistograms

private

Definition at line 161 of file CSCSkim.h.

Referenced by beginJob(), CSCSkim(), doCSCSkimming(), and endJob().

makeHistogramsForMessyEvents

bool CSCSkim::makeHistogramsForMessyEvents

private

Definition at line 162 of file CSCSkim.h.

Referenced by beginJob(), CSCSkim(), doMessyEventSkimming(), and endJob().

mevnChambers0

TH1F* CSCSkim::mevnChambers0

private

Definition at line 184 of file CSCSkim.h.

Referenced by beginJob(), doMessyEventSkimming(), and endJob().

mevnChambers1

TH1F* CSCSkim::mevnChambers1

private

Definition at line 187 of file CSCSkim.h.

Referenced by beginJob(), doMessyEventSkimming(), and endJob().

mevnRecHits0

TH1F* CSCSkim::mevnRecHits0

private

Definition at line 183 of file CSCSkim.h.

Referenced by beginJob(), doMessyEventSkimming(), and endJob().

mevnRecHits1

TH1F* CSCSkim::mevnRecHits1

private

Definition at line 186 of file CSCSkim.h.

Referenced by beginJob(), doMessyEventSkimming(), and endJob().

mevnSegments0

TH1F* CSCSkim::mevnSegments0

private

Definition at line 185 of file CSCSkim.h.

Referenced by beginJob(), doMessyEventSkimming(), and endJob().

mevnSegments1

TH1F* CSCSkim::mevnSegments1

private

Definition at line 188 of file CSCSkim.h.

Referenced by beginJob(), doMessyEventSkimming(), and endJob().

minimumHitChambers

int CSCSkim::minimumHitChambers

private

Definition at line 158 of file CSCSkim.h.

Referenced by CSCSkim(), and doCSCSkimming().

minimumSegments

int CSCSkim::minimumSegments

private

Definition at line 159 of file CSCSkim.h.

Referenced by CSCSkim(), and doCSCSkimming().

nCSCHitsMin

int CSCSkim::nCSCHitsMin

private

Definition at line 170 of file CSCSkim.h.

Referenced by CSCSkim(), doBFieldStudySelection(), and doLongSATrack().

nEventsAnalyzed

int CSCSkim::nEventsAnalyzed

private

Definition at line 117 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsCertainChamber

int CSCSkim::nEventsCertainChamber

private

Definition at line 122 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsChambersBothSides

int CSCSkim::nEventsChambersBothSides

private

Definition at line 119 of file CSCSkim.h.

Referenced by beginJob(), doCSCSkimming(), and endJob().

nEventsDTOverlap

int CSCSkim::nEventsDTOverlap

private

Definition at line 123 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsForBFieldStudies

int CSCSkim::nEventsForBFieldStudies

private

Definition at line 126 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsHaloLike

int CSCSkim::nEventsHaloLike

private

Definition at line 124 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsLongSATrack

int CSCSkim::nEventsLongSATrack

private

Definition at line 125 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsMessy

int CSCSkim::nEventsMessy

private

Definition at line 121 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsOverlappingChambers

int CSCSkim::nEventsOverlappingChambers

private

Definition at line 120 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nEventsSelected

int CSCSkim::nEventsSelected

private

Definition at line 118 of file CSCSkim.h.

Referenced by beginJob(), endJob(), and filter().

nLayersWithHitsMinimum

int CSCSkim::nLayersWithHitsMinimum

private

Definition at line 157 of file CSCSkim.h.

Referenced by CSCSkim(), doCSCSkimming(), and doMessyEventSkimming().

nTrHitsMin

int CSCSkim::nTrHitsMin

private

Definition at line 172 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().

nValidHitsMin

int CSCSkim::nValidHitsMin

private

Definition at line 176 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().

outputFileName

std::string CSCSkim::outputFileName

private

Definition at line 136 of file CSCSkim.h.

Referenced by PhaseITreeProducer.ModuleLvlValuesReader::CreateTree2(), CSCSkim(), and InefficientDoubleROC.InefficientDeadROCs::ReadHistograms().

pMin

float CSCSkim::pMin

private

Definition at line 168 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().

redChiSqMax

float CSCSkim::redChiSqMax

private

Definition at line 175 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().

rExtMax

float CSCSkim::rExtMax

private

Definition at line 174 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().

rh_token

edm::EDGetTokenT<CSCRecHit2DCollection> CSCSkim::rh_token

private

Definition at line 148 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

sam_token

edm::EDGetTokenT<reco::TrackCollection> CSCSkim::sam_token

private

Definition at line 150 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

sdr_token

edm::EDGetTokenT<CSCStripDigiCollection> CSCSkim::sdr_token

private

Definition at line 146 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

sds_token

edm::EDGetTokenT<CSCStripDigiCollection> CSCSkim::sds_token

private

Definition at line 144 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

seg_token

edm::EDGetTokenT<CSCSegmentCollection> CSCSkim::seg_token

private

Definition at line 149 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

theHistogramFile

TFile* CSCSkim::theHistogramFile

private

Definition at line 133 of file CSCSkim.h.

Referenced by beginJob(), and endJob().

trk_token

edm::EDGetTokenT<reco::TrackCollection> CSCSkim::trk_token

private

Definition at line 151 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

typeOfSkim

int CSCSkim::typeOfSkim

private

Definition at line 156 of file CSCSkim.h.

Referenced by CSCSkim(), doCSCSkimming(), endJob(), and filter().

wdr_token

edm::EDGetTokenT<CSCWireDigiCollection> CSCSkim::wdr_token

private

Definition at line 145 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

wds_token

edm::EDGetTokenT<CSCWireDigiCollection> CSCSkim::wds_token

private

Definition at line 143 of file CSCSkim.h.

Referenced by CSCSkim(), and filter().

whichChamber

int CSCSkim::whichChamber

private

Definition at line 166 of file CSCSkim.h.

Referenced by CSCSkim(), and doCertainChamberSelection().

whichEndcap

int CSCSkim::whichEndcap

private

Definition at line 163 of file CSCSkim.h.

Referenced by CSCSkim(), and doCertainChamberSelection().

whichRing

int CSCSkim::whichRing

private

Definition at line 165 of file CSCSkim.h.

Referenced by CSCSkim(), and doCertainChamberSelection().

whichStation

int CSCSkim::whichStation

private

Definition at line 164 of file CSCSkim.h.

Referenced by CSCSkim(), and doCertainChamberSelection().

xxnCSCHits

TH1F * CSCSkim::xxnCSCHits

private

Definition at line 190 of file CSCSkim.h.

Referenced by beginJob().

xxnTrackerHits

TH1F * CSCSkim::xxnTrackerHits

private

Definition at line 190 of file CSCSkim.h.

Referenced by beginJob().

xxnValidHits

TH1F * CSCSkim::xxnValidHits

private

Definition at line 190 of file CSCSkim.h.

Referenced by beginJob().

xxP

TH1F* CSCSkim::xxP

private

Definition at line 190 of file CSCSkim.h.

Referenced by beginJob().

xxredChiSq

TH1F * CSCSkim::xxredChiSq

private

Definition at line 190 of file CSCSkim.h.

Referenced by beginJob().

zInnerMax

float CSCSkim::zInnerMax

private

Definition at line 171 of file CSCSkim.h.

Referenced by CSCSkim(), doBFieldStudySelection(), and doLongSATrack().

zLengthMin

float CSCSkim::zLengthMin

private

Definition at line 169 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().

zLengthTrMin

float CSCSkim::zLengthTrMin

private

Definition at line 173 of file CSCSkim.h.

Referenced by CSCSkim(), and doBFieldStudySelection().