|
|
|
#include <LumiReweightingStandAlone.h>
Public Member Functions | |
| double | ITweight (int npv) |
| double | ITweight3BX (float ave_int) |
| LumiReWeighting (std::string generatedFile, std::string dataFile, std::string GenHistName, std::string DataHistName) | |
| LumiReWeighting () | |
| LumiReWeighting (std::vector< float > MC_distr, std::vector< float > Lumi_distr) | |
| double | weight (float n_int) |
| double | weight3D (int pv1, int pv2, int pv3) |
| void | weight3D_init (float ScaleFactor, std::string WeightOutputFile="") |
| void | weight3D_set (std::string WeightFileName) |
| double | weightOOT (int npv_in_time, int npv_m50nsBX) |
| void | weightOOT_init () |
Protected Attributes | |
| TH1 * | Data_distr_ |
| TFile * | dataFile_ |
| std::string | dataFileName_ |
| std::string | DataHistName_ |
| bool | FirstWarning_ |
| TFile * | generatedFile_ |
| std::string | generatedFileName_ |
| std::string | GenHistName_ |
| TH1 * | MC_distr_ |
| double | Weight3D_ [50][50][50] |
| double | WeightOOTPU_ [25][25] |
| TH1 * | weights_ |
Definition at line 227 of file LumiReweightingStandAlone.h.
| reweight::LumiReWeighting::LumiReWeighting | ( | ) | [inline] |
Definition at line 230 of file LumiReweightingStandAlone.h.
{ } ;
| reweight::LumiReWeighting::LumiReWeighting | ( | std::string | generatedFile, |
| std::string | dataFile, | ||
| std::string | GenHistName, | ||
| std::string | DataHistName | ||
| ) | [inline] |
Definition at line 232 of file LumiReweightingStandAlone.h.
References gather_cfg::cout, Data_distr_, dataFile_, dataFileName_, DataHistName_, FirstWarning_, generatedFile_, generatedFileName_, GenHistName_, MC_distr_, EnsembleCalibrationLA_cfg::NBins, weightOOT_init(), and weights_.
:
generatedFileName_( generatedFile),
dataFileName_ ( dataFile ),
GenHistName_ ( GenHistName ),
DataHistName_ ( DataHistName )
{
generatedFile_ = new TFile( generatedFileName_.c_str() ) ; //MC distribution
dataFile_ = new TFile( dataFileName_.c_str() ); //Data distribution
Data_distr_ = new TH1( *(static_cast<TH1*>(dataFile_->Get( DataHistName_.c_str() )->Clone() )) );
MC_distr_ = new TH1( *(static_cast<TH1*>(generatedFile_->Get( GenHistName_.c_str() )->Clone() )) );
// normalize both histograms first
Data_distr_->Scale( 1.0/ Data_distr_->Integral() );
MC_distr_->Scale( 1.0/ MC_distr_->Integral() );
weights_ = new TH1( *(Data_distr_)) ;
// MC * data/MC = data, so the weights are data/MC:
weights_->SetName("lumiWeights");
TH1* den = new TH1(*(MC_distr_));
weights_->Divide( den ); // so now the average weight should be 1.0
std::cout << " Lumi/Pileup Reweighting: Computed Weights per In-Time Nint " << std::endl;
int NBins = weights_->GetNbinsX();
for(int ibin = 1; ibin<NBins+1; ++ibin){
std::cout << " " << ibin-1 << " " << weights_->GetBinContent(ibin) << std::endl;
}
weightOOT_init();
FirstWarning_ = true;
}
| reweight::LumiReWeighting::LumiReWeighting | ( | std::vector< float > | MC_distr, |
| std::vector< float > | Lumi_distr | ||
| ) | [inline] |
Definition at line 277 of file LumiReweightingStandAlone.h.
References dtNoiseDBValidation_cfg::cerr, gather_cfg::cout, Data_distr_, FirstWarning_, MC_distr_, EnsembleCalibrationLA_cfg::NBins, weightOOT_init(), and weights_.
{
// no histograms for input: use vectors
// now, make histograms out of them:
// first, check they are the same size...
if( MC_distr.size() != Lumi_distr.size() ){
std::cerr <<"ERROR: LumiReWeighting: input vectors have different sizes. Quitting... \n";
return;
}
Int_t NBins = MC_distr.size();
MC_distr_ = new TH1F("MC_distr","MC dist",NBins,-0.5, float(NBins)-0.5);
Data_distr_ = new TH1F("Data_distr","Data dist",NBins,-0.5, float(NBins)-0.5);
weights_ = new TH1F("luminumer","luminumer",NBins,-0.5, float(NBins)-0.5);
TH1* den = new TH1F("lumidenom","lumidenom",NBins,-0.5, float(NBins)-0.5);
for(int ibin = 1; ibin<NBins+1; ++ibin ) {
weights_->SetBinContent(ibin, Lumi_distr[ibin-1]);
Data_distr_->SetBinContent(ibin, Lumi_distr[ibin-1]);
den->SetBinContent(ibin,MC_distr[ibin-1]);
MC_distr_->SetBinContent(ibin,MC_distr[ibin-1]);
}
// check integrals, make sure things are normalized
float deltaH = weights_->Integral();
if(fabs(1.0 - deltaH) > 0.02 ) { //*OOPS*...
weights_->Scale( 1.0/ deltaH );
Data_distr_->Scale( 1.0/ deltaH );
}
float deltaMC = den->Integral();
if(fabs(1.0 - deltaMC) > 0.02 ) {
den->Scale(1.0/ deltaMC );
MC_distr_->Scale(1.0/ deltaMC );
}
weights_->Divide( den ); // so now the average weight should be 1.0
std::cout << " Lumi/Pileup Reweighting: Computed Weights per In-Time Nint " << std::endl;
for(int ibin = 1; ibin<NBins+1; ++ibin){
std::cout << " " << ibin-1 << " " << weights_->GetBinContent(ibin) << std::endl;
}
weightOOT_init();
FirstWarning_ = true;
}
| double reweight::LumiReWeighting::ITweight | ( | int | npv | ) | [inline] |
Definition at line 1297 of file LumiReweightingStandAlone.h.
References newFWLiteAna::bin, and weights_.
| double reweight::LumiReWeighting::ITweight3BX | ( | float | ave_int | ) | [inline] |
Definition at line 1302 of file LumiReweightingStandAlone.h.
References newFWLiteAna::bin, and weights_.
| double reweight::LumiReWeighting::weight | ( | float | n_int | ) | [inline] |
Definition at line 1307 of file LumiReweightingStandAlone.h.
References newFWLiteAna::bin, and weights_.
| double reweight::LumiReWeighting::weight3D | ( | int | pv1, |
| int | pv2, | ||
| int | pv3 | ||
| ) | [inline] |
| void reweight::LumiReWeighting::weight3D_init | ( | float | ScaleFactor, |
| std::string | WeightOutputFile = "" |
||
| ) | [inline] |
Definition at line 333 of file LumiReweightingStandAlone.h.
References newFWLiteAna::base, gather_cfg::cout, Data_distr_, funct::exp(), factorial(), i, j, gen::k, MC_distr_, timingPdfMaker::mean, min, EdgesToViz::outfile, Weight3D_, and x.
{
//create histogram to write output weights, save pain of generating them again...
TH3D* WHist = new TH3D("WHist","3D weights",50,0.,50.,50,0.,50.,50,0.,50. );
TH3D* DHist = new TH3D("DHist","3D weights",50,0.,50.,50,0.,50.,50,0.,50. );
TH3D* MHist = new TH3D("MHist","3D weights",50,0.,50.,50,0.,50.,50,0.,50. );
using std::min;
if( MC_distr_->GetEntries() == 0 ) {
std::cout << " MC and Data distributions are not initialized! You must call the LumiReWeighting constructor. " << std::endl;
}
// arrays for storing number of interactions
double MC_ints[50][50][50];
double Data_ints[50][50][50];
for (int i=0; i<50; i++) {
for(int j=0; j<50; j++) {
for(int k=0; k<50; k++) {
MC_ints[i][j][k] = 0.;
Data_ints[i][j][k] = 0.;
}
}
}
double factorial[50];
double PowerSer[50];
double base = 1.;
factorial[0] = 1.;
PowerSer[0]=1.;
for (int i = 1; i<50; ++i) {
base = base*float(i);
factorial[i] = base;
}
double x;
double xweight;
double probi, probj, probk;
double Expval, mean;
int xi;
// Get entries for Data, MC, fill arrays:
int NMCbin = MC_distr_->GetNbinsX();
for (int jbin=1;jbin<NMCbin+1;jbin++) {
x = MC_distr_->GetBinCenter(jbin);
xweight = MC_distr_->GetBinContent(jbin); //use as weight for matrix
//for Summer 11, we have this int feature:
xi = int(x);
// Generate Poisson distribution for each value of the mean
mean = double(xi);
if(mean<0.) {
std::cout << "LumiReweighting:BadInputValue" << " Your histogram generates MC luminosity values less than zero!"
<< " Please Check. Terminating." << std::endl;
}
if(mean==0.){
Expval = 1.;
}
else {
Expval = exp(-1.*mean);
}
base = 1.;
for (int i = 1; i<50; ++i) {
base = base*mean;
PowerSer[i] = base; // PowerSer is mean^i
}
// compute poisson probability for each Nvtx in weight matrix
for (int i=0; i<50; i++) {
probi = PowerSer[i]/factorial[i]*Expval;
for(int j=0; j<50; j++) {
probj = PowerSer[j]/factorial[j]*Expval;
for(int k=0; k<50; k++) {
probk = PowerSer[k]/factorial[k]*Expval;
// joint probability is product of event weights multiplied by weight of input distribution bin
MC_ints[i][j][k] = MC_ints[i][j][k]+probi*probj*probk*xweight;
}
}
}
}
int NDatabin = Data_distr_->GetNbinsX();
for (int jbin=1;jbin<NDatabin+1;jbin++) {
mean = (Data_distr_->GetBinCenter(jbin))*ScaleFactor;
xweight = Data_distr_->GetBinContent(jbin);
// Generate poisson distribution for each value of the mean
if(mean<0.) {
std::cout << "LumiReweighting:BadInputValue" << " Your histogram generates MC luminosity values less than zero!"
<< " Please Check. Terminating." << std::endl;
}
if(mean==0.){
Expval = 1.;
}
else {
Expval = exp(-1.*mean);
}
base = 1.;
for (int i = 1; i<50; ++i) {
base = base*mean;
PowerSer[i] = base;
}
// compute poisson probability for each Nvtx in weight matrix
for (int i=0; i<50; i++) {
probi = PowerSer[i]/factorial[i]*Expval;
for(int j=0; j<50; j++) {
probj = PowerSer[j]/factorial[j]*Expval;
for(int k=0; k<50; k++) {
probk = PowerSer[k]/factorial[k]*Expval;
// joint probability is product of event weights multiplied by weight of input distribution bin
Data_ints[i][j][k] = Data_ints[i][j][k]+probi*probj*probk*xweight;
}
}
}
}
for (int i=0; i<50; i++) {
//if(i<5) std::cout << "i = " << i << std::endl;
for(int j=0; j<50; j++) {
for(int k=0; k<50; k++) {
if( (MC_ints[i][j][k])>0.) {
Weight3D_[i][j][k] = Data_ints[i][j][k]/MC_ints[i][j][k];
}
else {
Weight3D_[i][j][k] = 0.;
}
WHist->SetBinContent( i+1,j+1,k+1,Weight3D_[i][j][k] );
DHist->SetBinContent( i+1,j+1,k+1,Data_ints[i][j][k] );
MHist->SetBinContent( i+1,j+1,k+1,MC_ints[i][j][k] );
// if(i<5 && j<5 && k<5) std::cout << Weight3D_[i][j][k] << " " ;
}
// if(i<5 && j<5) std::cout << std::endl;
}
}
if(! WeightOutputFile.empty() ) {
std::cout << " 3D Weight Matrix initialized! " << std::endl;
std::cout << " Writing weights to file " << WeightOutputFile << " for re-use... " << std::endl;
TFile * outfile = new TFile(WeightOutputFile.c_str(),"RECREATE");
WHist->Write();
MHist->Write();
DHist->Write();
outfile->Write();
outfile->Close();
outfile->Delete();
}
return;
}
| void reweight::LumiReWeighting::weight3D_set | ( | std::string | WeightFileName | ) | [inline] |
Definition at line 509 of file LumiReweightingStandAlone.h.
References gather_cfg::cout, i, EdgesToViz::infile, j, gen::k, and Weight3D_.
{
TFile *infile = new TFile(WeightFileName.c_str());
TH1F *WHist = (TH1F*)infile->Get("WHist");
// Check if the histogram exists
if (!WHist) {
std::cout << " Could not find the histogram WHist in the file "
<< "in the file " << WeightFileName << "." << std::endl;
return;
}
for (int i=0; i<50; i++) {
for(int j=0; j<50; j++) {
for(int k=0; k<50; k++) {
Weight3D_[i][j][k] = WHist->GetBinContent(i,j,k);
}
}
}
std::cout << " 3D Weight Matrix initialized! " << std::endl;
return;
}
| double reweight::LumiReWeighting::weightOOT | ( | int | npv_in_time, |
| int | npv_m50nsBX | ||
| ) | [inline] |
Definition at line 1327 of file LumiReweightingStandAlone.h.
References newFWLiteAna::bin, dtNoiseDBValidation_cfg::cerr, gather_cfg::cout, FirstWarning_, WeightOOTPU_, and weights_.
{
static double Correct_Weights2011[25] = { // residual correction to match lumi spectrum
5.30031,
2.07903,
1.40729,
1.27687,
1.0702,
0.902094,
0.902345,
0.931449,
0.78202,
0.824686,
0.837735,
0.910261,
1.01394,
1.1599,
1.12778,
1.58423,
1.78868,
1.58296,
2.3291,
3.86641,
0,
0,
0,
0,
0
};
if(FirstWarning_) {
std::cout << " **** Warning: Out-of-time pileup reweighting appropriate only for PU_S3 **** " << std::endl;
std::cout << " **** will be applied **** " << std::endl;
FirstWarning_ = false;
}
// Note: for the "uncorrelated" out-of-time pileup, reweighting is only done on the 50ns
// "late" bunch (BX=+1), since that is basically the only one that matters in terms of
// energy deposition.
if(npv_in_time < 0) {
std::cerr << " no in-time beam crossing found\n! " ;
std::cerr << " Returning event weight=0\n! ";
return 0.;
}
if(npv_m50nsBX < 0) {
std::cerr << " no out-of-time beam crossing found\n! " ;
std::cerr << " Returning event weight=0\n! ";
return 0.;
}
int bin = weights_->GetXaxis()->FindBin( npv_in_time );
double inTimeWeight = weights_->GetBinContent( bin );
double TotalWeight = 1.0;
TotalWeight = inTimeWeight * WeightOOTPU_[bin-1][npv_m50nsBX] * Correct_Weights2011[bin-1];
return TotalWeight;
}
| void reweight::LumiReWeighting::weightOOT_init | ( | ) | [inline] |
Definition at line 538 of file LumiReweightingStandAlone.h.
References iint, and WeightOOTPU_.
Referenced by LumiReWeighting().
{
// The following are poisson distributions with different means, where the maximum
// of the function has been normalized to weight 1.0
// These are used to reweight the out-of-time pileup to match the in-time distribution.
// The total event weight is the product of the in-time weight, the out-of-time weight,
// and a residual correction to fix the distortions caused by the fact that the out-of-time
// distribution is not flat.
static double weight_24[25] = {
0,
0,
0,
0,
2.46277e-06,
2.95532e-05,
0.000104668,
0.000401431,
0.00130034,
0.00342202,
0.00818132,
0.0175534,
0.035784,
0.0650836,
0.112232,
0.178699,
0.268934,
0.380868,
0.507505,
0.640922,
0.768551,
0.877829,
0.958624,
0.99939,
1
};
static double weight_23[25] = {
0,
1.20628e-06,
1.20628e-06,
2.41255e-06,
1.20628e-05,
6.39326e-05,
0.000252112,
0.000862487,
0.00244995,
0.00616527,
0.0140821,
0.0293342,
0.0564501,
0.100602,
0.164479,
0.252659,
0.36268,
0.491427,
0.627979,
0.75918,
0.873185,
0.957934,
0.999381,
1,
0.957738
};
static double weight_22[25] = {
0,
0,
0,
5.88636e-06,
3.0609e-05,
0.000143627,
0.000561558,
0.00173059,
0.00460078,
0.0110616,
0.0238974,
0.0475406,
0.0875077,
0.148682,
0.235752,
0.343591,
0.473146,
0.611897,
0.748345,
0.865978,
0.953199,
0.997848,
1,
0.954245,
0.873688
};
static double weight_21[25] = {
0,
0,
1.15381e-06,
8.07665e-06,
7.1536e-05,
0.000280375,
0.00107189,
0.00327104,
0.00809396,
0.0190978,
0.0401894,
0.0761028,
0.13472,
0.216315,
0.324649,
0.455125,
0.598241,
0.739215,
0.861866,
0.953911,
0.998918,
1,
0.956683,
0.872272,
0.76399
};
static double weight_20[25] = {
0,
0,
1.12532e-06,
2.58822e-05,
0.000145166,
0.000633552,
0.00215048,
0.00592816,
0.0145605,
0.0328367,
0.0652649,
0.11893,
0.19803,
0.305525,
0.436588,
0.581566,
0.727048,
0.8534,
0.949419,
0.999785,
1,
0.953008,
0.865689,
0.753288,
0.62765
};
static double weight_19[25] = {
0,
0,
1.20714e-05,
5.92596e-05,
0.000364337,
0.00124994,
0.00403953,
0.0108149,
0.025824,
0.0544969,
0.103567,
0.17936,
0.283532,
0.416091,
0.562078,
0.714714,
0.846523,
0.947875,
1,
0.999448,
0.951404,
0.859717,
0.742319,
0.613601,
0.48552
};
static double weight_18[25] = {
0,
3.20101e-06,
2.88091e-05,
0.000164319,
0.000719161,
0.00250106,
0.00773685,
0.0197513,
0.0443693,
0.0885998,
0.159891,
0.262607,
0.392327,
0.543125,
0.69924,
0.837474,
0.943486,
0.998029,
1,
0.945937,
0.851807,
0.729309,
0.596332,
0.467818,
0.350434
};
static double weight_17[25] = {
1.03634e-06,
7.25437e-06,
4.97443e-05,
0.000340956,
0.00148715,
0.00501485,
0.0143067,
0.034679,
0.0742009,
0.140287,
0.238288,
0.369416,
0.521637,
0.682368,
0.828634,
0.939655,
1,
0.996829,
0.94062,
0.841575,
0.716664,
0.582053,
0.449595,
0.331336,
0.234332
};
static double weight_16[25] = {
4.03159e-06,
2.41895e-05,
0.000141106,
0.00081942,
0.00314565,
0.00990662,
0.026293,
0.0603881,
0.120973,
0.214532,
0.343708,
0.501141,
0.665978,
0.820107,
0.938149,
1,
0.99941,
0.940768,
0.837813,
0.703086,
0.564023,
0.42928,
0.312515,
0.216251,
0.14561
};
static double weight_15[25] = {
9.76084e-07,
5.07564e-05,
0.000303562,
0.00174036,
0.00617959,
0.0188579,
0.047465,
0.101656,
0.189492,
0.315673,
0.474383,
0.646828,
0.809462,
0.934107,
0.998874,
1,
0.936163,
0.827473,
0.689675,
0.544384,
0.40907,
0.290648,
0.198861,
0.12951,
0.0808051
};
static double weight_14[25] = {
1.13288e-05,
0.000124617,
0.000753365,
0.00345056,
0.0123909,
0.0352712,
0.0825463,
0.16413,
0.287213,
0.44615,
0.625826,
0.796365,
0.930624,
0.999958,
1,
0.934414,
0.816456,
0.672939,
0.523033,
0.386068,
0.269824,
0.180342,
0.114669,
0.0698288,
0.0406496
};
static double weight_13[25] = {
2.54296e-05,
0.000261561,
0.00167018,
0.00748083,
0.0241308,
0.0636801,
0.138222,
0.255814,
0.414275,
0.600244,
0.779958,
0.92256,
0.999155,
1,
0.927126,
0.804504,
0.651803,
0.497534,
0.35976,
0.245834,
0.160904,
0.0991589,
0.0585434,
0.0332437,
0.0180159
};
static double weight_12[25] = {
5.85742e-05,
0.000627706,
0.00386677,
0.0154068,
0.0465892,
0.111683,
0.222487,
0.381677,
0.5719,
0.765001,
0.915916,
1,
0.999717,
0.921443,
0.791958,
0.632344,
0.475195,
0.334982,
0.223666,
0.141781,
0.0851538,
0.048433,
0.0263287,
0.0133969,
0.00696683
};
static double weight_11[25] = {
0.00015238,
0.00156064,
0.00846044,
0.0310939,
0.0856225,
0.187589,
0.343579,
0.541892,
0.74224,
0.909269,
0.998711,
1,
0.916889,
0.77485,
0.608819,
0.447016,
0.307375,
0.198444,
0.121208,
0.070222,
0.0386492,
0.0201108,
0.0100922,
0.00484937,
0.00222458
};
static double weight_10[25] = {
0.000393044,
0.00367001,
0.0179474,
0.060389,
0.151477,
0.302077,
0.503113,
0.720373,
0.899568,
1,
0.997739,
0.909409,
0.75728,
0.582031,
0.415322,
0.277663,
0.174147,
0.102154,
0.0566719,
0.0298642,
0.0147751,
0.00710995,
0.00319628,
0.00140601,
0.000568796
};
static double weight_9[25] = {
0.00093396,
0.00854448,
0.0380306,
0.113181,
0.256614,
0.460894,
0.690242,
0.888781,
1,
0.998756,
0.899872,
0.735642,
0.552532,
0.382726,
0.246114,
0.147497,
0.0825541,
0.0441199,
0.0218157,
0.0103578,
0.00462959,
0.0019142,
0.000771598,
0.000295893,
0.000111529
};
static double weight_8[25] = {
0.00240233,
0.0192688,
0.0768653,
0.205008,
0.410958,
0.65758,
0.875657,
0.999886,
1,
0.889476,
0.711446,
0.517781,
0.345774,
0.212028,
0.121208,
0.0644629,
0.0324928,
0.0152492,
0.00673527,
0.0028547,
0.00117213,
0.000440177,
0.000168471,
5.80689e-05,
1.93563e-05
};
static double weight_7[25] = {
0.00617233,
0.0428714,
0.150018,
0.350317,
0.612535,
0.856525,
0.999923,
1,
0.87544,
0.679383,
0.478345,
0.303378,
0.176923,
0.0950103,
0.0476253,
0.0222211,
0.00972738,
0.00392962,
0.0015258,
0.000559168,
0.000183928,
6.77983e-05,
1.67818e-05,
7.38398e-06,
6.71271e-07
};
static double weight_6[25] = {
0.0154465,
0.0923472,
0.277322,
0.55552,
0.833099,
0.999035,
1,
0.855183,
0.641976,
0.428277,
0.256804,
0.139798,
0.0700072,
0.0321586,
0.0137971,
0.00544756,
0.00202316,
0.000766228,
0.000259348,
8.45836e-05,
1.80362e-05,
8.70713e-06,
3.73163e-06,
6.21938e-07,
0
};
static double weight_5[25] = {
0.0382845,
0.191122,
0.478782,
0.797314,
1,
0.997148,
0.831144,
0.59461,
0.371293,
0.205903,
0.103102,
0.0471424,
0.0194997,
0.00749415,
0.00273709,
0.000879189,
0.000286049,
0.000102364,
1.70606e-05,
3.98081e-06,
2.27475e-06,
0,
0,
0,
0
};
static double weight_4[25] = {
0.0941305,
0.373824,
0.750094,
1,
0.997698,
0.800956,
0.532306,
0.304597,
0.152207,
0.0676275,
0.0270646,
0.00975365,
0.00326077,
0.00101071,
0.000301781,
7.41664e-05,
1.58563e-05,
3.58045e-06,
1.02299e-06,
0,
5.11493e-07,
0,
0,
0,
0
};
static double weight_3[25] = {
0.222714,
0.667015,
1,
0.999208,
0.750609,
0.449854,
0.224968,
0.0965185,
0.0361225,
0.012084,
0.00359618,
0.000977166,
0.000239269,
6.29422e-05,
1.16064e-05,
1.78559e-06,
0,
4.46398e-07,
0,
0,
0,
0,
0,
0,
0
};
static double weight_2[25] = {
0.499541,
0.999607,
1,
0.666607,
0.333301,
0.13279,
0.0441871,
0.0127455,
0.00318434,
0.00071752,
0.000132204,
2.69578e-05,
5.16999e-06,
2.21571e-06,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
};
static double weight_1[25] = {
0.999165,
1,
0.499996,
0.166868,
0.0414266,
0.00831053,
0.00137472,
0.000198911,
2.66302e-05,
2.44563e-06,
2.71737e-07,
2.71737e-07,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
};
static double weight_0[25] = {
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
};
//WeightOOTPU_ = {0};
double* WeightPtr = 0;
for(int iint = 0; iint<25; ++iint){
if(iint ==0) WeightPtr = weight_0;
if(iint ==1) WeightPtr = weight_1;
if(iint ==2) WeightPtr = weight_2;
if(iint ==3) WeightPtr = weight_3;
if(iint ==4) WeightPtr = weight_4;
if(iint ==5) WeightPtr = weight_5;
if(iint ==6) WeightPtr = weight_6;
if(iint ==7) WeightPtr = weight_7;
if(iint ==8) WeightPtr = weight_8;
if(iint ==9) WeightPtr = weight_9;
if(iint ==10) WeightPtr = weight_10;
if(iint ==11) WeightPtr = weight_11;
if(iint ==12) WeightPtr = weight_12;
if(iint ==13) WeightPtr = weight_13;
if(iint ==14) WeightPtr = weight_14;
if(iint ==15) WeightPtr = weight_15;
if(iint ==16) WeightPtr = weight_16;
if(iint ==17) WeightPtr = weight_17;
if(iint ==18) WeightPtr = weight_18;
if(iint ==19) WeightPtr = weight_19;
if(iint ==20) WeightPtr = weight_20;
if(iint ==21) WeightPtr = weight_21;
if(iint ==22) WeightPtr = weight_22;
if(iint ==23) WeightPtr = weight_23;
if(iint ==24) WeightPtr = weight_24;
for(int ibin = 0; ibin<25; ++ibin){
WeightOOTPU_[iint][ibin] = *(WeightPtr+ibin);
}
}
}
TH1* reweight::LumiReWeighting::Data_distr_ [protected] |
Definition at line 1409 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting(), and weight3D_init().
TFile* reweight::LumiReWeighting::dataFile_ [protected] |
Definition at line 1404 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting().
std::string reweight::LumiReWeighting::dataFileName_ [protected] |
Definition at line 1400 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting().
std::string reweight::LumiReWeighting::DataHistName_ [protected] |
Definition at line 1402 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting().
bool reweight::LumiReWeighting::FirstWarning_ [protected] |
Definition at line 1414 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting(), and weightOOT().
TFile* reweight::LumiReWeighting::generatedFile_ [protected] |
Definition at line 1403 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting().
std::string reweight::LumiReWeighting::generatedFileName_ [protected] |
Definition at line 1399 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting().
std::string reweight::LumiReWeighting::GenHistName_ [protected] |
Definition at line 1401 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting().
TH1* reweight::LumiReWeighting::MC_distr_ [protected] |
Definition at line 1408 of file LumiReweightingStandAlone.h.
Referenced by LumiReWeighting(), and weight3D_init().
double reweight::LumiReWeighting::Weight3D_[50][50][50] [protected] |
Definition at line 1412 of file LumiReweightingStandAlone.h.
Referenced by weight3D(), weight3D_init(), and weight3D_set().
double reweight::LumiReWeighting::WeightOOTPU_[25][25] [protected] |
Definition at line 1411 of file LumiReweightingStandAlone.h.
Referenced by weightOOT(), and weightOOT_init().
TH1* reweight::LumiReWeighting::weights_ [protected] |
Definition at line 1405 of file LumiReweightingStandAlone.h.
Referenced by ITweight(), ITweight3BX(), LumiReWeighting(), weight(), and weightOOT().
1.7.3