#include <ShallowSimhitClustersProducer.h>

Inheritance diagram for ShallowSimhitClustersProducer:

Public Member Functions
	ShallowSimhitClustersProducer (const edm::ParameterSet &)

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () 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

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)

	~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

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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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
shallow::CLUSTERMAP::const_iterator	match_cluster (const unsigned &, const float &, const shallow::CLUSTERMAP &, const edmNew::DetSetVector< SiStripCluster > &) const

void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
const edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > >	clusters_token_

std::string	Prefix

std::string	runningmode_

std::vector< edm::EDGetTokenT< std::vector< PSimHit > > >	simhits_tokens_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
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::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 12 of file ShallowSimhitClustersProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 18 of file ShallowSimhitClustersProducer.cc.

References edm::EDConsumerBase::consumes(), edm::ParameterSet::getParameter(), Prefix, produce(), and simhits_tokens_.

   : clusters_token_( consumes< edmNew::DetSetVector<SiStripCluster> >(iConfig.getParameter<edm::InputTag>("Clusters"))),
     Prefix( iConfig.getParameter<std::string>("Prefix") ),
         runningmode_( iConfig.getParameter<std::string>("runningMode") )
 {
     std::vector<edm::InputTag> simhits_tags = iConfig.getParameter<std::vector<edm::InputTag> >("InputTags");
     for(auto itag : simhits_tags) {
         simhits_tokens_.push_back(
             consumes< std::vector<PSimHit> >(itag)
             );
     }
 
   produces <std::vector<unsigned> >      ( Prefix + "hits"       );
   produces <std::vector<float> >         ( Prefix + "strip"      );
   produces <std::vector<float> >         ( Prefix + "localtheta" );
   produces <std::vector<float> >         ( Prefix + "localphi"   );
   produces <std::vector<float> >         ( Prefix + "localx"     );
   produces <std::vector<float> >         ( Prefix + "localy"     );
   produces <std::vector<float> >         ( Prefix + "localz"     );
   produces <std::vector<float> >         ( Prefix + "momentum"   );
   produces <std::vector<float> >         ( Prefix + "energyloss" );
   produces <std::vector<float> >         ( Prefix + "time"       );
   produces <std::vector<int> >            ( Prefix + "particle"   );
   produces <std::vector<unsigned short> > ( Prefix + "process"    );
 }         

Member Function Documentation

shallow::CLUSTERMAP::const_iterator ShallowSimhitClustersProducer::match_cluster	(	const unsigned &	id,
		const float &	strip_,
		const shallow::CLUSTERMAP &	clustermap,
		const edmNew::DetSetVector< SiStripCluster > &	clusters
	)		const

private

Definition at line 115 of file ShallowSimhitClustersProducer.cc.

References edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::end(), and edmNew::DetSetVector< T >::find().

Referenced by produce().

                                                                                                                                                        {
   shallow::CLUSTERMAP::const_iterator cluster = clustermap.end();
   edmNew::DetSetVector<SiStripCluster>::const_iterator clustersDetSet = clusters.find(id);
   if( clustersDetSet != clusters.end() ) {
     edmNew::DetSet<SiStripCluster>::const_iterator left, right=clustersDetSet->begin();
     while( right != clustersDetSet->end() && strip_ > right->barycenter() ) 
       right++;
     left = right-1;
     if(right!=clustersDetSet->end() && right!=clustersDetSet->begin()) { 
       unsigned firstStrip = (right->barycenter()-strip_) < (strip_-left->barycenter()) ? right->firstStrip() : left->firstStrip();
       cluster = clustermap.find( std::make_pair( id, firstStrip));
     }
     else if(right != clustersDetSet->begin())
       cluster = clustermap.find( std::make_pair( id, left->firstStrip()));
     else 
       cluster = clustermap.find( std::make_pair( id, right->firstStrip()));
   }
   return cluster;
 }

void ShallowSimhitClustersProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 45 of file ShallowSimhitClustersProducer.cc.

