Particle Flow Algorithm. More...

#include <PFBlockAlgo.h>

Public Types
typedef std::vector< std::unique_ptr< reco::PFBlockElement > >	ElementList

typedef std::array< std::pair< unsigned int, unsigned int >, reco::PFBlockElement::kNBETypes >	ElementRanges

Public Member Functions
void	buildElements (const edm::Event &)

reco::PFBlockCollection	findBlocks ()
	build blocks More...

	PFBlockAlgo ()

void	setDebug (bool debug)
	sets debug printout flag More...

void	setImporters (const std::vector< edm::ParameterSet > &, edm::ConsumesCollector &)

void	setLinkers (const std::vector< edm::ParameterSet > &)

void	updateEventSetup (const edm::EventSetup &)

	~PFBlockAlgo ()

Private Member Functions
void	link (const reco::PFBlockElement el1, const reco::PFBlockElement el2, double &dist) const
	check whether 2 elements are linked. Returns distance More...

void	packLinks (reco::PFBlock &block, const std::unordered_map< std::pair< unsigned int, unsigned int >, double > &links) const

Private Attributes
bool	debug_
	if true, debug printouts activated More...

ElementList	elements_

const std::unordered_map< std::string, reco::PFBlockElement::Type >	elementTypes_

std::vector< std::unique_ptr< BlockElementImporterBase > >	importers_

std::vector< std::unique_ptr< KDTreeLinkerBase > >	kdtrees_

std::vector< std::unique_ptr< BlockElementLinkerBase > >	linkTests_

unsigned int	linkTestSquare_ [reco::PFBlockElement::kNBETypes][reco::PFBlockElement::kNBETypes]

ElementRanges	ranges_

bool	useHO_

Friends
std::ostream &	operator<< (std::ostream &, const PFBlockAlgo &)

Detailed Description

Particle Flow Algorithm.

Author: Colin Bernet (rewrite/refactor by L. Gray)

Date: January 2006 (April 2014)

Definition at line 36 of file PFBlockAlgo.h.

Member Typedef Documentation

typedef std::vector<std::unique_ptr<reco::PFBlockElement> > PFBlockAlgo::ElementList

Definition at line 40 of file PFBlockAlgo.h.

typedef std::array<std::pair<unsigned int,unsigned int>,reco::PFBlockElement::kNBETypes> PFBlockAlgo::ElementRanges

Definition at line 42 of file PFBlockAlgo.h.

Constructor & Destructor Documentation

PFBlockAlgo::PFBlockAlgo ( )

Definition at line 69 of file PFBlockAlgo.cc.

References ECAL, HCAL, hcaldqm::constants::HO, and INIT_ENTRY.

                          : 
   debug_(false),
   elementTypes_( {
         INIT_ENTRY(PFBlockElement::TRACK),
     INIT_ENTRY(PFBlockElement::PS1),
     INIT_ENTRY(PFBlockElement::PS2),
     INIT_ENTRY(PFBlockElement::ECAL),
     INIT_ENTRY(PFBlockElement::HCAL),
     INIT_ENTRY(PFBlockElement::GSF),
     INIT_ENTRY(PFBlockElement::BREM),
     INIT_ENTRY(PFBlockElement::HFEM),
     INIT_ENTRY(PFBlockElement::HFHAD),
     INIT_ENTRY(PFBlockElement::SC),
     INIT_ENTRY(PFBlockElement::HO),
     INIT_ENTRY(PFBlockElement::HGCAL)  
       } ) {}

PFBlockAlgo::~PFBlockAlgo ( )

Definition at line 142 of file PFBlockAlgo.cc.

References gather_cfg::cout, debug_, and elements_.

                           {
 
 #ifdef PFLOW_DEBUG
   if(debug_)
     cout<<"~PFBlockAlgo - number of remaining elements: "
     <<elements_.size()<<endl;
 #endif  
 }

Member Function Documentation

void PFBlockAlgo::buildElements ( const edm::Event & evt )

Definition at line 299 of file PFBlockAlgo.cc.

References a, b, elements_, mps_fire::i, importers_, kdtrees_, and ranges_.

