#include <MuScleFitCorrector.h>

Public Member Functions
void	applyPtCorrection (TLorentzVector &lorentzVector, const int &chg)

void	applyPtSmearing (TLorentzVector &lorentzVector, const int &chg, bool fake=false)

double	getCorrectPt (const TLorentzVector &lorentzVector, const int &chg)

resolutionFunctionBase< double * > *	getResolFunction ()

std::vector< double >	getResolMCParVec ()

scaleFunctionBase< double * > *	getScaleFunction ()

double	getSigmaPtDiffSquared (const double &pt, const double &eta)

double	getSmearedPt (const TLorentzVector &lorentzVector, const int &chg, bool fake)

	MuScleFitCorrector (const TString &identifier)

	MuScleFitCorrector ()

	~MuScleFitCorrector ()

Protected Member Functions
void	convertToArrays ()

void	readParameters (const TString &fileName)

Protected Attributes
TString	fileName_

TRandom3 *	gRandom_

double *	resolDataParArray_

std::vector< double >	resolDataParVec_

double *	resolMCParArray_

std::vector< double >	resolMCParVec_

resolutionFunctionBase< double * > *	resolutionFunction_

int	resolutionFunctionId_

scaleFunctionBase< double * > *	scaleFunction_

int	scaleFunctionId_

double *	scaleParArray_

std::vector< double >	scaleParVec_

bool	useResol_

Detailed Description

Definition at line 28 of file MuScleFitCorrector.h.

Constructor & Destructor Documentation

heppy::MuScleFitCorrector::MuScleFitCorrector ( const TString & identifier )

inline

The constructor takes a string identifying the parameters to read. It parses the txt file containing the parameters, extracts the index of the correction function and saves the corresponding pointer. It then fills the vector of parameters.

Definition at line 37 of file MuScleFitCorrector.h.

References fileName_, gRandom_, and readParameters().

     {
       fileName_ = identifier;
       readParameters( identifier ); 
       gRandom_ = new TRandom3();
     }

heppy::MuScleFitCorrector::MuScleFitCorrector ( )

inline

Definition at line 44 of file MuScleFitCorrector.h.

44 {}

heppy::MuScleFitCorrector::~MuScleFitCorrector ( )

inline

Definition at line 45 of file MuScleFitCorrector.h.

45 {}

Member Function Documentation

void heppy::MuScleFitCorrector::applyPtCorrection	(	TLorentzVector &	lorentzVector,
		const int &	chg
	)

inline

Definition at line 96 of file MuScleFitCorrector.h.

References eta, getCorrectPt(), visualization-live-secondInstance_cfg::m, and phi().

                                                                         {
     
     double eta = lorentzVector.Eta();
     double phi = lorentzVector.Phi();
     double m  = lorentzVector.M(); 
     double corrPt = getCorrectPt(lorentzVector, chg);
     lorentzVector.SetPtEtaPhiM(corrPt,eta,phi,m);
     
   };

void heppy::MuScleFitCorrector::applyPtSmearing	(	TLorentzVector &	lorentzVector,
		const int &	chg,
		bool	fake = `false`
	)

inline

Definition at line 107 of file MuScleFitCorrector.h.

References eta, getSmearedPt(), visualization-live-secondInstance_cfg::m, and phi().

                                                                                        {
     double eta = lorentzVector.Eta();
     double phi = lorentzVector.Phi();
     double m  = lorentzVector.M(); 
     double smearedPt = getSmearedPt(lorentzVector, chg, fake);
     lorentzVector.SetPtEtaPhiM(smearedPt,eta,phi,m);  
   };

void heppy::MuScleFitCorrector::convertToArrays ( )

inlineprotected

Definition at line 138 of file MuScleFitCorrector.h.

References gather_cfg::cout, cmsRelvalreport::exit, scaleFunctionBase< T >::parNum(), resolutionFunctionBase< T >::parNum(), resolDataParArray_, resolDataParVec_, resolMCParArray_, resolMCParVec_, resolutionFunction_, scaleFunction_, scaleParArray_, scaleParVec_, and useResol_.

