No OneTemporary
Actions

Size

43 KB

Subscribers

None

View Options

	diff --git a/parameters/config.xml b/parameters/config.xml
	index 4ca539e..05044e1 100644
	--- a/parameters/config.xml
	+++ b/parameters/config.xml
	@@ -1,231 +1,233 @@
	<nuisance>
	<!-- # ###################################################### -->
	<!-- # NUISANCE CONFIGURATION OPTIONS -->
	<!-- # This file is read in by default at runtime -->
	<!-- # If you want to override on a case by case bases use -q at runtime -->
	<!-- # ###################################################### -->

	<!-- # MAIN Configs -->
	<!-- # ###################################################### -->

	<!-- # Logger goes from -->
	<!-- # 1 Quiet -->
	<!-- # 2 Fitter -->
	<!-- # 3 Samples -->
	<!-- # 4 Reconfigure Loops -->
	<!-- # 5 Every Event print out (SHOUT) -->
	<!-- # -1 DEBUGGING -->
	<config VERBOSITY='4'/>

	<!-- # ERROR goes from -->
	<!-- # 0 NONE -->
	<!-- # 1 FATAL -->
	<!-- # 2 WARN -->
	<config ERROR='2'/>
	<config TRACE='0'/>

	<config cores='1' />
	<config spline_test_throws='50' />
	<config spline_cores='1' />
	<config spline_chunks='20' />
	<config spline_procchunk='-1' />

	<config Electron_NThetaBins='4' />
	<config Electron_NEnergyBins='4' />
	<config Electron_ThetaWidth='1.0' />
	<config Electron_EnergyWidth='0.10' />

	<!-- Do we want to remove FSI, undefined and nuclear particles from the GENIE particle stack? -->
	<config RemoveFSIParticles='0' />
	<config RemoveUndefParticles='0' />
	<config RemoveNuclearParticles='0'/>
	<config MINERvASaveExtraCCQE='0' />

	<!-- # Input Configs -->
	<!-- # ###################################################### -->

	<!-- # Default Requirements file for the externalDataFitter Package -->
	<!-- # MAX Events : -1 is no cut. Events will be scaled automatically to give good xsec predictions. -->
	<config MAXEVENTS='-1'/>
	<!-- Include empty stacks in the THStack -->
	<config includeemptystackhists='0'/>

	<!-- # Turn on/off event manager -->
	<!-- # EventManager enables us to only loop number of events once for multiple projections of the same measurements -->
	<!-- # e.g. MiniBooNE CC1pi+ Q2 and MiniBooNE CC1pi+ Tmu would ordinarily require 2 reconfigures, but with this enabled it requires only one -->
	<config EventManager='1'/>

	<!-- # Event Directories -->
	<!-- # Can setup default directories and use @EVENT_DIR/path to link to it -->
	<config EVENT_DIR='/data2/stowell/NIWG/'/>
	<config NEUT_EVENT_DIR='/data2/stowell/NIWG/neut/fit_samples_neut5.3.3/'/>
	<config GENIE_EVENT_DIR='/data2/stowell/NIWG/genie/fit_samples_R.2.10.0/'/>
	<config NUWRO_EVENT_DIR='/data2/stowell/NIWG/nuwro/fit_samples/'/>
	<config GIBUU_EVENT_DIR='/data/GIBUU/DIR/'/>
	<config SaveNuWroExtra='0' />

	<!-- # In PrepareGENIE the reconstructed splines can be saved into the file -->
	<config save_genie_splines='1'/>

	<!-- # In InputHandler the option to regenerate NuWro flux/xsec plots is available -->
	<!-- # Going to move this to its own app soon -->

	<!-- # DEVEL CONFIG OPTION, don't touch! -->
	<config CacheSize='0'/>

	<!-- # ReWeighting Configuration Options -->
	<!-- # ###################################################### -->

	<!-- # Convert Dials in output statements using dial conversion card -->
	<config convert_dials='0'/>

	<!-- # Vetos can be used to specify RW dials NOT to be loaded in -->
	<!-- # Useful if one specific one has an issue -->
	<config FitWeight_fNIWGRW_veto=''/>
	<config FitWeight_fNuwroRW_veto=''/>
	<config FitWeight_fNeutRW_veto=''/>
	<config FitWeight_fGenieRW_veto=''/>

	<!-- # Output Options -->
	<!-- # ###################################################### -->

	<!-- # Save Nominal prediction with all rw engines at default -->
	<config savenominal='0'/>

	<!-- # Save prefit with values at starting values -->
	<config saveprefit='0'/>

	<!-- # Here's the full list of drawing options -->
	<!-- DATA/MC/EVT/FINE/RATIO/MODES/SHAPE/WGHT/WEIGHTS/FLUX/XSEC/MASK/COV/INCOV/DECOMP/CANVPDG/CANVMC/SETTINGS'/>
	<!-- #config drawopts DATA/MC/EVT/FINE/RATIO/MODES/SHAPE/RESIDUAL/MATRIX/FLUX/MASK/MAP -->
	<!-- #config drawopts DATA/MC -->
	<config drawopts='DATA/MC/EVT/FINE/RATIO/MODES/SHAPE/FLUX/XSEC/MASK/COV/INCOV/DECOMP/CANVPDG/CANVMC/SETTINGS/PROJ/CANVSLICEMC'/>

	<config nuisflat_SavePreFSI='true' />

	<config InterpolateSigmaQ0Histogram='1' />
	<config InterpolateSigmaQ0HistogramRes='100' />
	<config InterpolateSigmaQ0HistogramThrow='1' />
	<config InterpolateSigmaQ0HistogramNTHROWS='100000' />

	<!-- # Save the shape scaling applied with option SHAPE into the main MC hist -->
	<config saveshapescaling='0'/>

	<config CorrectGENIEMECNorm='1'/>

	<!-- # Set style of 1D output histograms -->
	<config linecolour='1'/>
	<config linestyle='1'/>
	<config linewidth='1'/>

	<!-- # For GenericFlux -->
	<config isLiteMode='0'/>

	<!-- # Statistical Options -->
	<!-- # ###################################################### -->

	<!-- # Add MC Statistical error to likelihoods -->
	<config addmcerror='0'/>

	<!-- # NUISMIN Configurations -->
	<!-- # ###################################################### -->

	<config MAXCALLS='1000000'/>
	<config MAXITERATIONS='1000000'/>
	<config TOLERANCE='0.001'/>

	<!-- # Number of events required in low stats routines -->
	<config LOWSTATEVENTS='25000'/>


	<!-- # Error band generator configs -->
	<!-- # ###################################################### -->

	<!-- # For -f ErrorBands creates error bands for given measurements -->
	<!-- # How many throws do we want (The higher the better precision) -->
	<config error_throws='500'/>

	<!-- # Are we throwing uniform or according to Gaussian? -->
	<!-- # Only use uniform if wanting to study the limits of a dial. -->
	<config error_uniform='0'/>
	<config WriteSeperateStacks='1'/>

	<!-- # Other Individual Case Configs -->
	<!-- # ###################################################### -->

	<!-- # Covariance throw options for fake data studies with MiniBooNE data. -->
	<config thrown_covariance='FULL'/>
	<config throw_mc_stat='0.0'/>
	<config throw_diag_syst='0'/>
	<config throw_corr_syst='0'/>
	<config throw_mc_stat='0'/>

	<!-- # Apply a shift to the muon momentum before calculation of Q2 -->
	<config muon_momentum_shift='0.0'/>
	<config muon_momentum_throw='0'/>

	<!-- # MINERvA Specific Configs -->
	<config MINERvA_CCinc_XSec_2DEavq3_nu_hadron_cut='0'/>
	<config MINERvA_CCinc_XSec_2DEavq3_nu_useq3true='0'/>
	<config Modes_split_PN_NN='0'/>

	<!-- Use only signal events when reconfiguring -->
	<config SignalReconfigures='false'/>
	<config FullEventOnSignalReconfigure="true"/>

	<!-- # SciBooNE specific -->
	<config SciBarDensity='1.04'/>
	<config SciBarRecoDist='12.0'/>
	<config PenetratingMuonEnergy='1.4'/>
	<config FlatEfficiency='1.0'/>
	<config NumRangeSteps='50'/>
	<config UseProton='true'/>
	<config UseZackEff='false'/>

	<config MINERvADensity='1.04'/>
	<config MINERvARecoDist='10.0'/>

	<!-- Different way of reweighting in GENIE -->
	<config GENIEWeightEngine_CCRESMode="kModeMaMv"/>
	<!--
	<config GENIEWeightEngine_CCRESMode="kModeMa"/>
	-->
	<config GENIEWeightEngine_CCQEMode="kModeMa"/>
	<!--
	<config GENIEWeightEngine_CCQEMode="kModeNormAndMaShape"/> Taking shape into account (don't really use this...)
	<config GENIEWeightEngine_CCQEMode="kModeZExp"/> Using z-expansion
	-->

	<!-- CCQE/2p2h/1pi Gaussian enhancement method -->
	<!-- Apply tilt-shift weights or normal Gaussian parameters-->
	<config Gaussian_Enhancement="Normal" />
	<!--
	<config Gaussian_Enhancement="Tilt-Shift" />
	-->

	<config NToyThrows='100000' />

	<!-- Use NOvA Weights or not -->
	<config NOvA_Weights="false" />

	-<!-- Tune name, for GENIE v3+ -->
	-<config GENIETune="G18_02a_00_000" />
	+<!-- Tune name, for GENIE v3+ Must specify this or
	+too ,any opportunities for mistakes.
	+<config GENIETune="G18_02a_00_000" /> -->
	<config GENIEEventGeneratorList="Default" />

	+
	<!--
	<config GENIEXSecModelCCRES="genie::ReinSehgalRESPXSec" />
	<config GENIEXSecModelCOH="genie::ReinSehgalCOHPiPXSec" />
	<config GENIEXSecModelCCQE="genie::LwlynSmithQELCCPXSec" />
	-->

	<!--
	<config GENIEXSecModelCCQE="genie::NievesQELCCPXSec" />
	<config GENIEXSecModelCCRES="genie::BergerSehgalRESPXSec2014" />
	<config GENIEXSecModelCOH="genie::BergerSehgalCOHPiPXSec2015" />
	-->

	<config UseShapeCovar="0" />
	<config CC0piNBINS="156" />


	</nuisance>
	diff --git a/src/Reweight/GENIEWeightEngine.cxx b/src/Reweight/GENIEWeightEngine.cxx
	index 4888d02..97c060e 100644
	--- a/src/Reweight/GENIEWeightEngine.cxx
	+++ b/src/Reweight/GENIEWeightEngine.cxx
	@@ -1,464 +1,478 @@
	#include "GENIEWeightEngine.h"

	#ifdef __GENIE_ENABLED__
	#ifdef GENIE_PRE_R3
	#include "Algorithm/AlgConfigPool.h"
	#include "EVGCore/EventRecord.h"
	#include "GHEP/GHepRecord.h"
	#include "Ntuple/NtpMCEventRecord.h"
	#ifndef __NO_GENIE_REWEIGHT__
	#include "ReWeight/GReWeightAGKY.h"
	#include "ReWeight/GReWeightDISNuclMod.h"
	#include "ReWeight/GReWeightFGM.h"
	#include "ReWeight/GReWeightFZone.h"
	#include "ReWeight/GReWeightINuke.h"
	#include "ReWeight/GReWeightNonResonanceBkg.h"
	#include "ReWeight/GReWeightNuXSecCCQE.h"
	#include "ReWeight/GReWeightNuXSecCCQEvec.h"
	#include "ReWeight/GReWeightNuXSecCCRES.h"
	#include "ReWeight/GReWeightNuXSecCOH.h"
	#include "ReWeight/GReWeightNuXSecDIS.h"
	#include "ReWeight/GReWeightNuXSecNC.h"
	#include "ReWeight/GReWeightNuXSecNCEL.h"
	#include "ReWeight/GReWeightNuXSecNCRES.h"
	#include "ReWeight/GReWeightResonanceDecay.h"
	#include "ReWeight/GSystUncertainty.h"
	#ifdef __GENIE_EMP_MECRW_ENABLED
	#include "ReWeight/GReWeightXSecEmpiricalMEC.h"
	#endif
	#endif
	#if __GENIE_VERSION__ >= 212
	#include "ReWeight/GReWeightNuXSecCCQEaxial.h"
	#endif
	#else // GENIE v3
	#include "Framework/Algorithm/AlgConfigPool.h"
	#include "Framework/EventGen/EventRecord.h"
	#include "Framework/GHEP/GHepParticle.h"
	#include "Framework/GHEP/GHepRecord.h"
	#include "Framework/Ntuple/NtpMCEventRecord.h"
	#include "Framework/Utils/AppInit.h"
	#include "Framework/Utils/RunOpt.h"

	using namespace genie;

	#ifndef __NO_GENIE_REWEIGHT__
	#include "RwCalculators/GReWeightAGKY.h"
	#include "RwCalculators/GReWeightDISNuclMod.h"
	#include "RwCalculators/GReWeightFGM.h"
	#include "RwCalculators/GReWeightFZone.h"
	#include "RwCalculators/GReWeightINuke.h"
	#include "RwCalculators/GReWeightNonResonanceBkg.h"
	#include "RwCalculators/GReWeightNuXSecCCQE.h"
	#include "RwCalculators/GReWeightNuXSecCCQEaxial.h"
	#include "RwCalculators/GReWeightNuXSecCCQEvec.h"
	#include "RwCalculators/GReWeightNuXSecCCRES.h"
	#include "RwCalculators/GReWeightNuXSecCOH.h"
	#include "RwCalculators/GReWeightNuXSecDIS.h"
	#include "RwCalculators/GReWeightNuXSecNC.h"
	#include "RwCalculators/GReWeightNuXSecNCEL.h"
	#include "RwCalculators/GReWeightNuXSecNCRES.h"
	#include "RwCalculators/GReWeightResonanceDecay.h"
	#include "RwCalculators/GReWeightXSecEmpiricalMEC.h"
	#include "RwFramework/GSystUncertainty.h"
	using namespace genie::rew;
	#endif
	#endif
	#endif

	#include "FitLogger.h"

	GENIEWeightEngine::GENIEWeightEngine(std::string name) {
	#ifdef __GENIE_ENABLED__
	#ifndef __NO_GENIE_REWEIGHT__
	// Setup the NEUT Reweight engien
	fCalcName = name;
	NUIS_LOG(DEB, "Setting up GENIE RW : " << fCalcName);

	// Create RW Engine suppressing cout
	StopTalking();
	fGenieRW = new genie::rew::GReWeight();

	// Get List of Vetos (Just for debugging)
	std::string rw_engine_list =
	FitPar::Config().GetParS("FitWeight_fGenieRW_veto");
	bool xsec_ncel = rw_engine_list.find("xsec_ncel") == std::string::npos;
	bool xsec_ccqe = rw_engine_list.find("xsec_ccqe") == std::string::npos;
	bool xsec_coh = rw_engine_list.find("xsec_coh") == std::string::npos;
	bool xsec_nnres = rw_engine_list.find("xsec_nonresbkg") == std::string::npos;
	bool xsec_nudis = rw_engine_list.find("nuclear_dis") == std::string::npos;
	bool xsec_resdec =
	rw_engine_list.find("hadro_res_decay") == std::string::npos;
	bool xsec_fzone = rw_engine_list.find("hadro_intranuke") == std::string::npos;
	bool xsec_intra = rw_engine_list.find("hadro_fzone") == std::string::npos;
	bool xsec_agky = rw_engine_list.find("hadro_agky") == std::string::npos;
	bool xsec_qevec = rw_engine_list.find("xsec_ccqe_vec") == std::string::npos;
	bool xsec_dis = rw_engine_list.find("xsec_dis") == std::string::npos;
	bool xsec_nc = rw_engine_list.find("xsec_nc") == std::string::npos;
	bool xsec_ccres = rw_engine_list.find("xsec_ccres") == std::string::npos;
	bool xsec_ncres = rw_engine_list.find("xsec_ncres") == std::string::npos;
	bool xsec_nucqe = rw_engine_list.find("nuclear_qe") == std::string::npos;
	bool xsec_qeaxial =
	rw_engine_list.find("xsec_ccqe_axial") == std::string::npos;
	#ifdef __GENIE_EMP_MECRW_ENABLED
	bool xsec_empMEC = rw_engine_list.find("xsec_empMEC") == std::string::npos;
	#endif

	#ifndef GENIE_PRE_R3
	genie::RunOpt *grunopt = genie::RunOpt::Instance();
	grunopt->EnableBareXSecPreCalc(true);
	grunopt->SetEventGeneratorList(Config::GetParS("GENIEEventGeneratorList"));
	+ if(!Config::HasPar("GENIETune")){
	+ NUIS_ABORT("GENIE tune was not specified, this is required when reweighting GENIE V3+ events. Add a config parameter like: <config GENIETune=\"G18_10a_02_11a\" /> to your nuisance card.");
	+ }
	grunopt->SetTuneName(Config::GetParS("GENIETune"));
	grunopt->BuildTune();
	std::string genv =
	std::string(getenv("GENIE")) + "/config/Messenger_laconic.xml";
	genie::utils::app_init::MesgThresholds(genv);
	#endif

	// Now actually add the RW Calcs
	if (xsec_ncel)
	fGenieRW->AdoptWghtCalc("xsec_ncel", new genie::rew::GReWeightNuXSecNCEL);
	if (xsec_ccqe) {
	fGenieRW->AdoptWghtCalc("xsec_ccqe", new genie::rew::GReWeightNuXSecCCQE);
	// (dynamic_cast<GReWeightNuXSecCCQE*> (fGenieRW->WghtCalc("xsec_ccqe")))
	// ->SetXSecModel( FitPar::Config().GetParS("GENIEXSecModelCCQE") );
	}
	#ifdef __GENIE_EMP_MECRW_ENABLED
	if (xsec_empMEC) {
	fGenieRW->AdoptWghtCalc("xsec_empMEC",
	new genie::rew::GReWeightXSecEmpiricalMEC);
	}
	#endif
	if (xsec_coh) {
	fGenieRW->AdoptWghtCalc("xsec_coh", new genie::rew::GReWeightNuXSecCOH());
	// (dynamic_cast<GReWeightNuXSecCOH*> (fGenieRW->WghtCalc("xsec_coh")))
	// ->SetXSecModel( FitPar::Config().GetParS("GENIEXSecModelCOH") );
	}

	if (xsec_nnres)
	fGenieRW->AdoptWghtCalc("xsec_nonresbkg",
	new genie::rew::GReWeightNonResonanceBkg);
	if (xsec_nudis)
	fGenieRW->AdoptWghtCalc("nuclear_dis", new genie::rew::GReWeightDISNuclMod);
	if (xsec_resdec)
	fGenieRW->AdoptWghtCalc("hadro_res_decay",
	new genie::rew::GReWeightResonanceDecay);
	if (xsec_fzone)
	fGenieRW->AdoptWghtCalc("hadro_fzone", new genie::rew::GReWeightFZone);
	if (xsec_intra)
	fGenieRW->AdoptWghtCalc("hadro_intranuke", new genie::rew::GReWeightINuke);
	if (xsec_agky)
	fGenieRW->AdoptWghtCalc("hadro_agky", new genie::rew::GReWeightAGKY);
	if (xsec_qevec)
	fGenieRW->AdoptWghtCalc("xsec_ccqe_vec",
	new genie::rew::GReWeightNuXSecCCQEvec);
	#if __GENIE_VERSION__ >= 212
	if (xsec_qeaxial)
	fGenieRW->AdoptWghtCalc("xsec_ccqe_axial",
	new genie::rew::GReWeightNuXSecCCQEaxial);
	#endif

	if (xsec_dis)
	fGenieRW->AdoptWghtCalc("xsec_dis", new genie::rew::GReWeightNuXSecDIS);
	if (xsec_nc)
	fGenieRW->AdoptWghtCalc("xsec_nc", new genie::rew::GReWeightNuXSecNC);
	if (xsec_ccres) {
	#if __GENIE_VERSION__ < 213
	fGenieRW->AdoptWghtCalc("xsec_ccres", new genie::rew::GReWeightNuXSecCCRES);
	#else
	fGenieRW->AdoptWghtCalc(
	"xsec_ccres",
	new genie::rew::GReWeightNuXSecCCRES(
	FitPar::Config().GetParS("GENIEXSecModelCCRES"), "Default"));
	#endif
	}

	if (xsec_ncres)
	fGenieRW->AdoptWghtCalc("xsec_ncres", new genie::rew::GReWeightNuXSecNCRES);
	if (xsec_nucqe)
	fGenieRW->AdoptWghtCalc("nuclear_qe", new genie::rew::GReWeightFGM);

	-#if __GENIE_VERSION__ >= 212
	// Set the CCQE reweighting style
	GReWeightNuXSecCCQE *rwccqe =
	dynamic_cast<GReWeightNuXSecCCQE *>(fGenieRW->WghtCalc("xsec_ccqe"));

	// For MaCCQE reweighting
	std::string ccqetype = FitPar::Config().GetParS("GENIEWeightEngine_CCQEMode");
	if (ccqetype == "kModeMa") {
	NUIS_LOG(DEB, "Setting GENIE ReWeight CCQE to kModeMa");
	rwccqe->SetMode(GReWeightNuXSecCCQE::kModeMa);
	} else if (ccqetype == "kModeNormAndMaShape") {
	NUIS_LOG(DEB, "Setting GENIE ReWeight CCQE to kModeNormAndMaShape");
	rwccqe->SetMode(GReWeightNuXSecCCQE::kModeNormAndMaShape);
	// For z-expansion reweighting
	} else if (ccqetype == "kModeZExp") {
	NUIS_LOG(DEB, "Setting GENIE ReWeight CCQE to kModeZExp");
	rwccqe->SetMode(GReWeightNuXSecCCQE::kModeZExp);
	} else {
	NUIS_ERR(FTL, "Did not find specified GENIE ReWeight CCQE mode");
	NUIS_ABORT("You provided: " << ccqetype << " in parameters/config.xml");
	}

	+#if (__GENIE_VERSION__ >= 212) and \
	+ (__GENIE_VERSION__ <= \
	+ 300) // This doesn't currently work as is for GENIE v3, but the reweighting
	+ // in v3 supposedly does similar checks anyway.
	+
	// Check the UserPhysicsOptions too!
	AlgConfigPool *Pool = genie::AlgConfigPool::Instance();
	Registry *full = Pool->GlobalParameterList();
	+
	std::string name_ax = full->GetAlg("AxialFormFactorModel").name;
	std::string config_ax = full->GetAlg("AxialFormFactorModel").config;
	+
	if (name_ax == "genie::DipoleAxialFormFactorModel" &&
	ccqetype == "kModeZExp") {
	- NUIS_ERR(FTL,
	- "Trying to run Z Expansion reweighting with Llewelyn-Smith model.");
	+ NUIS_ERR(
	+ FTL,
	+ "Trying to run Z Expansion reweighting with Llewelyn-Smith model.");
	NUIS_ERR(FTL, "Please check your "
	- << std::getenv("GENIE")
	- << "/config/UserPhysicsOptions.xml to match generated");
	+ << std::getenv("GENIE")
	+ << "/config/UserPhysicsOptions.xml to match generated");
	NUIS_ERR(FTL, "You're telling me " << name_ax << "/" << config_ax);
	NUIS_ABORT("Also check your "
	- << std::getenv("NUISANCE")
	- << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	- << ccqetype);
	+ << std::getenv("NUISANCE")
	+ << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	+ << ccqetype);
	}

	if (name_ax == "genie::ZExpAxialFormFactorModel" && ccqetype != "kModeZExp") {
	- NUIS_ERR(FTL,
	- "Trying to run Llewelyn-Smith reweighting with Z Expansion model.");
	+ NUIS_ERR(
	+ FTL,
	+ "Trying to run Llewelyn-Smith reweighting with Z Expansion model.");
	NUIS_ERR(FTL, "Please change your "
	- << std::getenv("GENIE")
	- << "/config/UserPhysicsOptions.xml to match generated");
	+ << std::getenv("GENIE")
	+ << "/config/UserPhysicsOptions.xml to match generated");
	NUIS_ERR(FTL, "You're telling me " << name_ax << "/" << config_ax);
	NUIS_ABORT("Also check your "
	- << std::getenv("NUISANCE")
	- << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	- << ccqetype);
	+ << std::getenv("NUISANCE")
	+ << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	+ << ccqetype);
	}

	std::string name_qelcc =
	full->GetAlg("XSecModel@genie::EventGenerator/QEL-CC").name;
	std::string config_qelcc =
	full->GetAlg("XSecModel@genie::EventGenerator/QEL-CC").config;
	if (config_qelcc == "Default" && ccqetype == "kModeZExp") {
	- NUIS_ERR(FTL,
	- "Trying to run Z Expansion reweighting with Llewelyn-Smith model.");
	+ NUIS_ERR(
	+ FTL,
	+ "Trying to run Z Expansion reweighting with Llewelyn-Smith model.");
	NUIS_ERR(FTL, "Please change your "
	- << std::getenv("GENIE")
	- << "/config/UserPhysicsOptions.xml to match generated");
	+ << std::getenv("GENIE")
	+ << "/config/UserPhysicsOptions.xml to match generated");
	NUIS_ERR(FTL, "You're telling me " << name_qelcc << "/" << config_qelcc);
	NUIS_ABORT("Also check your "
	- << std::getenv("NUISANCE")
	- << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	- << ccqetype);
	+ << std::getenv("NUISANCE")
	+ << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	+ << ccqetype);
	}

	if (config_qelcc == "ZExp" && ccqetype != "kModeZExp") {
	- NUIS_ERR(FTL,
	- "Trying to run Llewelyn-Smith reweighting with Z Expansion model.");
	+ NUIS_ERR(
	+ FTL,
	+ "Trying to run Llewelyn-Smith reweighting with Z Expansion model.");
	NUIS_ERR(FTL, "Please change your "
	- << std::getenv("GENIE")
	- << "/config/UserPhysicsOptions.xml to match generated");
	+ << std::getenv("GENIE")
	+ << "/config/UserPhysicsOptions.xml to match generated");
	NUIS_ERR(FTL, "You're telling me " << name_qelcc << "/" << config_qelcc);
	NUIS_ABORT("Also check your "
	- << std::getenv("NUISANCE")
	- << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	- << ccqetype);
	+ << std::getenv("NUISANCE")
	+ << "/parameters/config.xml GENIEWeightEngine_CCQEMode: "
	+ << ccqetype);
	}
	#endif

	if (xsec_ccres) {
	// Default to include shape and normalization changes for CCRES (can be
	// changed downstream if desired)
	GReWeightNuXSecCCRES *rwccres =
	dynamic_cast<GReWeightNuXSecCCRES *>(fGenieRW->WghtCalc("xsec_ccres"));

	std::string marestype =
	FitPar::Config().GetParS("GENIEWeightEngine_CCRESMode");
	if (!marestype.compare("kModeNormAndMaMvShape")) {
	rwccres->SetMode(GReWeightNuXSecCCRES::kModeNormAndMaMvShape);
	} else if (!marestype.compare("kModeMaMv")) {
	rwccres->SetMode(GReWeightNuXSecCCRES::kModeMaMv);
	} else {
	NUIS_ABORT("Unkown MARES Mode in GENIE Weight Engine : " << marestype);
	}
	}
	if (xsec_ncres) {
	// Default to include shape and normalization changes for NCRES (can be
	// changed downstream if desired)
	GReWeightNuXSecNCRES *rwncres =
	dynamic_cast<GReWeightNuXSecNCRES *>(fGenieRW->WghtCalc("xsec_ncres"));
	rwncres->SetMode(GReWeightNuXSecNCRES::kModeMaMv);
	}

	if (xsec_dis) {
	// Default to include shape and normalization changes for DIS (can be
	// changed downstream if desired)
	GReWeightNuXSecDIS *rwdis =
	dynamic_cast<GReWeightNuXSecDIS *>(fGenieRW->WghtCalc("xsec_dis"));
	rwdis->SetMode(GReWeightNuXSecDIS::kModeABCV12u);

	// Set Abs Twk Config
	fIsAbsTwk = (FitPar::Config().GetParB("setabstwk"));
	}

	// allow cout again
	StartTalking();

	#else
	- NUIS_ERR(FTL, "GENIE ReWeight is __NOT ENABLED__ in GENIE and you're trying to "
	- "run NUISANCE with it enabled");
	+ NUIS_ERR(FTL,
	+ "GENIE ReWeight is __NOT ENABLED__ in GENIE and you're trying to "
	+ "run NUISANCE with it enabled");
	NUIS_ERR(FTL, "Check your genie-config --libs for reweighting");
	NUIS_ERR(FTL, "If not present you need to recompile GENIE");
	NUIS_ABORT("If present you need to contact NUISANCE authors");

	#endif
	#endif
	};

	void GENIEWeightEngine::IncludeDial(std::string name, double startval) {
	#ifdef __GENIE_ENABLED__
	#ifndef __NO_GENIE_REWEIGHT__

	// Get First enum
	int nuisenum = Reweight::ConvDial(name, kGENIE);

	// Check ZExp sillyness in GENIE
	// If ZExpansion parameters are used we need to set a different mode in GENIE
	// ReWeight... GENIE doesn't have a setter either...
	-#if __GENIE_VERSION__ >= 212
	+#if (__GENIE_VERSION__ >= 212) and (__GENIE_VERSION__ <= 300)
	std::string ccqetype = FitPar::Config().GetParS("GENIEWeightEngine_CCQEMode");
	if (ccqetype != "kModeZExp" &&
	(name == "ZExpA1CCQE" \|\| name == "ZExpA2CCQE" \|\| name == "ZExpA3CCQE" \|\|
	name == "ZExpA4CCQE")) {
	NUIS_ERR(FTL, "Found a Z-expansion parameter in GENIE although the GENIE "
	- "ReWeighting engine is set to use Llewelyn-Smith and MaQE!");
	+ "ReWeighting engine is set to use Llewelyn-Smith and MaQE!");
	NUIS_ABORT("Change your GENIE UserPhysicsOptions.xml in "
	- << std::getenv("GENIE")
	- << "/config/UserPhysicsOptions.xml to match requirements");
	+ << std::getenv("GENIE")
	+ << "/config/UserPhysicsOptions.xml to match requirements");
	}

	if ((ccqetype != "kModeMa" && ccqetype != "kModeMaNormAndMaShape") &&
	(name == "MaCCQE")) {
	NUIS_ERR(FTL, "Found MaCCQE parameter in GENIE although the GENIE "
	- "ReWeighting engine is set to not use this!");
	+ "ReWeighting engine is set to not use this!");
	NUIS_ABORT("Change your GENIE UserPhysicsOptions.xml in "
	- << std::getenv("GENIE")
	- << "/config/UserPhysicsOptions.xml to match requirements");
	+ << std::getenv("GENIE")
	+ << "/config/UserPhysicsOptions.xml to match requirements");
	}
	#endif

	// 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
	genie::rew::GSyst_t rwsyst = GSyst::FromString(singlename);

	// Fill Maps
	int index = fValues.size();
	fValues.push_back(0.0);
	fGENIESysts.push_back(rwsyst);

	// Initialize dial
	NUIS_LOG(DEB, "Registering " << singlename << " from " << name);
	fGenieRW->Systematics().Init(fGENIESysts[index]);

	// If Absolute
	if (fIsAbsTwk) {
	GSystUncertainty::Instance()->SetUncertainty(rwsyst, 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 GENIEWeightEngine::SetDialValue(int nuisenum, double val) {
	#ifdef __GENIE_ENABLED__
	#ifndef __NO_GENIE_REWEIGHT__
	std::vector<size_t> indices = fEnumIndex[nuisenum];
	for (uint i = 0; i < indices.size(); i++) {
	fValues[indices[i]] = val;
	fGenieRW->Systematics().Set(fGENIESysts[indices[i]], val);
	}
	#endif
	#endif
	}

	void GENIEWeightEngine::SetDialValue(std::string name, double val) {
	#ifdef __GENIE_ENABLED__
	#ifndef __NO_GENIE_REWEIGHT__
	std::vector<size_t> indices = fNameIndex[name];
	for (uint i = 0; i < indices.size(); i++) {
	fValues[indices[i]] = val;
	fGenieRW->Systematics().Set(fGENIESysts[indices[i]], val);
	}
	#endif
	#endif
	}

	void GENIEWeightEngine::Reconfigure(bool silent) {
	#ifdef __GENIE_ENABLED__
	#ifndef __NO_GENIE_REWEIGHT__
	// Hush now...
	if (silent)
	StopTalking();

	// Reconf
	fGenieRW->Reconfigure();
	fGenieRW->Print();

	// Shout again
	if (silent)
	StartTalking();
	#endif
	#endif
	}

	double GENIEWeightEngine::CalcWeight(BaseFitEvt *evt) {
	double rw_weight = 1.0;

	#ifdef __GENIE_ENABLED__
	#ifndef __NO_GENIE_REWEIGHT__
	// Make nom weight
	if (!evt) {
	NUIS_ABORT("evt not found : " << evt);
	}

	// Skip Non GENIE
	if (evt->fType != kGENIE)
	return 1.0;

	if (!(evt->genie_event)) {
	NUIS_ABORT("evt->genie_event not found!" << evt->genie_event);
	}

	if (!(evt->genie_event->event)) {
	NUIS_ABORT("evt->genie_event->event GHepRecord not found!"
	- << (evt->genie_event->event));
	+ << (evt->genie_event->event));
	}

	if (!fGenieRW) {
	NUIS_ABORT("GENIE RW Not Found!" << fGenieRW);
	}

	rw_weight = fGenieRW->CalcWeight(*(evt->genie_event->event));
	// std::cout << "Returning GENIE Weight for electron scattering = " <<
	// rw_weight << std::endl;
	// if (rw_weight != 1.0 )std::cout << "mode=" << evt->Mode << " rw_weight = "
	// << rw_weight << std::endl;
	#endif
	#endif

	// Return rw_weight
	return rw_weight;
	}
	diff --git a/src/Reweight/WeightUtils.cxx b/src/Reweight/WeightUtils.cxx
	index eecb32c..8429a6a 100644
	--- a/src/Reweight/WeightUtils.cxx
	+++ b/src/Reweight/WeightUtils.cxx
	@@ -1,592 +1,592 @@
	#include "WeightUtils.h"

	#include "FitLogger.h"
	#ifdef __T2KREW_ENABLED__
	#include "T2KGenieReWeight.h"
	#include "T2KNIWGReWeight.h"
	#include "T2KNIWGUtils.h"
	#include "T2KNeutReWeight.h"
	#include "T2KNeutUtils.h"
	#include "T2KReWeight.h"
	using namespace t2krew;
	#endif

	#ifdef __NIWG_ENABLED__
	#include "NIWGReWeight.h"
	#include "NIWGSyst.h"
	#endif

	#ifdef __NEUT_ENABLED__
	#include "NReWeight.h"
	#include "NSyst.h"
	#endif

	#ifdef __NUWRO_REWEIGHT_ENABLED__
	#include "NuwroReWeight.h"
	#include "NuwroSyst.h"
	#endif

	#ifdef __GENIE_ENABLED__
	#ifdef GENIE_PRE_R3
	#ifndef __NO_GENIE_REWEIGHT__
	#include "ReWeight/GReWeight.h"
	#include "ReWeight/GSyst.h"
	#endif
	#else
	using namespace genie;
	#ifndef __NO_GENIE_REWEIGHT__
	#include "RwFramework/GReWeight.h"
	#include "RwFramework/GSyst.h"
	using namespace genie::rew;
	#endif
	#endif
	#endif

	#ifdef __NOVA_ENABLED__
	#include "NOvARwgtEngine.h"
	#endif

	#include "GlobalDialList.h"
	#include "ModeNormEngine.h"
	#include "NUISANCESyst.h"
	#include "OscWeightEngine.h"

	//********************************************************************
	TF1 FitBase::GetRWConvFunction(std::string const &type,
	std::string const &name) {
	//********************************************************************

	std::string dialfunc = "x";
	std::string parType = type;
	double low = -10000.0;
	double high = 10000.0;
	if (parType.find("parameter") == std::string::npos)
	parType += "_parameter";

	std::string line;
	std::ifstream card(
	(GeneralUtils::GetTopLevelDir() + "/parameters/dial_conversion.card")
	.c_str(),
	std::ifstream::in);

	while (std::getline(card >> std::ws, line, '\n')) {
	std::vector<std::string> inputlist = GeneralUtils::ParseToStr(line, " ");

	// Check the line length
	if (inputlist.size() < 4)
	continue;

	// Check whether this is a comment
	if (inputlist[0].c_str()[0] == '#')
	continue;

	// Check whether this is the correct parameter type
	if (inputlist[0].compare(parType) != 0)
	continue;

	// Check the parameter name
	if (inputlist[1].compare(name) != 0)
	continue;

	// inputlist[2] should be the units... ignore for now

	dialfunc = inputlist[3];

	// High and low are optional, check whether they exist
	if (inputlist.size() > 4)
	low = GeneralUtils::StrToDbl(inputlist[4]);
	if (inputlist.size() > 5)
	high = GeneralUtils::StrToDbl(inputlist[5]);
	}

	TF1 convfunc = TF1((name + "_convfunc").c_str(), dialfunc.c_str(), low, high);
	return convfunc;
	}

	//********************************************************************
	std::string FitBase::GetRWUnits(std::string const &type,
	std::string const &name) {
	//********************************************************************

	std::string unit = "sig.";
	std::string parType = type;

	if (parType.find("parameter") == std::string::npos) {
	parType += "_parameter";
	}

	std::string line;
	std::ifstream card(
	(GeneralUtils::GetTopLevelDir() + "/parameters/dial_conversion.card")
	.c_str(),
	std::ifstream::in);

	while (std::getline(card >> std::ws, line, '\n')) {
	std::vector<std::string> inputlist = GeneralUtils::ParseToStr(line, " ");

	// Check the line length
	if (inputlist.size() < 3)
	continue;

	// Check whether this is a comment
	if (inputlist[0].c_str()[0] == '#')
	continue;

	// Check whether this is the correct parameter type
	if (inputlist[0].compare(parType) != 0)
	continue;

	// Check the parameter name
	if (inputlist[1].compare(name) != 0)
	continue;

	unit = inputlist[2];
	break;
	}

	return unit;
	}

	//********************************************************************
	double FitBase::RWAbsToSigma(std::string const &type, std::string const &name,
	double val) {
	//********************************************************************
	TF1 f1 = GetRWConvFunction(type, name);
	double conv_val = f1.GetX(val);
	if (fabs(conv_val) < 1E-10)
	conv_val = 0.0;

	NUIS_LOG(FIT, "AbsToSigma(" << name << ") = " << val << " -> " << conv_val);
	return conv_val;
	}

	//********************************************************************
	double FitBase::RWSigmaToAbs(std::string const &type, std::string const &name,
	double val) {
	//********************************************************************
	TF1 f1 = GetRWConvFunction(type, name);
	double conv_val = f1.Eval(val);
	return conv_val;
	}

	//********************************************************************
	double FitBase::RWFracToSigma(std::string const &type, std::string const &name,
	double val) {
	//********************************************************************
	TF1 f1 = GetRWConvFunction(type, name);
	double conv_val = f1.GetX((val * f1.Eval(0.0)));
	if (fabs(conv_val) < 1E-10)
	conv_val = 0.0;
	return conv_val;
	}

	//********************************************************************
	double FitBase::RWSigmaToFrac(std::string const &type, std::string const &name,
	double val) {
	//********************************************************************
	TF1 f1 = GetRWConvFunction(type, name);
	double conv_val = f1.Eval(val) / f1.Eval(0.0);
	return conv_val;
	}

	int FitBase::ConvDialType(std::string const &type) {
	if (!type.compare("neut_parameter"))
	return kNEUT;
	else if (!type.compare("niwg_parameter"))
	return kNIWG;
	else if (!type.compare("nuwro_parameter"))
	return kNUWRO;
	else if (!type.compare("t2k_parameter"))
	return kT2K;
	else if (!type.compare("genie_parameter"))
	return kGENIE;
	else if (!type.compare("custom_parameter"))
	return kCUSTOM;
	else if (!type.compare("norm_parameter"))
	return kNORM;
	else if (!type.compare("likeweight_parameter"))
	return kLIKEWEIGHT;
	else if (!type.compare("spline_parameter"))
	return kSPLINEPARAMETER;
	else if (!type.compare("osc_parameter"))
	return kOSCILLATION;
	else if (!type.compare("modenorm_parameter"))
	return kMODENORM;
	else if (!type.compare("nova_parameter"))
	return kNOvARWGT;
	else
	return kUNKNOWN;
	}

	std::string FitBase::ConvDialType(int type) {
	switch (type) {
	case kNEUT: {
	return "neut_parameter";
	}
	case kNIWG: {
	return "niwg_parameter";
	}
	case kNUWRO: {
	return "nuwro_parameter";
	}
	case kT2K: {
	return "t2k_parameter";
	}
	case kGENIE: {
	return "genie_parameter";
	}
	case kNORM: {
	return "norm_parameter";
	}
	case kCUSTOM: {
	return "custom_parameter";
	}
	case kLIKEWEIGHT: {
	return "likeweight_parameter";
	}
	case kSPLINEPARAMETER: {
	return "spline_parameter";
	}
	case kOSCILLATION: {
	return "osc_parameter";
	}
	case kMODENORM: {
	return "modenorm_parameter";
	}
	case kNOvARWGT: {
	return "nova_parameter";
	}
	default:
	return "unknown_parameter";
	}
	}

	int FitBase::GetDialEnum(std::string const &type, std::string const &name) {
	return FitBase::GetDialEnum(FitBase::ConvDialType(type), name);
	}

	int FitBase::GetDialEnum(int type, std::string const &name) {
	int offset = type * 1000;
	int this_enum = Reweight::kNoDialFound; // Not Found

	NUIS_LOG(DEB, "Getting dial enum " << type << " " << name);
	// Select Types
	switch (type) {
	// NEUT DIAL TYPE
	case kNEUT: {
	#ifdef __NEUT_ENABLED__
	int neut_enum = (int)neut::rew::NSyst::FromString(name);
	if (neut_enum != 0) {
	this_enum = neut_enum + offset;
	}
	#else
	this_enum = Reweight::kNoTypeFound; // Not enabled
	#endif
	break;
	}

	// NIWG DIAL TYPE
	case kNIWG: {
	#ifdef __NIWG_ENABLED__
	int niwg_enum = (int)niwg::rew::NIWGSyst::FromString(name);
	if (niwg_enum != 0) {
	this_enum = niwg_enum + offset;
	}
	#else
	this_enum = Reweight::kNoTypeFound;
	#endif
	break;
	}

	// NUWRO DIAL TYPE
	case kNUWRO: {
	#ifdef __NUWRO_REWEIGHT_ENABLED__
	int nuwro_enum = (int)nuwro::rew::NuwroSyst::FromString(name);
	if (nuwro_enum > 0) {
	this_enum = nuwro_enum + offset;
	}
	#else
	this_enum = Reweight::kNoTypeFound;
	#endif
	}

	// GENIE DIAL TYPE
	case kGENIE: {
	#if defined(__GENIE_ENABLED__) && !defined(__NO_GENIE_REWEIGHT__)
	int genie_enum = (int)genie::rew::GSyst::FromString(name);
	if (genie_enum > 0) {
	this_enum = genie_enum + offset;
	}
	#else
	this_enum = Reweight::kNoTypeFound;
	#endif
	break;
	}

	case kCUSTOM: {
	int custom_enum = 0; // PLACEHOLDER
	this_enum = custom_enum + offset;
	break;
	}

	// T2K DIAL TYPE
	case kT2K: {
	#ifdef __T2KREW_ENABLED__
	int t2k_enum = (int)t2krew::T2KSyst::FromString(name);
	if (t2k_enum > 0) {
	this_enum = t2k_enum + offset;
	}
	#else
	this_enum = Reweight::kNoTypeFound;
	#endif
	break;
	}

	case kNORM: {
	if (gNormEnums.find(name) == gNormEnums.end()) {
	gNormEnums[name] = gNormEnums.size() + 1 + offset;
	}
	this_enum = gNormEnums[name];
	break;
	}

	case kLIKEWEIGHT: {
	if (gLikeWeightEnums.find(name) == gLikeWeightEnums.end()) {
	gLikeWeightEnums[name] = gLikeWeightEnums.size() + 1 + offset;
	}
	this_enum = gLikeWeightEnums[name];
	break;
	}

	case kSPLINEPARAMETER: {
	if (gSplineParameterEnums.find(name) == gSplineParameterEnums.end()) {
	gSplineParameterEnums[name] = gSplineParameterEnums.size() + 1 + offset;
	}
	this_enum = gSplineParameterEnums[name];
	break;
	}
	case kOSCILLATION: {
	#ifdef __PROB3PP_ENABLED__
	int oscEnum = OscWeightEngine::SystEnumFromString(name);
	if (oscEnum != 0) {
	this_enum = oscEnum + offset;
	}
	#else
	this_enum = Reweight::kNoTypeFound; // Not enabled
	#endif
	}
	case kMODENORM: {
	size_t us_pos = name.find_first_of('_');
	std::string numstr = name.substr(us_pos + 1);
	int mode_num = std::atoi(numstr.c_str());
	NUIS_LOG(FTL, "Getting mode num " << mode_num);
	if (!mode_num) {
	NUIS_ABORT("Attempting to parse dial name: \""
	<< name << "\" as a mode norm dial but failed.");
	}
	this_enum = 60 + mode_num + offset;
	break;
	}
	}

	// If Not Enabled
	if (this_enum == Reweight::kNoTypeFound) {
	NUIS_ERR(FTL, "RW Engine not supported for " << FitBase::ConvDialType(type));
	NUIS_ABORT("Check dial " << name);
	}

	// If Not Found
	if (this_enum == Reweight::kNoDialFound) {
	NUIS_ABORT("Dial " << name << " not found.");
	}

	return this_enum;
	}

	int Reweight::ConvDialType(std::string const &type) {
	return FitBase::ConvDialType(type);
	}

	std::string Reweight::ConvDialType(int type) {
	return FitBase::ConvDialType(type);
	}

	int Reweight::GetDialType(int type) {
	int t = (type / 1000);
	return t > kNOvARWGT ? Reweight::kNoDialFound : t;
	}

	int Reweight::RemoveDialType(int type) { return (type % 1000); }

	int Reweight::NEUTEnumFromName(std::string const &name) {
	#ifdef __NEUT_ENABLED__
	int neutenum = (int)neut::rew::NSyst::FromString(name);
	return (neutenum > 0) ? neutenum : Reweight::kNoDialFound;
	#else
	return Reweight::kGeneratorNotBuilt;
	#endif
	}

	int Reweight::NIWGEnumFromName(std::string const &name) {
	#ifdef __NIWG_ENABLED__
	int niwgenum = (int)niwg::rew::NIWGSyst::FromString(name);
	return (niwgenum != 0) ? niwgenum : Reweight::kNoDialFound;
	#else
	return Reweight::kGeneratorNotBuilt;
	#endif
	}

	int Reweight::NUWROEnumFromName(std::string const &name) {
	#ifdef __NUWRO_REWEIGHT_ENABLED__
	int nuwroenum = (int)nuwro::rew::NuwroSyst::FromString(name);
	return (nuwroenum > 0) ? nuwroenum : Reweight::kNoDialFound;
	#else
	return Reweight::kGeneratorNotBuilt;
	#endif
	}

	int Reweight::GENIEEnumFromName(std::string const &name) {
	-#ifdef defined(__GENIE_ENABLED__) && !defined(__NO_GENIE_REWEIGHT__)
	+#if defined(__GENIE_ENABLED__) && !defined(__NO_GENIE_REWEIGHT__)
	int genieenum = (int)genie::rew::GSyst::FromString(name);
	return (genieenum > 0) ? genieenum : Reweight::kNoDialFound;
	#else
	return Reweight::kGeneratorNotBuilt;
	#endif
	}

	int Reweight::T2KEnumFromName(std::string const &name) {
	#ifdef __T2KREW_ENABLED__
	int t2kenum = (int)t2krew::T2KSyst::FromString(name);
	return (t2kenum > 0) ? t2kenum : Reweight::kNoDialFound;
	#else
	return Reweight::kGeneratorNotBuilt;
	#endif
	}

	int Reweight::OscillationEnumFromName(std::string const &name) {
	#ifdef __PROB3PP_ENABLED__
	int oscEnum = OscWeightEngine::SystEnumFromString(name);
	return (oscEnum > 0) ? oscEnum : Reweight::kNoDialFound;
	#else
	return Reweight::kGeneratorNotBuilt;
	#endif
	}

	int Reweight::NUISANCEEnumFromName(std::string const &name, int type) {
	int nuisenum = Reweight::DialList().EnumFromNameAndType(name, type);
	return nuisenum;
	}

	int Reweight::CustomEnumFromName(std::string const &name) {
	int custenum = Reweight::ConvertNUISANCEDial(name);
	return custenum;
	}

	int Reweight::ConvDial(std::string const &name, std::string const &type,
	bool exceptions) {
	return Reweight::ConvDial(name, Reweight::ConvDialType(type), exceptions);
	}

	int Reweight::ConvDial(std::string const &fullname, int type, bool exceptions) {
	std::string name =
	GeneralUtils::ParseToStr(fullname, ",")[0]; // Only use first dial given

	// Produce offset seperating each type.
	int offset = type * 1000;
	int genenum = Reweight::kNoDialFound;

	switch (type) {
	case kNEUT:
	genenum = NEUTEnumFromName(name);
	break;

	case kNIWG:
	genenum = NIWGEnumFromName(name);
	break;

	case kNUWRO:
	genenum = NUWROEnumFromName(name);
	break;

	case kGENIE:
	genenum = GENIEEnumFromName(name);
	break;

	case kT2K:
	genenum = T2KEnumFromName(name);
	break;

	case kCUSTOM:
	genenum = CustomEnumFromName(name);
	break;

	case kNORM:
	case kLIKEWEIGHT:
	case kSPLINEPARAMETER:
	case kNEWSPLINE:
	genenum = NUISANCEEnumFromName(name, type);
	break;

	case kOSCILLATION:
	genenum = OscillationEnumFromName(name);
	break;

	case kMODENORM:
	genenum = ModeNormEngine::SystEnumFromString(name);
	break;

	#ifdef __NOVA_ENABLED__
	case kNOvARWGT:
	genenum = NOvARwgtEngine::GetWeightGeneratorIndex(name);
	break;
	#endif

	default:
	genenum = Reweight::kNoTypeFound;
	break;
	}

	// Throw if required.
	if (exceptions) {
	// If Not Enabled
	if (genenum == Reweight::kGeneratorNotBuilt) {
	NUIS_ERR(FTL,
	"RW Engine not supported for " << FitBase::ConvDialType(type));
	NUIS_ABORT("Check dial " << name);
	}

	// If no type enabled
	if (genenum == Reweight::kNoTypeFound) {
	NUIS_ABORT("Type mismatch inside ConvDialEnum");
	}

	// If Not Found
	if (genenum == Reweight::kNoDialFound) {
	NUIS_ABORT("Dial " << name << " not found.");
	}
	}

	// Add offset if no issue
	int nuisenum = genenum;
	if ((genenum != Reweight::kGeneratorNotBuilt) &&
	(genenum != Reweight::kNoTypeFound) &&
	(genenum != Reweight::kNoDialFound)) {
	nuisenum += offset;
	}

	// Now register dial
	Reweight::DialList().RegisterDialEnum(name, type, nuisenum);

	return nuisenum;
	}

	std::string Reweight::ConvDial(int nuisenum) {
	for (size_t i = 0; i < Reweight::DialList().fAllDialEnums.size(); i++) {
	if (Reweight::DialList().fAllDialEnums[i] == nuisenum) {
	return Reweight::DialList().fAllDialNames[i];
	}
	}

	NUIS_LOG(FIT, "Cannot find dial with enum = " << nuisenum);
	return "";
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 3, 6:44 AM (21 h, 3 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 4979885
Default Alt Text: (43 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions