CMS 3D CMS Logo
pftools::PFClusterCalibration

pftools::PFClusterCalibration Class Reference

#include <RecoParticleFlow/PFClusterTools/interface/PFClusterCalibration.h>

List of all members.

Public Member Functions

void calibrate (Calibratable &c)
void calibrateTree (TTree *tree)
double getCalibratedEcalEnergy (const double &ecalE, const double &hcalE, const double &eta, const double &phi) const
double getCalibratedEnergy (const double &ecalE, const double &hcalE, const double &eta, const double &phi) const
void getCalibratedEnergyEmbedAInHcal (double &ecalE, double &hcalE, const double &eta, const double &phi) const
double getCalibratedHcalEnergy (const double &ecalE, const double &hcalE, const double &eta, const double &phi) const
void getCalibrationResultWrapper (const Calibratable &c, CalibrationResultWrapper &crw)
std::vector< std::string > * getKnownSectorNames ()
 PFClusterCalibration ()
void setAllowNegativeEnergy (const bool &allowIt)
void setBarrelBoundary (const double &eta)
void setCorrections (const double &lowEP0, const double &lowEP1, const double &globalP0, const double &globalP1)
void setDoCorrection (const int &doCorrection)
void setDoEtaCorrection (const int doEtaCorrection)
void setEcalHcalEnergyCuts (const double &ecalCut, const double &hcalCut)
void setEtaCorrectionParameters (std::vector< double > params)
void setEvolutionParameters (const std::string &sector, std::vector< double > params)
void setMaxEToCorrect (double maxE)
virtual ~PFClusterCalibration ()

Private Member Functions

void init ()

Private Attributes

int allowNegativeEnergy_
double barrelEndcapEtaDiv_
TF1 * correction_
double correctionLowLimit_
int doCorrection_
int doEtaCorrection_
double ecalOnlyDiv_
TF1 * etaCorrection_
double globalP0_
double globalP1_
double hcalOnlyDiv_
double lowEP0_
double lowEP1_
double maxEToCorrect_
std::vector< std::string > names_
std::map< std::string, TF1 > namesAndFunctions_

Friends

std::ostream & operator<< (std::ostream &s, const PFClusterCalibration &cc)

Detailed Description

Definition at line 36 of file PFClusterCalibration.h.

Constructor & Destructor Documentation

PFClusterCalibration::PFClusterCalibration (  ) 

Definition at line 103 of file PFClusterCalibration.cc.

References init().

00103                                            :
00104         barrelEndcapEtaDiv_(1.0), ecalOnlyDiv_(0.3), hcalOnlyDiv_(0.5),
00105                         doCorrection_(1), allowNegativeEnergy_(0), doEtaCorrection_(1),
00106                         maxEToCorrect_(-1.0), correctionLowLimit_(0.), globalP0_(0.0),
00107                         globalP1_(1.0), lowEP0_(0.0), lowEP1_(1.0) {
00108   //    std::cout << __PRETTY_FUNCTION__ << std::endl;
00109         init();
00110         //      std::cout
00111         //                      << "WARNING! PFClusterCalibration evolution functions have not yet been initialised - ensure this is done.\n";
00112         //      std::cout << "PFClusterCalibration construction complete."<< std::endl;
00113 
00114 }

PFClusterCalibration::~PFClusterCalibration (  )  [virtual]

Definition at line 116 of file PFClusterCalibration.cc.

References correction_, and etaCorrection_.

00116                                             {
00117         delete correction_;
00118         delete etaCorrection_;
00119 }

Member Function Documentation

void PFClusterCalibration::calibrate ( Calibratable &  c  ) 

Definition at line 262 of file PFClusterCalibration.cc.

References pftools::Calibratable::calibrations_, crw, and getCalibrationResultWrapper().

Referenced by calibrateTree().

00262                                                     {
00263         CalibrationResultWrapper crw;
00264         getCalibrationResultWrapper(c, crw);
00265         c.calibrations_.push_back(crw);
00266 
00267 }

void PFClusterCalibration::calibrateTree ( TTree *  tree  ) 

Definition at line 291 of file PFClusterCalibration.cc.

References calibrate(), GenMuonPlsPt100GeV_cfg::cout, and python::tagInventory::entries.