Referenced by readParameters().

                         {
     
     int resolParNum = resolutionFunction_->parNum();
     int scaleParNum = scaleFunction_->parNum();
     
     int resolDataParVecSize = resolDataParVec_.size();
     int resolMCParVecSize = resolMCParVec_.size();
     int scaleParVecSize = scaleParVec_.size();
     
     useResol_ = false;
     if (resolDataParVecSize!=0 && resolMCParVecSize!=0)  useResol_ = true;
 
     if( resolParNum != resolDataParVecSize && useResol_) {
       std::cout << "Error: inconsistent number of parameters: resolutionFunction has "<<resolParNum<<" parameters but "<<resolDataParVecSize<<" have been read from file" << std::endl;
       exit(1);
     }
     
     if( resolParNum != resolMCParVecSize && useResol_) {
       std::cout << "Error: inconsistent number of parameters: resolutionFunction has "<<resolParNum<<" parameters but "<<resolMCParVecSize<<" have been read from file" << std::endl;
       exit(1);
     }
     
     if( scaleParNum != scaleParVecSize ) {
       std::cout << "Error: inconsistent number of parameters: scaleFunction has "<<scaleParNum<<" parameters but "<<scaleParVecSize<<" have been read from file" << std::endl;
       exit(1);
     }
     
     
     std::vector<double>::const_iterator scaleParIt = scaleParVec_.begin();
     std::vector<double>::const_iterator resolDataParIt = resolDataParVec_.begin();
     std::vector<double>::const_iterator resolMCParIt = resolMCParVec_.begin();
     
     scaleParArray_ = new double[scaleParNum];
     resolDataParArray_ = new double[resolParNum];
     resolMCParArray_ = new double[resolParNum];
     
     for ( int iPar=0; iPar<scaleParNum; ++iPar) {
       double parameter = *scaleParIt;
       scaleParArray_[iPar] = parameter;
       ++scaleParIt;
     }
     
     if (useResol_){
       for ( int iPar=0; iPar<resolParNum; ++iPar) {
     double parameter = *resolDataParIt;
     resolDataParArray_[iPar] = parameter;
     ++resolDataParIt;
       }
       
       for ( int iPar=0; iPar<resolParNum; ++iPar) {
     double parameter = *resolMCParIt;
     resolMCParArray_[iPar] = parameter;
     ++resolMCParIt;
       }
     }
     
   }

double heppy::MuScleFitCorrector::getCorrectPt	(	const TLorentzVector &	lorentzVector,
		const int &	chg
	)

inline

Definition at line 52 of file MuScleFitCorrector.h.

References chg, EnergyCorrector::pt, scaleFunctionBase< T >::scale(), scaleFunction_, and scaleParArray_.

Referenced by applyPtCorrection().

                                                                            {
     
     // Loop on all the functions and apply them iteratively on the pt corrected by the previous function.
     double pt = lorentzVector.Pt();
     pt = ( scaleFunction_->scale( pt, lorentzVector.Eta(), lorentzVector.Phi(), chg, scaleParArray_) );
     return pt;
   };

resolutionFunctionBase<double * >* heppy::MuScleFitCorrector::getResolFunction ( )

inline

Definition at line 49 of file MuScleFitCorrector.h.

References resolutionFunction_.

49 { return resolutionFunction_; }

heppy::MuScleFitCorrector::resolutionFunction_

resolutionFunctionBase< double * > * resolutionFunction_

Definition: MuScleFitCorrector.h:302

std::vector<double> heppy::MuScleFitCorrector::getResolMCParVec ( )

inline

Definition at line 115 of file MuScleFitCorrector.h.

References resolMCParVec_.

115 { return resolMCParVec_; }

heppy::MuScleFitCorrector::resolMCParVec_

std::vector< double > resolMCParVec_

Definition: MuScleFitCorrector.h:130

scaleFunctionBase<double * >* heppy::MuScleFitCorrector::getScaleFunction ( )

inline

Definition at line 48 of file MuScleFitCorrector.h.

References scaleFunction_.

48 { return scaleFunction_; }

heppy::MuScleFitCorrector::scaleFunction_

scaleFunctionBase< double * > * scaleFunction_

Definition: MuScleFitCorrector.h:301

double heppy::MuScleFitCorrector::getSigmaPtDiffSquared	(	const double &	pt,
		const double &	eta
	)

inline

Definition at line 61 of file MuScleFitCorrector.h.

References resolDataParArray_, resolMCParArray_, resolutionFunction_, and resolutionFunctionBase< T >::sigmaPt().

Referenced by getSmearedPt().

                                                                      {
   
     double sigmaPtData = resolutionFunction_->sigmaPt(pt, eta, resolDataParArray_);
     double sigmaPtMC = resolutionFunction_->sigmaPt(pt, eta, resolMCParArray_);
     return (sigmaPtData*sigmaPtData - sigmaPtMC*sigmaPtMC);
     
   };

double heppy::MuScleFitCorrector::getSmearedPt	(	const TLorentzVector &	lorentzVector,
		const int &	chg,
		bool	fake
	)

inline

Definition at line 71 of file MuScleFitCorrector.h.

References gather_cfg::cout, eta, cmsRelvalreport::exit, fileName_, getSigmaPtDiffSquared(), gRandom_, EnergyCorrector::pt, and mathSSE::sqrt().

Referenced by applyPtSmearing().

                                                                                        {
     
     double pt = lorentzVector.Pt();
     double eta = lorentzVector.Eta();
     double squaredDiff = getSigmaPtDiffSquared(pt,eta);
     if (squaredDiff < 0) return pt;
     double Cfact = 0.;
     if (fileName_.Contains("smearPrompt")) Cfact = 0.85; // smear Summer12 against 2012 Prompt data
     else if (fileName_.Contains("smearReReco")) Cfact = 0.75; // smear Summer12 against 2012 ReReco data
     else if (fileName_.Contains("2011_MC")) Cfact = 0.8; // smear Fall11 against 2011 ReReco data
     else {
       std::cout<<"Are you sure you want to smear data??"<<std::endl;
       exit(1);
     }
     double sPar = Cfact*sqrt(squaredDiff);
     double curv = ((double)chg/pt);
     double normSmearFact = gRandom_->Gaus(0,sPar);
     if (fake) normSmearFact = sPar;
     double smearedCurv = curv + fabs(curv)*normSmearFact;
     
     return 1./((double)chg*smearedCurv);
     
   };

