PFBlockAlgo Class Reference

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
typedef reco::PFBlockCollection::const_iterator	IBC
typedef ElementList::iterator	IE
	define these in *Fwd files in DataFormats/ParticleFlowReco? More...
typedef ElementList::const_iterator	IEC
typedef std::unique_ptr< BlockElementImporterBase >	ImporterPtr
typedef std::unique_ptr< KDTreeLinkerBase >	KDTreePtr
typedef std::unique_ptr< BlockElementLinkerBase >	LinkTestPtr

Public Member Functions
const std::unique_ptr< reco::PFBlockCollection > &	blocks () const
void	buildElements (const edm::Event &)
void	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 > &)
std::unique_ptr< reco::PFBlockCollection >	transferBlocks ()
void	updateEventSetup (const edm::EventSetup &)
	~PFBlockAlgo ()

Private Member Functions
void	link (const reco::PFBlockElement *el1, const reco::PFBlockElement *el2, PFBlockLink::Type &linktype, reco::PFBlock::LinkTest &linktest, double &dist) const
	check whether 2 elements are linked. Returns distance and linktype More...
bool	linkPrefilter (const reco::PFBlockElement *last, const reco::PFBlockElement *next) const
	Avoid to check links when not useful. More...
void	packLinks (reco::PFBlock &block, const std::unordered_map< std::pair< unsigned int, unsigned int >, PFBlockLink > &links) const

Private Attributes
std::vector< ElementList::value_type::pointer >	bare_elements_
std::unique_ptr< reco::PFBlockCollection >	blocks_
bool	debug_
	if true, debug printouts activated More...
ElementList	elements_
const std::unordered_map< std::string, reco::PFBlockElement::Type >	elementTypes_
std::vector< ImporterPtr >	importers_
std::vector< KDTreePtr >	kdtrees_
std::vector< LinkTestPtr >	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 91 of file PFBlockAlgo.h.

Member Typedef Documentation

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

Definition at line 95 of file PFBlockAlgo.h.

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

Definition at line 104 of file PFBlockAlgo.h.

typedef reco::PFBlockCollection::const_iterator PFBlockAlgo::IBC

Definition at line 102 of file PFBlockAlgo.h.

typedef ElementList::iterator PFBlockAlgo::IE

define these in *Fwd files in DataFormats/ParticleFlowReco?

Definition at line 100 of file PFBlockAlgo.h.

typedef ElementList::const_iterator PFBlockAlgo::IEC

Definition at line 101 of file PFBlockAlgo.h.

typedef std::unique_ptr<BlockElementImporterBase> PFBlockAlgo::ImporterPtr

Definition at line 96 of file PFBlockAlgo.h.

typedef std::unique_ptr<KDTreeLinkerBase> PFBlockAlgo::KDTreePtr

Definition at line 98 of file PFBlockAlgo.h.

typedef std::unique_ptr<BlockElementLinkerBase> PFBlockAlgo::LinkTestPtr

Definition at line 97 of file PFBlockAlgo.h.

Constructor & Destructor Documentation

PFBlockAlgo::PFBlockAlgo

(

)

Definition at line 67 of file PFBlockAlgo.cc.

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

                         : 
  blocks_( new reco::PFBlockCollection ),  
  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 145 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

const std::unique_ptr< reco::PFBlockCollection >& PFBlockAlgo::blocks ( ) const

inline

Returns

collection of blocks

Definition at line 129 of file PFBlockAlgo.h.

Referenced by operator<<().

    {return blocks_;}

void PFBlockAlgo::buildElements

(

const edm::Event &

evt

)