00291                                                      {
00292         std::cout << __PRETTY_FUNCTION__
00293                         << ": WARNING! This isn't working properly yet!\n";
00294         TBranch* calibBr = input->GetBranch("Calibratable");
00295         Calibratable* calib_ptr = new Calibratable();
00296         calibBr->SetAddress(&calib_ptr);
00297 
00298         //      TBranch* newBranch = input->Branch("NewCalibratable",
00299         //                      "pftools::Calibratable", &calib_ptr, 32000, 2);
00300 
00301         std::cout << "Looping over tree's "<< input->GetEntries()
00302                         << " entries...\n";
00303         for (unsigned entries(0); entries < 20000; entries++) {
00304                 if (entries % 10000== 0)
00305                         std::cout << "\tProcessing entry "<< entries << "\n";
00306                 input->GetEntry(entries);
00307                 calibrate(*calib_ptr);
00308                 input->Fill();
00309         }
00310         //input.Write("",TObject::kOverwrite);
00311 }

double PFClusterCalibration::getCalibratedEcalEnergy ( const double &  ecalE,
const double &  hcalE,
const double &  eta,
const double &  phi 
) const

Definition at line 177 of file PFClusterCalibration.cc.

References barrelEndcapEtaDiv_, and namesAndFunctions_.

Referenced by pftools::Exercises3::evaluateCalibrator(), pftools::Exercises2::evaluateCalibrator(), getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), and getCalibrationResultWrapper().

00178                                                                                  {
00179         const TF1* theFunction(0);
00180 
00181         if (fabs(eta) < barrelEndcapEtaDiv_) {
00182                 //barrel
00183                 theFunction = &(namesAndFunctions_.find("ecalHcalEcalBarrel")->second);
00184         } else {
00185                 //endcap
00186                 theFunction = &(namesAndFunctions_.find("ecalHcalEcalEndcap")->second);
00187         }
00188 
00189         assert(theFunction != 0);
00190         double totalE(ecalE + hcalE);
00191         double bCoeff = theFunction->Eval(totalE);
00192         return ecalE * bCoeff;
00193 }

double PFClusterCalibration::getCalibratedEnergy ( const double &  ecalE,
const double &  hcalE,
const double &  eta,
const double &  phi 
) const

Definition at line 213 of file PFClusterCalibration.cc.

References allowNegativeEnergy_, correction_, doCorrection_, doEtaCorrection_, etaCorrection_, getCalibratedEcalEnergy(), getCalibratedHcalEnergy(), and maxEToCorrect_.

Referenced by pftools::Exercises3::evaluateCalibrator(), pftools::Exercises2::evaluateCalibrator(), and getCalibrationResultWrapper().

00214                                                                                  {
00215         double totalE(ecalE + hcalE);
00216         double answer(totalE);
00217 
00218         answer = getCalibratedEcalEnergy(ecalE, hcalE, eta, phi)
00219                         + getCalibratedHcalEnergy(ecalE, hcalE, eta, phi);
00220         if (doEtaCorrection_)
00221                 answer = answer/etaCorrection_->Eval(eta);
00222 
00223         if (maxEToCorrect_> 0 && answer < maxEToCorrect_)
00224                 return correction_->Eval(answer);
00225         if (doCorrection_) {
00226                 if (maxEToCorrect_> 0 && answer < maxEToCorrect_)
00227                         answer = correction_->Eval(answer);
00228                 else if (maxEToCorrect_ < 0) {
00229                         answer = correction_->Eval(answer);
00230                 }
00231         }
00232         if (!allowNegativeEnergy_ && answer < 0)
00233                 return 0;
00234         return answer;
00235 
00236 }

void PFClusterCalibration::getCalibratedEnergyEmbedAInHcal ( double &  ecalE,
double &  hcalE,
const double &  eta,
const double &  phi 
) const

Definition at line 238 of file PFClusterCalibration.cc.

References a, allowNegativeEnergy_, correction_, doCorrection_, doEtaCorrection_, etaCorrection_, getCalibratedEcalEnergy(), and getCalibratedHcalEnergy().

