Page MenuHomeHEPForge
Files F10881815

No OneTemporary
Actions

View Options

diff --git a/cmake/NIWGSetup.cmake b/cmake/NIWGSetup.cmake
index ec49cca..559a225 100644
--- a/cmake/NIWGSetup.cmake
+++ b/cmake/NIWGSetup.cmake
@@ -1,29 +1,37 @@
# Copyright 2016 L. Pickering, P Stowell, R. Terri, C. Wilkinson, C. Wret
################################################################################
# This file is part of NUISANCE.
#
# NUISANCE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# NUISANCE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with NUISANCE. If not, see <http://www.gnu.org/licenses/>.
################################################################################
if(NIWG_ROOT STREQUAL "")
cmessage(FATAL_ERROR "Variable NIWG_ROOT is not defined. Either configure with -DNIWG_ROOT or \"\$ export NIWG=/path/to/NIWGReWeight\". This must be set to point to a prebuilt NIWGReWeight instance.")
endif()
LIST(APPEND EXTRA_CXX_FLAGS -D__NIWG_ENABLED__)
+find_file(NIWGRWLOWQE NIWGReWeightEffectiveQELowQ2Suppression.h
+ PATHS ${NIWG_ROOT})
+
+if( NOT "${NIWGRWLOWQE} " STREQUAL "NIWGRWLOWQE-NOTFOUND ")
+ cmessage(STATUS "Found ${NIWGRWLOWQE}")
+ LIST(APPEND EXTRA_CXX_FLAGS -DHAVE_NIWGRW_LOWQ2)
+endif()
+
LIST(APPEND RWENGINE_INCLUDE_DIRECTORIES ${NIWG_ROOT})
LIST(APPEND EXTRA_LINK_DIRS ${NIWG_ROOT})
LIST(APPEND EXTRA_LIBS NIWGReWeight)
diff --git a/src/Reweight/NIWGWeightEngine.cxx b/src/Reweight/NIWGWeightEngine.cxx
index 54bc4fd..09f2d3a 100644
--- a/src/Reweight/NIWGWeightEngine.cxx
+++ b/src/Reweight/NIWGWeightEngine.cxx
@@ -1,216 +1,222 @@
#include "NIWGWeightEngine.h"
NIWGWeightEngine::NIWGWeightEngine(std::string name) {
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
// Setup the NEUT Reweight engien
fCalcName = name;
NUIS_LOG(FIT, "Setting up NIWG RW : " << fCalcName);
// Create RW Engine suppressing cout
StopTalking();
fNIWGRW = new niwg::rew::NIWGReWeight();
// Get List of Veto Calcs (For Debugging)
- std::string rw_engine_list = FitPar::Config().GetParS("FitWeight_fNIWGRW_veto");
+ std::string rw_engine_list =
+ FitPar::Config().GetParS("FitWeight_fNIWGRW_veto");
bool niwg_2012a = rw_engine_list.find("niwg_2012a") == std::string::npos;
bool niwg_2014a = rw_engine_list.find("niwg_2014a") == std::string::npos;
bool niwg_pimult = rw_engine_list.find("niwg_pimult") == std::string::npos;
bool niwg_mec = rw_engine_list.find("niwg_mec") == std::string::npos;
bool niwg_rpa = rw_engine_list.find("niwg_rpa") == std::string::npos;
bool niwg_eff_rpa = rw_engine_list.find("niwg_eff_rpa") == std::string::npos;
- bool niwg_proton = rw_engine_list.find("niwg_protonFSIbug") == std::string::npos;
- bool niwg_hadron = rw_engine_list.find("niwg_HadronMultSwitch") == std::string::npos;
+ bool niwg_proton =
+ rw_engine_list.find("niwg_protonFSIbug") == std::string::npos;
+ bool niwg_hadron =
+ rw_engine_list.find("niwg_HadronMultSwitch") == std::string::npos;
bool niwg_qelowq2 = rw_engine_list.find("niwg_LowQEQ2") == std::string::npos;
// Add the RW Calcs
if (niwg_2012a)
fNIWGRW->AdoptWghtCalc("niwg_2012a", new niwg::rew::NIWGReWeight2012a);
if (niwg_2014a)
fNIWGRW->AdoptWghtCalc("niwg_2014a", new niwg::rew::NIWGReWeight2014a);
if (niwg_pimult)
fNIWGRW->AdoptWghtCalc("niwg_pimult", new niwg::rew::NIWGReWeightPiMult);
if (niwg_mec)
fNIWGRW->AdoptWghtCalc("niwg_mec", new niwg::rew::NIWGReWeightMEC);
if (niwg_rpa)
fNIWGRW->AdoptWghtCalc("niwg_rpa", new niwg::rew::NIWGReWeightRPA);
if (niwg_eff_rpa)
fNIWGRW->AdoptWghtCalc("niwg_eff_rpa",
- new niwg::rew::NIWGReWeightEffectiveRPA);
+ new niwg::rew::NIWGReWeightEffectiveRPA);
if (niwg_proton)
fNIWGRW->AdoptWghtCalc("niwg_protonFSIbug",
- new niwg::rew::NIWGReWeightProtonFSIbug);
+ new niwg::rew::NIWGReWeightProtonFSIbug);
if (niwg_hadron)
fNIWGRW->AdoptWghtCalc("niwg_HadronMultSwitch",
- new niwg::rew::NIWGReWeightHadronMultSwitch);
- // Add in Luke's low Q2 suppression
+ new niwg::rew::NIWGReWeightHadronMultSwitch);
+// Add in Luke's low Q2 suppression
+#ifdef HAVE_NIWGRW_LOWQ2
if (niwg_qelowq2)
- fNIWGRW->AdoptWghtCalc("niwg_QELowQ2", new niwg::rew::NIWGReWeightEffectiveQELowQ2Suppression);
+ fNIWGRW->AdoptWghtCalc(
+ "niwg_QELowQ2", new niwg::rew::NIWGReWeightEffectiveQELowQ2Suppression);
+#endif
fNIWGRW->Reconfigure();
// Set Abs Twk Config
fIsAbsTwk = (FitPar::Config().GetParB("setabstwk"));
// allow cout again
StartTalking();
#else
NUIS_ABORT("NIWG RW Enabled but NEUT RW is not!");
#endif
#else
NUIS_ABORT("NIWG RW NOT ENABLED!");
#endif
};
void NIWGWeightEngine::IncludeDial(std::string name, double startval) {
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
// Get First enum
int nuisenum = Reweight::ConvDial(name, kNIWG);
// Setup Maps
fEnumIndex[nuisenum]; // = std::vector<size_t>(0);
fNameIndex[name]; // = std::vector<size_t>(0);
// Split by commas
std::vector<std::string> allnames = GeneralUtils::ParseToStr(name, ",");
for (uint i = 0; i < allnames.size(); i++) {
std::string singlename = allnames[i];
// Get RW
niwg::rew::NIWGSyst_t gensyst = niwg::rew::NIWGSyst::FromString(name);
// Fill Maps
int index = fValues.size();
fValues.push_back(0.0);
fNIWGSysts.push_back(gensyst);
// Initialize dial
NUIS_LOG(FIT, "Registering " << singlename << " from " << name);
fNIWGRW->Systematics().Init(fNIWGSysts[index]);
// If Absolute
if (fIsAbsTwk) {
niwg::rew::NIWGSystUncertainty::Instance()->SetUncertainty(
fNIWGSysts[index], 1.0, 1.0);
}
// Setup index
fEnumIndex[nuisenum].push_back(index);
fNameIndex[name].push_back(index);
}
// Set Value if given
if (startval != -999.9) {
SetDialValue(nuisenum, startval);
}
#endif
#endif
}
void NIWGWeightEngine::SetDialValue(int nuisenum, double val) {
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
std::vector<size_t> indices = fEnumIndex[nuisenum];
for (uint i = 0; i < indices.size(); i++) {
fValues[indices[i]] = val;
std::cout << "Setting NIWG Dial Value " << i << " " << indices[i] << " "
- << fNIWGSysts[indices[i]] << std::endl;
+ << fNIWGSysts[indices[i]] << std::endl;
fNIWGRW->Systematics().Set(fNIWGSysts[indices[i]], val);
}
#endif
#endif
}
void NIWGWeightEngine::SetDialValue(std::string name, double val) {
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
std::vector<size_t> indices = fNameIndex[name];
for (uint i = 0; i < indices.size(); i++) {
fValues[indices[i]] = val;
fNIWGRW->Systematics().Set(fNIWGSysts[indices[i]], val);
}
#endif
#endif
}
void NIWGWeightEngine::Reconfigure(bool silent) {
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
// Hush now...
if (silent)
StopTalking();
// Reconf
fNIWGRW->Reconfigure();
// Shout again
if (silent)
StartTalking();
#endif
#endif
}
double NIWGWeightEngine::CalcWeight(BaseFitEvt *evt) {
double rw_weight = 1.0;
#ifdef __NEUT_ENABLED__
#ifdef __NIWG_ENABLED__
// Skip Non GENIE
if (evt->fType != kNEUT)
return 1.0;
// Hush now
StopTalking();
niwg::rew::NIWGEvent *niwg_event =
- NIWGWeightEngine::GetNIWGEventLocal(evt->fNeutVect);
+ NIWGWeightEngine::GetNIWGEventLocal(evt->fNeutVect);
rw_weight *= fNIWGRW->CalcWeight(*niwg_event);
delete niwg_event;
// Speak Now
StartTalking();
#endif
#endif
// Return rw_weight
return rw_weight;
}
#ifdef __NEUT_ENABLED__
#ifdef __NIWG_ENABLED__
niwg::rew::NIWGEvent *NIWGWeightEngine::GetNIWGEventLocal(NeutVect *nvect) {
niwg::rew::NIWGEvent *fDummyNIWGEvent = NULL;
fDummyNIWGEvent = new niwg::rew::NIWGEvent();
fDummyNIWGEvent->detid = 1; // MiniBooNE (apply CCQE LowE variations)
fDummyNIWGEvent->neutmode = nvect->Mode;
fDummyNIWGEvent->targetA = nvect->TargetA;
fDummyNIWGEvent->recenu_ccqe_sk = -1;
if (nvect->Ibound == 0)
fDummyNIWGEvent->targetA = 1; // RT: identifies as H, rather than O16
// Fill initial particle stack
for (int ip = 0; ip < nvect->Npart(); ++ip) {
niwg::rew::NIWGPartStack fDummyPartStack;
fDummyPartStack.p = (nvect->PartInfo(ip)->fP) * 0.001; // Convert to GeV
fDummyPartStack.pdg = nvect->PartInfo(ip)->fPID;
fDummyPartStack.chase = nvect->PartInfo(ip)->fIsAlive;
fDummyPartStack.parent =
- nvect->ParentIdx(ip) -
- 1; // WARNING: this needs to be tested with a NeutRoot file
+ nvect->ParentIdx(ip) -
+ 1; // WARNING: this needs to be tested with a NeutRoot file
fDummyNIWGEvent->part_stack.push_back(fDummyPartStack);
}
fDummyNIWGEvent->CalcKinematics();
return fDummyNIWGEvent;
}
#endif
#endif
diff --git a/src/Reweight/NIWGWeightEngine.h b/src/Reweight/NIWGWeightEngine.h
index 96fddda..ae4ce81 100644
--- a/src/Reweight/NIWGWeightEngine.h
+++ b/src/Reweight/NIWGWeightEngine.h
@@ -1,77 +1,79 @@
#ifndef WEIGHT_ENGINE_NIWG_H
#define WEIGHT_ENGINE_NIWG_H
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
#include "NIWGReWeight.h"
#include "NIWGReWeight1piAngle.h"
#include "NIWGReWeight2010a.h"
#include "NIWGReWeight2012a.h"
#include "NIWGReWeight2014a.h"
#include "NIWGReWeightDeltaMass.h"
#include "NIWGReWeightEffectiveRPA.h"
+#ifdef HAVE_NIWGRW_LOWQ2
#include "NIWGReWeightEffectiveQELowQ2Suppression.h"
+#endif
#include "NIWGReWeightHadronMultSwitch.h"
#include "NIWGReWeightMEC.h"
#include "NIWGReWeightPiMult.h"
#include "NIWGReWeightProtonFSIbug.h"
#include "NIWGReWeightRPA.h"
#include "NIWGReWeightSpectralFunc.h"
#include "NIWGReWeightSplineEnu.h"
#include "NIWGSyst.h"
#include "NIWGSystUncertainty.h"
#include "NReWeight.h"
#include "NReWeightCasc.h"
#include "NReWeightNuXSecCCQE.h"
#include "NReWeightNuXSecCCRES.h"
#include "NReWeightNuXSecCOH.h"
#include "NReWeightNuXSecDIS.h"
#include "NReWeightNuXSecNC.h"
#include "NReWeightNuXSecNCEL.h"
#include "NReWeightNuXSecNCRES.h"
#include "NReWeightNuXSecRES.h"
#include "NReWeightNuclPiless.h"
#include "NSyst.h"
#include "NSystUncertainty.h"
#include "neutpart.h"
#include "neutvect.h"
#include "NEUTInputHandler.h"
#endif
#endif
#include "FitLogger.h"
#include "GeneratorUtils.h"
#include "WeightEngineBase.h"
#include "FitWeight.h"
class NIWGWeightEngine : public WeightEngineBase {
public:
NIWGWeightEngine(std::string name);
~NIWGWeightEngine() {};
void IncludeDial(std::string name, double startval);
void SetDialValue(std::string name, double val);
void SetDialValue(int nuisenum, double val);
void Reconfigure(bool silent = false);
double CalcWeight(BaseFitEvt* evt);
inline bool NeedsEventReWeight() { return true; };
#ifdef __NIWG_ENABLED__
#ifdef __NEUT_ENABLED__
std::vector<niwg::rew::NIWGSyst_t> fNIWGSysts;
niwg::rew::NIWGEvent* GetNIWGEventLocal(NeutVect* nvect);
niwg::rew::NIWGReWeight* fNIWGRW;
#endif
#endif
};
#endif

File Metadata

Mime Type
text/x-diff
Expires
Sat, May 3, 6:51 AM (16 h, 59 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4974955
Default Alt Text
(11 KB)

Event Timeline