SeedMultiplicityAnalyzer Class Reference

#include <myTKAnalyses/TrackRecoMonitoring/src/SeedMultiplicityAnalyzer.cc>

Inheritance diagram for SeedMultiplicityAnalyzer:

Classes
class	FromTrackRefSeedFilter

Public Member Functions
	SeedMultiplicityAnalyzer (const edm::ParameterSet &)
	~SeedMultiplicityAnalyzer () override
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
	~EDAnalyzer () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

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

Private Attributes
std::vector< unsigned int >	_binseta
std::vector< unsigned int >	_binsmult
std::string	_buildername
std::vector< TH2F * >	_hbpixcluslenangle
std::vector< TH2F * >	_hbpixclusleneta
std::vector< TH2F * >	_hfpixcluslenangle
std::vector< TH2F * >	_hfpixclusleneta
std::vector< TH1F * >	_hpixelrhmult
std::vector< TH1F * >	_hseedeta
std::vector< std::vector< TH2F * > >	_hseedeta2D
std::vector< TH1F * >	_hseedmult
std::vector< std::vector< TH2F * > >	_hseedmult2D
std::vector< TH2F * >	_hseedphieta
std::vector< std::string >	_labels
std::vector< double >	_maxs
std::vector< edm::EDGetTokenT< std::map< unsigned int, int > > >	_multiplicityMapTokens
std::vector< unsigned int >	_seedbins
std::vector< edm::EDGetTokenT< TrajectorySeedCollection > >	_seedcollTokens
std::vector< FromTrackRefSeedFilter >	_seedfilters
std::vector< double >	_seedmax
std::vector< unsigned int >	_selections

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: <one line="" class="" summary>="">

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

Definition at line 69 of file SeedMultiplicityAnalyzer.cc.

Constructor & Destructor Documentation

SeedMultiplicityAnalyzer()

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

explicit