00239                                                                            {
00240 
00241         double ecalEOld(ecalE);
00242         double hcalEOld(hcalE);
00243 
00244         ecalE = getCalibratedEcalEnergy(ecalEOld, hcalEOld, eta, phi);
00245         hcalE = getCalibratedHcalEnergy(ecalEOld, hcalEOld, eta, phi);
00246 
00247         double preCorrection(ecalE + hcalE);
00248         if (doEtaCorrection_)
00249                 preCorrection = preCorrection/etaCorrection_->Eval(eta);
00250 
00251         if (doCorrection_) {
00252                 double corrE = correction_->Eval(preCorrection);
00253                 //a term  = difference
00254                 double a = corrE - preCorrection;
00255                 hcalE += a;
00256         }
00257         if (hcalE < 0 && !allowNegativeEnergy_)
00258                 hcalE = 0;
00259 
00260 }

double PFClusterCalibration::getCalibratedHcalEnergy ( const double &  ecalE,
const double &  hcalE,
const double &  eta,
const double &  phi 
) const

Definition at line 195 of file PFClusterCalibration.cc.

References barrelEndcapEtaDiv_, and namesAndFunctions_.

Referenced by pftools::Exercises3::evaluateCalibrator(), pftools::Exercises2::evaluateCalibrator(), getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), and getCalibrationResultWrapper().

00196                                                                                  {
00197         const TF1* theFunction(0);
00198 
00199         if (fabs(eta) < barrelEndcapEtaDiv_) {
00200                 //barrel
00201                 theFunction = &(namesAndFunctions_.find("ecalHcalHcalBarrel")->second);
00202         } else {
00203                 //endcap
00204                 theFunction = &(namesAndFunctions_.find("ecalHcalHcalEndcap")->second);
00205         }
00206 
00207         double totalE(ecalE + hcalE);
00208         assert(theFunction != 0);
00209         double cCoeff = theFunction->Eval(totalE);
00210         return hcalE * cCoeff;
00211 }

void PFClusterCalibration::getCalibrationResultWrapper ( const Calibratable &  c,
CalibrationResultWrapper &  crw 
)

Definition at line 269 of file PFClusterCalibration.cc.

References pftools::CalibrationResultWrapper::b_, pftools::CalibrationResultWrapper::c_, pftools::Calibratable::cluster_energyEcal_, pftools::Calibratable::cluster_energyHcal_, pftools::Calibratable::cluster_meanEcal_, pftools::CalibrationResultWrapper::ecalEnergy_, pftools::CalibratableElement::eta_, getCalibratedEcalEnergy(), getCalibratedEnergy(), getCalibratedHcalEnergy(), pftools::CalibrationResultWrapper::hcalEnergy_, pftools::LINEARCORR, pftools::CalibrationResultWrapper::particleEnergy_, pftools::CalibratableElement::phi_, pftools::CalibrationResultWrapper::provenance_, pftools::Calibratable::sim_energyEvent_, and pftools::CalibrationResultWrapper::truthEnergy_.

Referenced by calibrate().

00270                                                {
00271 
00272         crw.ecalEnergy_ = getCalibratedEcalEnergy(c.cluster_energyEcal_,
00273                         c.cluster_energyHcal_, fabs(c.cluster_meanEcal_.eta_),
00274                         fabs(c.cluster_meanEcal_.phi_));
00275 
00276         crw.hcalEnergy_ = getCalibratedHcalEnergy(c.cluster_energyEcal_,
00277                         c.cluster_energyHcal_, fabs(c.cluster_meanEcal_.eta_),
00278                         fabs(c.cluster_meanEcal_.phi_));
00279 
00280         crw.particleEnergy_ = getCalibratedEnergy(c.cluster_energyEcal_,
00281                         c.cluster_energyHcal_, fabs(c.cluster_meanEcal_.eta_),
00282                         fabs(c.cluster_meanEcal_.phi_));
00283 
00284         crw.provenance_ = LINEARCORR;
00285         crw.b_ = crw.ecalEnergy_ / c.cluster_energyEcal_;
00286         crw.c_ = crw.hcalEnergy_ / c.cluster_energyHcal_;
00287         crw.truthEnergy_ = c.sim_energyEvent_;
00288 
00289 }

std::vector<std::string>* pftools::PFClusterCalibration::getKnownSectorNames (  )  [inline]

Definition at line 121 of file PFClusterCalibration.h.

References names_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00121                                                     {
00122                 return &names_;
00123         }

void PFClusterCalibration::init ( void   )  [private]

Definition at line 12 of file PFClusterCalibration.cc.

