PFClusterProducer Class Reference

Producer for particle flow clusters (PFCluster). More...

#include <PFClusterProducer.h>

Inheritance diagram for PFClusterProducer:

Public Member Functions
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &iL, edm::EventSetup const &iE)
	PFClusterProducer (const edm::ParameterSet &)
virtual void	produce (edm::Event &, const edm::EventSetup &)
	~PFClusterProducer ()
Public Member Functions inherited from edm::EDProducer
	EDProducer ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducer ()
Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Attributes
bool	applyCrackCorrections_
PFClusterAlgo	clusterAlgo_
	clustering algorithm More...
const CaloGeometryRecord *	geom
edm::InputTag	inputTagPFClustersPS_
edm::InputTag	inputTagPFRecHits_
std::shared_ptr < PFEnergyCalibration >	pfEnergyCalibration_
bool	produces_eeps
double	threshPFClusterES_
bool	verbose_
	verbose ? More...

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
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 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

Producer for particle flow clusters (PFCluster).

This producer makes use of PFClusterAlgo, the clustering algorithm for particle flow clusters.

Author

Colin Bernet

Date

July 2006

Definition at line 43 of file PFClusterProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 64 of file PFClusterProducer.cc.

References PFClusterAlgo::EGPositionCalc, PFClusterAlgo::EGPositionFormula, edm::hlt::Exception, edm::ParameterSet::existsAs(), relativeConstraints::geom, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), edm::ParameterSet::getUntrackedParameter(), NULL, PFClusterAlgo::PFPositionCalc, reco::PFCluster::setDepthCorParameters(), and AlCaHLTBitMon_QueryRunRegistry::string.

