reco::Mustache Class Reference

#include <Mustache.h>

Public Member Functions
void	FillMustacheVar (const std::vector< CaloCluster > &clusters)
int	InsideMust ()
float	LowestMustClust ()
void	MustacheClust (const std::vector< CaloCluster > &clusters, std::vector< unsigned int > &insideMust, std::vector< unsigned int > &outsideMust)
float	MustacheE ()
float	MustacheEOut ()
float	MustacheEtOut ()
void	MustacheID (const CaloClusterPtrVector &clusters, int &nclusters, float &EoutsideMustache)
void	MustacheID (const reco::SuperCluster &sc, int &nclusters, float &EoutsideMustache)
void	MustacheID (const std::vector< const CaloCluster * > &, int &nclusers, float &EoutsideMustache)
int	OutsideMust ()

Private Member Functions
template<class RandomAccessPtrIterator >
void	MustacheID (const RandomAccessPtrIterator &, const RandomAccessPtrIterator &, int &nclusters, float &EoutsideMustache)

Private Attributes
float	Energy_In_Mustache_
float	Energy_Outside_Mustache_
float	Et_Outside_Mustache_
int	excluded_
int	included_
float	LowestClusterEInMustache_

Detailed Description

Definition at line 18 of file Mustache.h.

Member Function Documentation

FillMustacheVar()

void reco::Mustache::FillMustacheVar

(

const std::vector< CaloCluster > &

clusters

)

Definition at line 231 of file Mustache.cc.

                                                                       {
    Energy_In_Mustache_ = 0;
    Energy_Outside_Mustache_ = 0;
    LowestClusterEInMustache_ = 0;
    excluded_ = 0;
    included_ = 0;
    std::multimap<float, unsigned int> OrderedClust;
    std::vector<unsigned int> insideMust;
    std::vector<unsigned int> outsideMust;
    MustacheClust(clusters, insideMust, outsideMust);
    included_ = insideMust.size();
    excluded_ = outsideMust.size();
    for (unsigned int i = 0; i < insideMust.size(); ++i) {
      unsigned int index = insideMust[i];
      Energy_In_Mustache_ = clusters[index].energy() + Energy_In_Mustache_;
      OrderedClust.insert(make_pair(clusters[index].energy(), index));
    }
    for (unsigned int i = 0; i < outsideMust.size(); ++i) {
      unsigned int index = outsideMust[i];
      Energy_Outside_Mustache_ = clusters[index].energy() + Energy_Outside_Mustache_;
      Et_Outside_Mustache_ = clusters[index].energy() * sin(clusters[index].position().theta()) + Et_Outside_Mustache_;
    }
    std::multimap<float, unsigned int>::iterator it;
    it = OrderedClust.begin();
    unsigned int lowEindex = (*it).second;
    LowestClusterEInMustache_ = clusters[lowEindex].energy();
  }

References bsc_activity_cfg::clusters, HCALHighEnergyHPDFilter_cfi::energy, mps_fire::i, position, funct::sin(), and theta().

InsideMust()

int reco::Mustache::InsideMust ( )

inline

Definition at line 34 of file Mustache.h.

{ return included_; }

References included_.

LowestMustClust()

float reco::Mustache::LowestMustClust ( )

inline

Definition at line 33 of file Mustache.h.

{ return LowestClusterEInMustache_; }

References LowestClusterEInMustache_.

MustacheClust()

void reco::Mustache::MustacheClust	(	const std::vector< CaloCluster > &	clusters,
		std::vector< unsigned int > &	insideMust,
		std::vector< unsigned int > &	outsideMust
	)

Definition at line 196 of file Mustache.cc.

                                                                     {
    unsigned int ncl = clusters.size();
    if (!ncl)
      return;
 
    //loop over all clusters to find the one with highest energy
    float emax = 0;
    int imax = -1;
    for (unsigned int i = 0; i < ncl; ++i) {
      float e = (clusters[i]).energy();
      if (e > emax) {
        emax = e;
        imax = i;
      }
    }
 
    if (imax < 0)
      return;
    float eta0 = (clusters[imax]).eta();
    float phi0 = (clusters[imax]).phi();
 
    for (unsigned int k = 0; k < ncl; k++) {
      bool inMust =
          MustacheKernel::inMustache(eta0, phi0, (clusters[k]).energy(), (clusters[k]).eta(), (clusters[k]).phi());
      //return indices of Clusters outside the Mustache
      if (!(inMust)) {
        outsideMust.push_back(k);
      } else {  //return indices of Clusters inside the Mustache
        insideMust.push_back(k);
      }
    }
  }