References correction_, correctionLowLimit_, etaCorrection_, stor::func(), globalP0_, globalP1_, lowEP0_, lowEP1_, name, names_, and namesAndFunctions_.

Referenced by PFClusterCalibration().

00012                                 {
00013   
00014   //std::cout << __PRETTY_FUNCTION__ << std::endl;
00015         correction_ = new TF1("correction",
00016                         "((x-[0])/[1])*(x>[4])+((x-[2])/[3])*(x<[4])");
00017         etaCorrection_
00018                         = new TF1( "etaCorrection",
00019                                         "(1-[0]*x-[1]*x*x)*(x<[2])+([3]+[4]*x)*(x>[2]&&x<[5])+(1-[6]*x-[7]*x*x)*(x>[5])");
00020 
00021         correction_->FixParameter(0, globalP0_);
00022         correction_->FixParameter(1, globalP1_);
00023         correction_->FixParameter(2, lowEP0_);
00024         correction_->FixParameter(3, lowEP1_);
00025         correction_->FixParameter(4, correctionLowLimit_);
00026 
00027         /* These are the types of calibration I know about:
00028          * ecalOnly_elementName
00029          * etc. Sorry, it's not very nice, but well, neither is ROOT... */
00030 
00031         std::string eheb("ecalHcalEcalBarrel");
00032         names_.push_back(eheb);
00033         std::string ehee("ecalHcalEcalEndcap");
00034         names_.push_back(ehee);
00035         std::string ehhb("ecalHcalHcalBarrel");
00036         names_.push_back(ehhb);
00037         std::string ehhe("ecalHcalHcalEndcap");
00038         names_.push_back(ehhe);
00039 
00040         /* char
00041          * funcString("([0]*[5]*x*([1]-[5]*x)/pow(([2]+[5]*x),3)+[3]*pow([5]*x, 0.1))*([5]*x<[8] && [5]*x>[7])+[4]*([5]*x>[8])+([6]*[5]*x)*([5]*x<[7])");
00042          */
00043 
00044         char
00045                         * funcString("([0]*[5]*x)*([5]*x<=[1])+([2]+[3]*exp([4]*[5]*x))*([5]*x>[1])");
00046 
00047         //Create functions for each sector
00048         for (std::vector<std::string>::const_iterator cit = names_.begin(); cit
00049                         != names_.end(); ++cit) {
00050                 std::string name = *cit;
00051                 TF1 func(name.c_str(), funcString);
00052                 //some sensible defaults
00053                 func.FixParameter(0, 1);
00054                 func.FixParameter(1, 0);
00055                 func.FixParameter(2, 1);
00056                 func.FixParameter(3, 0);
00057                 func.FixParameter(4, 0);
00058                 func.FixParameter(5, 1);
00059 
00060                 func.SetMinimum(0);
00061                 //Store in map
00062                 namesAndFunctions_[name] = func;
00063 
00064         }
00065 }

void pftools::PFClusterCalibration::setAllowNegativeEnergy ( const bool &  allowIt  )  [inline]

Definition at line 81 of file PFClusterCalibration.h.

References allowNegativeEnergy_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00081                                                          {
00082                 allowNegativeEnergy_ = allowIt;
00083         }

void pftools::PFClusterCalibration::setBarrelBoundary ( const double &  eta  )  [inline]

Definition at line 103 of file PFClusterCalibration.h.

References barrelEndcapEtaDiv_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00103                                                   {
00104                 barrelEndcapEtaDiv_ = eta;
00105         }

void PFClusterCalibration::setCorrections ( const double &  lowEP0,
const double &  lowEP1,
const double &  globalP0,
const double &  globalP1 
)

Definition at line 156 of file PFClusterCalibration.cc.

References correction_, correctionLowLimit_, globalP0_, globalP1_, lowEP0_, and lowEP1_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00157                                                                                       {
00158         //'a' term is -globalP0/globalP1
00159         globalP0_ = globalP0;
00160         globalP1_ = globalP1;
00161         //Specifically for low energies...
00162         lowEP0_ = lowEP0;
00163         lowEP1_ = lowEP1;
00164         //Intersection of two straight lines => matching at...
00165         correctionLowLimit_ = (lowEP0_ - globalP0_)/(globalP1_ - lowEP1_);
00166 
00167         correction_->FixParameter(0, globalP0_);
00168         correction_->FixParameter(1, globalP1_);
00169         correction_->FixParameter(2, lowEP0_);
00170         correction_->FixParameter(3, lowEP1_);
00171         correction_->FixParameter(4, correctionLowLimit_);
00172 
00173         //      std::cout << __PRETTY_FUNCTION__ << ": setting correctionLowLimit_ = "
00174         //              << correctionLowLimit_ << "\n";
00175 }