void heppy::MuScleFitCorrector::readParameters ( const TString & fileName )

inlineprotected

Definition at line 199 of file MuScleFitCorrector.h.

References convertToArrays(), gather_cfg::cout, recoMuon::in, align_cfg::iteration, geometryCSVtoXML::line, pileupDistInMC::num, scaleFunctionBase< T >::parNum(), resolutionFunctionBase< T >::parNum(), resolDataParArray_, resolDataParVec_, resolMCParArray_, resolMCParVec_, resolutionFunction_, resolutionFunctionId_, resolutionFunctionService(), scaleFunction_, scaleFunctionId_, scaleFunctionService(), scaleParArray_, scaleParVec_, AlCaHLTBitMon_QueryRunRegistry::string, and useResol_.

Referenced by MuScleFitCorrector().

                                               {
     scaleParArray_ = 0;
     resolDataParArray_ = 0;
     resolMCParArray_ = 0;
     
     // Read the parameters file
     ifstream parametersFile(fileName.Data());
     
     if( !parametersFile.is_open() ) {
       std::cout << "Error: file " << fileName << " not found. Aborting." << std::endl;
       abort();
     }
     
     std::string line;
     int nReadPar = 0;
     std::string iteration("Iteration ");
     // Loop on the file lines
     while (parametersFile) {
       
       getline( parametersFile, line );
       size_t lineInt = line.find("value");
       size_t iterationSubStr = line.find(iteration);
       
       if( iterationSubStr != std::string::npos ) {
     
     std::stringstream sLine(line);
     std::string num;
     int scaleFunctionNum = 0;
     int resolutionFunctionNum = 0;
     int wordCounter = 0;
     
     // Warning: this strongly depends on the parameters file structure.                                                                                   
     while( sLine >> num ) {
       ++wordCounter;
       if( wordCounter == 8 ) {
       std::stringstream in(num);
       in >> resolutionFunctionNum;
       }
       
       if( wordCounter == 9 ) {
         std::stringstream in(num);
         in >> scaleFunctionNum;
       }
     }
     
     scaleFunctionId_ = scaleFunctionNum;
     scaleFunction_ = scaleFunctionService(scaleFunctionNum);
     resolutionFunctionId_ = resolutionFunctionNum;
     resolutionFunction_ = resolutionFunctionService(resolutionFunctionNum);
     
     /*       std::cout<<"Function IDs: "<<std::endl; */
     /*       std::cout<<"     scale function number "<<scaleFunctionId_<<std::endl; */
     /*       std::cout<<"     resolution function number "<<resolutionFunctionId_<<std::endl; */
     
       }
       
       int nScalePar = scaleFunction_->parNum();
       int nResolPar = resolutionFunction_->parNum();
       
       if ( (lineInt != std::string::npos) ) {
     size_t subStr1 = line.find("value");
     std::stringstream paramStr;
     double param = 0;
     paramStr << line.substr(subStr1+5);
     paramStr >> param;
     // Fill the last vector of parameters, which corresponds to this iteration.
     if (nReadPar<nScalePar) {
       scaleParVec_.push_back(param);
     }
     else if (nReadPar < (nScalePar+nResolPar) ) {
       resolDataParVec_.push_back(param);
     }
     else if (nReadPar < (nScalePar+2*nResolPar) ) {
       resolMCParVec_.push_back(param);
     }
     ++nReadPar;
       }
     }
     convertToArrays();
     
     /*   std::cout<<"Scale function n. "<<scaleFunctionId_<<" has "<<scaleFunction_->parNum()<<"parameters:"<<std::endl; */
     /*   for (int ii=0; ii<scaleFunction_->parNum(); ++ii){ */
     /*     std::cout<<"par["<<ii<<"] = "<<scaleParArray_[ii]<<std::endl; */
     /*   } */
     
     if (useResol_){
       
       /*     std::cout<<"Resolution data function n. "<<resolutionFunctionId_<<" has "<<resolutionFunction_->parNum()<<"parameters:"<<std::endl; */
       /*     for (int ii=0; ii<resolutionFunction_->parNum(); ++ii){ */
       /*       std::cout<<"par["<<ii<<"] = "<<resolDataParArray_[ii]<<std::endl; */
       /*     } */
       
       /*     std::cout<<"Resolution MC function n. "<<resolutionFunctionId_<<" has "<<resolutionFunction_->parNum()<<"parameters:"<<std::endl; */
       /*     for (int ii=0; ii<resolutionFunction_->parNum(); ++ii){ */
       /*       std::cout<<"par["<<ii<<"] = "<<resolMCParArray_[ii]<<std::endl; */
       /*     } */
       
     } 
   }