{
    
  verbose_ = 
    iConfig.getUntrackedParameter<bool>("verbose",false);
  
  pfEnergyCalibration_ = 
    std::shared_ptr<PFEnergyCalibration>(new PFEnergyCalibration());

  // parameters for clustering
  
  double threshBarrel = 
    iConfig.getParameter<double>("thresh_Barrel");
  double threshSeedBarrel = 
    iConfig.getParameter<double>("thresh_Seed_Barrel");

  double threshPtBarrel = 
    iConfig.getParameter<double>("thresh_Pt_Barrel");
  double threshPtSeedBarrel = 
    iConfig.getParameter<double>("thresh_Pt_Seed_Barrel");

  double threshCleanBarrel = 
    iConfig.getParameter<double>("thresh_Clean_Barrel");
  std::vector<double> minS4S1CleanBarrel = 
    iConfig.getParameter< std::vector<double> >("minS4S1_Clean_Barrel");

  double threshEndcap = 
    iConfig.getParameter<double>("thresh_Endcap");
  double threshSeedEndcap = 
    iConfig.getParameter<double>("thresh_Seed_Endcap");

  double threshPtEndcap = 
    iConfig.getParameter<double>("thresh_Pt_Endcap");
  double threshPtSeedEndcap = 
    iConfig.getParameter<double>("thresh_Pt_Seed_Endcap");

  double threshCleanEndcap = 
    iConfig.getParameter<double>("thresh_Clean_Endcap");
  std::vector<double> minS4S1CleanEndcap = 
    iConfig.getParameter< std::vector<double> >("minS4S1_Clean_Endcap");

  double threshDoubleSpikeBarrel = 
    iConfig.getParameter<double>("thresh_DoubleSpike_Barrel");
  double minS6S2DoubleSpikeBarrel = 
    iConfig.getParameter<double>("minS6S2_DoubleSpike_Barrel");
  double threshDoubleSpikeEndcap = 
    iConfig.getParameter<double>("thresh_DoubleSpike_Endcap");
  double minS6S2DoubleSpikeEndcap = 
    iConfig.getParameter<double>("minS6S2_DoubleSpike_Endcap");

  int nNeighbours = 
    iConfig.getParameter<int>("nNeighbours");

//   double posCalcP1 = 
//     iConfig.getParameter<double>("posCalcP1");

  int posCalcNCrystal = 
    iConfig.getParameter<int>("posCalcNCrystal");
    
  double showerSigma = 
    iConfig.getParameter<double>("showerSigma");
    
  bool useCornerCells =
    iConfig.getParameter<bool>("useCornerCells");

  bool cleanRBXandHPDs =
    iConfig.getParameter<bool>("cleanRBXandHPDs");


  clusterAlgo_.setThreshBarrel( threshBarrel );
  clusterAlgo_.setThreshSeedBarrel( threshSeedBarrel );
  
  clusterAlgo_.setThreshPtBarrel( threshPtBarrel );
  clusterAlgo_.setThreshPtSeedBarrel( threshPtSeedBarrel );
  
  clusterAlgo_.setThreshCleanBarrel(threshCleanBarrel);
  clusterAlgo_.setS4S1CleanBarrel(minS4S1CleanBarrel);

  clusterAlgo_.setThreshDoubleSpikeBarrel( threshDoubleSpikeBarrel );
  clusterAlgo_.setS6S2DoubleSpikeBarrel( minS6S2DoubleSpikeBarrel );

  clusterAlgo_.setThreshEndcap( threshEndcap );
  clusterAlgo_.setThreshSeedEndcap( threshSeedEndcap );

  clusterAlgo_.setThreshPtEndcap( threshPtEndcap );
  clusterAlgo_.setThreshPtSeedEndcap( threshPtSeedEndcap );

  clusterAlgo_.setThreshCleanEndcap(threshCleanEndcap);
  clusterAlgo_.setS4S1CleanEndcap(minS4S1CleanEndcap);

  clusterAlgo_.setThreshDoubleSpikeEndcap( threshDoubleSpikeEndcap );
  clusterAlgo_.setS6S2DoubleSpikeEndcap( minS6S2DoubleSpikeEndcap );

  clusterAlgo_.setNNeighbours( nNeighbours );

  // setup the position calculation (only affects ECAL position correction)
  std::string poscalctype = PositionCalcType__PFPositionCalc;
  if( iConfig.existsAs<std::string>("PositionCalcType") ) {
    poscalctype = iConfig.getParameter<std::string>("PositionCalcType");
  }
  if( poscalctype == PositionCalcType__EGPositionCalc ) {
    clusterAlgo_.setPositionCalcType(PFClusterAlgo::EGPositionCalc);    
    edm::ParameterSet pc_config = 
      iConfig.getParameterSet("PositionCalcConfig");
    clusterAlgo_.setEGammaPosCalc(pc_config);
  } else if( poscalctype == PositionCalcType__EGPositionFormula) {
    clusterAlgo_.setPositionCalcType(PFClusterAlgo::EGPositionFormula);
    edm::ParameterSet pc_config = 
      iConfig.getParameterSet("PositionCalcConfig");
    double w0 = pc_config.getParameter<double>("W0");
    clusterAlgo_.setPosCalcW0(w0);
  } else if( poscalctype == PositionCalcType__PFPositionCalc) {
    clusterAlgo_.setPositionCalcType(PFClusterAlgo::PFPositionCalc);
  } else {
    throw cms::Exception("InvalidClusteringType")
      << "You have not chosen a valid position calculation type,"
      << " please choose from \""
      << PositionCalcType__EGPositionCalc << "\", \""
      << PositionCalcType__EGPositionFormula << "\", or \""
      << PositionCalcType__PFPositionCalc << "\"!";
  }

  // p1 set to the minimum rechit threshold:
  double posCalcP1 = threshBarrel<threshEndcap ? threshBarrel:threshEndcap;
  clusterAlgo_.setPosCalcP1( posCalcP1 );
  clusterAlgo_.setPosCalcNCrystal( posCalcNCrystal );
  clusterAlgo_.setShowerSigma( showerSigma );

  clusterAlgo_.setUseCornerCells( useCornerCells  );
  clusterAlgo_.setCleanRBXandHPDs( cleanRBXandHPDs);

  int dcormode = 
    iConfig.getParameter<int>("depthCor_Mode");
  
  double dcora = 
    iConfig.getParameter<double>("depthCor_A");
  double dcorb = 
    iConfig.getParameter<double>("depthCor_B");
  double dcorap = 
    iConfig.getParameter<double>("depthCor_A_preshower");
  double dcorbp = 
    iConfig.getParameter<double>("depthCor_B_preshower");

  if( dcormode !=0 )
    reco::PFCluster::setDepthCorParameters( dcormode, 
                        dcora, dcorb, 
                        dcorap, dcorbp );


  geom = NULL;
  // access to the collections of rechits from the various detectors:

  
  inputTagPFRecHits_ = 
    iConfig.getParameter<InputTag>("PFRecHits");
  //---ab
  produces_eeps = iConfig.existsAs<InputTag>("PFClustersPS");
  if( produces_eeps ) {    
    inputTagPFClustersPS_ = 
      iConfig.getParameter<InputTag>("PFClustersPS");
    threshPFClusterES_ = iConfig.getParameter<double>("thresh_Preshower");
    applyCrackCorrections_ = 
      iConfig.getParameter<bool>("applyCrackCorrections");
    if (inputTagPFClustersPS_.label().empty()) {
      produces_eeps = false;
    } else {
      produces<reco::PFCluster::EEtoPSAssociation>();
    }
  }

  //inputTagClusterCollectionName_ =  iConfig.getParameter<string>("PFClusterCollectionName");    
 
  // produces<reco::PFClusterCollection>(inputTagClusterCollectionName_);
   produces<reco::PFClusterCollection>();
   produces<reco::PFRecHitCollection>("Cleaned");   

    //---ab
}