Definition at line 130 of file SeedMultiplicityAnalyzer.cc.

    : _buildername(iConfig.getParameter<std::string>("TTRHBuilder")),
      _seedcollTokens(),
      _seedbins(),
      _seedmax(),
      _seedfilters(),
      _multiplicityMapTokens(),
      _labels(),
      _selections(),
      _binsmult(),
      _binseta(),
      _maxs(),
      _hseedmult2D(),
      _hseedeta2D() {
  //now do what ever initialization is needed
 
  //
 
  std::vector<edm::ParameterSet> seedCollectionConfigs =
      iConfig.getParameter<std::vector<edm::ParameterSet>>("seedCollections");
 
  for (std::vector<edm::ParameterSet>::const_iterator scps = seedCollectionConfigs.begin();
       scps != seedCollectionConfigs.end();
       ++scps) {
    _seedcollTokens.push_back(consumes<TrajectorySeedCollection>(scps->getParameter<edm::InputTag>("src")));
    _seedbins.push_back(scps->getUntrackedParameter<unsigned int>("nBins", 1000));
    _seedmax.push_back(scps->getUntrackedParameter<double>("maxValue", 100000.));
 
    if (scps->exists("trackFilter")) {
      _seedfilters.push_back(
          FromTrackRefSeedFilter(consumesCollector(), scps->getParameter<edm::ParameterSet>("trackFilter")));
    } else {
      _seedfilters.push_back(FromTrackRefSeedFilter());
    }
  }
 
  std::vector<edm::ParameterSet> correlationConfigs =
      iConfig.getParameter<std::vector<edm::ParameterSet>>("multiplicityCorrelations");
 
  for (std::vector<edm::ParameterSet>::const_iterator ps = correlationConfigs.begin(); ps != correlationConfigs.end();
       ++ps) {
    _multiplicityMapTokens.push_back(
        consumes<std::map<unsigned int, int>>(ps->getParameter<edm::InputTag>("multiplicityMap")));
    _labels.push_back(ps->getParameter<std::string>("detLabel"));
    _selections.push_back(ps->getParameter<unsigned int>("detSelection"));
    _binsmult.push_back(ps->getParameter<unsigned int>("nBins"));
    _binseta.push_back(ps->getParameter<unsigned int>("nBinsEta"));
    _maxs.push_back(ps->getParameter<double>("maxValue"));
  }
 
  edm::Service<TFileService> tfserv;
 
  std::vector<unsigned int>::const_iterator nseedbins = _seedbins.begin();
  std::vector<double>::const_iterator seedmax = _seedmax.begin();
  std::vector<FromTrackRefSeedFilter>::const_iterator filter = _seedfilters.begin();
 
  for (std::vector<edm::ParameterSet>::const_iterator scps = seedCollectionConfigs.begin();
       scps != seedCollectionConfigs.end();
       ++scps, ++nseedbins, ++seedmax, ++filter) {
    std::string extendedlabel = std::string(scps->getParameter<edm::InputTag>("src").encode()) + filter->suffix();
 
    std::string hname = extendedlabel + std::string("_mult");
    std::string htitle = extendedlabel + std::string(" seed multiplicity");
    _hseedmult.push_back(tfserv->make<TH1F>(
        hname.c_str(), htitle.c_str(), *nseedbins + 1, 0.5 - *seedmax / (*nseedbins), *seedmax + 0.5));
    _hseedmult[_hseedmult.size() - 1]->GetXaxis()->SetTitle("seeds");
    _hseedmult[_hseedmult.size() - 1]->GetYaxis()->SetTitle("events");
 
    hname = extendedlabel + std::string("_eta");
    htitle = extendedlabel + std::string(" seed pseudorapidity");
    _hseedeta.push_back(tfserv->make<TH1F>(hname.c_str(), htitle.c_str(), 80, -4., 4.));
    _hseedeta[_hseedeta.size() - 1]->GetXaxis()->SetTitle("#eta");
    _hseedeta[_hseedeta.size() - 1]->GetYaxis()->SetTitle("seeds");
 
    hname = extendedlabel + std::string("_phieta");
    htitle = extendedlabel + std::string(" seed phi vs pseudorapidity");
    _hseedphieta.push_back(tfserv->make<TH2F>(hname.c_str(), htitle.c_str(), 80, -4., 4., 80, -M_PI, M_PI));
    _hseedphieta[_hseedphieta.size() - 1]->GetXaxis()->SetTitle("#eta");
    _hseedphieta[_hseedphieta.size() - 1]->GetYaxis()->SetTitle("#phi");
 
    _hseedmult2D.push_back(std::vector<TH2F*>());
    _hseedeta2D.push_back(std::vector<TH2F*>());
 
    hname = extendedlabel + std::string("_npixelrh");
    htitle = extendedlabel + std::string(" seed SiPixelRecHit multiplicity");
    _hpixelrhmult.push_back(tfserv->make<TH1F>(hname.c_str(), htitle.c_str(), 5, -.5, 4.5));
    _hpixelrhmult[_hpixelrhmult.size() - 1]->GetXaxis()->SetTitle("NRecHits");
    _hpixelrhmult[_hpixelrhmult.size() - 1]->GetYaxis()->SetTitle("seeds");
 
    hname = extendedlabel + std::string("_bpixleneta");
    htitle = extendedlabel + std::string(" seed BPIX cluster length vs pseudorapidity");
    _hbpixclusleneta.push_back(tfserv->make<TH2F>(hname.c_str(), htitle.c_str(), 80, -4., 4., 40, -0.5, 39.5));
    _hbpixclusleneta[_hbpixclusleneta.size() - 1]->GetXaxis()->SetTitle("#eta");
    _hbpixclusleneta[_hbpixclusleneta.size() - 1]->GetYaxis()->SetTitle("length");
 
    hname = extendedlabel + std::string("_fpixleneta");
    htitle = extendedlabel + std::string(" seed FPIX cluster length vs pseudorapidity");
    _hfpixclusleneta.push_back(tfserv->make<TH2F>(hname.c_str(), htitle.c_str(), 80, -4., 4., 40, -0.5, 39.5));
    _hfpixclusleneta[_hfpixclusleneta.size() - 1]->GetXaxis()->SetTitle("#eta");
    _hfpixclusleneta[_hfpixclusleneta.size() - 1]->GetYaxis()->SetTitle("length");
 
    hname = extendedlabel + std::string("_bpixlenangle");
    htitle = extendedlabel + std::string(" seed BPIX cluster length vs track projection");
    _hbpixcluslenangle.push_back(tfserv->make<TH2F>(hname.c_str(), htitle.c_str(), 200, -1., 1., 40, -0.5, 39.5));
    _hbpixcluslenangle[_hbpixcluslenangle.size() - 1]->GetXaxis()->SetTitle("projection");
    _hbpixcluslenangle[_hbpixcluslenangle.size() - 1]->GetYaxis()->SetTitle("length");
 
    hname = extendedlabel + std::string("_fpixlenangle");
    htitle = extendedlabel + std::string(" seed FPIX cluster length vs track projection");
    _hfpixcluslenangle.push_back(tfserv->make<TH2F>(hname.c_str(), htitle.c_str(), 200, -1., 1., 40, -0.5, 39.5));
    _hfpixcluslenangle[_hfpixcluslenangle.size() - 1]->GetXaxis()->SetTitle("projection");
    _hfpixcluslenangle[_hfpixcluslenangle.size() - 1]->GetYaxis()->SetTitle("length");
 
    for (unsigned int i = 0; i < _multiplicityMapTokens.size(); ++i) {
      std::string hname2D = extendedlabel + _labels[i];
      hname2D += "_mult";
      std::string htitle2D = extendedlabel + " seeds multiplicity";
      htitle2D += " vs ";
      htitle2D += _labels[i];
      htitle2D += " hits";
      _hseedmult2D[_hseedmult2D.size() - 1].push_back(tfserv->make<TH2F>(hname2D.c_str(),
                                                                         htitle2D.c_str(),
                                                                         _binsmult[i],
                                                                         0.,
                                                                         _maxs[i],
                                                                         *nseedbins + 1,
                                                                         0.5 - *seedmax / (*nseedbins),
                                                                         *seedmax + 0.5));
      _hseedmult2D[_hseedmult2D.size() - 1][_hseedmult2D[_hseedmult2D.size() - 1].size() - 1]->GetXaxis()->SetTitle(
          "hits");
      _hseedmult2D[_hseedmult2D.size() - 1][_hseedmult2D[_hseedmult2D.size() - 1].size() - 1]->GetYaxis()->SetTitle(
          "seeds");
 
      hname2D = extendedlabel + _labels[i];
      hname2D += "_eta";
      htitle2D = extendedlabel + " seeds pseudorapidity";
      htitle2D += " vs ";
      htitle2D += _labels[i];
      htitle2D += " hits";
      _hseedeta2D[_hseedeta2D.size() - 1].push_back(
          tfserv->make<TH2F>(hname2D.c_str(), htitle2D.c_str(), _binseta[i], 0., _maxs[i], 80, -4., 4.));
      _hseedeta2D[_hseedeta2D.size() - 1][_hseedeta2D[_hseedeta2D.size() - 1].size() - 1]->GetXaxis()->SetTitle("hits");
      _hseedeta2D[_hseedeta2D.size() - 1][_hseedeta2D[_hseedeta2D.size() - 1].size() - 1]->GetYaxis()->SetTitle("#eta");
    }
  }
}