void pftools::PFClusterCalibration::setDoCorrection ( const int &  doCorrection  )  [inline]

Definition at line 87 of file PFClusterCalibration.h.

References doCorrection_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00087                                                       {
00088                 doCorrection_ = doCorrection;
00089         }

void pftools::PFClusterCalibration::setDoEtaCorrection ( const int  doEtaCorrection  )  [inline]

Definition at line 91 of file PFClusterCalibration.h.

References doEtaCorrection_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00091                                                            {
00092                 doEtaCorrection_ = doEtaCorrection;
00093         }

void pftools::PFClusterCalibration::setEcalHcalEnergyCuts ( const double &  ecalCut,
const double &  hcalCut 
) [inline]

Definition at line 96 of file PFClusterCalibration.h.

References GenMuonPlsPt100GeV_cfg::cout, ecalOnlyDiv_, and hcalOnlyDiv_.

Referenced by pftools::Exercises3::Exercises3().

00096                                                                                  {
00097                 std::cout << __PRETTY_FUNCTION__ << "WARNING! These will be ignored.\n";
00098                 ecalOnlyDiv_ = ecalCut;
00099                 hcalOnlyDiv_ = hcalCut;
00100         }

void PFClusterCalibration::setEtaCorrectionParameters ( std::vector< double >  params  ) 

Definition at line 121 of file PFClusterCalibration.cc.

References count, GenMuonPlsPt100GeV_cfg::cout, lat::endl(), and etaCorrection_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00121                                                                               {
00122         if (params.size() != 6) {
00123                 std::cout << __PRETTY_FUNCTION__ << ": params is of the wrong length."
00124                                 << std::endl;
00125                 return;
00126         }
00127         //      std::cout << "Fixing eta correction:\n\t";
00128         unsigned count(0);
00129         for (std::vector<double>::const_iterator dit = params.begin(); dit
00130                         != params.end(); ++dit) {
00131           //std::cout << *dit << "\t";
00132                 etaCorrection_->FixParameter(count, *dit);
00133                 ++count;
00134         }
00135         //      std::cout << std::endl;
00136         /*for(double eta(0); eta < 2.5; eta += 0.05) {
00137          std::cout << "Eta = " << eta << ",\tcorr = " << etaCorrection_->Eval(eta) << "\n"; 
00138          }*/
00139 }

void PFClusterCalibration::setEvolutionParameters ( const std::string &  sector,
std::vector< double >  params 
)

Definition at line 141 of file PFClusterCalibration.cc.

References count, stor::func(), and namesAndFunctions_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00142                                           {
00143         TF1* func = &(namesAndFunctions_.find(sector)->second);
00144         unsigned count(0);
00145         //std::cout << "Fixing for "<< sector << "\n";
00146         for (std::vector<double>::const_iterator dit = params.begin(); dit
00147                         != params.end(); ++dit) {
00148                 func->FixParameter(count, *dit);
00149                 //std::cout << "\t"<< count << ": "<< *dit;
00150                 ++count;
00151         }
00152         //      std::cout << std::endl;
00153         func->SetMinimum(0);
00154 }

void pftools::PFClusterCalibration::setMaxEToCorrect ( double  maxE  )  [inline]

Definition at line 107 of file PFClusterCalibration.h.

References maxEToCorrect_.

Referenced by pftools::Exercises2::Exercises2(), and pftools::Exercises3::Exercises3().

00107                                            {
00108                 maxEToCorrect_ = maxE;
00109         }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  s,
const PFClusterCalibration &  cc 
) [friend]

Definition at line 313 of file PFClusterCalibration.cc.