Referenced by PFBlockProducer::produce().

                                                    {
   // import block elements as defined in python configuration
   ranges_.fill(std::make_pair(0,0));
   elements_.clear();
   for( const auto& importer : importers_ ) {
     importer->importToBlock(evt,elements_);
   }
 
   std::sort(elements_.begin(),elements_.end(),
             [](const auto& a, const auto& b) { return a->type() < b->type(); } );
   
   // list is now partitioned, so mark the boundaries so we can efficiently skip chunks  
   unsigned current_type = ( !elements_.empty() ? elements_[0]->type() : 0 );
   unsigned last_type = ( !elements_.empty() ? elements_.back()->type() : 0 );
   ranges_[current_type].first  = 0;
   ranges_[last_type].second = elements_.size()-1;
   for( size_t i = 0; i < elements_.size(); ++i ) {
     const auto the_type = elements_[i]->type();
     if( the_type != current_type ) {
       ranges_[the_type].first = i; 
       ranges_[current_type].second = i-1;      
       current_type = the_type;
     }
   }  
   // -------------- Loop over block elements ---------------------
 
   // Here we provide to all KDTree linkers the collections to link.
   // Glowinski & Gouzevitch
   
   for (ElementList::iterator it = elements_.begin();
        it != elements_.end(); ++it) {
     for( const auto& kdtree : kdtrees_ ) {
       if( (*it)->type() == kdtree->targetType() ) {
     kdtree->insertTargetElt(it->get());
       }
       if( (*it)->type() == kdtree->fieldType() ) {
     kdtree->insertFieldClusterElt(it->get());
       }
     }    
   }
   //std::cout << "(new) imported: " << elements_.size() << " elements!" << std::endl;
 }

reco::PFBlockCollection PFBlockAlgo::findBlocks ( )

build blocks

Definition at line 151 of file PFBlockAlgo.cc.

References gather_cfg::blocks, elements_, mps_fire::i, kdtrees_, crabWrapper::key, relativeConstraints::keys, linkTests_, linkTestSquare_, min(), p1, p2, packLinks(), and ranges_.

Referenced by PFBlockProducer::produce().

                                               {
   // Glowinski & Gouzevitch
   for( const auto& kdtree : kdtrees_ ) {
     kdtree->process();
   }  
   // !Glowinski & Gouzevitch
   reco::PFBlockCollection blocks;
   // the blocks have not been passed to the event, and need to be cleared
   blocks.reserve(elements_.size());
 
   QuickUnion qu(elements_.size());
   const auto elem_size = elements_.size();
   for( unsigned i = 0; i < elem_size; ++i ) {
     for( unsigned j = 0; j < elem_size; ++j ) {
       if( qu.connected(i,j) || j == i ) continue;
       if( !linkTests_[linkTestSquare_[elements_[i]->type()][elements_[j]->type()]] ) {
         j = ranges_[elements_[j]->type()].second;
         continue;
       }
       auto p1(elements_[i].get()), p2(elements_[j].get());
       const PFBlockElement::Type type1 = p1->type();
       const PFBlockElement::Type type2 = p2->type();
       const unsigned index = linkTestSquare_[type1][type2];
       if( linkTests_[index]->linkPrefilter(p1,p2) ) {
         const double dist = linkTests_[index]->testLink(p1,p2);
         // compute linking info if it is possible
         if( dist > -0.5 ) {
           qu.unite(i,j);
         }
       }
     }
   }
   
   std::unordered_multimap<unsigned,unsigned> blocksmap(elements_.size());
   std::vector<unsigned> keys;
   keys.reserve(elements_.size());
   for( unsigned i = 0; i < elements_.size(); ++i ) {
     unsigned key = i; 
     while( key != qu.find(key) ) key = qu.find(key); // make sure we always find the root node...
     auto pos  = std::lower_bound(keys.begin(),keys.end(),key);
     if( pos == keys.end() || *pos != key ) {
       keys.insert(pos,key);      
     }
     blocksmap.emplace(key,i);
   }
 
   for( auto key : keys ) {
     blocks.push_back( reco::PFBlock() );
     auto range = blocksmap.equal_range(key);
     auto& the_block = blocks.back();
     ElementList::value_type::pointer p1(elements_[range.first->second].get());
     the_block.addElement(p1);
     const unsigned block_size = blocksmap.count(key) + 1;
     //reserve up to 1M or 8MB; pay rehash cost for more
     std::unordered_map<std::pair<unsigned int,unsigned int>, double > links(min(1000000u,block_size*block_size));
     auto itr = range.first;
     ++itr;
     for( ; itr != range.second; ++itr ) {
       ElementList::value_type::pointer p2(elements_[itr->second].get());
       const PFBlockElement::Type type1 = p1->type();
       const PFBlockElement::Type type2 = p2->type();        
       the_block.addElement(p2);
       const unsigned index = linkTestSquare_[type1][type2];
       if( nullptr != linkTests_[index] ) {
         const double dist = linkTests_[index]->testLink(p1,p2);
         links.emplace( std::make_pair(p1->index(), p2->index()), dist );
       }
     }
     packLinks( the_block, links );    
   }
   
   elements_.clear();
 
   return blocks;
 }