Definition at line 335 of file PFBlockAlgo.cc.

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

                                                   {
  // 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(); } );
  
  bare_elements_.resize(elements_.size());
  for( unsigned i = 0; i < elements_.size(); ++i ) {
    bare_elements_[i] = elements_[i].get();
  }

  // list is now partitioned, so mark the boundaries so we can efficiently skip chunks  
  unsigned current_type = ( elements_.size() ? elements_[0]->type() : 0 );
  unsigned last_type = ( elements_.size() ? 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;
}

void PFBlockAlgo::findBlocks

(

)

build blocks

Definition at line 154 of file PFBlockAlgo.cc.

References bare_elements_, blocks_, elements_, mps_fire::i, diffTreeTool::index, kdtrees_, crabWrapper::key, relativeConstraints::keys, linkPrefilter(), linkTests_, linkTestSquare_, min(), PFBlockLink::NONE, p1, p2, packLinks(), and ranges_.

                             {
  // Glowinski & Gouzevitch
  for( const auto& kdtree : kdtrees_ ) {
    kdtree->process();
  }  
  // !Glowinski & Gouzevitch
  // the blocks have not been passed to the event, and need to be cleared
  if( blocks_.get() ) blocks_->clear();
  else                blocks_.reset( new reco::PFBlockCollection );
  blocks_->reserve(elements_.size());

  QuickUnion qu(bare_elements_.size());
  const auto elem_size = bare_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_[bare_elements_[i]->type()][bare_elements_[j]->type()]] ) {
        j = ranges_[bare_elements_[j]->type()].second;
        continue;
      }
      auto p1(bare_elements_[i]), p2(bare_elements_[j]);
      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);
  }

  PFBlockLink::Type linktype = PFBlockLink::NONE;
  PFBlock::LinkTest linktest = PFBlock::LINKTEST_RECHIT;
  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(bare_elements_[range.first->second]);
    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>, PFBlockLink > links(min(1000000u,block_size*block_size));
    auto itr = range.first;
    ++itr;
    for( ; itr != range.second; ++itr ) {
      ElementList::value_type::pointer p2(bare_elements_[itr->second]);
      const PFBlockElement::Type type1 = p1->type();
      const PFBlockElement::Type type2 = p2->type();        
      the_block.addElement(p2);
      linktest = PFBlock::LINKTEST_RECHIT; //rechit by default 
      linktype = static_cast<PFBlockLink::Type>(1<<(type1-1)|1<<(type2-1));
      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()) ,
                       PFBlockLink( linktype, linktest, dist,
                                    p1->index(), p2->index() ) );
      }
    }
    packLinks( the_block, links );    
  }
  
  bare_elements_.clear();
  elements_.clear();
}

void PFBlockAlgo::link ( const reco::PFBlockElement *  el1, const reco::PFBlockElement *  el2, PFBlockLink::Type &  linktype, reco::PFBlock::LinkTest &  linktest, double &  dist  ) const

inlineprivate

check whether 2 elements are linked. Returns distance and linktype

Definition at line 305 of file PFBlockAlgo.cc.

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

Referenced by packLinks().

                                  {
  constexpr unsigned rowsize = reco::PFBlockElement::kNBETypes;
  dist=-1.0;
  linktest = PFBlock::LINKTEST_RECHIT; //rechit by default 
  const PFBlockElement::Type type1 = el1->type();
  const PFBlockElement::Type type2 = el2->type();
  linktype = static_cast<PFBlockLink::Type>(1<<(type1-1)|1<<(type2-1));
  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);
}

bool PFBlockAlgo::linkPrefilter ( const reco::PFBlockElement *  last, const reco::PFBlockElement *  next  ) const

inlineprivate

Avoid to check links when not useful.

Definition at line 294 of file PFBlockAlgo.cc.

References constexpr, diffTreeTool::index, reco::PFBlockElement::kNBETypes, plotBeamSpotDB::last, linkTests_, hpstanc_transforms::max, min(), GetRecoTauVFromDQM_MC_cff::next, and mps_fire::result.

Referenced by findBlocks().

                                                        {
  constexpr unsigned rowsize = reco::PFBlockElement::kNBETypes;
  const PFBlockElement::Type type1 = (last)->type();
  const PFBlockElement::Type type2 = (next)->type();
  const unsigned index = rowsize*std::max(type1,type2) + std::min(type1,type2);
  bool result =  linkTests_[index]->linkPrefilter(last,next);
  return result;  
}

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

private

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

Definition at line 237 of file PFBlockAlgo.cc.

References reco::PFBlock::bookLinkData(), constexpr, gather_cfg::cout, debug_, reco::PFBlock::elements(), diffTreeTool::index, reco::PFBlockElement::kNBETypes, link(), reco::PFBlock::linkData(), linkTests_, PFBlockLink::NONE, 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;
      PFBlock::LinkTest linktest 
    = PFBlock::LINKTEST_RECHIT; 

      // 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.dist();
    linktest = link_itr->second.test();
    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;
    PFBlockLink::Type linktype = PFBlockLink::NONE;
    bool bTestLink = ( nullptr == linkTests_[index] ? false : linkTests_[index]->linkPrefilter(&(els[i1]),&(els[i2])) );
    if (bTestLink) link( & els[i1], & els[i2], linktype, linktest, dist);
      }

      //loading link data according to link test used: RECHIT 
      //block.setLink( i1, i2, chi2, block.linkData() );