PFClusterProducer::~PFClusterProducer

(

)

Definition at line 245 of file PFClusterProducer.cc.

{}

Member Function Documentation

void PFClusterProducer::beginLuminosityBlock ( edm::LuminosityBlock const &  iL, edm::EventSetup const &  iE  )

virtual

Reimplemented from edm::EDProducer.

Definition at line 248 of file PFClusterProducer.cc.

References edm::eventsetup::EventSetupRecord::cacheIdentifier(), DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, relativeConstraints::geom, edm::EventSetup::get(), NULL, and groupFilesInBlocks::temp.

                                                  {
  const CaloGeometryRecord& temp = iE.get<CaloGeometryRecord>();
  if( geom == NULL || (geom->cacheIdentifier() != temp.cacheIdentifier()) ) {
    geom = &temp;    
    edm::ESHandle<CaloGeometry> cgeom;
    geom->get(cgeom);
    clusterAlgo_.setEBGeom(cgeom->getSubdetectorGeometry(DetId::Ecal,
                             EcalBarrel));
    clusterAlgo_.setEEGeom(cgeom->getSubdetectorGeometry(DetId::Ecal,
                             EcalEndcap));
    clusterAlgo_.setPreshowerGeom(cgeom->getSubdetectorGeometry(DetId::Ecal,
                                   EcalPreshower));
  }
}

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

virtual

Implements edm::EDProducer.

Definition at line 264 of file PFClusterProducer.cc.

