#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::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () 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
void	analyze (const edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< unsigned int >	_binseta

std::vector< unsigned int >	_binsmult

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

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	_magFieldToken

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

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	_TTRHBuilderToken

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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 131 of file SeedMultiplicityAnalyzer.cc.

References edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : _magFieldToken(esConsumes(edm::ESInputTag{"", iConfig.getParameter<std::string>("TTRHBuilder")})),
       _TTRHBuilderToken(esConsumes()),
       _seedcollTokens(),
       _seedbins(),
       _seedmax(),
       _seedfilters(),
       _multiplicityMapTokens(),
       _labels(),
       _selections(),
       _binsmult(),
       _binseta(),
       _maxs(),
       _hseedmult2D(),
       _hseedeta2D() {
   //now do what ever initialization is needed
   usesResource(TFileService::kSharedResource);
 
   //
 
   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");
     }
   }
 }

◆ ~SeedMultiplicityAnalyzer()

SeedMultiplicityAnalyzer::~SeedMultiplicityAnalyzer ( )

override

Definition at line 280 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::one::EDAnalyzerBase.

Definition at line 290 of file SeedMultiplicityAnalyzer.cc.

References _hbpixcluslenangle, _hbpixclusleneta, _hfpixcluslenangle, _hfpixclusleneta, _hpixelrhmult, _hseedeta, _hseedeta2D, _hseedmult, _hseedmult2D, _hseedphieta, _magFieldToken, _multiplicityMapTokens, _seedcollTokens, _seedfilters, _selections, _TTRHBuilderToken, SiPixelRecHit::cluster(), DetId::det(), PVValHelper::eta, ALCARECOTkAlBeamHalo_cff::filter, TrackingRecHit::geographicalId(), edm::EventSetup::getData(), mps_fire::i, iEvent, iseed, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localMomentum(), VarParsing::mult, phi, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, DetId::rawId(), rpcPointValidation_cfi::recHit, fileCollector::seed, DetachedQuadStep_cff::seeds, mathSSE::sqrt(), DetId::subdetId(), DetId::Tracker, trajectoryStateTransform::transientState(), trackerHitRTTI::vector, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                           {
   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
 
   const auto theMF = &iSetup.getData(_magFieldToken);
   const auto& theTTRHBuilder = iSetup.getData(_TTRHBuilderToken);
 
   // 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().end() - 1));
         TrajectoryStateOnSurface state =
             trajectoryStateTransform::transientState(seed->startingState(), recHit->surface(), theMF);
         //      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);
         }
 
         int npixelrh = 0;
         for (auto const& hit : seed->recHits()) {
           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);
 
             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);
     }
   }
 }