References _binseta, _binsmult, _hbpixcluslenangle, _hbpixclusleneta, _hfpixcluslenangle, _hfpixclusleneta, _hpixelrhmult, _hseedeta, _hseedeta2D, _hseedmult, _hseedmult2D, _hseedphieta, _labels, _maxs, _multiplicityMapTokens, _seedbins, _seedcollTokens, _seedfilters, _seedmax, _selections, edm::EDConsumerBase::consumes(), edm::EDConsumerBase::consumesCollector(), edm::InputTag::encode(), ALCARECOTkAlBeamHalo_cff::filter, edm::ParameterSet::getParameter(), mps_fire::i, M_PI, TFileService::make(), and AlCaHLTBitMon_QueryRunRegistry::string.

~SeedMultiplicityAnalyzer()

SeedMultiplicityAnalyzer::~SeedMultiplicityAnalyzer ( )

override

Definition at line 277 of file SeedMultiplicityAnalyzer.cc.

                                                    {
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
}

Member Function Documentation

analyze()

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

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 287 of file SeedMultiplicityAnalyzer.cc.

                                                                                          {
  using namespace edm;
 
  // compute cluster multiplicities
 
  std::vector<int> tmpmult(_multiplicityMapTokens.size(), -1);
  for (unsigned int i = 0; i < _multiplicityMapTokens.size(); ++i) {
    Handle<std::map<unsigned int, int>> mults;
    iEvent.getByToken(_multiplicityMapTokens[i], mults);
 
    // check if the selection exists
 
    std::map<unsigned int, int>::const_iterator mult = mults->find(_selections[i]);
 
    if (mult != mults->end()) {
      tmpmult[i] = mult->second;
    } else {
      edm::LogWarning("DetSelectionNotFound") << " DetSelection " << _selections[i] << " not found";
    }
  }
 
  // preparation for loop on seeds
 
  //  TrajectoryStateTransform tsTransform;
  TSCBLBuilderNoMaterial tscblBuilder;  // I could have used TSCBLBuilderWithPropagator
 
  edm::ESHandle<MagneticField> theMF;
  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
 
  edm::ESHandle<TransientTrackingRecHitBuilder> theTTRHBuilder;
  iSetup.get<TransientRecHitRecord>().get(_buildername, theTTRHBuilder);
 
  // I need:
  // - beamspot bs POSTPONED
 
  std::vector<TH1F*>::iterator histomult = _hseedmult.begin();
  std::vector<std::vector<TH2F*>>::iterator histomult2D = _hseedmult2D.begin();
  std::vector<TH1F*>::iterator histoeta = _hseedeta.begin();
  std::vector<TH2F*>::iterator histophieta = _hseedphieta.begin();
  std::vector<std::vector<TH2F*>>::iterator histoeta2D = _hseedeta2D.begin();
  std::vector<TH1F*>::iterator hpixelrhmult = _hpixelrhmult.begin();
  std::vector<TH2F*>::iterator histobpixleneta = _hbpixclusleneta.begin();
  std::vector<TH2F*>::iterator histofpixleneta = _hfpixclusleneta.begin();
  std::vector<TH2F*>::iterator histobpixlenangle = _hbpixcluslenangle.begin();
  std::vector<TH2F*>::iterator histofpixlenangle = _hfpixcluslenangle.begin();
  std::vector<FromTrackRefSeedFilter>::iterator filter = _seedfilters.begin();
 
  // loop on seed collections
 
  for (std::vector<edm::EDGetTokenT<TrajectorySeedCollection>>::const_iterator coll = _seedcollTokens.begin();
       coll != _seedcollTokens.end() && histomult != _hseedmult.end() && histomult2D != _hseedmult2D.end() &&
       histoeta != _hseedeta.end() && histoeta2D != _hseedeta2D.end() && histophieta != _hseedphieta.end() &&
       hpixelrhmult != _hpixelrhmult.end() && histobpixleneta != _hbpixclusleneta.end() &&
       histofpixleneta != _hfpixclusleneta.end() && histobpixlenangle != _hbpixcluslenangle.end() &&
       histofpixlenangle != _hfpixcluslenangle.end();
       ++coll,
                                                                               ++histomult,
                                                                               ++histomult2D,
                                                                               ++histoeta,
                                                                               ++histophieta,
                                                                               ++histoeta2D,
                                                                               ++hpixelrhmult,
                                                                               ++histobpixleneta,
                                                                               ++histofpixleneta,
                                                                               ++histobpixlenangle,
                                                                               ++histofpixlenangle,
                                                                               ++filter) {
    filter->prepareEvent(iEvent);
 
    Handle<TrajectorySeedCollection> seeds;
    iEvent.getByToken(*coll, seeds);
 
    /*
    (*histomult)->Fill(seeds->size());
    
    for(unsigned int i=0;i<_multiplicityMaps.size();++i) {
      if(tmpmult[i]>=0) (*histomult2D)[i]->Fill(tmpmult[i],seeds->size());
    }
    */
 
    // loop on seeds
 
    unsigned int nseeds = 0;
    unsigned int iseed = 0;
    for (TrajectorySeedCollection::const_iterator seed = seeds->begin(); seed != seeds->end(); ++seed, ++iseed) {
      if (filter->isSelected(iseed)) {
        ++nseeds;
 
        TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder->build(&*(seed->recHits().second - 1));
        TrajectoryStateOnSurface state =
            trajectoryStateTransform::transientState(seed->startingState(), recHit->surface(), theMF.product());
        //      TrajectoryStateClosestToBeamLine tsAtClosestApproachSeed = tscblBuilder(*state.freeState(),bs); // here I need them BS
 
        double eta = state.globalMomentum().eta();
        double phi = state.globalMomentum().phi();
 
        (*histoeta)->Fill(eta);
        (*histophieta)->Fill(eta, phi);
 
        for (unsigned int i = 0; i < _multiplicityMapTokens.size(); ++i) {
          if (tmpmult[i] >= 0)
            (*histoeta2D)[i]->Fill(tmpmult[i], eta);
        }
 
        // loop on rec hits
 
        TrajectorySeed::range rechits = seed->recHits();
 
        int npixelrh = 0;
        for (TrajectorySeed::const_iterator hit = rechits.first; hit != rechits.second; ++hit) {
          const SiPixelRecHit* sphit = dynamic_cast<const SiPixelRecHit*>(&(*hit));
          if (sphit) {
            ++npixelrh;
            // compute state on recHit surface
            TransientTrackingRecHit::RecHitPointer ttrhit = theTTRHBuilder->build(&*hit);
            TrajectoryStateOnSurface tsos =
                trajectoryStateTransform::transientState(seed->startingState(), ttrhit->surface(), theMF.product());
 
            if (sphit->geographicalId().det() == DetId::Tracker &&
                sphit->geographicalId().subdetId() == PixelSubdetector::PixelBarrel) {
              (*histobpixleneta)->Fill(eta, sphit->cluster()->sizeY());
              if (tsos.isValid()) {
                //      double normdx = sin(atan2(tsos.localMomentum().x(),tsos.localMomentum().z()));
                double normdx = tsos.localMomentum().x() / sqrt(tsos.localMomentum().x() * tsos.localMomentum().x() +
                                                                tsos.localMomentum().z() * tsos.localMomentum().z());
                (*histobpixlenangle)->Fill(normdx, sphit->cluster()->sizeY());
              }
            } else if (sphit->geographicalId().det() == DetId::Tracker &&
                       sphit->geographicalId().subdetId() == PixelSubdetector::PixelEndcap) {
              (*histofpixleneta)->Fill(eta, sphit->cluster()->sizeX());
              if (tsos.isValid()) {
                //      double normdy = sin(atan2(tsos.localMomentum().y(),tsos.localMomentum().z()));
                double normdy = tsos.localMomentum().y() / sqrt(tsos.localMomentum().y() * tsos.localMomentum().y() +
                                                                tsos.localMomentum().z() * tsos.localMomentum().z());
                (*histofpixlenangle)->Fill(normdy, sphit->cluster()->sizeX());
              }
            } else {
              edm::LogError("InconsistentSiPixelRecHit")
                  << "SiPixelRecHit with a non-pixel DetId " << sphit->geographicalId().rawId();
            }
          }
        }
        (*hpixelrhmult)->Fill(npixelrh);
      }
    }
    (*histomult)->Fill(nseeds);
 
    for (unsigned int i = 0; i < _multiplicityMapTokens.size(); ++i) {
      if (tmpmult[i] >= 0)
        (*histomult2D)[i]->Fill(tmpmult[i], nseeds);
    }
  }
}