References fastPrimaryVertexProducer_cfi::clusters, clusters_token_, shallow::drift(), edm::EventSetup::get(), edm::Event::getByLabel(), edm::Event::getByToken(), hfClusterShapes_cfi::hits, mps_fire::i, shallow::make_cluster_map(), match_cluster(), eostools::move(), Prefix, LaserDQM_cfg::process, edm::Event::put(), runningmode_, simhits_tokens_, findQualityFiles::size, StripGeomDetUnit::specificTopology(), digitizers_cfi::strip, StripTopology::strip(), ntuplemaker::time, hit::x, hit::y, and hit::z.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), HTMLExport.HTMLExportStatic::export(), and ShallowSimhitClustersProducer().

                                                        {
   shallow::CLUSTERMAP clustermap = shallow::make_cluster_map(iEvent,clusters_token_);
 
   int size = clustermap.size();
   auto          hits         = std::make_unique <std::vector<unsigned>>       (size, 0);
   auto          strip        = std::make_unique <std::vector<float>>          (size, -100);
   auto          localtheta   = std::make_unique <std::vector<float>>          (size, -100);
   auto          localphi     = std::make_unique <std::vector<float>>          (size, -100);
   auto          localx       = std::make_unique <std::vector<float>>          (size, -100);
   auto          localy       = std::make_unique <std::vector<float>>          (size, -100);
   auto          localz       = std::make_unique <std::vector<float>>          (size, -100);
   auto          momentum     = std::make_unique <std::vector<float>>          (size, 0);
   auto          energyloss   = std::make_unique <std::vector<float>>          (size, -1);
   auto          time         = std::make_unique <std::vector<float>>          (size, -1);
   auto          particle     = std::make_unique <std::vector<int>>            (size, -500);
   auto          process      = std::make_unique <std::vector<unsigned short>> (size, 0);
 
   edm::ESHandle<TrackerGeometry> theTrackerGeometry;         iSetup.get<TrackerDigiGeometryRecord>().get( theTrackerGeometry );  
   edm::ESHandle<MagneticField> magfield;             iSetup.get<IdealMagneticFieldRecord>().get(magfield);            
   edm::ESHandle<SiStripLorentzAngle> SiStripLorentzAngle;    iSetup.get<SiStripLorentzAngleRcd>().get(runningmode_, SiStripLorentzAngle);      
   edm::Handle<edmNew::DetSetVector<SiStripCluster> > clusters;  iEvent.getByLabel("siStripClusters", "", clusters);
 
     for(auto& simhit_token : simhits_tokens_) {
         edm::Handle< std::vector<PSimHit> > simhits; 
         iEvent.getByToken(simhit_token, simhits);
     for(auto const& hit : *simhits ) {
       
       const uint32_t id = hit.detUnitId();
       const StripGeomDetUnit* theStripDet = dynamic_cast<const StripGeomDetUnit*>( theTrackerGeometry->idToDet( id ) );
       const LocalVector drift = shallow::drift(theStripDet, *magfield, *SiStripLorentzAngle);
 
       const float driftedstrip_ = theStripDet->specificTopology().strip( hit.localPosition()+0.5*drift );
       const float     hitstrip_ = theStripDet->specificTopology().strip( hit.localPosition()           );
 
       shallow::CLUSTERMAP::const_iterator cluster = match_cluster( id, driftedstrip_, clustermap, *clusters); 
       if(cluster != clustermap.end()) {
                 unsigned i = cluster->second;
                 hits->at(i)+=1;
                 if(hits->at(i) == 1) {
                     strip->at(i) = hitstrip_;
                     localtheta->at(i) = hit.thetaAtEntry();
                     localphi->at(i) = hit.phiAtEntry();
                     localx->at(i) = hit.localPosition().x();
                     localy->at(i) = hit.localPosition().y();
                     localz->at(i) = hit.localPosition().z();
                     momentum->at(i) = hit.pabs();
                     energyloss->at(i) = hit.energyLoss();
                     time->at(i) = hit.timeOfFlight();
                     particle->at(i) = hit.particleType();
                     process->at(i) = hit.processType();
                 }
       }    
     } 
   }
 
   iEvent.put(std::move(hits),        Prefix + "hits"      );
   iEvent.put(std::move(strip),       Prefix + "strip"      );
   iEvent.put(std::move(localtheta),  Prefix + "localtheta" );
   iEvent.put(std::move(localphi),    Prefix + "localphi" );
   iEvent.put(std::move(localx),      Prefix + "localx" );
   iEvent.put(std::move(localy),      Prefix + "localy" );
   iEvent.put(std::move(localz),      Prefix + "localz" );
   iEvent.put(std::move(momentum),    Prefix + "momentum" );
   iEvent.put(std::move(energyloss),  Prefix + "energyloss" );
   iEvent.put(std::move(time),        Prefix + "time" );
   iEvent.put(std::move(particle),    Prefix + "particle" );
   iEvent.put(std::move(process),     Prefix + "process" );
 }