#ifdef PFLOW_DEBUG
      if( debug_ )
    cout << "Setting link between elements " << i1 << " and " << i2
         << " of dist =" << dist << " computed from link test "
         << linktest << endl;
#endif
      block.setLink( i1, i2, dist, block.linkData(), linktest );
    }
  }

}

void PFBlockAlgo::setDebug ( bool  debug )

inline

sets debug printout flag

Definition at line 125 of file PFBlockAlgo.h.

References debug.

{debug_ = debug;}

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

Definition at line 133 of file PFBlockAlgo.cc.

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

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

void PFBlockAlgo::setLinkers

(

const std::vector< edm::ParameterSet > &

confs

)

Definition at line 85 of file PFBlockAlgo.cc.

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

                                                                    {
   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);
    BlockElementLinkerBase * linker =
      BlockElementLinkerFactory::get()->create(linkerName,conf);
    linkTests_[index].reset(linker);
    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));
    }
  }
}

std::unique_ptr< reco::PFBlockCollection > PFBlockAlgo::transferBlocks ( )

inline

Definition at line 133 of file PFBlockAlgo.h.

References groupFilesInBlocks::block, plotBeamSpotDB::last, eostools::move(), and GetRecoTauVFromDQM_MC_cff::next.

{return std::move(blocks_);}

void PFBlockAlgo::updateEventSetup

(

const edm::EventSetup &

es

)

Definition at line 326 of file PFBlockAlgo.cc.

References importers_.

                                                          {
  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 383 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(PFBlockAlgo::IEC ie = a.elements_.begin(); 
      ie != a.elements_.end(); ++ie) {
    out<<"\t"<<**ie <<endl;
  }

  
  //   const PFBlockCollection& blocks = a.blocks();

  const std::unique_ptr< reco::PFBlockCollection >& blocks
    = a.blocks(); 
    
  if(!blocks.get() ) {
    out<<"blocks already transfered"<<endl;
  }
  else {
    out<<"number of blocks : "<<blocks->size()<<endl;
    out<<endl;
    
    for(PFBlockAlgo::IBC ib=blocks->begin(); 
    ib != blocks->end(); ++ib) {
      out<<(*ib)<<endl;
    }
  }

  return out;
}

Member Data Documentation

std::vector<ElementList::value_type::pointer> PFBlockAlgo::bare_elements_

private

Definition at line 159 of file PFBlockAlgo.h.

Referenced by buildElements(), and findBlocks().

std::unique_ptr< reco::PFBlockCollection > PFBlockAlgo::blocks_

private

Definition at line 155 of file PFBlockAlgo.h.

Referenced by findBlocks().

bool PFBlockAlgo::debug_

private

if true, debug printouts activated

Definition at line 163 of file PFBlockAlgo.h.

Referenced by link(), packLinks(), and ~PFBlockAlgo().

ElementList PFBlockAlgo::elements_

private

Definition at line 158 of file PFBlockAlgo.h.

Referenced by buildElements(), findBlocks(), operator<<(), and ~PFBlockAlgo().

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

private

Definition at line 171 of file PFBlockAlgo.h.

Referenced by setLinkers().

std::vector<ImporterPtr> PFBlockAlgo::importers_

private

Definition at line 168 of file PFBlockAlgo.h.

Referenced by buildElements(), setImporters(), and updateEventSetup().

std::vector<KDTreePtr> PFBlockAlgo::kdtrees_

private

Definition at line 175 of file PFBlockAlgo.h.

Referenced by buildElements(), findBlocks(), and setLinkers().

std::vector<LinkTestPtr> PFBlockAlgo::linkTests_

private

Definition at line 172 of file PFBlockAlgo.h.

Referenced by findBlocks(), link(), linkPrefilter(), packLinks(), and setLinkers().

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

private

Definition at line 173 of file PFBlockAlgo.h.

Referenced by findBlocks(), and setLinkers().

ElementRanges PFBlockAlgo::ranges_

private

Definition at line 160 of file PFBlockAlgo.h.

Referenced by buildElements(), and findBlocks().

bool PFBlockAlgo::useHO_

private

Definition at line 166 of file PFBlockAlgo.h.