References _buildername, _hbpixcluslenangle, _hbpixclusleneta, _hfpixcluslenangle, _hfpixclusleneta, _hpixelrhmult, _hseedeta, _hseedeta2D, _hseedmult, _hseedmult2D, _hseedphieta, _multiplicityMapTokens, _seedcollTokens, _seedfilters, _selections, TransientTrackingRecHitBuilder::build(), SiPixelRecHit::cluster(), DetId::det(), PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), ALCARECOTkAlBeamHalo_cff::filter, TrackingRecHit::geographicalId(), edm::EventSetup::get(), get, TrajectoryStateOnSurface::globalMomentum(), mps_fire::i, iEvent, iseed, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localMomentum(), VarParsing::mult, phi, PV3DBase< T, PVType, FrameType >::phi(), PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, edm::ESHandle< T >::product(), DetId::rawId(), rpcPointValidation_cfi::recHit, TrackInfoProducer_cfi::rechits, SurveyInfoScenario_cff::seed, InitialStep_cff::seeds, mathSSE::sqrt(), DetId::subdetId(), DetId::Tracker, trajectoryStateTransform::transientState(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Member Data Documentation

_binseta

std::vector<unsigned int> SeedMultiplicityAnalyzer::_binseta

private

Definition at line 105 of file SeedMultiplicityAnalyzer.cc.

Referenced by SeedMultiplicityAnalyzer().

_binsmult

std::vector<unsigned int> SeedMultiplicityAnalyzer::_binsmult

private

Definition at line 104 of file SeedMultiplicityAnalyzer.cc.

Referenced by SeedMultiplicityAnalyzer().

_buildername

std::string SeedMultiplicityAnalyzer::_buildername

private

Definition at line 96 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze().

_hbpixcluslenangle

std::vector<TH2F*> SeedMultiplicityAnalyzer::_hbpixcluslenangle

private

Definition at line 113 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hbpixclusleneta

std::vector<TH2F*> SeedMultiplicityAnalyzer::_hbpixclusleneta

private

Definition at line 111 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hfpixcluslenangle

std::vector<TH2F*> SeedMultiplicityAnalyzer::_hfpixcluslenangle

private

Definition at line 114 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hfpixclusleneta

std::vector<TH2F*> SeedMultiplicityAnalyzer::_hfpixclusleneta

private

Definition at line 112 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hpixelrhmult

std::vector<TH1F*> SeedMultiplicityAnalyzer::_hpixelrhmult

private

Definition at line 110 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hseedeta

std::vector<TH1F*> SeedMultiplicityAnalyzer::_hseedeta

private

Definition at line 108 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hseedeta2D

std::vector<std::vector<TH2F*> > SeedMultiplicityAnalyzer::_hseedeta2D

private

Definition at line 116 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hseedmult

std::vector<TH1F*> SeedMultiplicityAnalyzer::_hseedmult

private

Definition at line 107 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hseedmult2D

std::vector<std::vector<TH2F*> > SeedMultiplicityAnalyzer::_hseedmult2D

private

Definition at line 115 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_hseedphieta

std::vector<TH2F*> SeedMultiplicityAnalyzer::_hseedphieta

private

Definition at line 109 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_labels

std::vector<std::string> SeedMultiplicityAnalyzer::_labels

private

Definition at line 102 of file SeedMultiplicityAnalyzer.cc.

Referenced by validation.SimpleValidation::_doPlots(), plotting.PlotFolder::draw(), and SeedMultiplicityAnalyzer().

_maxs

std::vector<double> SeedMultiplicityAnalyzer::_maxs

private

Definition at line 106 of file SeedMultiplicityAnalyzer.cc.

Referenced by SeedMultiplicityAnalyzer().

_multiplicityMapTokens

std::vector<edm::EDGetTokenT<std::map<unsigned int, int> > > SeedMultiplicityAnalyzer::_multiplicityMapTokens

private

Definition at line 101 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_seedbins

std::vector<unsigned int> SeedMultiplicityAnalyzer::_seedbins

private

Definition at line 98 of file SeedMultiplicityAnalyzer.cc.

Referenced by SeedMultiplicityAnalyzer().

_seedcollTokens

std::vector<edm::EDGetTokenT<TrajectorySeedCollection> > SeedMultiplicityAnalyzer::_seedcollTokens

private

Definition at line 97 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_seedfilters

std::vector<FromTrackRefSeedFilter> SeedMultiplicityAnalyzer::_seedfilters

private

Definition at line 100 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().

_seedmax

std::vector<double> SeedMultiplicityAnalyzer::_seedmax

private

Definition at line 99 of file SeedMultiplicityAnalyzer.cc.

Referenced by SeedMultiplicityAnalyzer().

_selections

std::vector<unsigned int> SeedMultiplicityAnalyzer::_selections

private

Definition at line 103 of file SeedMultiplicityAnalyzer.cc.

Referenced by analyze(), and SeedMultiplicityAnalyzer().