00313                                                                              {
00314         s << "PFClusterCalibration: dump...\n";
00315         s << "barrelEndcapEtaDiv:\t" << cc.barrelEndcapEtaDiv_ << ", ecalOnlyDiv:\t" << cc.ecalOnlyDiv_;
00316         s << ", \nhcalOnlyDiv:\t" << cc.hcalOnlyDiv_ << ", doCorrection:\t" << cc.doCorrection_;
00317         s << ", \nallowNegativeEnergy:\t" << cc.allowNegativeEnergy_;
00318         s << ", \ncorrectionLowLimit:\t" << cc.correctionLowLimit_ << ",parameters:\t" << cc.globalP0_ << ", ";
00319         s << cc.globalP1_ << ", " << cc.lowEP0_ << ", " << cc.lowEP1_;
00320         s << "\ndoEtaCorrection:\t" << cc.doEtaCorrection_;
00321         return s;
00322 }

Member Data Documentation

int pftools::PFClusterCalibration::allowNegativeEnergy_ [private]

Definition at line 141 of file PFClusterCalibration.h.

Referenced by getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), pftools::operator<<(), and setAllowNegativeEnergy().

double pftools::PFClusterCalibration::barrelEndcapEtaDiv_ [private]

Definition at line 134 of file PFClusterCalibration.h.

Referenced by getCalibratedEcalEnergy(), getCalibratedHcalEnergy(), pftools::operator<<(), and setBarrelBoundary().

TF1* pftools::PFClusterCalibration::correction_ [private]

Definition at line 152 of file PFClusterCalibration.h.

Referenced by getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), init(), setCorrections(), and ~PFClusterCalibration().

double pftools::PFClusterCalibration::correctionLowLimit_ [private]

Definition at line 145 of file PFClusterCalibration.h.

Referenced by init(), pftools::operator<<(), and setCorrections().

int pftools::PFClusterCalibration::doCorrection_ [private]

Definition at line 140 of file PFClusterCalibration.h.

Referenced by getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), pftools::operator<<(), and setDoCorrection().

int pftools::PFClusterCalibration::doEtaCorrection_ [private]

Definition at line 142 of file PFClusterCalibration.h.

Referenced by getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), pftools::operator<<(), and setDoEtaCorrection().

double pftools::PFClusterCalibration::ecalOnlyDiv_ [private]

Definition at line 137 of file PFClusterCalibration.h.

Referenced by pftools::operator<<(), and setEcalHcalEnergyCuts().

TF1* pftools::PFClusterCalibration::etaCorrection_ [private]

Definition at line 154 of file PFClusterCalibration.h.

Referenced by getCalibratedEnergy(), getCalibratedEnergyEmbedAInHcal(), init(), setEtaCorrectionParameters(), and ~PFClusterCalibration().

double pftools::PFClusterCalibration::globalP0_ [private]

Definition at line 146 of file PFClusterCalibration.h.

Referenced by init(), pftools::operator<<(), and setCorrections().

double pftools::PFClusterCalibration::globalP1_ [private]

Definition at line 147 of file PFClusterCalibration.h.

Referenced by init(), pftools::operator<<(), and setCorrections().

double pftools::PFClusterCalibration::hcalOnlyDiv_ [private]

Definition at line 138 of file PFClusterCalibration.h.

Referenced by pftools::operator<<(), and setEcalHcalEnergyCuts().

double pftools::PFClusterCalibration::lowEP0_ [private]

Definition at line 148 of file PFClusterCalibration.h.

Referenced by init(), pftools::operator<<(), and setCorrections().

double pftools::PFClusterCalibration::lowEP1_ [private]

Definition at line 149 of file PFClusterCalibration.h.

Referenced by init(), pftools::operator<<(), and setCorrections().

double pftools::PFClusterCalibration::maxEToCorrect_ [private]

Definition at line 143 of file PFClusterCalibration.h.

Referenced by getCalibratedEnergy(), and setMaxEToCorrect().

std::vector<std::string> pftools::PFClusterCalibration::names_ [private]

Definition at line 157 of file PFClusterCalibration.h.

Referenced by getKnownSectorNames(), and init().

std::map<std::string, TF1> pftools::PFClusterCalibration::namesAndFunctions_ [private]

Definition at line 156 of file PFClusterCalibration.h.

Referenced by getCalibratedEcalEnergy(), getCalibratedHcalEnergy(), init(), and setEvolutionParameters().

The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:50:07 2009 for CMSSW by  doxygen 1.5.4