diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc
index 9348d7bf86c570740253cc47e644c71fc7535319..e5830e1a18e1ed2f4f3c88edfffaf2bbea6d3254 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddBase.cc
@@ -67,6 +67,7 @@ void fastNLOCoeffAddBase::Read(istream& table, int ITabVersionRead){
//________________________________________________________________________________________________________________ //
void fastNLOCoeffAddBase::ReadCoeffAddBase(istream& table, int ITabVersionRead){
+ debug["ReadCoeffAddBase::ReadCoeffAddBase"]<<"Start reading coefficients for table version "<<ITabVersionRead<<endl;
CheckCoeffConstants(this);
char buffer[5257];
// string stest;
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc
index 6d3ee3dec03cf29c1952071d8844d4f544e49dc5..7472f8bd2d8e48a6356e10e22c8bfd9a0d609468 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOCoeffAddFix.cc
@@ -67,6 +67,7 @@ void fastNLOCoeffAddFix::ReadRest(istream& table, int ITabVersionRead){
//________________________________________________________________________________________________________________ //
void fastNLOCoeffAddFix::ReadCoeffAddFix(istream& table, int ITabVersionRead){
+ debug["ReadCoeffAddFix::ReadCoeffAddFix"]<<"Start reading coefficients for table version "<<ITabVersionRead<<endl;
CheckCoeffConstants(this);
Nscalevar.resize(NScaleDim);
vector<int> Nscalenode(NScaleDim);
@@ -89,10 +90,8 @@ void fastNLOCoeffAddFix::ReadCoeffAddFix(istream& table, int ITabVersionRead){
for(int i=0;i<NScaleDim;i++){
ScaleFac[i].resize(Nscalevar[i]);
}
- fastNLOTools::ReadVector( ScaleFac , table , 1);
+ fastNLOTools::ReadVector( ScaleFac , table , 1 );
- // printf(" * fastNLOCoeffAddFix::Read().bins %d, NScalevar[0] %d, Nscalenode[0] %d, ScaleFac[0][0] %d, NScaleDim %d \n",
- // fNObsBins, Nscalevar[0] , Nscalenode[0] , ScaleFac[0][0], NScaleDim );
fastNLOTools::ResizeVector( ScaleNode , fNObsBins, 1 , Nscalevar[0] , Nscalenode[0] );
int nsn = fastNLOTools::ReadVector( ScaleNode , table );
debug["fastNLOCoeffAddFix::Read()"]<<"Read "<<nsn<<" lines of ScaleNode."<<endl;
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOLHAPDF.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOLHAPDF.cc
index 391ffe19492baa87f86186a6bedc8045186f9e56..1cd2db8e40dd1db7104c8ffe48babe411fed9cc8 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOLHAPDF.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOLHAPDF.cc
@@ -669,20 +669,20 @@ void fastNLOLHAPDF::PrintScaleUncertaintyVec(fastNLO::EScaleUncertaintyStyle eSc
}
-// Statistical uncertainty (from fastNLOReader)
+// Numerical uncertainty (from fastNLOReader)
//______________________________________________________________________________
-XsUncertainty fastNLOLHAPDF::GetXsUncertainty(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm) {
- return fastNLOReader::GetXsUncertainty(eStatUnc, lNorm);
+XsUncertainty fastNLOLHAPDF::GetXsUncertainty(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm) {
+ return fastNLOReader::GetXsUncertainty(eNumUnc, lNorm);
}
//______________________________________________________________________________
-// std::vector< std::vector<double> > fastNLOLHAPDF::GetXsUncertaintyVec(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm, int iprint) {
-// return fastNLOReader::GetXsUncertaintyVec(eStatUnc, lNorm, iprint);
-std::vector< std::vector<double> > fastNLOLHAPDF::GetStatUncertaintyVec(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm, int iprint) {
- return fastNLOReader::GetStatUncertaintyVec(eStatUnc, lNorm, iprint);
+// std::vector< std::vector<double> > fastNLOLHAPDF::GetXsUncertaintyVec(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm, int iprint) {
+// return fastNLOReader::GetXsUncertaintyVec(eNumUnc, lNorm, iprint);
+std::vector< std::vector<double> > fastNLOLHAPDF::GetNumUncertaintyVec(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm, int iprint) {
+ return fastNLOReader::GetNumUncertaintyVec(eNumUnc, lNorm, iprint);
}
//______________________________________________________________________________
-// void fastNLOLHAPDF::PrintXsUncertaintyVec(fastNLO::EStatUncertaintyStyle eStatUnc, std::string UncName, bool lNorm) {
-// fastNLOReader::PrintXsUncertaintyVec(eStatUnc, UncName, lNorm);
-void fastNLOLHAPDF::PrintStatUncertaintyVec(fastNLO::EStatUncertaintyStyle eStatUnc, std::string UncName, bool lNorm) {
- fastNLOReader::PrintStatUncertaintyVec(eStatUnc, UncName, lNorm);
+// void fastNLOLHAPDF::PrintXsUncertaintyVec(fastNLO::ENumUncertaintyStyle eNumUnc, std::string UncName, bool lNorm) {
+// fastNLOReader::PrintXsUncertaintyVec(eNumUnc, UncName, lNorm);
+void fastNLOLHAPDF::PrintNumUncertaintyVec(fastNLO::ENumUncertaintyStyle eNumUnc, std::string UncName, bool lNorm) {
+ fastNLOReader::PrintNumUncertaintyVec(eNumUnc, UncName, lNorm);
}
diff --git a/v2.5/toolkit/fastnlotoolkit/fastNLOReader.cc b/v2.5/toolkit/fastnlotoolkit/fastNLOReader.cc
index 7887ef6fb360f350c473c446242e7963b483a680..4746d9787e727897fe9824695ddc690a31e0270d 100644
--- a/v2.5/toolkit/fastnlotoolkit/fastNLOReader.cc
+++ b/v2.5/toolkit/fastnlotoolkit/fastNLOReader.cc
@@ -3618,38 +3618,58 @@ void fastNLOReader::PrintScaleUncertaintyVec(fastNLO::EScaleUncertaintyStyle eSc
}
-// Statistical uncertainty (from CoeffInfoBlocks)
+// Numerical uncertainty (from CoeffInfoBlocks)
//______________________________________________________________________________
-XsUncertainty fastNLOReader::GetXsUncertainty(const EStatUncertaintyStyle eStatUnc, bool lNorm) {
+XsUncertainty fastNLOReader::GetXsUncertainty(const ENumUncertaintyStyle eNumUnc, bool lNorm) {
//
XsUncertainty XsUnc;
vector < double > MyXSection;
vector < double > MydXSection;
unsigned int NObsBin = GetNObsBin();
+ //! For approximation bias get reference PDF and member
+ if (eNumUnc == kApproxBias) {
+ // Find perturbative (additive) contributions
+ for (unsigned int j = 0 ; j<BBlocksSMCalc.size() ; j++) {
+ for (unsigned int i = 0 ; i<BBlocksSMCalc[j].size() ; i++) {
+ if (BBlocksSMCalc[j][i] && BBlocksSMCalc[j][i]->IsEnabled()) {
+ if (fastNLOCoeffAddFlex::CheckCoeffConstants(BBlocksSMCalc[j][i],true))
+ // CalcCrossSectionv21((fastNLOCoeffAddFlex*)BBlocksSMCalc[j][i]);
+ cout << "FLEX" << endl;
+ if ( BBlocksSMCalc[j][i].HasCoeffInfoBlock(1,0) ){
+ cout << "FLEX YES" << endl;
+ }
+ else if (fastNLOCoeffAddFix::CheckCoeffConstants(BBlocksSMCalc[j][i],true))
+ cout << "FIX" << endl;
+ }
+ }
+ }
+ }
+ exit(2);
+
//! Cross section and absolute uncertainties
CalcCrossSection();
MyXSection = GetCrossSection(lNorm);
MydXSection = GetUncertainty(lNorm);
//! Fill return struct
- if (eStatUnc == kStatNone) {
- logger.info["GetStatUncertainty"]<<"No statistical uncertainty selected, uncertainties will be zero."<<endl;
+ if (eNumUnc == kNumNone) {
+ logger.info["GetNumUncertainty"]<<"No numerical uncertainty selected, uncertainties will be zero."<<endl;
for (unsigned int iobs = 0; iobs < NObsBin; iobs++) {
XsUnc.xs.push_back(MyXSection[iobs]);
XsUnc.dxsu.push_back(0);
XsUnc.dxsl.push_back(0);
}
- } else if (eStatUnc == kStatInt) {
- logger.info["GetStatUncertainty"]<<"Statistical integration uncertainty selected."<<endl;
+ } else if (eNumUnc == kStatInt) {
+ logger.info["GetNumUncertainty"]<<"Statistical integration uncertainty selected."<<endl;
for (unsigned int iobs = 0; iobs < NObsBin; iobs++) {
XsUnc.xs.push_back(MyXSection[iobs]);
XsUnc.dxsu.push_back(MydXSection[iobs]);
XsUnc.dxsl.push_back(-MydXSection[iobs]);
}
} else {
- logger.error["GetStatUncertainty"]<<"ERROR! No valid statistical uncertainty style selected, exiting."<<endl;
- logger.error["GetStatUncertainty"]<<"Style enum = "<<eStatUnc<<endl;
+ logger.error["GetNumUncertainty"]<<"ERROR! No valid numerical uncertainty style selected, exiting."<<endl;
+ logger.error["GetNumUncertainty"]<<"Style enum = "<<eNumUnc<<endl;
exit(1);
}
@@ -3662,7 +3682,7 @@ XsUncertainty fastNLOReader::GetXsUncertainty(const EStatUncertaintyStyle eStatU
XsUnc.dxsu[iobs] = 0.;
XsUnc.dxsl[iobs] = 0.;
}
- logger.debug["GetStatUncertainty"]<<"iobs = " << iobs << ", dxsl = " << XsUnc.dxsl[iobs] << ", dxsu = " << XsUnc.dxsu[iobs] <<endl;
+ logger.debug["GetNumUncertainty"]<<"iobs = " << iobs << ", dxsl = " << XsUnc.dxsl[iobs] << ", dxsu = " << XsUnc.dxsu[iobs] <<endl;
}
return XsUnc;
@@ -3670,12 +3690,12 @@ XsUncertainty fastNLOReader::GetXsUncertainty(const EStatUncertaintyStyle eStatU
//______________________________________________________________________________
-// std::vector< std::vector<double> > fastNLOReader::GetXsUncertaintyVec(const EStatUncertaintyStyle eStatUnc, bool lNorm, int iprint) {
-std::vector< std::vector<double> > fastNLOReader::GetStatUncertaintyVec(const EStatUncertaintyStyle eStatUnc, bool lNorm, int iprint) {
- XsUncertainty xsUnc = fastNLOReader::GetXsUncertainty(eStatUnc, lNorm);
+// std::vector< std::vector<double> > fastNLOReader::GetXsUncertaintyVec(const ENumUncertaintyStyle eNumUnc, bool lNorm, int iprint) {
+std::vector< std::vector<double> > fastNLOReader::GetNumUncertaintyVec(const ENumUncertaintyStyle eNumUnc, bool lNorm, int iprint) {
+ XsUncertainty xsUnc = fastNLOReader::GetXsUncertainty(eNumUnc, lNorm);
if (iprint > 0) {
- string style{StatUncertaintyStyle_to_string(eStatUnc)};
- string UncName = " # Relative statistical uncertainties (" + style + ")";
+ string style{NumUncertaintyStyle_to_string(eNumUnc)};
+ string UncName = " # Relative numerical uncertainties (" + style + ")";
fastNLOTools::PrintXSUncertainty(xsUnc, UncName);
}
std::vector<std::vector<double> > xsUncVec;
@@ -3689,8 +3709,8 @@ std::vector< std::vector<double> > fastNLOReader::GetStatUncertaintyVec(const ES
//______________________________________________________________________________
-// void fastNLOReader::PrintXsUncertaintyVec(fastNLO::EStatUncertaintyStyle eStatUnc, std::string UncName, bool lNorm) {
-void fastNLOReader::PrintStatUncertaintyVec(fastNLO::EStatUncertaintyStyle eStatUnc, std::string UncName, bool lNorm) {
- XsUncertainty xsUnc = GetXsUncertainty(eStatUnc, lNorm);
+// void fastNLOReader::PrintXsUncertaintyVec(fastNLO::ENumUncertaintyStyle eNumUnc, std::string UncName, bool lNorm) {
+void fastNLOReader::PrintNumUncertaintyVec(fastNLO::ENumUncertaintyStyle eNumUnc, std::string UncName, bool lNorm) {
+ XsUncertainty xsUnc = GetXsUncertainty(eNumUnc, lNorm);
fastNLOTools::PrintXSUncertainty(xsUnc, UncName);
}
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOConstants.h.in b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOConstants.h.in
index 8f225cfe032ca1a853d32b33123191a42c4f350f..4a3496a2a5ad0e4607c7e3f7008f5d6242efd1d2 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOConstants.h.in
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOConstants.h.in
@@ -131,23 +131,26 @@ namespace fastNLO {
return{kScaleNone};
}
- enum EStatUncertaintyStyle {
- kStatNone = 0, // no statistical uncertainty
- kStatInt = 1 // statistical uncertainty from MC integration
+ enum ENumUncertaintyStyle {
+ kNumNone = 0, // no numerical uncertainty
+ kStatInt = 1, // statistical uncertainty from MC integration
+ kApproxBias = 2 // bias from approximation through interpolation
};
- constexpr std::string_view StatUncertaintyStyle_to_string(EStatUncertaintyStyle estyle) {
+ constexpr std::string_view NumUncertaintyStyle_to_string(ENumUncertaintyStyle estyle) {
switch (estyle) {
- case kStatNone: return "NN";
- case kStatInt: return "ST";
- default: return "??";
+ case kNumNone: return "NN";
+ case kStatInt: return "ST";
+ case kApproxBias: return "AB";
+ default: return "??";
}
}
- constexpr std::optional<EStatUncertaintyStyle> StatUncertaintyStyle_to_enum(std::string_view sstyle) {
- if (sstyle == "NN") return kStatNone;
+ constexpr std::optional<ENumUncertaintyStyle> NumUncertaintyStyle_to_enum(std::string_view sstyle) {
+ if (sstyle == "NN") return kNumNone;
if (sstyle == "ST") return kStatInt;
- return{kStatNone};
+ if (sstyle == "AB") return kApproxBias;
+ return{kNumNone};
}
enum EPDFUncertaintyStyle {
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOLHAPDF.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOLHAPDF.h
index af931c3f9bdad835d6f82328696cd0be0752d341..ca88c53ba6c5d94c3742fef8c63fa45f4570fb62 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOLHAPDF.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOLHAPDF.h
@@ -63,11 +63,11 @@ public:
//! Return struct with vectors (for C++) or vector of vectors (for Python) containing the cross section values and the selected uncertainty
//! Enum of Uncertaintstyle decides on method to call, but does not work for Python extension --> switch back to use differently named UncertaintyVec methods
// Use implementations in fastNLOReader for these
- XsUncertainty GetXsUncertainty(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm = false);
- // std::vector< std::vector<double> > GetXsUncertaintyVec(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm = false, int iprint = 0);
- // void PrintXsUncertaintyVec(fastNLO::EStatUncertaintyStyle, std::string UncName, bool lNorm = false);
- std::vector< std::vector<double> > GetStatUncertaintyVec(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm = false, int iprint = 0);
- void PrintStatUncertaintyVec(fastNLO::EStatUncertaintyStyle, std::string UncName, bool lNorm = false);
+ XsUncertainty GetXsUncertainty(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm = false);
+ // std::vector< std::vector<double> > GetXsUncertaintyVec(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm = false, int iprint = 0);
+ // void PrintXsUncertaintyVec(fastNLO::ENumUncertaintyStyle, std::string UncName, bool lNorm = false);
+ std::vector< std::vector<double> > GetNumUncertaintyVec(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm = false, int iprint = 0);
+ void PrintNumUncertaintyVec(fastNLO::ENumUncertaintyStyle, std::string UncName, bool lNorm = false);
//
XsUncertainty GetXsUncertainty(const fastNLO::EScaleUncertaintyStyle eScaleUnc, bool lNorm = false, double sclfac = 1.);
// std::vector< std::vector<double> > GetXsUncertaintyVec(const fastNLO::EScaleUncertaintyStyle eScaleUnc, bool lNorm = false, int iprint = 0, double sclfac = 1.);
diff --git a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOReader.h b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOReader.h
index 1814ad13bf2c7100d13af40530f27321fa8b7ebf..8dc51655931310869cc4134b24d40f20a719dd7f 100644
--- a/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOReader.h
+++ b/v2.5/toolkit/fastnlotoolkit/include/fastnlotk/fastNLOReader.h
@@ -107,12 +107,12 @@ public:
// void PrintXsUncertaintyVec(fastNLO::EScaleUncertaintyStyle, std::string UncName, bool lNorm = false, double sclfac =1.);
std::vector< std::vector<double> > GetScaleUncertaintyVec(const fastNLO::EScaleUncertaintyStyle eScaleUnc, bool lNorm = false, int iprint = 0, double sclfac = 1.);
void PrintScaleUncertaintyVec(fastNLO::EScaleUncertaintyStyle, std::string UncName, bool lNorm = false, double sclfac =1.);
- //! Statistical uncertainty
- XsUncertainty GetXsUncertainty(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm = false);
- // std::vector< std::vector<double> > GetXsUncertaintyVec(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm = false, int iprint = 0);
- // void PrintXsUncertaintyVec(fastNLO::EStatUncertaintyStyle, std::string UncName, bool lNorm = false);
- std::vector< std::vector<double> > GetStatUncertaintyVec(const fastNLO::EStatUncertaintyStyle eStatUnc, bool lNorm = false, int iprint = 0);
- void PrintStatUncertaintyVec(fastNLO::EStatUncertaintyStyle, std::string UncName, bool lNorm = false);
+ //! Numerical uncertainty
+ XsUncertainty GetXsUncertainty(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm = false);
+ // std::vector< std::vector<double> > GetXsUncertaintyVec(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm = false, int iprint = 0);
+ // void PrintXsUncertaintyVec(fastNLO::ENumUncertaintyStyle, std::string UncName, bool lNorm = false);
+ std::vector< std::vector<double> > GetNumUncertaintyVec(const fastNLO::ENumUncertaintyStyle eNumUnc, bool lNorm = false, int iprint = 0);
+ void PrintNumUncertaintyVec(fastNLO::ENumUncertaintyStyle, std::string UncName, bool lNorm = false);
double RescaleCrossSectionUnits(double binsize, int xunits); // Rescale according to kAbsoluteUnits and Ipublunits settings
diff --git a/v2.5/toolkit/src/fnlo-tk-rootout.cc b/v2.5/toolkit/src/fnlo-tk-rootout.cc
index a6a29cc7fa084f32487840c06b1c1cbe7ce917e7..fd19705be7831f6045544915bb90c6eb582cf2c4 100644
--- a/v2.5/toolkit/src/fnlo-tk-rootout.cc
+++ b/v2.5/toolkit/src/fnlo-tk-rootout.cc
@@ -168,7 +168,7 @@ int main(int argc, char** argv) {
EScaleUncertaintyStyle eScaleUnc = kScaleNone;
EPDFUncertaintyStyle ePDFUnc = kPDFNone;
// EAsUncertaintyStyle eAsUnc = kAsNone;
- EStatUncertaintyStyle eStatUnc = kStatNone;
+ ENumUncertaintyStyle eNumUnc = kNumNone;
string chunc;
if (argc > 3) {
chunc = (const char*) argv[3];
@@ -502,8 +502,8 @@ int main(int argc, char** argv) {
if (ITabVersion < 25000) {
info["fnlo-tk-rootout"] << "Table version " << ITabVersion << "too small; statistical uncertainties not available." << endl;
}
- eStatUnc = kStatInt;
- XsUnc = fnlo->GetXsUncertainty(eStatUnc, lNorm);
+ eNumUnc = kStatInt;
+ XsUnc = fnlo->GetXsUncertainty(eNumUnc, lNorm);
string chname = "ST";
UncName = " # Relative statistical uncertainties (" + chname + " " + PDFFiles[iPDF] + " " + sOrder + ")";
LineName += "_dxst";
diff --git a/v2.5/toolkit/src/fnlo-tk-yodaout.cc b/v2.5/toolkit/src/fnlo-tk-yodaout.cc
index 6b6d299d3b759cccaf63421b9d480649bbbfc29c..cf0340c08d56406685f80b2a1e46303c11be4696 100644
--- a/v2.5/toolkit/src/fnlo-tk-yodaout.cc
+++ b/v2.5/toolkit/src/fnlo-tk-yodaout.cc
@@ -130,6 +130,7 @@ int main(int argc, char** argv) {
man << " L6 (LHAPDF6 PDF uncertainty --> LHAPDF6 PDFs)" << endl;
man << " AS (a_s(M_Z) variation uncertainty with GRV evolution)" << endl;
man << " ST (statistical uncertainty of x section calculation, if available)" << endl;
+ man << " AB (approximation bias of x section interpolation, if available)" << endl;
man << "[order]: Fixed-order precision to use, def. = NLO" << endl;
man << " Alternatives: LO, NLO_only, NNLO, NNLO_only (if available)" << endl;
man << "[norm]: Normalize if applicable, def. = no." << endl;
@@ -173,7 +174,7 @@ int main(int argc, char** argv) {
EScaleUncertaintyStyle eScaleUnc = kScaleNone;
EPDFUncertaintyStyle ePDFUnc = kPDFNone;
EAsUncertaintyStyle eAsUnc = kAsNone;
- EStatUncertaintyStyle eStatUnc = kStatNone;
+ ENumUncertaintyStyle eNumUnc = kNumNone;
string chunc;
if (argc > 3) {
chunc = (const char*) argv[3];
@@ -215,8 +216,11 @@ int main(int argc, char** argv) {
eAsUnc = kAsGRV;
shout["fnlo-tk-yodaout"] << "Showing a_s(M_Z) uncertainty with GRV evolution." << endl;
} else if ( chunc == "ST" ) {
- eStatUnc = kStatInt;
+ eNumUnc = kStatInt;
shout["fnlo-tk-yodaout"] << "Showing statistical uncertainty of x section calculation." << endl;
+ } else if ( chunc == "AB" ) {
+ eNumUnc = kApproxBias;
+ shout["fnlo-tk-yodaout"] << "Showing approximation bias from interpolation of x section calculation." << endl;
} else {
error["fnlo-tk-yodaout"] << "Illegal choice of uncertainty, " << chunc << ", aborted!" << endl;
exit(1);
@@ -508,9 +512,13 @@ int main(int argc, char** argv) {
UncName = " # Relative a_s(M_Z) uncertainties";
LineName += "_dxa_s";
} else if ( chunc == "ST" ) {
- XsUnc = fnlo->GetXsUncertainty(eStatUnc, lNorm);
+ XsUnc = fnlo->GetXsUncertainty(eNumUnc, lNorm);
UncName = " # Relative statistical uncertainties";
LineName += "_dxst";
+ } else if ( chunc == "AB" ) {
+ XsUnc = fnlo->GetXsUncertainty(eNumUnc, lNorm);
+ UncName = " # Relative approximation bias";
+ LineName += "_dxab";
} else if ( chunc != "none" ) {
XsUnc = fnlo->GetXsUncertainty(ePDFUnc, lNorm);
UncName = " # Relative PDF uncertainties";