void PFBlockAlgo::link	(	const reco::PFBlockElement *	el1,
		const reco::PFBlockElement *	el2,
		double &	dist
	)		const

inlineprivate

check whether 2 elements are linked. Returns distance

Definition at line 273 of file PFBlockAlgo.cc.

References constexpr, gather_cfg::cout, debug_, reco::PFBlockElement::kNBETypes, linkTests_, SiStripPI::max, min(), and reco::PFBlockElement::type().

Referenced by packLinks().

                                   {
   constexpr unsigned rowsize = reco::PFBlockElement::kNBETypes;
   dist=-1.0;
   const PFBlockElement::Type type1 = el1->type();
   const PFBlockElement::Type type2 = el2->type();
   const unsigned index = rowsize*std::max(type1,type2) + std::min(type1,type2);
   if(debug_ ) { 
     std::cout << " PFBlockAlgo links type1 " << type1 
           << " type2 " << type2 << std::endl;
   }
   
   // index is always checked in the preFilter above, no need to check here
   dist = linkTests_[index]->testLink(el1,el2);
 }

void PFBlockAlgo::packLinks	(	reco::PFBlock &	block,
		const std::unordered_map< std::pair< unsigned int, unsigned int >, double > &	links
	)		const

private

compute missing links in the blocks (the recursive procedure does not build all links)

Definition at line 228 of file PFBlockAlgo.cc.

References reco::PFBlock::bookLinkData(), constexpr, reco::PFBlock::elements(), reco::PFBlockElement::kNBETypes, link(), reco::PFBlock::linkData(), linkTests_, reco::PFBlock::setLink(), and edm::OwnVector< T, P >::size().

Referenced by findBlocks().

                                                                                                 {
   constexpr unsigned rowsize = reco::PFBlockElement::kNBETypes;
   
   const edm::OwnVector< reco::PFBlockElement >& els = block.elements();
   
   block.bookLinkData();
   unsigned elsize = els.size();
   //First Loop: update all link data
   for( unsigned i1=0; i1<elsize; ++i1 ) {
     for( unsigned i2=0; i2<i1; ++i2 ) {
       
       // no reflexive link
       //if( i1==i2 ) continue;
       
       double dist = -1;
       
       bool linked = false;
 
       // are these elements already linked ?
       // this can be optimized
       const auto link_itr = links.find(std::make_pair(i2,i1));
       if( link_itr != links.end() ) {
     dist = link_itr->second;
     linked = true;
       }      
       
       if(!linked) {
         const PFBlockElement::Type type1 = els[i1].type();
         const PFBlockElement::Type type2 = els[i2].type();
         const auto minmax = std::minmax(type1,type2);
         const unsigned index = rowsize*minmax.second + minmax.first;
     bool bTestLink = ( nullptr == linkTests_[index] ? false : linkTests_[index]->linkPrefilter(&(els[i1]),&(els[i2])) );
     if (bTestLink) link( & els[i1], & els[i2], dist);
       }
 
       //loading link data according to link test used: RECHIT 
       //block.setLink( i1, i2, chi2, block.linkData() );
       block.setLink( i1, i2, dist, block.linkData() );
     }
   }
 
 }

void PFBlockAlgo::setDebug ( bool debug )

inline

sets debug printout flag

Definition at line 63 of file PFBlockAlgo.h.

References groupFilesInBlocks::block, and debug.

Referenced by PFBlockProducer::PFBlockProducer().

63 {debug_ = debug;}

debug

#define debug

Definition: HDRShower.cc:19

PFBlockAlgo::debug_

bool debug_

if true, debug printouts activated

Definition: PFBlockAlgo.h:82

