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 "";
 }