#include <Lfluk.h>
Public Member Functions | |
Lfluk () | |
virtual | ~Lfluk () |
void | SetConfig (const std::string param, const std::string skew, const std::string na49fit, const double wmin, const double wmax) |
void | Config (const Registry ®) |
void | Init () |
void | SetParameters (std::vector< double > par) |
const std::vector< double > & | GetParameters () |
double | GetWeight (int ptype, double pt, double pz) |
double | GetMeanPT (int ptype) |
double | GetReweightedMeanPT (int ptype) |
double | GetPTshift (int ptype, double pz_low=0., double pz_up=120.) |
double | GetNFrac (int ptype, double pz_low=0., double pz_up=120., double pt_low=0., double pt_up=1.) |
TH2F * | GetReweightedPTXF (int ptype) |
TH2F * | GetPTXF (int ptype) |
TH2D * | GetWeightHistogram (int ptype) |
TH2 * | GetWeightHist (const std::string &ptype) |
TH1 * | GetFlukKPiRatio () |
TH1 * | GetPiPlusReWProj () |
TH1 * | GetKPlusf05Proj () |
TH1 * | GetKPlusf05PipReWRatio () |
Private Types | |
enum | EParticleType { kPiPlus = 8, kPiMinus = 9, kKPlus = 11, kKMinus = 12, kK0L = 10, kUnknown = 0 } |
typedef enum Lfluk::EParticleType | ParticleType_t |
Private Member Functions | |
double | CalcWeight (int ptype, double pt, double pz) |
double | GetSKZPWeight (const Lfluk::ParticleType_t particle, const double pT, const double xF) |
double | GetSKPCWeight (const Lfluk::ParticleType_t particle, const double pT, const double xF) |
double | GetQuadWeight (const Lfluk::ParticleType_t particle, const double pT, const double xF) |
double | GetMeanPTWeight (const Lfluk::ParticleType_t particle, const double pT, const double xF) |
void | SkewSKZP (const double xF, const double A, const double B, const double C, long double &Ap, long double &Bp, long double &Cp) |
void | SkewSKPC (const double xF, const double A, const double B, const double C, const double D, const double E, double &Ap, double &Bp, double &Cp, double &Dp, double &Ep) |
double | GetSKZPA (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKZPB (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKZPC (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKPCA (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKPCB (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKPCC (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKPCD (const Lfluk::ParticleType_t particle, double xf) const |
double | GetSKPCE (const Lfluk::ParticleType_t particle, double xf) const |
std::string | GetParticleName (Lfluk::ParticleType_t ptype) |
Lfluk::ParticleType_t | GetParticleEnum (const std::string &ptype) |
Lfluk::ParticleType_t | GetParticleEnum (int ptype) |
void | RecalculateWeights () |
Private Attributes | |
std::string | fParam |
std::string | fSkew |
std::string | fNA49Fit |
std::string | fPath |
double | fMinW |
double | fMaxW |
double | fKPiRatScale |
bool | fWghtFromHist |
bool | fUseFlukPi |
std::vector< double > | fPar |
std::vector< ParticleType_t > | fPlist |
std::map < Lfluk::ParticleType_t, TH2F * > | fPTXF |
std::map < Lfluk::ParticleType_t, TH2F * > | fWeightedPTXF |
std::map < Lfluk::ParticleType_t, TH2D * > | fWeightHist |
std::map < Lfluk::ParticleType_t, double > | fMeanPT |
std::map < Lfluk::ParticleType_t, double > | fN |
std::map < Lfluk::ParticleType_t, double > | fNWeighted |
std::map < Lfluk::ParticleType_t, double > | fWeightedMeanPT |
std::map < Lfluk::ParticleType_t, int > | fNBinsY |
std::map < Lfluk::ParticleType_t, int > | fNBinsX |
TF1 * | fNA49pirat |
std::vector< double > | fPiRatio |
std::vector< double > | fFluka05KPiRatio |
std::vector< double > | fFluka05PiRatio |
std::vector< double > | fKPiRatio |
bool | isFirst |
TH1 * | fFlukKPiRat |
TH1 * | fFlukPiRat |
TH1 * | fPiPlusReWProj |
TH1 * | fKPlusf05Proj |
TH1 * | fKPlusf05PipReWRatio |
Definition at line 20 of file Lfluk.h.
typedef enum Lfluk::EParticleType Lfluk::ParticleType_t [private] |
enum Lfluk::EParticleType [private] |
Lfluk::Lfluk | ( | ) |
Definition at line 21 of file Lfluk.cxx.
00022 :fParam("skzp"), 00023 fSkew("lin"), 00024 fNA49Fit("Poly3"), 00025 fPath(""), 00026 fMinW(-999.0), 00027 fMaxW(999.0), 00028 fKPiRatScale(1.0), 00029 fWghtFromHist(true), 00030 fUseFlukPi(false), 00031 fPar(0), 00032 fFlukKPiRat(0) 00033 { 00034 00035 }
double Lfluk::CalcWeight | ( | int | ptype, | |
double | pt, | |||
double | pz | |||
) | [private] |
Definition at line 528 of file Lfluk.cxx.
References fKPiRatio, fMaxW, fMinW, fN, fNWeighted, fPar, fParam, fPiRatio, GetMeanPTWeight(), GetParticleEnum(), GetQuadWeight(), GetSKPCWeight(), GetSKZPWeight(), kK0L, kKMinus, kKPlus, kPiMinus, kPiPlus, Msg::kWarning, and MAXMSG.
Referenced by GetWeight(), and RecalculateWeights().
00529 { 00530 double weight=1.; 00531 00532 if (fPar.size()==0) 00533 { 00534 MAXMSG("MCReweight",Msg::kWarning,10) 00535 <<"You need to set the parameters before calling " 00536 <<"Zfluk::CalcWeight (use SetParameters(vector<double>))"<<std::endl 00537 <<"Returning weight = "<<weight<<std::endl; 00538 return weight; 00539 } 00540 00541 double xF=pz/120.; 00542 Lfluk::ParticleType_t eptype=GetParticleEnum(ptype); 00543 00544 // This is SKZP parameterization 00545 if (xF>1.||xF<0.) return weight; 00546 00547 if (eptype==kPiPlus) 00548 { 00549 if (pT>1.||pT<0.) return weight; 00550 00551 if(fParam.find("skzp") != string::npos) //default 00552 { 00553 weight = Lfluk::GetSKZPWeight(eptype, pT, xF); 00554 } 00555 if(fParam.find("skpc") != string::npos) 00556 { 00557 weight = Lfluk::GetSKPCWeight(eptype, pT, xF); 00558 } 00559 if(fParam.find("quad") != string::npos) 00560 { 00561 weight = Lfluk::GetQuadWeight(eptype, pT, xF); 00562 } 00563 if(fParam.find("meanpt") != string::npos) 00564 { 00565 weight = Lfluk::GetMeanPTWeight(eptype, pT, xF); 00566 } 00567 00568 if(weight < fMinW) weight = fMinW; 00569 if(weight > fMaxW) weight = fMaxW; 00570 00571 } 00572 else if (eptype==kKPlus) 00573 { 00574 weight=fKPiRatio[int(pz)+1]; 00575 } 00576 else if (eptype==kPiMinus) 00577 { 00578 weight=CalcWeight(kPiPlus,pT,pz)*fPiRatio[int(pz)+1]; 00579 } 00580 else if (eptype==kKMinus) 00581 { 00582 weight=CalcWeight(kKPlus,pT,pz); 00583 } 00584 else if (eptype==kK0L) 00585 { 00586 //N(K0L) approximately given with (N(K+)+3*N(K-))/4 00587 weight= ((fNWeighted[kKPlus]+3.*fNWeighted[kKMinus]) 00588 /(fN[kKPlus]+3.*fN[kKMinus])); 00589 } 00590 00591 if(weight < -999.0) weight = fMinW; 00592 if(weight > 999.0) weight = fMaxW; 00593 00594 00595 return weight; 00596 }
void Lfluk::Config | ( | const Registry & | reg | ) |
Definition at line 273 of file Lfluk.cxx.
References fKPiRatScale, fMaxW, fMinW, fNA49Fit, fParam, fPath, fSkew, fUseFlukPi, fWghtFromHist, and Registry::Get().
00274 { 00275 reg.Get("WEIGHT_MIN", fMinW); 00276 reg.Get("WEIGHT_MAX", fMaxW); 00277 reg.Get("KPiRatioScale", fKPiRatScale); 00278 00279 if(fMaxW < 990.0 && fMinW > -990.0 && fMaxW <= fMinW) 00280 { 00281 fMaxW = fMinW + 10.0; 00282 cout << "Lfluk::Config - Weight Max <= Weight Min, setting fMaxW = " << fMaxW << " fMinW = " << fMinW << endl; 00283 } 00284 00285 const char *value_char = 0; 00286 00287 if(reg.Get("ZRatTuneParam", value_char) && value_char) 00288 { 00289 stringstream strstrm; 00290 strstrm << value_char; 00291 fParam = strstrm.str(); 00292 } 00293 00294 value_char = 0; 00295 if(reg.Get("ZRatTuneSkew", value_char) && value_char) 00296 { 00297 stringstream strstrm; 00298 strstrm << value_char; 00299 fSkew = strstrm.str(); 00300 } 00301 00302 value_char = 0; 00303 if(reg.Get("NA49FIT", value_char) && value_char) 00304 { 00305 stringstream strstrm; 00306 strstrm << value_char; 00307 fNA49Fit = strstrm.str(); 00308 } 00309 00310 value_char = 0; 00311 if(reg.Get("ROOTFILES", value_char) && value_char) 00312 { 00313 stringstream strstrm; 00314 strstrm << value_char; 00315 fPath = strstrm.str(); 00316 } 00317 00318 value_char = 0; 00319 if(reg.Get("WGHTFROMHIST", value_char) && value_char) 00320 { 00321 if(std::strcmp(value_char, "no") == 0) 00322 { 00323 fWghtFromHist = false; 00324 } 00325 } 00326 00327 value_char = 0; 00328 if(reg.Get("UseFlukaPiRatio", value_char) && value_char) 00329 { 00330 if(std::strcmp(value_char, "yes") == 0) 00331 { 00332 fUseFlukPi = true; 00333 } 00334 } 00335 00336 00337 cout << "Lfluk::Config" << endl; 00338 cout << " Root File Path = " << fPath << endl 00339 << " Get Weight From Hist = " << fWghtFromHist << endl 00340 << " Parameterization = " << fParam << endl 00341 << " Skew Config = " << fSkew << endl 00342 << " Use Fluka Pi Ratio = " << fUseFlukPi << endl 00343 << " NA49 Ratio Fit = " << fNA49Fit << endl 00344 << " KPi Ratio Scale = " << fKPiRatScale << endl 00345 << " Weight Min = " << fMinW << endl 00346 << " Weight Max = " << fMaxW << endl; 00347 00348 00349 }
TH1* Lfluk::GetFlukKPiRatio | ( | ) | [inline] |
TH1* Lfluk::GetKPlusf05PipReWRatio | ( | ) | [inline] |
Definition at line 52 of file Lfluk.h.
References fKPlusf05PipReWRatio.
00052 {return fKPlusf05PipReWRatio;};
TH1* Lfluk::GetKPlusf05Proj | ( | ) | [inline] |
double Lfluk::GetMeanPT | ( | int | ptype | ) | [inline] |
Definition at line 39 of file Lfluk.h.
References fMeanPT, and GetParticleEnum().
00039 {return fMeanPT[GetParticleEnum(ptype)];};
double Lfluk::GetMeanPTWeight | ( | const Lfluk::ParticleType_t | particle, | |
const double | pT, | |||
const double | xF | |||
) | [private] |
Definition at line 905 of file Lfluk.cxx.
References MuELoss::e, fPar, and kPiPlus.
Referenced by CalcWeight().
00906 { 00907 double weight = 1.0; 00908 00909 if(particle == kPiPlus) 00910 { 00911 if(fPar.size() != 5) 00912 { 00913 cout << "Problem in Lfluk::GetMeanPTWeight - Number of pars is not 4: npars = " << fPar.size() << endl; 00914 } 00915 else 00916 { 00917 double linxF = fPar[3]+fPar[4]*xF; 00918 if(linxF == 0.0) 00919 { 00920 linxF = 1e-20; 00921 } 00922 double exparg = fPar[2]*pT / linxF; 00923 if(exparg > 100.0) exparg = 100.0; 00924 if(exparg < -100.0) exparg = -100.0; 00925 weight = (fPar[0] + fPar[1]*xF) * exp(exparg); 00926 } 00927 } 00928 00929 00930 //cout << "xF = " << xF << " pT = " << pT << " meanPT weight = " << weight << endl; 00931 return weight; 00932 }
double Lfluk::GetNFrac | ( | int | ptype, | |
double | pz_low = 0. , |
|||
double | pz_up = 120. , |
|||
double | pt_low = 0. , |
|||
double | pt_up = 1. | |||
) |
Definition at line 1330 of file Lfluk.cxx.
References fPTXF, fWeightedPTXF, and GetParticleEnum().
01331 { 01332 //returns the fractional change in number of particles due to reweighting in xf-pt region 01333 //given by pz_low, pz_up and pt_low, pt_up 01334 01335 Lfluk::ParticleType_t eptype=GetParticleEnum(ptype); 01336 if (fPTXF.find(eptype)==fPTXF.end()) return 1.; 01337 01338 int xlow=int(pz_low+1.); 01339 int xup=int(pz_up+1.); 01340 int ylow=int(50.*pt_low+1.); 01341 int yup=int(50.*pt_up+1.); 01342 01343 double wsum(0.); 01344 double sum(0.); 01345 for (int i=xlow;i<xup;i++) { 01346 for (int j=ylow;j<yup;j++) { 01347 sum+=fPTXF[eptype]->GetBinContent(i,j); 01348 wsum+=fWeightedPTXF[eptype]->GetBinContent(i,j); 01349 } 01350 } 01351 01352 return wsum/sum; 01353 }
const std::vector<double>& Lfluk::GetParameters | ( | ) | [inline] |
Lfluk::ParticleType_t Lfluk::GetParticleEnum | ( | int | ptype | ) | [private] |
Definition at line 1383 of file Lfluk.cxx.
References kK0L, kKMinus, kKPlus, kPiMinus, kPiPlus, and kUnknown.
01384 { 01385 switch (ptype) 01386 { 01387 case 8 : return kPiPlus; break; 01388 case 211 : return kPiPlus; break; 01389 case 9 : return kPiMinus; break; 01390 case -211: return kPiMinus; break; 01391 case 11 : return kKPlus; break; 01392 case 321 : return kKPlus; break; 01393 case 12 : return kKMinus; break; 01394 case -321: return kKMinus; break; 01395 case 10 : return kK0L; break; 01396 case 130 : return kK0L; break; 01397 default: return kUnknown; break; 01398 } 01399 return kUnknown; 01400 01401 }
Lfluk::ParticleType_t Lfluk::GetParticleEnum | ( | const std::string & | ptype | ) | [private] |
Definition at line 1373 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, kPiPlus, and kUnknown.
Referenced by CalcWeight(), GetMeanPT(), GetNFrac(), GetPTshift(), GetPTXF(), GetReweightedMeanPT(), GetReweightedPTXF(), GetWeight(), GetWeightHist(), and GetWeightHistogram().
std::string Lfluk::GetParticleName | ( | Lfluk::ParticleType_t | ptype | ) | [private] |
Definition at line 1356 of file Lfluk.cxx.
References kK0L, kKMinus, kKPlus, kPiMinus, kPiPlus, and kUnknown.
Referenced by GetWeight(), Init(), and RecalculateWeights().
01357 { 01358 switch (ptype) 01359 { 01360 case kPiPlus: return "PiPlus"; break; 01361 case kPiMinus: return "PiMinus"; break; 01362 case kKPlus: return "KPlus"; break; 01363 case kKMinus: return "KMinus"; break; 01364 case kK0L: return "K0L"; break; 01365 case kUnknown: return "Unknown"; break; 01366 default: return "Unknown"; break; 01367 } 01368 01369 return "Unknown"; 01370 }
TH1* Lfluk::GetPiPlusReWProj | ( | ) | [inline] |
double Lfluk::GetPTshift | ( | int | ptype, | |
double | pz_low = 0. , |
|||
double | pz_up = 120. | |||
) |
Definition at line 1299 of file Lfluk.cxx.
References fMeanPT, fPTXF, fWeightedMeanPT, fWeightedPTXF, and GetParticleEnum().
01300 { 01301 //returns the pT shift for ptype particle due to reweighting in xf slice 01302 //given by pz_low and pz_up 01303 //this function returns correct ptshift only if the parameters were set using SetParameters 01304 01305 Lfluk::ParticleType_t eptype=GetParticleEnum(ptype); 01306 if (fPTXF.find(eptype)==fPTXF.end()) return 0.; 01307 01308 if (pz_low==0.&&pz_up==120.) return fWeightedMeanPT[eptype]-fMeanPT[eptype]; 01309 01310 int xlow=int(pz_low+1.); 01311 int xup=int(pz_up+1.); 01312 01313 double pt; 01314 double meanpt(0.); 01315 double sum(0.); 01316 for (int i=xlow;i<xup;i++) { 01317 for (int j=1;j<51;j++) { 01318 pt=0.02*j-0.01; 01319 meanpt+=fWeightedPTXF[eptype]->GetBinContent(i,j)*pt; 01320 sum+=fWeightedPTXF[eptype]->GetBinContent(i,j); 01321 } 01322 } 01323 meanpt/=sum; 01324 meanpt*=1000.; //GeV to MeV 01325 01326 return meanpt-fMeanPT[eptype]; 01327 01328 }
TH2F* Lfluk::GetPTXF | ( | int | ptype | ) | [inline] |
Definition at line 44 of file Lfluk.h.
References fPTXF, and GetParticleEnum().
Referenced by Init().
00044 {return fPTXF[GetParticleEnum(ptype)];};
double Lfluk::GetQuadWeight | ( | const Lfluk::ParticleType_t | particle, | |
const double | pT, | |||
const double | xF | |||
) | [private] |
Definition at line 692 of file Lfluk.cxx.
References fPar, fParam, and kPiPlus.
Referenced by CalcWeight().
00693 { 00694 double weight = 1.0; 00695 00696 if(particle == kPiPlus) 00697 { 00698 if(fParam == "quad0") 00699 { 00700 if(fPar.size() != 9) 00701 { 00702 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 9: npars = " << fPar.size() << endl; 00703 } 00704 else 00705 { 00706 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00707 + fPar[3]*pT + fPar[4]*pT*xF + fPar[5]*pT*xF*xF 00708 + fPar[6]*pT*pT + fPar[7]*pT*pT*xF + fPar[8]*pT*pT*xF*xF; 00709 } 00710 } 00711 else if(fParam == "quad1") 00712 { 00713 if(fPar.size() != 8) 00714 { 00715 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00716 } 00717 else 00718 { 00719 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00720 + fPar[3]*pT + fPar[4]*pT*xF + fPar[5]*pT*xF*xF 00721 + fPar[6]*pT*pT + fPar[7]*pT*pT*xF ; 00722 } 00723 } 00724 else if(fParam == "quad2") 00725 { 00726 if(fPar.size() != 8) 00727 { 00728 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00729 } 00730 else 00731 { 00732 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00733 + fPar[3]*pT + fPar[4]*pT*xF + fPar[5]*pT*xF*xF 00734 + fPar[6]*pT*pT + fPar[7]*pT*pT*xF*xF; 00735 } 00736 } 00737 else if(fParam == "quad3") 00738 { 00739 if(fPar.size() != 8) 00740 { 00741 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00742 } 00743 else 00744 { 00745 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00746 + fPar[3]*pT + fPar[4]*pT*xF + fPar[5]*pT*xF*xF 00747 + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00748 } 00749 } 00750 else if(fParam == "quad4") 00751 { 00752 if(fPar.size() != 8) 00753 { 00754 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00755 } 00756 else 00757 { 00758 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00759 + fPar[3]*pT + fPar[4]*pT*xF 00760 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00761 } 00762 } 00763 else if(fParam == "quad5") 00764 { 00765 if(fPar.size() != 8) 00766 { 00767 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00768 } 00769 else 00770 { 00771 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00772 + fPar[3]*pT + fPar[4]*pT*xF*xF 00773 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00774 } 00775 } 00776 else if(fParam == "quad6") 00777 { 00778 if(fPar.size() != 8) 00779 { 00780 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00781 } 00782 else 00783 { 00784 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00785 + fPar[3]*pT*xF + fPar[4]*pT*xF*xF 00786 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00787 } 00788 } 00789 else if(fParam == "quad7") 00790 { 00791 if(fPar.size() != 8) 00792 { 00793 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00794 } 00795 else 00796 { 00797 weight = fPar[0] + fPar[1]*xF 00798 + fPar[2]*pT + fPar[3]*pT*xF + fPar[4]*pT*xF*xF 00799 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00800 } 00801 } 00802 else if(fParam == "quad8") 00803 { 00804 if(fPar.size() != 8) 00805 { 00806 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00807 } 00808 else 00809 { 00810 weight = fPar[0] + fPar[1]*xF*xF 00811 + fPar[2]*pT + fPar[3]*pT*xF + fPar[4]*pT*xF*xF 00812 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00813 } 00814 } 00815 else if(fParam == "quad9") 00816 { 00817 if(fPar.size() != 8) 00818 { 00819 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 8: npars = " << fPar.size() << endl; 00820 } 00821 else 00822 { 00823 weight = fPar[0]*xF + fPar[1]*xF*xF 00824 + fPar[2]*pT + fPar[3]*pT*xF + fPar[4]*pT*xF*xF 00825 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF + fPar[7]*pT*pT*xF*xF; 00826 } 00827 } 00828 else if(fParam == "quad124") 00829 { 00830 if(fPar.size() != 6) 00831 { 00832 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 7: npars = " << fPar.size() << endl; 00833 } 00834 else 00835 { 00836 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00837 + fPar[3]*pT + fPar[4]*pT*xF 00838 + fPar[5]*pT*pT ; 00839 } 00840 } 00841 else if(fParam == "quad134") 00842 { 00843 if(fPar.size() != 6) 00844 { 00845 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 7: npars = " << fPar.size() << endl; 00846 } 00847 else 00848 { 00849 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00850 + fPar[3]*pT + fPar[4]*pT*xF 00851 + fPar[5]*pT*pT*xF ; 00852 } 00853 } 00854 else if(fParam == "quad1234") 00855 { 00856 if(fPar.size() != 5) 00857 { 00858 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 7: npars = " << fPar.size() << endl; 00859 } 00860 else 00861 { 00862 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00863 + fPar[3]*pT + fPar[4]*pT*xF ; 00864 } 00865 } 00866 else if(fParam == "quad14") 00867 { 00868 if(fPar.size() != 7) 00869 { 00870 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 7: npars = " << fPar.size() << endl; 00871 } 00872 else 00873 { 00874 weight = fPar[0] + fPar[1]*xF + fPar[2]*xF*xF 00875 + fPar[3]*pT + fPar[4]*pT*xF 00876 + fPar[5]*pT*pT + fPar[6]*pT*pT*xF ; 00877 } 00878 } 00879 else if(fParam == "quad147") 00880 { 00881 if(fPar.size() != 6) 00882 { 00883 cerr << "Problem in Lfluk::GetQuadWeight - Number of pars is not 6: npars = " << fPar.size() << endl; 00884 } 00885 else 00886 { 00887 weight = fPar[0] + fPar[1]*xF 00888 + fPar[2]*pT + fPar[3]*pT*xF 00889 + fPar[4]*pT*pT + fPar[5]*pT*pT*xF ; 00890 } 00891 } 00892 else 00893 { 00894 cerr << "Problem in Lfluk::GetQuadWeight - Not a valid Parameterization " << fParam << endl; 00895 } 00896 00897 00898 } 00899 00900 //cout << "xF = " << xF << " pT = " << pT << " quad weight = " << weight << endl; 00901 return weight; 00902 }
double Lfluk::GetReweightedMeanPT | ( | int | ptype | ) | [inline] |
Definition at line 40 of file Lfluk.h.
References fWeightedMeanPT, and GetParticleEnum().
00040 {return fWeightedMeanPT[GetParticleEnum(ptype)];};
TH2F* Lfluk::GetReweightedPTXF | ( | int | ptype | ) | [inline] |
Definition at line 43 of file Lfluk.h.
References fWeightedPTXF, and GetParticleEnum().
Referenced by RecalculateWeights().
00043 {return fWeightedPTXF[GetParticleEnum(ptype)];};
double Lfluk::GetSKPCA | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1411 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKPCWeight().
01412 { 01413 if (xf<0.25) 01414 { 01415 // 01416 //form: Par[0]*std::pow(1.0-xf, Par[1])*(1.0+Par[2]*xf)*std::pow(xf, -Par[3]); 01417 // 01418 switch (particle) 01419 { 01420 case kPiPlus: 01421 return 0.0462498*std::pow(1.0-xf, 20.8206)*(1.0+11911.3*xf)*std::pow(xf, -1.0*0.96808); 01422 case kPiMinus: 01423 break; 01424 case kKPlus: 01425 break; 01426 case kKMinus: 01427 break; 01428 default: 01429 break; 01430 } 01431 } 01432 else 01433 { 01434 // 01435 //form: Par[4]*(1.0-xf)*std::exp(Par[5]*std::pow(xf, Par[6])); 01436 // 01437 switch (particle) 01438 { 01439 case kPiPlus: 01440 return 1250.0*(1.0-xf)*std::exp(-13.6097*std::pow(xf, 0.597619)); 01441 case kPiMinus: 01442 break; 01443 case kKPlus: 01444 break; 01445 case kKMinus: 01446 break; 01447 default: 01448 break; 01449 } 01450 } 01451 01452 return 1.0; 01453 01454 }
double Lfluk::GetSKPCB | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1457 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKPCWeight().
01458 { 01459 01460 // 01461 //form: Par[0]*std::pow(1.0-xf, Par[1])*(1.0+Par[2]*xf)*std::pow(xf, -Par[3]); 01462 // 01463 01464 switch (particle) 01465 { 01466 case kPiPlus: 01467 return 3.31629*std::pow(1.0-xf, 2.48421)*(1.0+22.7285*xf)*std::pow(xf, -1.0*2.38778); 01468 case kPiMinus: 01469 break; 01470 case kKPlus: 01471 break; 01472 case kKMinus: 01473 break; 01474 default: 01475 break; 01476 } 01477 01478 return 0.0; 01479 }
double Lfluk::GetSKPCC | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1482 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKPCWeight().
01483 { 01484 if (xf<0.35) 01485 { 01486 // 01487 //form: Par[0]*std::pow(1.0-xf, Par[1])*(1.0+Par[2]*xf)*std::pow(xf, -Par[3]); 01488 // 01489 switch (particle) 01490 { 01491 case kPiPlus: 01492 return 0.074085*std::pow(1.0-xf, 11.2413)*(1.0+168369.0*xf)*std::pow(xf, -1.0*2.47553); 01493 case kPiMinus: 01494 break; 01495 case kKPlus: 01496 break; 01497 case kKMinus: 01498 break; 01499 default: 01500 break; 01501 } 01502 } 01503 else 01504 { 01505 // 01506 //form: Par[4]*(1.0-xf)*std::exp(Par[5]*xf); 01507 // 01508 switch (particle) 01509 { 01510 case kPiPlus: 01511 return 49071.3*(1.0-xf)*std::exp(-12.1073*xf); 01512 case kPiMinus: 01513 break; 01514 case kKPlus: 01515 break; 01516 case kKMinus: 01517 break; 01518 default: 01519 break; 01520 } 01521 } 01522 01523 01524 return 0.0; 01525 }
double Lfluk::GetSKPCD | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1528 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKPCWeight().
01529 { 01530 if (xf<0.1) 01531 { 01532 // 01533 //form: Par[0]*std::exp(Par[1]*std::pow(xf, Par[2])); 01534 // 01535 switch (particle) 01536 { 01537 case kPiPlus: 01538 return 35.8788*std::exp(-1.95477*std::pow(xf, 0.0638124)); 01539 case kPiMinus: 01540 break; 01541 case kKPlus: 01542 break; 01543 case kKMinus: 01544 break; 01545 default: 01546 break; 01547 } 01548 } 01549 else 01550 { 01551 // 01552 //form: Par[3] + par[4]*xf + par[5]*xf*xf +par[6]*xf*xf*xf 01553 // 01554 switch (particle) 01555 { 01556 case kPiPlus: 01557 return 7.47623 + -7.35376*xf + -14.6949*xf*xf + 22.7689*xf*xf*xf; 01558 case kPiMinus: 01559 break; 01560 case kKPlus: 01561 break; 01562 case kKMinus: 01563 break; 01564 default: 01565 break; 01566 } 01567 } 01568 01569 01570 return 0.0; 01571 01572 }
double Lfluk::GetSKPCE | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1575 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKPCWeight().
01576 { 01577 if (xf<0.25) 01578 { 01579 // 01580 //form: Par[0]*std::exp(Par[1]*std::pow(xf, Par[2]))*(Par{3] + Par[4]*xf + Par[5]*xf*xf); 01581 // 01582 switch (particle) 01583 { 01584 case kPiPlus: 01585 return 3.88469*std::exp(-6.20932*std::pow(xf, 0.26879))*(1.29961 + 53.0232*xf + 121.575*xf*xf); 01586 case kPiMinus: 01587 break; 01588 case kKPlus: 01589 break; 01590 case kKMinus: 01591 break; 01592 default: 01593 break; 01594 } 01595 } 01596 else 01597 { 01598 // 01599 //form: (Par[6]+Par[7]*xf)/std::pow(xf, Par[8]); 01600 // 01601 switch (particle) 01602 { 01603 case kPiPlus: 01604 return (-0.26414 + 1.87321*xf)/std::pow(xf, 1.28207); 01605 case kPiMinus: 01606 break; 01607 case kKPlus: 01608 break; 01609 case kKMinus: 01610 break; 01611 default: 01612 break; 01613 } 01614 } 01615 01616 01617 return 0.0; 01618 01619 }
double Lfluk::GetSKPCWeight | ( | const Lfluk::ParticleType_t | particle, | |
const double | pT, | |||
const double | xF | |||
) | [private] |
Definition at line 646 of file Lfluk.cxx.
References GetSKPCA(), GetSKPCB(), GetSKPCC(), GetSKPCD(), GetSKPCE(), kKMinus, kKPlus, kPiMinus, kPiPlus, and SkewSKPC().
Referenced by CalcWeight().
00647 { 00648 double weight = 1.0; 00649 double A, B, C, D, E; 00650 double Ap, Bp, Cp, Dp, Ep; 00651 00652 if (particle==kPiPlus) 00653 { 00654 if (pT>=0.03) 00655 { 00656 A = Lfluk::GetSKPCA(particle, xF); 00657 B = Lfluk::GetSKPCB(particle, xF); 00658 C = Lfluk::GetSKPCC(particle, xF); 00659 D = Lfluk::GetSKPCD(particle, xF); 00660 E = Lfluk::GetSKPCE(particle, xF); 00661 00662 Lfluk::SkewSKPC(xF, A, B, C, D, E, Ap, Bp, Cp, Dp, Ep); 00663 00664 if(Ep < -20.0) Ep = -20.0; 00665 double arg = -Dp*std::pow(pT,Ep)+D*std::pow(pT,E); 00666 if(arg > 100.0) arg = 100.0; 00667 if(arg < -100.0) arg = -100.0; 00668 weight=(Ap+Bp*pT+Cp*pT*pT)/(A+B*pT+C*pT*pT)*std::exp(arg); 00669 } 00670 else 00671 { 00672 weight = Lfluk::GetSKPCWeight(particle, 0.031, xF); // for low pT 00673 } 00674 } 00675 else if (particle==kKPlus) 00676 { 00677 weight = 1.0; 00678 } 00679 else if (particle==kPiMinus) 00680 { 00681 weight = 1.0; 00682 } 00683 else if (particle==kKMinus) 00684 { 00685 weight = 1.0; 00686 } 00687 00688 return weight; 00689 }
double Lfluk::GetSKZPA | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1050 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKZPWeight().
01051 { 01052 01053 switch (particle) 01054 { 01055 case kPiPlus: 01056 return -0.007607*std::pow(1.0-xf, 4.045)*(1.0+0.9620e+4*xf)*std::pow(xf, -2.975); 01057 case kPiMinus: 01058 return -0.006306*std::pow(1.0-xf, 5.730)*(1.0+0.1365e+5*xf)*std::pow(xf, -2.900); 01059 case kKPlus: 01060 return -0.005187*std::pow(1.0-xf, 4.119)*(1.0+0.2170e+4*xf)*std::pow(xf, -2.767); 01061 case kKMinus: 01062 return -8.854 *std::pow(1.0-xf, 6.778)*(1.0-0.6050 *xf)*std::pow(xf, -1.827); 01063 default: 01064 break; 01065 } 01066 01067 return 1.0; 01068 }
double Lfluk::GetSKZPB | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1071 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKZPWeight().
01072 { 01073 switch (particle) 01074 { 01075 case kPiPlus: 01076 return 0.05465*std::pow(1.0-xf, 2.675)*(1.0+0.6959e+5*xf)*std::pow(xf, -3.144); 01077 case kPiMinus: 01078 return 0.04608*std::pow(1.0-xf, 3.291)*(1.0+0.5857e+5*xf)*std::pow(xf, -3.209); 01079 case kKPlus: 01080 return 0.4918 *std::pow(1.0-xf, 2.672)*(1.0+0.1373e+4*xf)*std::pow(xf, -2.927); 01081 case kKMinus: 01082 return 0.02857*std::pow(1.0-xf, 7.494)*(1.0+0.5879e+5*xf)*std::pow(xf, -2.577); 01083 default: 01084 break; 01085 } 01086 01087 return 0.0; 01088 }
double Lfluk::GetSKZPC | ( | const Lfluk::ParticleType_t | particle, | |
double | xf | |||
) | const [private] |
Definition at line 1091 of file Lfluk.cxx.
References kKMinus, kKPlus, kPiMinus, and kPiPlus.
Referenced by GetSKZPWeight().
01092 { 01093 if (xf<0.22) 01094 { 01095 switch (particle) 01096 { 01097 case kPiPlus: 01098 return -7.058/std::pow(xf, -0.1419 ) + 9.188; 01099 case kPiMinus: 01100 return -16.52 /std::pow(xf, -0.06204) + 18.12; 01101 case kKPlus: 01102 return -16.10 /std::pow(xf, -0.04582) + 17.92; 01103 case kKMinus: 01104 return -16.13 /std::pow(xf, -0.05678) + 17.39; 01105 default: 01106 break; 01107 } 01108 } 01109 else 01110 { 01111 switch (particle) 01112 { 01113 case kPiPlus: 01114 return 3.008/std::exp((xf-0.1948)*3.577) + 2.616 *xf + 0.1225; 01115 case kPiMinus: 01116 return 2.972/std::exp((xf-0.1758)*2.266) + 1.730 *xf + 0.04196; 01117 case kKPlus: 01118 return 6.905/std::exp((xf+0.1630)*6.718) - 0.4257*xf + 2.486; 01119 case kKMinus: 01120 return 3.916/std::exp((xf-4.615) *0.03255) - 4.702 *xf + 0.4062; 01121 default: 01122 break; 01123 } 01124 } 01125 01126 01127 return 0.0; 01128 }
double Lfluk::GetSKZPWeight | ( | const Lfluk::ParticleType_t | particle, | |
const double | pT, | |||
const double | xF | |||
) | [private] |
Definition at line 600 of file Lfluk.cxx.
References GetSKZPA(), GetSKZPB(), GetSKZPC(), kKMinus, kKPlus, kPiMinus, kPiPlus, and SkewSKZP().
Referenced by CalcWeight().
00601 { 00602 double weight = 1.0; 00603 double A,B,C; 00604 long double Ap,Bp,Cp; 00605 00606 if (particle==kPiPlus) 00607 { 00608 //Calculate weight for pions 00609 if (pT>=0.03) 00610 { 00611 // calculate the A, B and C in SKZP parameterization 00612 // A, B and C are best fit to Fluka 05 00613 00614 A = Lfluk::GetSKZPA(particle, xF); 00615 B = Lfluk::GetSKZPB(particle, xF); 00616 C = Lfluk::GetSKZPC(particle, xF); 00617 00618 Lfluk::SkewSKZP(xF, A, B, C, Ap, Bp, Cp); 00619 00620 if(Cp < -100.0) Cp = -100.0; 00621 if(Cp > 100.0) Cp = 100.0; 00622 weight=(Ap+Bp*pT)/(A+B*pT)*exp(-(Cp-C)*pow(pT,3./2.)); 00623 } 00624 else 00625 { 00626 weight = Lfluk::GetSKZPWeight(particle, 0.031, xF); // for low pT 00627 } 00628 } 00629 else if (particle==kKPlus) 00630 { 00631 weight = 1.0; 00632 } 00633 else if (particle==kPiMinus) 00634 { 00635 weight = 1.0; 00636 } 00637 else if (particle==kKMinus) 00638 { 00639 weight = 1.0; 00640 } 00641 00642 return weight; 00643 }
double Lfluk::GetWeight | ( | int | ptype, | |
double | pt, | |||
double | pz | |||
) |
Definition at line 463 of file Lfluk.cxx.
References CalcWeight(), fWeightHist, fWghtFromHist, GetParticleEnum(), GetParticleName(), kKPlus, kPiMinus, and kPiPlus.
00464 { 00465 00466 00467 if(fWghtFromHist) 00468 { 00469 00470 double weight = 1.0; 00471 00472 Lfluk::ParticleType_t eptype=GetParticleEnum(ptype); 00473 string name = GetParticleName(eptype); 00474 00475 if(eptype != kPiPlus && eptype != kKPlus && eptype != kPiMinus && eptype != kPiMinus) 00476 { 00477 return 1.0; 00478 } 00479 00480 if (pz > 120.0 || pz < 0.0 || pT < 0.0) 00481 { 00482 return weight; 00483 } 00484 00485 const int nbinsx = fWeightHist[eptype] -> GetNbinsX(); 00486 const int nbinsy = fWeightHist[eptype] -> GetNbinsY(); 00487 00488 int binx = (fWeightHist[eptype] -> GetXaxis()) -> FindFixBin(pz); 00489 int biny = (fWeightHist[eptype] -> GetYaxis()) -> FindFixBin(pT); 00490 00491 if (pT > 1.0) biny = nbinsy+1; 00492 00493 if(!(binx < 0) && !(biny < 0) && !(binx > nbinsx+1) && !(biny > nbinsy+1)) 00494 { 00495 weight = fWeightHist[eptype] -> GetBinContent(binx, biny); 00496 } 00497 00498 /* 00499 double wt = CalcWeight(eptype,pT,pz); 00500 string name = GetParticleName(eptype); 00501 //if(name == "PiMinus" && pz > 117 && pz < 119 && weight-wt != 0) 00502 if(weight - wt != 0) 00503 { 00504 cout << " Lfluk::GetWeight(): ptype = " << name << " pz = " << pz << " pt = " << pT << " weight from calc = " 00505 << setprecision(10) << wt << " weight from hist = " << weight << " diff = " << weight - wt << endl; 00506 } 00507 */ 00508 00509 /* 00510 if((name == "PiPlus" || name == "KPlus") && (binx == 2) && biny == nbinsy+1) 00511 { 00512 cout << "get weight called : name = " << name << " pz = " << pz << " pt = " << pT << " weight = " << weight << endl; 00513 } 00514 00515 */ 00516 00517 00518 return weight; 00519 } 00520 00521 else 00522 { 00523 return CalcWeight(ptype,pT,pz); 00524 } 00525 }
TH2 * Lfluk::GetWeightHist | ( | const std::string & | ptype | ) |
Definition at line 452 of file Lfluk.cxx.
References fWeightHist, and GetParticleEnum().
00453 { 00454 TH2* hist = 0; 00455 hist = dynamic_cast <TH2*> (fWeightHist[GetParticleEnum(ptype)]->Clone()); 00456 hist->SetDirectory(0); 00457 00458 return hist; 00459 00460 }
TH2D* Lfluk::GetWeightHistogram | ( | int | ptype | ) | [inline] |
Definition at line 45 of file Lfluk.h.
References fWeightHist, and GetParticleEnum().
00045 {return fWeightHist[GetParticleEnum(ptype)];};
void Lfluk::Init | ( | void | ) |
Definition at line 43 of file Lfluk.cxx.
References base, fFluka05KPiRatio, fFluka05PiRatio, fFlukKPiRat, fFlukPiRat, fKPiRatio, fMeanPT, fN, fNA49Fit, fNA49pirat, fNWeighted, Form(), fPath, fPiRatio, fPlist, fPTXF, fWeightedMeanPT, fWeightedPTXF, fWeightHist, GetParticleName(), GetPTXF(), gSystem(), isFirst, Msg::kDebug, Msg::kFatal, kK0L, kKMinus, kKPlus, kPiMinus, kPiPlus, and MSG.
00044 { 00045 cout << "Lfluk::Init" << endl; 00046 00047 std::string dir = ""; 00048 TH1::AddDirectory(kFALSE); 00049 00050 // topDir is where the fluka05 pt-xf histogram file is 00051 std::string topDir=dir; // user may set location of input data 00052 if(topDir=="") { // by default, this code looks in a standard place 00053 topDir="MCReweight/data"; 00054 std::string base=""; 00055 base=getenv("SRT_PRIVATE_CONTEXT"); 00056 if (base!="" && base!=".") { 00057 // check if directory exists in SRT_PRIVATE_CONTEXT 00058 std::string path = base + "/" + topDir; 00059 void *dir_ptr = gSystem -> OpenDirectory(path.c_str()); 00060 if(!dir_ptr) base=getenv("SRT_PUBLIC_CONTEXT"); // if it doesn't exist then use SRT_PUBLIC_CONTEXT 00061 } 00062 else base=getenv("SRT_PUBLIC_CONTEXT"); 00063 if(base=="") { 00064 MSG("MCReweight",Msg::kFatal)<<"No SRT_PUBLIC_CONTEXT set"<<std::endl; 00065 assert(false); 00066 } 00067 topDir = base+ "/" + topDir; 00068 } 00069 00070 MSG("Lfluk",Msg::kDebug) <<"Lfluk reading data from: "<<topDir<<std::endl; 00071 std::string fileName =topDir+"/fluka05ptxf.root"; 00072 00073 TFile* hFile=new TFile(fileName.c_str(), "READ"); 00074 if(!(hFile->IsOpen())) 00075 { 00076 hFile = new TFile("/minos/scratch/loiacono/Data/ForMonFit/fluka05ptxf.root", "READ"); 00077 if(!hFile || !(hFile->IsOpen())) 00078 { 00079 cout << "Can't open /minos/scratch/loiacono/Data/ForMonFit/fluka05ptxf.root" << endl; 00080 cout << " Failed to open file: " << fileName << endl; 00081 cout << " **************I am going to crash***************"<< endl; 00082 } 00083 00084 } 00085 else 00086 { 00087 cout << " Reading Fluka PTXF from: " << fileName << endl; 00088 } 00089 00090 00091 fPlist.push_back(kPiPlus); 00092 fPlist.push_back(kPiMinus); 00093 fPlist.push_back(kKPlus); 00094 fPlist.push_back(kKMinus); 00095 fPlist.push_back(kK0L); 00096 00097 for (std::vector<ParticleType_t>::iterator itPlist=fPlist.begin();itPlist!=fPlist.end(); itPlist++) 00098 { 00099 TH2F* hist=dynamic_cast <TH2F*> (hFile->Get(Form("hF05ptxf%s",GetParticleName(*itPlist).c_str()))->Clone()); 00100 hist->SetDirectory(0); 00101 TH2F* hist2=dynamic_cast <TH2F*> (hist->Clone(Form("hWeightedPTXF%s",GetParticleName(*itPlist).c_str()))); 00102 hist2->SetDirectory(0); 00103 hist2->SetTitle(Form("%s weighted pt-pz",GetParticleName(*itPlist).c_str())); 00104 00105 const int nbinsx = 120; 00106 const int nbinsy = hist -> GetNbinsY(); 00107 //cout << "nbinsx = " << nbinsx << "nbinsy = " << nbinsy << endl; 00108 //fWeightHist[*itPlist]=dynamic_cast<TH2D*> (hist->Clone(Form("hWeight%s",GetParticleName(*itPlist).c_str()))); 00109 // 00110 //The bins need to be the same as the bins that the pt-pz plots for the horn current scans!!!!!!!!!!!!!!!!!!!!!!! 00111 // 00112 fWeightHist[*itPlist] = new TH2D(Form("hWeightedPTXF%s",GetParticleName(*itPlist).c_str()),GetParticleName(*itPlist).c_str(), nbinsx, 0, 120, nbinsy, 0, 1); 00113 for(int ibinx = 0; ibinx <= nbinsx+1; ++ibinx) 00114 { 00115 for(int ibiny = 0; ibiny <= nbinsy+1; ++ibiny) 00116 { 00117 //cout << "ibinx = " << ibinx << "ibiny = " << ibiny << endl; 00118 fWeightHist[*itPlist] -> SetBinContent(ibinx, ibiny, 1.0); 00119 } 00120 } 00121 //TH2D* temp = dynamic_cast<TH2D*>(hist->Clone()); 00122 //fWeightHist[*itPlist]->Divide(temp); 00123 fWeightHist[*itPlist]->SetDirectory(0); 00124 00125 std::pair<Lfluk::ParticleType_t, TH2F* > p(*itPlist, hist); 00126 std::pair<Lfluk::ParticleType_t, TH2F* > p2(*itPlist, hist2); 00127 fPTXF.insert(p); 00128 fWeightedPTXF.insert(p2); 00129 00130 fPTXF[*itPlist]->SetDirectory(0); 00131 fWeightedPTXF[*itPlist]->SetDirectory(0); 00132 00133 // 00134 // Projection DOES include overflow bins 00135 // Get Mean DOES NOT 00136 // 00137 fMeanPT[*itPlist]=fPTXF[*itPlist]->ProjectionY()->GetMean()*1000.; 00138 fWeightedMeanPT[*itPlist]=fWeightedPTXF[*itPlist]->ProjectionY()->GetMean()*1000.; 00139 00140 double N=fPTXF[*itPlist]->ProjectionY()->GetSumOfWeights(); 00141 double wN=fWeightedPTXF[*itPlist]->ProjectionY()->GetSumOfWeights(); 00142 00143 fN[*itPlist]=N; 00144 fNWeighted[*itPlist]=wN; 00145 } 00146 hFile->Close(); 00147 delete hFile; 00148 hFile=0; 00149 00150 // 00151 //Get NA49 Ratio from Fit. 00152 // 00153 std::string path = string(fPath + "na49Ratio.root"); 00154 TFile *fitfile = new TFile(path.c_str(), "READ"); 00155 if(!(fitfile->IsOpen())) 00156 { 00157 cout << " Failed to open file: " << path << endl; 00158 cout << " **************I am going to crash***************"<< endl; 00159 } 00160 else 00161 { 00162 cout << " Reading NA49 Pi Ratio from: " << path << endl; 00163 } 00164 00165 stringstream name; 00166 name << "NA49PipPimRatio_" << fNA49Fit << "_fit"; 00167 if(!(fitfile -> Get(name.str().c_str()))) 00168 { 00169 cout << " Failed to get " << name.str() << " from " << path << endl; 00170 } 00171 fNA49pirat = dynamic_cast<TF1 *>( (fitfile -> Get(name.str().c_str())) -> Clone()); 00172 if(!fNA49pirat) 00173 { 00174 cout << " Failed to get " << name.str() << " from " << path << endl; 00175 fNA49pirat = 0; 00176 } 00177 fitfile -> Close(); 00178 delete fitfile; 00179 00180 00181 /* 00182 // 00183 //added stuff above xf=0.5. 00184 //see MuonPhysics/Fit/Misc/NA49PiRatio.cxx 00185 // 00186 00187 //na49 data thru xf = 0.5 00188 double xfna49[] ={0.01, 0.02, 0.03, 0.04, 0.05, 00189 0.075, 0.1, 0.125, 0.15, 0.2, 00190 0.25, 0.3, 0.4, 0.5, 70.5, 00191 80.5, 90.5, 100.5, 119.5}; 00192 double pipna49[]={25.756, 20.903, 16.683, 13.389, 10.981, 00193 7.067, 4.904, 3.531, 2.648, 1.5499, 00194 0.9734, 0.5996, 0.2455, 0.1081, 3.69741, 00195 4.36113,5.3943, 5.89819,7.60617}; 00196 double pimna49[]={24.424, 19.247, 14.938, 11.757, 9.516, 00197 5.790, 3.803, 2.561, 1.826, 0.9555, 00198 0.5475, 0.3190, 0.1041, 0.0336, 1.0, 00199 1.0, 1.0, 1.0, 1.0}; 00200 //double piratna49[14]; 00201 double piratna49[19]; 00202 00203 for (int i=0;i<19;i++) piratna49[i]=pipna49[i]/pimna49[i]; 00204 for (int i=0;i<14;i++) xfna49[i]*=120.; 00205 TGraph* pina49=new TGraph(19,xfna49,piratna49); 00206 fNA49pirat = new TMVA::TSpline1("sp0", pina49); 00207 */ 00208 00209 fPiRatio.resize(122); 00210 fFluka05KPiRatio.resize(122); 00211 fFluka05PiRatio.resize(122); 00212 fKPiRatio.resize(122); 00213 TH1D* piplus=dynamic_cast<TH1D*> (GetPTXF(8) 00214 ->ProjectionX()->Clone("piplus")); 00215 TH1D* piminus=dynamic_cast<TH1D*> (GetPTXF(9) 00216 ->ProjectionX()->Clone("piplus")); 00217 TH1D* kplus=dynamic_cast<TH1D*> (GetPTXF(11) 00218 ->ProjectionX()->Clone("kplus")); 00219 00220 kplus->Divide(piplus); 00221 piplus->Divide(piminus); 00222 00223 fFlukKPiRat = dynamic_cast<TH1D*>( kplus->Clone("FlukKPiRatio") ); 00224 fFlukPiRat = dynamic_cast<TH1D*>( piplus->Clone("FlukPiRatio") ); 00225 00226 00227 00228 for (int i=1;i<121;i++) 00229 { 00230 if (kplus->GetBinContent(i)!=0.) 00231 fFluka05KPiRatio[i] = kplus->GetBinContent(i); 00232 else if (i<119) 00233 fFluka05KPiRatio[i] = (fFluka05KPiRatio[i-2]+fFluka05KPiRatio[i-1] 00234 +kplus->GetBinContent(i+1)+kplus->GetBinContent(i+2))/4.; 00235 else 00236 fFluka05KPiRatio[i] = fFluka05KPiRatio[i-1]; 00237 00238 fFlukKPiRat -> SetBinContent(i, fFluka05KPiRatio[i]); 00239 } 00240 00241 00242 00243 for (int i=1;i<121;i++) 00244 { 00245 if (piplus->GetBinContent(i)!=0.) 00246 fFluka05PiRatio[i] = piplus->GetBinContent(i); 00247 else if (i<119) 00248 fFluka05PiRatio[i] = (fFluka05PiRatio[i-2]+fFluka05PiRatio[i-1] 00249 +piplus->GetBinContent(i+1)+piplus->GetBinContent(i+2))/4.; 00250 else 00251 fFluka05PiRatio[i] = fFluka05PiRatio[i-1]; 00252 00253 fFlukPiRat -> SetBinContent(i, fFluka05PiRatio[i]); 00254 } 00255 00256 00257 isFirst=true; 00258 00259 00260 }
void Lfluk::RecalculateWeights | ( | ) | [private] |
Definition at line 1132 of file Lfluk.cxx.
References CalcWeight(), Divide(), fFluka05KPiRatio, fFluka05PiRatio, fKPiRatio, fKPiRatScale, fNA49pirat, fNWeighted, fPiRatio, fPlist, fPTXF, fUseFlukPi, fWeightedMeanPT, fWeightedPTXF, fWeightHist, GetParticleName(), GetReweightedPTXF(), and isFirst.
Referenced by SetParameters().
01133 { 01134 01135 if (isFirst) { 01136 for (int i=0;i<121;i++) { 01137 fKPiRatio[i]=1.; 01138 fPiRatio[i]=1.; 01139 } 01140 } 01141 for (std::vector<ParticleType_t>::iterator itPlist=fPlist.begin(); 01142 itPlist!=fPlist.end(); itPlist++) 01143 { 01144 double xf,pt; 01145 double meanpt(0.); 01146 double sum(0.); 01147 const int nbinsx = fPTXF[*itPlist]->GetNbinsX(); 01148 const int nbinsy = fPTXF[*itPlist]->GetNbinsY(); 01149 for (int i=0;i<=nbinsx+1;i++) 01150 { 01151 for (int j=0;j<=nbinsy+1;j++) 01152 { 01153 xf=fPTXF[*itPlist]->GetXaxis()->GetBinCenter(i); 01154 pt=fPTXF[*itPlist]->GetYaxis()->GetBinCenter(j); 01155 double weight = CalcWeight(*itPlist,pt,xf); 01156 01157 fWeightedPTXF[*itPlist] 01158 ->SetBinContent(i,j,(fPTXF[*itPlist]->GetBinContent(i,j) 01159 *weight)); 01160 01161 Lfluk::ParticleType_t eptype= *itPlist; 01162 string name = GetParticleName(eptype); 01163 fWeightHist[*itPlist]->SetBinContent(i,j,weight); 01164 if(weight - fWeightHist[*itPlist]->GetBinContent(i,j) != 0) 01165 //if(name == "PiPlus" && weight !=1.0) 01166 { 01167 cout << "Lfluk::RecalculateWeights(): name = " << name << " pz = " << xf << " pt = " << pt 01168 << " weight from calc = " << setprecision(10) << weight << " weight from hist = " 01169 << fWeightHist[*itPlist]->GetBinContent(i,j) 01170 << " diff = " << weight - fWeightHist[*itPlist]->GetBinContent(i,j) << endl; 01171 } 01172 01173 // 01174 // Projection DOES include overflow bins 01175 // Get Mean DOES NOT 01176 // 01177 //need to include the overflow in y for sure in fWeightedPTXF 01178 //because it is used in the ratios below 01179 //but in meanpt we don't want to use this bin 01180 //I have checked that the fluka "signal" in i=nbinsx+1 is always 0 01181 //so it doesn't matter if this bin is included or not. I think the 01182 //proper thing is that is should be because the projection does 01183 //include it 01184 // 01185 if(j == nbinsy+1) continue; 01186 meanpt+=fWeightedPTXF[*itPlist]->GetBinContent(i,j)*pt; 01187 sum+=fWeightedPTXF[*itPlist]->GetBinContent(i,j); 01188 01189 /*Lfluk::ParticleType_t eptype= *itPlist; 01190 string name = GetParticleName(eptype); 01191 if((name == "PiPlus" || name == "KPlus") && ((i == 2 && j == nbinsy+1) || (i==nbinsx+1 && j == 2))) 01192 { 01193 cout <<"name = " << name << " pz = " << xf << " pt = " << pt 01194 << " weight = " << weight << " fluksig = " << fPTXF[*itPlist]->GetBinContent(i,j) 01195 << " newsig = " << fWeightedPTXF[*itPlist]->GetBinContent(i,j) << endl; 01196 }*/ 01197 01198 01199 } 01200 } 01201 01202 meanpt/=sum; 01203 fWeightedMeanPT[*itPlist]=meanpt*1000.; //GeV to MeV 01204 fNWeighted[*itPlist]=sum; 01205 meanpt=0.; 01206 sum=0.; 01207 /* 01208 if(!isFirst) 01209 { 01210 for (int i=0;i<=fWeightHist[*itPlist]->GetNbinsX()+1;i++) 01211 { 01212 for (int j=0;j<=fWeightHist[*itPlist]->GetNbinsY()+1;j++) 01213 { 01214 xf=fWeightHist[*itPlist]->GetXaxis()->GetBinCenter(i); 01215 pt=fWeightHist[*itPlist]->GetYaxis()->GetBinCenter(j); 01216 double weight = CalcWeight(*itPlist,pt,xf); 01217 01218 Lfluk::ParticleType_t eptype= *itPlist; 01219 string name = GetParticleName(eptype); 01220 fWeightHist[*itPlist]->SetBinContent(i,j,weight); 01221 01222 01223 //if(name == "PiMinus" && weight - fWeightHist[*itPlist]->GetBinContent(i,j) != 0) 01224 //if(name == "PiPlus" && xf > 49 && xf < 50 && weight - fWeightHist[*itPlist]->GetBinContent(i,j) != 0) 01225 //if(name == "PiMinus" && xf > 117 && xf < 119 && weight - fWeightHist[*itPlist]->GetBinContent(i,j) != 0) 01226 if(weight - fWeightHist[*itPlist]->GetBinContent(i,j) != 0) 01227 { 01228 cout << "Lfluk::RecalculateWeights(): name = " << name << " pz = " << xf << " pt = " << pt 01229 << " weight from calc = " << setprecision(10) << weight << " weight from hist = " 01230 << fWeightHist[*itPlist]->GetBinContent(i,j) 01231 << " diff = " << weight - fWeightHist[*itPlist]->GetBinContent(i,j) << endl; 01232 } 01233 } 01234 } 01235 } 01236 */ 01237 } 01238 01239 01240 if (isFirst) 01241 { 01242 isFirst=false; 01243 const TH1D* piplus=dynamic_cast<TH1D*> (GetReweightedPTXF(8) 01244 ->ProjectionX()->Clone("piplus")); 01245 const TH1D* piminus=dynamic_cast<TH1D*> (GetReweightedPTXF(9) 01246 ->ProjectionX()->Clone("piminus")); 01247 TH1D* kplus_f05=dynamic_cast<TH1D*> (GetReweightedPTXF(11) 01248 ->ProjectionX()->Clone("kplus_f05")); 01249 TH1D* piplus_rat=dynamic_cast<TH1D*> (GetReweightedPTXF(8) 01250 ->ProjectionX()->Clone("piplus_f05")); 01251 01252 //fPiPlusReWProj = dynamic_cast<TH1D*>(piplus->Clone()); 01253 01254 piplus_rat -> Divide(piplus, piminus); 01255 01256 //fKPlusf05Proj = dynamic_cast<TH1D*>(kplus_f05->Clone()); 01257 01258 kplus_f05->Divide(piplus); 01259 01260 //fKPlusf05PipReWRatio = dynamic_cast<TH1D*>(kplus_f05->Clone()); 01261 01262 for (int i=1;i<121;i++) 01263 { 01264 if (kplus_f05->GetBinContent(i)!=0) 01265 { 01266 fKPiRatio[i] = (fFluka05KPiRatio[i]*fKPiRatScale)/kplus_f05->GetBinContent(i); 01267 } 01268 01269 if (piplus_rat->GetBinContent(i)!=0) 01270 { 01271 if(fUseFlukPi && fFluka05PiRatio[i] != 0) fPiRatio[i] = piplus_rat->GetBinContent(i)/fFluka05PiRatio[i]; 01272 else fPiRatio[i] = piplus_rat->GetBinContent(i)/fNA49pirat->Eval(piplus_rat->GetBinCenter(i)); 01273 01274 } 01275 /*if (i<62) 01276 { 01277 fPiRatio[i] = piplus->GetBinContent(i)/fNA49pirat->Eval(piplus->GetBinCenter(i)); 01278 } 01279 else 01280 { 01281 fPiRatio[i]=1.; 01282 }*/ 01283 } 01284 delete piplus; 01285 piplus=0; 01286 delete piminus; 01287 piminus=0; 01288 delete kplus_f05; 01289 kplus_f05=0; 01290 delete piplus_rat; 01291 piplus_rat = 0; 01292 01293 RecalculateWeights(); 01294 } 01295 01296 }
void Lfluk::SetConfig | ( | const std::string | param, | |
const std::string | skew, | |||
const std::string | na49fit, | |||
const double | wmin, | |||
const double | wmax | |||
) |
void Lfluk::SetParameters | ( | std::vector< double > | par | ) |
Definition at line 352 of file Lfluk.cxx.
References fPar, fParam, fSkew, isFirst, and RecalculateWeights().
00353 { 00354 fPar=par; 00355 isFirst=true; 00356 00357 if(fParam == "skzp" && fSkew == "fluka") 00358 { 00359 cout << " Pars = "; 00360 for(unsigned int ip = 0; ip < fPar.size(); ++ip) 00361 { 00362 cout << fPar[ip] << " "; 00363 } 00364 cout << "end pars " << endl; 00365 00366 /* 00367 Lfluk::ParticleType_t eptype=GetParticleEnum(8); 00368 00369 double xF; bool print = false; 00370 for (int i=0;i<fPTXF[eptype]->GetNbinsX()+1;i++) 00371 { 00372 xF=fPTXF[eptype]->GetXaxis()->GetBinCenter(i); 00373 xF = xF/120.0; 00374 if (xF>1.||xF<0.) continue; 00375 00376 if( fabs((int)(xF*10) - xF*10) < 0.1) print = true; 00377 00378 if(print) cout << "xF = " << xF; 00379 00380 double A = Lfluk::GetSKZPA(eptype, xF); 00381 if(print) cout << " A = " << A; 00382 00383 double B = Lfluk::GetSKZPB(eptype, xF); 00384 if(print) cout << " B = " << B; 00385 00386 double C = Lfluk::GetSKZPC(eptype, xF); 00387 if(print) cout << " C = " << C; 00388 00389 long double Ap= fPar[0]*pow((1.-xF),fPar[1])*(1.+fPar[2]*xF)*pow(xF,fPar[3]); 00390 if(print) cout << " Ap = " << Ap; 00391 00392 long double Bp= fPar[4]*pow((1.-xF),fPar[5])*(1.+fPar[6]*xF)*pow(xF,fPar[7]); 00393 if(print) cout << " Bp = " << Bp; 00394 00395 long double Cp; 00396 if (xF<0.22) 00397 { 00398 Cp= fPar[8]/pow(xF,fPar[9])+fPar[10]; 00399 if(Cp < -100.0) Cp = -100.0; 00400 if(Cp > 100.0) Cp = 100.0; 00401 if(print) cout << " Cp = " << Cp; 00402 } 00403 else 00404 { 00405 double arg22 = (0.22-fPar[11])*fPar[12]; 00406 if(arg22 < -100.0) arg22 = -100.0; 00407 if(arg22 > 100.0) arg22 = 100.0; 00408 double match = (fPar[8]/pow(0.22,fPar[9])+fPar[10]- 00409 fPar[13]*0.22-fPar[14])*exp(arg22); 00410 double exparg = (xF-fPar[11])*fPar[12]; 00411 if(exparg < -100.0) exparg = -100.0; 00412 if(exparg > 100.0) exparg = 100.0; 00413 Cp = ( match / exp(exparg)) + fPar[13]*xF+fPar[14]; 00414 00415 if(Cp < -100.0) Cp = -100.0; 00416 if(Cp > 100.0) Cp = 100.0; 00417 if(print) cout << " Cp = " << Cp; 00418 } 00419 00420 00421 if(print) 00422 { 00423 cout << " exp(-(Cp-C)) = " << exp(-(Cp-C)) << endl; 00424 00425 cout << " pT = 0.01, (Ap+Bp*pT)/(A+B*pT) = " << (Ap+Bp*0.01)/(A+B*0.01); 00426 double weight=(Ap+Bp*0.01)/(A+B*0.01)*exp(-(Cp-C)*pow(0.01,3./2.)); 00427 cout << " weight = " << weight << endl; 00428 00429 cout << " pT = 0.95, (Ap+Bp*pT)/(A+B*pT) = " << (Ap+Bp*0.95)/(A+B*0.95); 00430 weight=(Ap+Bp*0.95)/(A+B*0.95)*exp(-(Cp-C)*pow(0.95,3./2.)); 00431 cout << " weight = " << weight << endl; 00432 00433 } 00434 print = false; 00435 00436 } 00437 */ 00438 00439 cout << "Done Setting pars...recalc weights" << endl; 00440 cout << endl; 00441 00442 } 00443 00444 00445 00446 00447 00448 RecalculateWeights(); 00449 }
void Lfluk::SkewSKPC | ( | const double | xF, | |
const double | A, | |||
const double | B, | |||
const double | C, | |||
const double | D, | |||
const double | E, | |||
double & | Ap, | |||
double & | Bp, | |||
double & | Cp, | |||
double & | Dp, | |||
double & | Ep | |||
) | [private] |
Definition at line 935 of file Lfluk.cxx.
Referenced by GetSKPCWeight().
00938 { 00939 00940 if(fSkew.find("lin") != string::npos) 00941 { 00942 if(fPar.size() == 10) 00943 { 00944 Ap=(fPar[0]+fPar[1]*xF)*A; 00945 Bp=(fPar[2]+fPar[3]*xF)*B; 00946 Cp=(fPar[4]+fPar[5]*xF)*C; 00947 Dp=(fPar[6]+fPar[7]*xF)*D; 00948 Ep=(fPar[8]+fPar[9]*xF)*E; 00949 00950 return; 00951 } 00952 } 00953 00954 if(fSkew.find("quad") != string::npos) 00955 { 00956 if(fPar.size() == 15) 00957 { 00958 Ap=(fPar[0]+fPar[1]*xF+fPar[2]*xF*xF)*A; 00959 Bp=(fPar[3]+fPar[4]*xF+fPar[5]*xF*xF)*B; 00960 Cp=(fPar[6]+fPar[7]*xF+fPar[8]*xF*xF)*C; 00961 Dp=(fPar[9]+fPar[10]*xF+fPar[11]*xF*xF)*D; 00962 Ep=(fPar[12]+fPar[13]*xF+fPar[14]*xF*xF)*E; 00963 00964 return; 00965 } 00966 } 00967 00968 cout << "Lfluk::SkewSKPC() - No valid skew option or wrong number of parameters" << endl 00969 << " fSkew = " << fSkew << endl 00970 << " NPars = " << fPar.size() << endl; 00971 00972 Ap = A; 00973 Bp = B; 00974 Cp = C; 00975 Dp = D; 00976 Ep = E; 00977 00978 }
void Lfluk::SkewSKZP | ( | const double | xF, | |
const double | A, | |||
const double | B, | |||
const double | C, | |||
long double & | Ap, | |||
long double & | Bp, | |||
long double & | Cp | |||
) | [private] |
Definition at line 981 of file Lfluk.cxx.
Referenced by GetSKZPWeight().
00982 { 00983 // scale/skew A, B and C 00984 00985 if(fSkew.find("fluka") != string::npos) 00986 { 00987 if(fPar.size() == 15) 00988 { 00989 Ap= fPar[0]*pow((1.-xF),fPar[1])*(1.+fPar[2]*xF)*pow(xF,fPar[3]); 00990 Bp= fPar[4]*pow((1.-xF),fPar[5])*(1.+fPar[6]*xF)*pow(xF,fPar[7]); 00991 00992 if (xF<0.22) 00993 { 00994 Cp= fPar[8]/pow(xF,fPar[9])+fPar[10]; 00995 } 00996 else 00997 { 00998 double arg22 = (0.22-fPar[11])*fPar[12]; 00999 if(arg22 < -100.0) arg22 = -100.0; 01000 if(arg22 > 100.0) arg22 = 100.0; 01001 double match = (fPar[8]/pow(0.22,fPar[9])+fPar[10]- 01002 fPar[13]*0.22-fPar[14])*exp(arg22); 01003 double exparg = (xF-fPar[11])*fPar[12]; 01004 if(exparg < -100.0) exparg = -100.0; 01005 if(exparg > 100.0) exparg = 100.0; 01006 Cp = ( match / exp(exparg)) + fPar[13]*xF+fPar[14]; 01007 01008 } 01009 01010 return; 01011 } 01012 } 01013 01014 if(fSkew.find("lin") != string::npos) 01015 { 01016 if(fPar.size() == 6) 01017 { 01018 Ap=(fPar[0]+fPar[1]*xF)*A; 01019 Bp=(fPar[2]+fPar[3]*xF)*B; 01020 Cp=(fPar[4]+fPar[5]*xF)*C; 01021 01022 return; 01023 } 01024 } 01025 01026 if(fSkew.find("quad") != string::npos) 01027 { 01028 if(fPar.size() == 9) 01029 { 01030 Ap=(fPar[0]+fPar[1]*xF+fPar[2]*xF*xF)*A; 01031 Bp=(fPar[3]+fPar[4]*xF+fPar[5]*xF*xF)*B; 01032 Cp=(fPar[6]+fPar[7]*xF+fPar[8]*xF*xF)*C; 01033 01034 return; 01035 } 01036 } 01037 01038 cout << "Lfluk::SkewSKZP() - No valid skew option or wrong number of parameters" << endl 01039 << " fSkew = " << fSkew << endl 01040 << " NPars = " << fPar.size() << endl; 01041 01042 Ap = A; 01043 Bp = B; 01044 Cp = C; 01045 01046 }
std::vector<double> Lfluk::fFluka05KPiRatio [private] |
Definition at line 125 of file Lfluk.h.
Referenced by Init(), and RecalculateWeights().
std::vector<double> Lfluk::fFluka05PiRatio [private] |
Definition at line 126 of file Lfluk.h.
Referenced by Init(), and RecalculateWeights().
TH1* Lfluk::fFlukKPiRat [private] |
Definition at line 131 of file Lfluk.h.
Referenced by GetFlukKPiRatio(), and Init().
TH1* Lfluk::fFlukPiRat [private] |
std::vector<double> Lfluk::fKPiRatio [private] |
Definition at line 127 of file Lfluk.h.
Referenced by CalcWeight(), Init(), and RecalculateWeights().
double Lfluk::fKPiRatScale [private] |
Definition at line 105 of file Lfluk.h.
Referenced by Config(), and RecalculateWeights().
TH1* Lfluk::fKPlusf05PipReWRatio [private] |
Definition at line 135 of file Lfluk.h.
Referenced by GetKPlusf05PipReWRatio().
TH1* Lfluk::fKPlusf05Proj [private] |
Definition at line 134 of file Lfluk.h.
Referenced by GetKPlusf05Proj().
double Lfluk::fMaxW [private] |
Definition at line 104 of file Lfluk.h.
Referenced by CalcWeight(), Config(), and SetConfig().
std::map<Lfluk::ParticleType_t, double > Lfluk::fMeanPT [private] |
Definition at line 116 of file Lfluk.h.
Referenced by GetMeanPT(), GetPTshift(), and Init().
double Lfluk::fMinW [private] |
Definition at line 103 of file Lfluk.h.
Referenced by CalcWeight(), Config(), and SetConfig().
std::map<Lfluk::ParticleType_t, double > Lfluk::fN [private] |
Definition at line 117 of file Lfluk.h.
Referenced by CalcWeight(), and Init().
std::string Lfluk::fNA49Fit [private] |
Definition at line 100 of file Lfluk.h.
Referenced by Config(), Init(), and SetConfig().
TF1* Lfluk::fNA49pirat [private] |
Definition at line 123 of file Lfluk.h.
Referenced by Init(), and RecalculateWeights().
std::map<Lfluk::ParticleType_t, int > Lfluk::fNBinsX [private] |
std::map<Lfluk::ParticleType_t, int > Lfluk::fNBinsY [private] |
std::map<Lfluk::ParticleType_t, double > Lfluk::fNWeighted [private] |
Definition at line 118 of file Lfluk.h.
Referenced by CalcWeight(), Init(), and RecalculateWeights().
std::vector<double> Lfluk::fPar [private] |
Definition at line 110 of file Lfluk.h.
Referenced by CalcWeight(), GetMeanPTWeight(), GetParameters(), GetQuadWeight(), SetParameters(), SkewSKPC(), and SkewSKZP().
std::string Lfluk::fParam [private] |
Definition at line 98 of file Lfluk.h.
Referenced by CalcWeight(), Config(), GetQuadWeight(), SetConfig(), and SetParameters().
std::string Lfluk::fPath [private] |
TH1* Lfluk::fPiPlusReWProj [private] |
Definition at line 133 of file Lfluk.h.
Referenced by GetPiPlusReWProj().
std::vector<double> Lfluk::fPiRatio [private] |
Definition at line 124 of file Lfluk.h.
Referenced by CalcWeight(), Init(), and RecalculateWeights().
std::vector<ParticleType_t> Lfluk::fPlist [private] |
Definition at line 111 of file Lfluk.h.
Referenced by Init(), and RecalculateWeights().
std::map<Lfluk::ParticleType_t, TH2F* > Lfluk::fPTXF [private] |
Definition at line 113 of file Lfluk.h.
Referenced by GetNFrac(), GetPTshift(), GetPTXF(), Init(), and RecalculateWeights().
std::string Lfluk::fSkew [private] |
Definition at line 99 of file Lfluk.h.
Referenced by Config(), SetConfig(), SetParameters(), SkewSKPC(), and SkewSKZP().
bool Lfluk::fUseFlukPi [private] |
Definition at line 108 of file Lfluk.h.
Referenced by Config(), and RecalculateWeights().
std::map<Lfluk::ParticleType_t, double > Lfluk::fWeightedMeanPT [private] |
Definition at line 119 of file Lfluk.h.
Referenced by GetPTshift(), GetReweightedMeanPT(), Init(), and RecalculateWeights().
std::map<Lfluk::ParticleType_t, TH2F* > Lfluk::fWeightedPTXF [private] |
Definition at line 114 of file Lfluk.h.
Referenced by GetNFrac(), GetPTshift(), GetReweightedPTXF(), Init(), and RecalculateWeights().
std::map<Lfluk::ParticleType_t, TH2D* > Lfluk::fWeightHist [private] |
Definition at line 115 of file Lfluk.h.
Referenced by GetWeight(), GetWeightHist(), GetWeightHistogram(), Init(), and RecalculateWeights().
bool Lfluk::fWghtFromHist [private] |
Definition at line 107 of file Lfluk.h.
Referenced by Config(), and GetWeight().
bool Lfluk::isFirst [private] |
Definition at line 129 of file Lfluk.h.
Referenced by Init(), RecalculateWeights(), and SetParameters().