void PFBlockAlgo::setImporters	(	const std::vector< edm::ParameterSet > &	confs,
		edm::ConsumesCollector &	sumes
	)

Definition at line 132 of file PFBlockAlgo.cc.

References beamerCreator::create(), reco::get(), Reconstruction_hiPF_cff::importerName, importers_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PFBlockProducer::PFBlockProducer().

                                                {
    importers_.reserve(confs.size());  
   for( const auto& conf : confs ) {
     const std::string& importerName = 
       conf.getParameter<std::string>("importerName");    
     importers_.emplace_back(BlockElementImporterFactory::get()->create(importerName,conf,sumes));
   }
 }

void PFBlockAlgo::setLinkers ( const std::vector< edm::ParameterSet > & confs )

Definition at line 86 of file PFBlockAlgo.cc.

References constexpr, beamerCreator::create(), elementTypes_, Exception, reco::get(), mps_fire::i, kdtrees_, reco::PFBlockElement::kNBETypes, hltParticleFlowForJets_cfi::linkerName, linkTests_, linkTestSquare_, SiStripPI::max, min(), tablePrinter::prefix, split, AlCaHLTBitMon_QueryRunRegistry::string, and hltParticleFlowForJets_cfi::useKDTree.

Referenced by PFBlockProducer::PFBlockProducer().

                                                                     {
    constexpr unsigned rowsize = reco::PFBlockElement::kNBETypes;
    for( unsigned i = 0; i < rowsize; ++i ) {
      for( unsigned j = 0; j < rowsize; ++j ) {
 
        linkTestSquare_[i][j] = 0;
      }
    }
   linkTests_.resize(rowsize*rowsize);
   const std::string prefix("PFBlockElement::");
   const std::string pfx_kdtree("KDTree");
   for( const auto& conf : confs ) {
     const std::string& linkerName = 
       conf.getParameter<std::string>("linkerName");
     const std::string&  linkTypeStr =
       conf.getParameter<std::string>("linkType");
     size_t split = linkTypeStr.find(':');
     if( split == std::string::npos ) {
       throw cms::Exception("MalformedLinkType")
     << "\"" << linkTypeStr << "\" is not a valid link type definition."
     << " This string should have the form \"linkFrom:linkTo\"";
     }
     std::string link1(prefix+linkTypeStr.substr(0,split));
     std::string link2(prefix+linkTypeStr.substr(split+1,std::string::npos));
     if( !(elementTypes_.count(link1) && elementTypes_.count(link2) ) ) {
       throw cms::Exception("InvalidBlockElementType")
     << "One of \"" << link1 << "\" or \"" << link2 
     << "\" are invalid block element types!";
     }
     const PFBlockElement::Type type1 = elementTypes_.at(link1);
     const PFBlockElement::Type type2 = elementTypes_.at(link2);    
     const unsigned index  = rowsize*std::max(type1,type2)+std::min(type1,type2);
     linkTests_[index].reset(BlockElementLinkerFactory::get()->create(linkerName,conf));
     linkTestSquare_[type1][type2] = index;
     linkTestSquare_[type2][type1] = index;
     // setup KDtree if requested
     const bool useKDTree = conf.getParameter<bool>("useKDTree");
     if( useKDTree ) {
       kdtrees_.emplace_back( KDTreeLinkerFactory::get()->create(pfx_kdtree+
                                 linkerName) );
       kdtrees_.back()->setTargetType(std::min(type1,type2));
       kdtrees_.back()->setFieldType(std::max(type1,type2));
     }
   }
 }

void PFBlockAlgo::updateEventSetup ( const edm::EventSetup & es )

Definition at line 290 of file PFBlockAlgo.cc.

References importers_.

Referenced by PFBlockProducer::beginLuminosityBlock().

                                                           {
   for( auto& importer : importers_ ) {
     importer->updateEventSetup(es);
   }
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	out,
		const PFBlockAlgo &	a
	)

friend

Definition at line 342 of file PFBlockAlgo.cc.

                                                               {
   if(! out) return out;
   
   out<<"====== Particle Flow Block Algorithm ======= ";
   out<<endl;
   out<<"number of unassociated elements : "<<a.elements_.size()<<endl;
   out<<endl;
   
   for(auto const& element : a.elements_) {
     out<<"\t"<< *element <<endl;
   }
   
   return out;
 }