Reference Manual

Go to the documentation of this file.
00001 // This is the file "FactorizedJetCorrector.cc". 
00002 // This is the implementation of the class FactorizedJetCorrector.
00003 // Author: Konstantinos Kousouris, Philipp Schieferdecker
00004 // Email:  kkousour@fnal.gov, philipp.schieferdecker@cern.ch
00005 
00006 #include "CondFormats/JetMETObjects/interface/FactorizedJetCorrector.h"
00007 #include "CondFormats/JetMETObjects/interface/SimpleJetCorrector.h"
00008 #include "CondFormats/JetMETObjects/interface/JetCorrectorParameters.h"
00009 #include "CondFormats/JetMETObjects/src/Utilities.cc"
00010 #include "Math/PtEtaPhiE4D.h"
00011 #include "Math/Vector3D.h"
00012 #include "Math/LorentzVector.h"
00013 #include <vector>
00014 #include <string>
00015 #include <sstream>
00016 
00017 //------------------------------------------------------------------------ 
00018 //--- Default FactorizedJetCorrector constructor -------------------------
00019 //------------------------------------------------------------------------
00020 FactorizedJetCorrector::FactorizedJetCorrector()
00021 {
00022   mJetEta = -9999;
00023   mJetPt  = -9999;
00024   mJetPhi = -9999;
00025   mJetE   = -9999;
00026   mJetEMF = -9999;
00027   mJetA   = -9999;
00028   mRho    = -9999;
00029   mLepPx  = -9999;
00030   mLepPy  = -9999;
00031   mLepPz  = -9999;
00032   mNPV    = -9999;
00033   mAddLepToJet      = false;
00034   mIsNPVset         = false;
00035   mIsJetEset        = false;
00036   mIsJetPtset       = false;
00037   mIsJetPhiset      = false;
00038   mIsJetEtaset      = false;
00039   mIsJetEMFset      = false;
00040   mIsJetAset        = false;
00041   mIsRhoset         = false;
00042   mIsLepPxset       = false;
00043   mIsLepPyset       = false;
00044   mIsLepPzset       = false;
00045   mIsAddLepToJetset = false;
00046 }
00047 //------------------------------------------------------------------------ 
00048 //--- FactorizedJetCorrector constructor ---------------------------------
00049 //------------------------------------------------------------------------
00050 FactorizedJetCorrector::FactorizedJetCorrector(const std::string& fLevels, const std::string& fFiles, const std::string& fOptions)
00051 {
00052   mJetEta = -9999;
00053   mJetPt  = -9999;
00054   mJetPhi = -9999;
00055   mJetE   = -9999;
00056   mJetEMF = -9999;
00057   mJetA   = -9999;
00058   mRho    = -9999;
00059   mLepPx  = -9999;
00060   mLepPy  = -9999;
00061   mLepPz  = -9999;
00062   mNPV    = -9999;
00063   mAddLepToJet      = false;
00064   mIsNPVset         = false;
00065   mIsJetEset        = false;
00066   mIsJetPtset       = false;
00067   mIsJetPhiset      = false;
00068   mIsJetEtaset      = false;
00069   mIsJetEMFset      = false;
00070   mIsJetAset        = false;
00071   mIsRhoset         = false; 
00072   mIsLepPxset       = false;
00073   mIsLepPyset       = false;
00074   mIsLepPzset       = false;
00075   mIsAddLepToJetset = false;
00076   initCorrectors(fLevels, fFiles, fOptions);       
00077 }
00078 //------------------------------------------------------------------------
00079 //--- FactorizedJetCorrector constructor ---------------------------------
00080 //------------------------------------------------------------------------
00081 FactorizedJetCorrector::FactorizedJetCorrector(const std::vector<JetCorrectorParameters>& fParameters)
00082 {
00083   mJetEta = -9999;
00084   mJetPt  = -9999;
00085   mJetPhi = -9999;
00086   mJetE   = -9999;
00087   mJetEMF = -9999;
00088   mJetA   = -9999;
00089   mRho    = -9999;
00090   mLepPx  = -9999;
00091   mLepPy  = -9999;
00092   mLepPz  = -9999;
00093   mNPV    = -9999;
00094   mAddLepToJet      = false;
00095   mIsNPVset         = false;
00096   mIsJetEset        = false;
00097   mIsJetPtset       = false;
00098   mIsJetPhiset      = false;
00099   mIsJetEtaset      = false;
00100   mIsJetEMFset      = false;
00101   mIsJetAset        = false;
00102   mIsRhoset         = false;
00103   mIsLepPxset       = false;
00104   mIsLepPyset       = false;
00105   mIsLepPzset       = false;
00106   mIsAddLepToJetset = false;
00107   for(unsigned i=0;i<fParameters.size();i++)
00108     {
00109       std::string ss = fParameters[i].definitions().level();
00110       if (ss == "L1Offset")
00111         mLevels.push_back(kL1);
00112       else if (ss == "L1JPTOffset")
00113         mLevels.push_back(kL1);
00114       else if (ss == "L2Relative")
00115         mLevels.push_back(kL2);
00116       else if (ss == "L3Absolute")
00117         mLevels.push_back(kL3);
00118       else if (ss == "L4EMF")
00119         mLevels.push_back(kL4);
00120       else if (ss == "L5Flavor")
00121         mLevels.push_back(kL5);
00122       else if (ss == "L6SLB")
00123         mLevels.push_back(kL6);
00124       else if (ss == "L7Parton")
00125         mLevels.push_back(kL7);
00126       else if (ss == "L1FastJet")
00127         mLevels.push_back(kL1fj);
00128       mCorrectors.push_back(new SimpleJetCorrector(fParameters[i]));
00129       mBinTypes.push_back(mapping(mCorrectors[i]->parameters().definitions().binVar()));
00130       mParTypes.push_back(mapping(mCorrectors[i]->parameters().definitions().parVar()));
00131     }  
00132 }
00133 
00134 //------------------------------------------------------------------------ 
00135 //--- FactorizedJetCorrector destructor ----------------------------------
00136 //------------------------------------------------------------------------
00137 FactorizedJetCorrector::~FactorizedJetCorrector()
00138 {
00139   for(unsigned i=0;i<mCorrectors.size();i++)
00140     delete mCorrectors[i];
00141 }
00142 //------------------------------------------------------------------------ 
00143 //--- initialises the correctors -----------------------------------------
00144 //------------------------------------------------------------------------
00145 void FactorizedJetCorrector::initCorrectors(const std::string& fLevels, const std::string& fFiles, const std::string& fOptions)
00146 {
00147   //---- Read the CorrectionLevels string and parse the requested sub-correction levels.
00148   std::vector<std::string> tmp = parseLevels(removeSpaces(fLevels));
00149   for(unsigned i=0;i<tmp.size();i++)
00150     {
00151       if (tmp[i] == "L1Offset")
00152         mLevels.push_back(kL1);
00153       else if (tmp[i] == "L1JPTOffset")
00154         mLevels.push_back(kL1);
00155       else if (tmp[i] == "L2Relative")
00156         mLevels.push_back(kL2);
00157       else if (tmp[i] == "L3Absolute")
00158         mLevels.push_back(kL3);
00159       else if (tmp[i] == "L4EMF")
00160         mLevels.push_back(kL4);
00161       else if (tmp[i] == "L5Flavor")
00162         mLevels.push_back(kL5);
00163       else if (tmp[i] == "L6SLB")
00164         mLevels.push_back(kL6);
00165       else if (tmp[i] == "L7Parton")
00166         mLevels.push_back(kL7);
00167       else if (tmp[i] == "L1FastJet")
00168         mLevels.push_back(kL1fj);
00169       else
00170         {
00171           std::stringstream sserr; 
00172           sserr<<"unknown correction level "<<tmp[i];
00173           handleError("FactorizedJetCorrector",sserr.str());
00174         }                                                       
00175     }            
00176   //---- Read the parameter filenames string and parse the requested sub-correction tags.
00177   std::vector<std::string> Files = parseLevels(removeSpaces(fFiles));
00178   //---- Read the Options string and define the FlavorOption and PartonOption.
00179   std::string FlavorOption = parseOption(removeSpaces(fOptions),"L5Flavor");
00180   std::string PartonOption = parseOption(removeSpaces(fOptions),"L7Parton");
00181   //---- Check the consistency between tags and requested sub-corrections. 
00182   checkConsistency(tmp,Files);  
00183   //---- Create instances of the requested sub-correctors.
00184   for(unsigned i=0;i<mLevels.size();i++)
00185     {               
00186       if (mLevels[i]==kL1 || mLevels[i]==kL2 || mLevels[i]==kL3 || mLevels[i]==kL4 || mLevels[i]==kL6 || mLevels[i]==kL1fj)
00187         mCorrectors.push_back(new SimpleJetCorrector(Files[i])); 
00188       else if (mLevels[i]==kL5 && FlavorOption.length()==0) 
00189         handleError("FactorizedJetCorrector","must specify flavor option when requesting L5Flavor correction!");
00190       else if (mLevels[i]==kL5 && FlavorOption.length()>0)
00191         mCorrectors.push_back(new SimpleJetCorrector(Files[i],FlavorOption));
00192       else if (mLevels[i]==kL7 && PartonOption.length()==0) 
00193         handleError("FactorizedJetCorrector","must specify parton option when requesting L7Parton correction!");
00194       else if (mLevels[i]==kL7 && PartonOption.length()>0)
00195         mCorrectors.push_back(new SimpleJetCorrector(Files[i],PartonOption));
00196       else 
00197         {
00198           std::stringstream sserr; 
00199           sserr<<"unknown correction level "<<tmp[i];
00200           handleError("FactorizedJetCorrector",sserr.str());
00201         }
00202       mBinTypes.push_back(mapping(mCorrectors[i]->parameters().definitions().binVar())); 
00203       mParTypes.push_back(mapping(mCorrectors[i]->parameters().definitions().parVar()));        
00204     } 
00205 }
00206 //------------------------------------------------------------------------ 
00207 //--- Mapping between variable names and variable types ------------------
00208 //------------------------------------------------------------------------
00209 std::vector<FactorizedJetCorrector::VarTypes> FactorizedJetCorrector::mapping(const std::vector<std::string>& fNames)
00210 {
00211   std::vector<VarTypes> result;
00212   for(unsigned i=0;i<fNames.size();i++)
00213     {
00214       std::string ss = fNames[i]; 
00215       if (ss=="JetPt")
00216          result.push_back(kJetPt);
00217       else if (ss=="JetEta")
00218          result.push_back(kJetEta); 
00219       else if (ss=="JetPhi")
00220          result.push_back(kJetPhi);
00221       else if (ss=="JetE")
00222          result.push_back(kJetE);
00223       else if (ss=="JetEMF")
00224          result.push_back(kJetEMF);
00225       else if (ss=="RelLepPt")
00226         result.push_back(kRelLepPt);
00227       else if (ss=="PtRel")
00228         result.push_back(kPtRel);
00229       else if (ss=="NPV")
00230         result.push_back(kNPV);
00231       else if (ss=="JetA")
00232         result.push_back(kJetA);
00233       else if (ss=="Rho")
00234         result.push_back(kRho);
00235       else
00236          {
00237            std::stringstream sserr; 
00238            sserr<<"unknown parameter name: "<<ss;
00239            handleError("FactorizedJetCorrector",sserr.str());
00240          }
00241     }
00242   return result;  
00243 }
00244 //------------------------------------------------------------------------ 
00245 //--- Consistency checker ------------------------------------------------
00246 //------------------------------------------------------------------------
00247 void FactorizedJetCorrector::checkConsistency(const std::vector<std::string>& fLevels, const std::vector<std::string>& fTags)
00248 {
00249   //---- First check: the number of tags must be equal to the number of sub-corrections.
00250   if (fLevels.size() != fTags.size()) 
00251     {
00252       std::stringstream sserr; 
00253       sserr<<"number of correction levels: "<<fLevels.size()<<" doesn't match # of tags: "<<fTags.size();
00254       handleError("FactorizedJetCorrector",sserr.str());
00255     }
00256   //---- Second check: each tag must contain the corresponding sub-correction level.
00257   for(unsigned int i=0;i<fTags.size();i++) 
00258     if ((int)fTags[i].find(fLevels[i])<0) 
00259       {
00260         std::stringstream sserr; 
00261         sserr<<"inconsistent tag: "<<fTags[i]<<" for "<<"the requested correction: "<<fLevels[i];
00262         handleError("FactorizedJetCorrector",sserr.str());
00263       }
00264 }
00265 //------------------------------------------------------------------------ 
00266 //--- String parser ------------------------------------------------------
00267 //------------------------------------------------------------------------
00268 std::vector<std::string> FactorizedJetCorrector::parseLevels(const std::string& ss)
00269 {
00270   std::vector<std::string> result;
00271   unsigned int pos(0),j,newPos;
00272   int i;
00273   std::string tmp;
00274   //---- The ss string must be of the form: "LX:LY:...:LZ"
00275   while (pos<ss.length())
00276     {
00277       tmp = "";
00278       i = ss.find(":" , pos);
00279       if (i<0 && pos==0)
00280         {
00281           result.push_back(ss);
00282           pos = ss.length();
00283         }
00284       else if (i<0 && pos>0)
00285         {
00286           for(j=pos;j<ss.length();j++)
00287             tmp+=ss[j];
00288           result.push_back(tmp);
00289           pos = ss.length();
00290         }  
00291       else
00292         {
00293           newPos = i;
00294           for(j=pos;j<newPos;j++)
00295             tmp+=ss[j];
00296           result.push_back(tmp);
00297           pos = newPos+1;     
00298         }
00299     }
00300   return result;
00301 }
00302 //------------------------------------------------------------------------ 
00303 //--- String parser ------------------------------------------------------
00304 //------------------------------------------------------------------------
00305 std::string FactorizedJetCorrector::parseOption(const std::string& ss, const std::string& type)
00306 {
00307   std::string result;
00308   int pos1(-1),pos2(-1);
00309   //---- The ss string must be of the form: "type1:option1&type2:option2&..."
00310   pos1 = ss.find(type+":");
00311   if (pos1<0)
00312     result = "";
00313   else
00314     {
00315       pos2 = ss.find("&",pos1+type.length()+1); 
00316       if (pos2<0)
00317         result = ss.substr(pos1+type.length()+1,ss.length()-pos1-type.length()-1);
00318       else
00319         result = ss.substr(pos1+type.length()+1,pos2-pos1-type.length()-1);
00320     }
00321   return result;
00322 }
00323 //------------------------------------------------------------------------ 
00324 //--- String manipulator -------------------------------------------------
00325 //------------------------------------------------------------------------
00326 std::string FactorizedJetCorrector::removeSpaces(const std::string& ss)
00327 {
00328   std::string result("");
00329   std::string aChar;
00330   for(unsigned int i=0;i<ss.length();i++)
00331     {
00332       aChar = ss.substr(i,1);
00333       if (aChar != " ")
00334         result+=aChar;
00335     }
00336   return result; 
00337 }
00338 //------------------------------------------------------------------------ 
00339 //--- Returns the correction ---------------------------------------------
00340 //------------------------------------------------------------------------
00341 float FactorizedJetCorrector::getCorrection()
00342 {
00343   std::vector<float> vv = getSubCorrections();
00344   return vv[vv.size()-1];
00345 }
00346 //------------------------------------------------------------------------ 
00347 //--- Returns the vector of subcorrections, up to a given level ----------
00348 //------------------------------------------------------------------------
00349 std::vector<float> FactorizedJetCorrector::getSubCorrections()
00350 {
00351   float scale,factor;
00352   std::vector<float> factors;
00353   std::vector<float> vx,vy;
00354   factor = 1;
00355   for(unsigned int i=0;i<mLevels.size();i++)
00356     { 
00357       vx = fillVector(mBinTypes[i]);
00358       vy = fillVector(mParTypes[i]);
00359       //if (mLevels[i]==kL2 || mLevels[i]==kL6)
00360         //mCorrectors[i]->setInterpolation(true); 
00361       scale = mCorrectors[i]->correction(vx,vy);        
00362       if (mLevels[i]==kL6 && mAddLepToJet) scale *= 1.0 + getLepPt() / mJetPt;
00363       factor*=scale; 
00364       factors.push_back(factor);        
00365       mJetE *=scale;
00366       mJetPt*=scale;
00367     }
00368   mIsNPVset    = false;
00369   mIsJetEset   = false;
00370   mIsJetPtset  = false;
00371   mIsJetPhiset = false;
00372   mIsJetEtaset = false;
00373   mIsJetEMFset = false;
00374   mIsJetAset   = false;
00375   mIsRhoset    = false;
00376   mIsLepPxset  = false;
00377   mIsLepPyset  = false;
00378   mIsLepPzset  = false;
00379   mAddLepToJet = false;
00380   return factors; 
00381 }
00382 //------------------------------------------------------------------------ 
00383 //--- Reads the parameter names and fills a vector of floats -------------
00384 //------------------------------------------------------------------------
00385 std::vector<float> FactorizedJetCorrector::fillVector(std::vector<VarTypes> fVarTypes)
00386 {
00387   std::vector<float> result;
00388   for(unsigned i=0;i<fVarTypes.size();i++) 
00389     {
00390       if (fVarTypes[i] == kJetEta)
00391         {
00392           if (!mIsJetEtaset) 
00393             handleError("FactorizedJetCorrector","jet eta is not set");
00394           result.push_back(mJetEta);
00395         }
00396       else if (fVarTypes[i] == kNPV)
00397         {
00398           if (!mIsNPVset)
00399             handleError("FactorizedJetCorrector","number of primary vertices is not set");
00400           result.push_back(mNPV);
00401         }
00402       else if (fVarTypes[i] == kJetPt) 
00403         {
00404           if (!mIsJetPtset)
00405             handleError("FactorizedJetCorrector","jet pt is not set");
00406           result.push_back(mJetPt);
00407         }
00408       else if (fVarTypes[i] == kJetPhi) 
00409         {
00410           if (!mIsJetPhiset) 
00411             handleError("FactorizedJetCorrector","jet phi is not set");
00412           result.push_back(mJetPhi);
00413         }
00414       else if (fVarTypes[i] == kJetE) 
00415         {
00416           if (!mIsJetEset) 
00417             handleError("FactorizedJetCorrector","jet E is not set");
00418           result.push_back(mJetE);
00419         }
00420       else if (fVarTypes[i] == kJetEMF) 
00421         {
00422           if (!mIsJetEMFset) 
00423             handleError("FactorizedJetCorrector","jet EMF is not set");
00424           result.push_back(mJetEMF);
00425         } 
00426       else if (fVarTypes[i] == kJetA) 
00427         {
00428           if (!mIsJetAset) 
00429             handleError("FactorizedJetCorrector","jet area is not set");
00430           result.push_back(mJetA);
00431         }
00432       else if (fVarTypes[i] == kRho) 
00433         {
00434           if (!mIsRhoset) 
00435             handleError("FactorizedJetCorrector","fastjet density Rho is not set");
00436           result.push_back(mRho);
00437         }
00438       else if (fVarTypes[i] == kRelLepPt) 
00439         {
00440           if (!mIsJetPtset||!mIsAddLepToJetset||!mIsLepPxset||!mIsLepPyset) 
00441             handleError("FactorizedJetCorrector","can't calculate rel lepton pt");
00442           result.push_back(getRelLepPt());
00443         }
00444       else if (fVarTypes[i] == kPtRel) 
00445         {
00446           if (!mIsJetPtset||!mIsJetEtaset||!mIsJetPhiset||!mIsJetEset||
00447               !mIsAddLepToJetset||!mIsLepPxset||!mIsLepPyset||!mIsLepPzset) 
00448             handleError("FactorizedJetCorrector","can't calculate ptrel");
00449           result.push_back(getPtRel());
00450         }
00451       else 
00452         {
00453           std::stringstream sserr; 
00454           sserr<<"unknown parameter "<<fVarTypes[i];
00455           handleError("FactorizedJetCorrector",sserr.str());
00456         }
00457     }
00458   return result;      
00459 }
00460 //------------------------------------------------------------------------ 
00461 //--- Calculate the lepPt (needed for the SLB) ---------------------------
00462 //------------------------------------------------------------------------
00463 float FactorizedJetCorrector::getLepPt() const
00464 {
00465   return std::sqrt(mLepPx*mLepPx + mLepPy*mLepPy);
00466 }
00467 //------------------------------------------------------------------------ 
00468 //--- Calculate the relLepPt (needed for the SLB) ---------------------------
00469 //------------------------------------------------------------------------
00470 float FactorizedJetCorrector::getRelLepPt() const
00471 {
00472   float lepPt = getLepPt();
00473   return (mAddLepToJet) ? lepPt/(mJetPt + lepPt) : lepPt/mJetPt;
00474 }
00475 //------------------------------------------------------------------------ 
00476 //--- Calculate the PtRel (needed for the SLB) ---------------------------
00477 //------------------------------------------------------------------------
00478 float FactorizedJetCorrector::getPtRel() const
00479 {
00480   typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiE4D<float> >
00481     PtEtaPhiELorentzVector;
00482   typedef ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float> >
00483     XYZVector;
00484   PtEtaPhiELorentzVector jet;
00485   XYZVector lep;
00486   jet.SetPt(mJetPt);
00487   jet.SetEta(mJetEta);
00488   jet.SetPhi(mJetPhi);
00489   jet.SetE(mJetE);
00490   lep.SetXYZ(mLepPx,mLepPy,mLepPz);
00491   float lj_x = (mAddLepToJet) ? lep.X()+jet.Px() : jet.Px();
00492   float lj_y = (mAddLepToJet) ? lep.Y()+jet.Py() : jet.Py();
00493   float lj_z = (mAddLepToJet) ? lep.Z()+jet.Pz() : jet.Pz();
00494   // absolute values squared
00495   float lj2  = lj_x*lj_x+lj_y*lj_y+lj_z*lj_z;
00496   if (lj2<=0) {
00497     std::stringstream sserr; 
00498     sserr<<"lepton+jet momentum sq is not positive: "<<lj2;
00499     handleError("FactorizedJetCorrector",sserr.str());
00500   }
00501   float lep2 = lep.X()*lep.X()+lep.Y()*lep.Y()+lep.Z()*lep.Z();
00502   // projection vec(mu) to lepjet axis
00503   float lepXlj = lep.X()*lj_x+lep.Y()*lj_y+lep.Z()*lj_z;
00504   // absolute value squared and normalized
00505   float pLrel2 = lepXlj*lepXlj/lj2;
00506   // lep2 = pTrel2 + pLrel2
00507   float pTrel2 = lep2-pLrel2;
00508   return (pTrel2 > 0) ? std::sqrt(pTrel2) : 0.0;
00509 }
00510 //------------------------------------------------------------------------ 
00511 //--- Setters ------------------------------------------------------------
00512 //------------------------------------------------------------------------
00513 void FactorizedJetCorrector::setNPV(int fNPV)
00514 {
00515   mNPV = fNPV;
00516   mIsNPVset = true;
00517 }
00518 void FactorizedJetCorrector::setJetEta(float fEta)
00519 {
00520   mJetEta = fEta;
00521   mIsJetEtaset = true;
00522 }
00523 //------------------------------------------------------------------------
00524 void FactorizedJetCorrector::setJetPt(float fPt)
00525 {
00526   mJetPt = fPt;
00527   mIsJetPtset  = true;
00528 }
00529 //------------------------------------------------------------------------
00530 void FactorizedJetCorrector::setJetPhi(float fPhi)
00531 {
00532   mJetPhi = fPhi;
00533   mIsJetPhiset  = true;
00534 }
00535 //------------------------------------------------------------------------
00536 void FactorizedJetCorrector::setJetE(float fE)
00537 {
00538   mJetE = fE;
00539   mIsJetEset   = true;
00540 }
00541 //------------------------------------------------------------------------
00542 void FactorizedJetCorrector::setJetEMF(float fEMF)
00543 {
00544   mJetEMF = fEMF;
00545   mIsJetEMFset = true;
00546 }
00547 //------------------------------------------------------------------------
00548 void FactorizedJetCorrector::setJetA(float fA)
00549 {
00550   mJetA = fA;
00551   mIsJetAset = true;
00552 }
00553 //------------------------------------------------------------------------
00554 void FactorizedJetCorrector::setRho(float fRho)
00555 {
00556   mRho = fRho;
00557   mIsRhoset = true;
00558 }
00559 //------------------------------------------------------------------------
00560 void FactorizedJetCorrector::setLepPx(float fPx)
00561 {
00562   mLepPx = fPx;
00563   mIsLepPxset  = true;
00564 }
00565 //------------------------------------------------------------------------
00566 void FactorizedJetCorrector::setLepPy(float fPy)
00567 {
00568   mLepPy = fPy;
00569   mIsLepPyset  = true;
00570 }
00571 //------------------------------------------------------------------------
00572 void FactorizedJetCorrector::setLepPz(float fPz)
00573 {
00574   mLepPz = fPz;
00575   mIsLepPzset  = true;
00576 }
00577 //------------------------------------------------------------------------
00578 void FactorizedJetCorrector::setAddLepToJet(bool fAddLepToJet)
00579 {
00580   mAddLepToJet = fAddLepToJet;
00581   mIsAddLepToJetset = true;
00582 }
/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/CondFormats/JetMETObjects/src/FactorizedJetCorrector.cc