References PFLayer::ECAL_ENDCAP, eCorr(), edm::hlt::Exception, newFWLiteAna::found, edm::Event::getByLabel(), edm::Ptr< T >::isNonnull(), edm::Ptr< T >::key(), PFLayer::PS1, PFLayer::PS2, edm::Event::put(), and python.multivaluedict::sort().

                                             {
  

  edm::Handle< reco::PFRecHitCollection > rechitsHandle;
  edm::Handle< edm::View<reco::PFCluster> > psclustersHandle;
  
  // access the rechits in the event
  bool found = iEvent.getByLabel( inputTagPFRecHits_, rechitsHandle );   

  if(!found ) {

    ostringstream err;
    err<<"cannot find rechits: "<<inputTagPFRecHits_;
    LogError("PFClusterProducer")<<err.str()<<endl;
    
    throw cms::Exception( "MissingProduct", err.str());
  }

  // do clustering
  clusterAlgo_.doClustering( rechitsHandle );
  
  if( verbose_ ) {
    LogInfo("PFClusterProducer")
      <<"  clusters --------------------------------- "<<endl
      <<clusterAlgo_<<endl;
  }    
  
  std::auto_ptr< std::vector<reco::PFCluster> > clusters = 
    clusterAlgo_.clusters();

  if( produces_eeps ) {
    iEvent.getByLabel( inputTagPFClustersPS_, psclustersHandle );
    // associate psclusters to ecal rechits
    std::auto_ptr<reco::PFCluster::EEtoPSAssociation> 
      outEEPS( new reco::PFCluster::EEtoPSAssociation );
    // make the association map of ECAL clusters to preshower clusters  
    edm::PtrVector<reco::PFCluster> clusterPtrsPS = 
      psclustersHandle->ptrVector();
    double dist = -1.0, min_dist = -1.0;
    // match PS clusters to EE clusters, minimum distance to EE is ensured
    // since the inner loop is over the EE clusters
    for( const auto& psclus : clusterPtrsPS ) {   
      if( psclus->energy() < threshPFClusterES_ ) continue;        
      switch( psclus->layer() ) { // just in case this isn't the ES...
      case PFLayer::PS1:
      case PFLayer::PS2:
    break;
      default:
    continue;
      }    
      edm::Ptr<reco::PFCluster> eematch,eeclus;
      dist = min_dist = -1.0; // reset
      for( size_t ic = 0; ic < clusters->size(); ++ic ) {
    eeclus = edm::Ptr<reco::PFCluster>(clusters.get(),ic);
    if( eeclus->layer() != PFLayer::ECAL_ENDCAP ) continue; 
    dist = testPreshowerDistance(eeclus,psclus);      
    if( dist == -1.0 || (min_dist != -1.0 && dist > min_dist) ) continue;
    if( dist < min_dist || min_dist == -1.0 ) {
      eematch = eeclus;
      min_dist = dist;
    }
      } // loop on EE clusters      
      if( eematch.isNonnull() ) {
    outEEPS->push_back(std::make_pair(eematch.key(),psclus));
      }
    } // loop on PS clusters    
    //sort the ps association
    std::sort(outEEPS->begin(),outEEPS->end(),sortByKey);
    
    std::vector<double> ps1_energies,ps2_energies;
    double ePS1, ePS2;
    for( size_t ic = 0 ; ic < clusters->size(); ++ic ) {
      ps1_energies.clear();
      ps2_energies.clear();
      ePS1 = ePS2 = 0;
      auto ee_key_val = std::make_pair(ic,edm::Ptr<reco::PFCluster>());
      const auto clustops = std::equal_range(outEEPS->begin(),
                         outEEPS->end(),
                         ee_key_val,
                         sortByKey);
      for( auto i_ps = clustops.first; i_ps != clustops.second; ++i_ps) {
    edm::Ptr<reco::PFCluster> psclus(i_ps->second);
    switch( psclus->layer() ) {
    case PFLayer::PS1:
      ps1_energies.push_back(psclus->energy());
      break;
    case PFLayer::PS2:
      ps2_energies.push_back(psclus->energy());
      break;
    default:
      break;
    }
      }
      const double eCorr= 
    pfEnergyCalibration_->energyEm(clusters->at(ic),
                       ps1_energies,ps2_energies,
                       ePS1,ePS2,
                       applyCrackCorrections_);
      clusters->at(ic).setCorrectedEnergy(eCorr);
    }

    iEvent.put(outEEPS);
  }

  // get clusters out of the clustering algorithm 
  // and put them in the event. There is no copy.
  //auto_ptr< vector<reco::PFCluster> > outClusters( clusters ); 
  auto_ptr< vector<reco::PFRecHit> > recHitsCleaned ( clusterAlgo_.rechitsCleaned() ); 
  edm::OrphanHandle<reco::PFClusterCollection> outHandle = 
    iEvent.put( clusters );    
  iEvent.put( recHitsCleaned, "Cleaned" ); 
}

Member Data Documentation

bool PFClusterProducer::applyCrackCorrections_

private

Definition at line 61 of file PFClusterProducer.h.

PFClusterAlgo PFClusterProducer::clusterAlgo_

private

clustering algorithm

Definition at line 59 of file PFClusterProducer.h.

const CaloGeometryRecord* PFClusterProducer::geom

private

Definition at line 60 of file PFClusterProducer.h.

edm::InputTag PFClusterProducer::inputTagPFClustersPS_

private

Definition at line 70 of file PFClusterProducer.h.

edm::InputTag PFClusterProducer::inputTagPFRecHits_

private

Definition at line 68 of file PFClusterProducer.h.

std::shared_ptr<PFEnergyCalibration> PFClusterProducer::pfEnergyCalibration_

private

Definition at line 62 of file PFClusterProducer.h.

bool PFClusterProducer::produces_eeps

private

Definition at line 69 of file PFClusterProducer.h.

double PFClusterProducer::threshPFClusterES_

private

Definition at line 71 of file PFClusterProducer.h.

bool PFClusterProducer::verbose_

private

verbose ?

Definition at line 65 of file PFClusterProducer.h.