References bsc_activity_cfg::clusters, MillePedeFileConverter_cfg::e, HCALHighEnergyHPDFilter_cfi::energy, PVValHelper::eta, mps_fire::i, reco::MustacheKernel::inMustache(), and dqmdumpme::k.

MustacheE()

float reco::Mustache::MustacheE ( )

inline

Definition at line 30 of file Mustache.h.

{ return Energy_In_Mustache_; }

References Energy_In_Mustache_.

MustacheEOut()

float reco::Mustache::MustacheEOut ( )

inline

Definition at line 31 of file Mustache.h.

{ return Energy_Outside_Mustache_; }

References Energy_Outside_Mustache_.

MustacheEtOut()

float reco::Mustache::MustacheEtOut ( )

inline

Definition at line 32 of file Mustache.h.

{ return Et_Outside_Mustache_; }

References Et_Outside_Mustache_.

MustacheID() [1/4]

void reco::Mustache::MustacheID	(	const CaloClusterPtrVector &	clusters,
		int &	nclusters,
		float &	EoutsideMustache
	)

Definition at line 148 of file Mustache.cc.

                                                                                                         {
    MustacheID(clusters.begin(), clusters.end(), nclusters, EoutsideMustache);
  }

References bsc_activity_cfg::clusters.

Referenced by PFElectronTranslator::createGsfElectrons(), and PFPhotonTranslator::createPhotons().

MustacheID() [2/4]

template<class RandomAccessPtrIterator >

void reco::Mustache::MustacheID ( const RandomAccessPtrIterator &  begin, const RandomAccessPtrIterator &  end, int &  nclusters, float &  EoutsideMustache  )

private

Definition at line 157 of file Mustache.cc.

                                                     {
    nclusters = 0;
    EoutsideMustache = 0;
 
    unsigned int ncl = end - begin;
    if (!ncl)
      return;
 
    //loop over all clusters to find the one with highest energy
    RandomAccessPtrIterator icl = begin;
    RandomAccessPtrIterator clmax = end;
    float emax = 0;
    for (; icl != end; ++icl) {
      const float e = (*icl)->energy();
      if (e > emax) {
        emax = e;
        clmax = icl;
      }
    }
 
    if (end == clmax)
      return;
 
    float eta0 = (*clmax)->eta();
    float phi0 = (*clmax)->phi();
 
    bool inMust = false;
    icl = begin;
    for (; icl != end; ++icl) {
      inMust = MustacheKernel::inMustache(eta0, phi0, (*icl)->energy(), (*icl)->eta(), (*icl)->phi());
 
      nclusters += (int)!inMust;
      EoutsideMustache += (!inMust) * ((*icl)->energy());
    }
  }

References begin, MillePedeFileConverter_cfg::e, end, reco::MustacheKernel::inMustache(), and createfilelist::int.

MustacheID() [3/4]

void reco::Mustache::MustacheID	(	const reco::SuperCluster &	sc,
		int &	nclusters,
		float &	EoutsideMustache
	)

Definition at line 144 of file Mustache.cc.

                                                                                               {
    MustacheID(sc.clustersBegin(), sc.clustersEnd(), nclusters, EoutsideMustache);
  }

References reco::SuperCluster::clustersBegin(), and reco::SuperCluster::clustersEnd().

MustacheID() [4/4]

void reco::Mustache::MustacheID	(	const std::vector< const CaloCluster * > &	clusters,
		int &	nclusers,
		float &	EoutsideMustache
	)

Definition at line 152 of file Mustache.cc.

                                                                                                                  {
    MustacheID(clusters.cbegin(), clusters.cend(), nclusters, EoutsideMustache);
  }

References bsc_activity_cfg::clusters.

OutsideMust()

int reco::Mustache::OutsideMust ( )

inline

Definition at line 35 of file Mustache.h.

{ return excluded_; }

References excluded_.

Member Data Documentation

Energy_In_Mustache_

float reco::Mustache::Energy_In_Mustache_

private

Definition at line 44 of file Mustache.h.

Referenced by MustacheE().

Energy_Outside_Mustache_

float reco::Mustache::Energy_Outside_Mustache_

private

Definition at line 45 of file Mustache.h.

Referenced by MustacheEOut().

Et_Outside_Mustache_

float reco::Mustache::Et_Outside_Mustache_

private

Definition at line 46 of file Mustache.h.

Referenced by MustacheEtOut().

excluded_

int reco::Mustache::excluded_

private

Definition at line 48 of file Mustache.h.

Referenced by OutsideMust().

included_

int reco::Mustache::included_

private

Definition at line 49 of file Mustache.h.

Referenced by InsideMust().

LowestClusterEInMustache_

float reco::Mustache::LowestClusterEInMustache_

private

Definition at line 47 of file Mustache.h.

Referenced by LowestMustClust().