diff --git a/src/FitBase/MeasurementBase.cxx b/src/FitBase/MeasurementBase.cxx
index cad257f..170c69a 100644
--- a/src/FitBase/MeasurementBase.cxx
+++ b/src/FitBase/MeasurementBase.cxx
@@ -1,589 +1,589 @@
 // 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/>.
 *******************************************************************************/
 
 #include "MeasurementBase.h"
 
 /*
   Constructor/Destructors
 */
 
 //********************************************************************
 // 2nd Level Constructor (Inherits From MeasurementBase.h)
 MeasurementBase::MeasurementBase(void) {
   //********************************************************************
 
   fScaleFactor = 1.0;
   fMCFilled = false;
   fNoData = false;
   fInput = NULL;
   NSignal = 0;
 
   // Set the default values
   // After-wards this gets set in SetupMeasurement
   EnuMin = 0.;
   EnuMax = 1.E5;
 
   fMeasurementSpeciesType = kSingleSpeciesMeasurement;
   fEventVariables = NULL;
   fIsJoint = false;
 
   fNPOT = 0xdeadbeef;
   fFluxIntegralOverride = 0xdeadbeef;
   fTargetVolume = 0xdeadbeef;
   fTargetMaterialDensity = 0xdeadbeef;
   fEvtRateScaleFactor = 0xdeadbeef;
 };
 
 void MeasurementBase::FinaliseMeasurement() {
   // Used to setup default data hists, covars, etc.
 }
 
 //********************************************************************
 // 2nd Level Destructor (Inherits From MeasurementBase.h)
 MeasurementBase::~MeasurementBase(){
     //********************************************************************
 
 };
 
 //********************************************************************
 double MeasurementBase::TotalIntegratedFlux(std::string intOpt, double low,
                                             double high) {
   //********************************************************************
 
   // Set Energy Limits
   if (low == -9999.9) low = this->EnuMin;
   if (high == -9999.9) high = this->EnuMax;
   return GetInput()->TotalIntegratedFlux(low, high, intOpt);
 };
 
 //********************************************************************
 double MeasurementBase::PredictedEventRate(std::string intOpt, double low,
                                            double high) {
   //********************************************************************
 
   // Set Energy Limits
   if (low == -9999.9) low = this->EnuMin;
   if (high == -9999.9) high = this->EnuMax;
 
   return GetInput()->PredictedEventRate(low, high, intOpt) * 1E-38;
 };
 
 //********************************************************************
 void MeasurementBase::SetupInputs(std::string inputfile) {
   //********************************************************************
 
   // Add this infile to the global manager
   if (FitPar::Config().GetParB("EventManager")) {
     fInput = FitBase::AddInput(fName, inputfile);
   } else {
     std::vector<std::string> file_descriptor =
         GeneralUtils::ParseToStr(inputfile, ":");
     if (file_descriptor.size() != 2) {
       ERR(FTL) << "File descriptor had no filetype declaration: \"" << inputfile
                << "\". expected \"FILETYPE:file.root\"" << std::endl;
       throw;
     }
     InputUtils::InputType inpType =
         InputUtils::ParseInputType(file_descriptor[0]);
 
     fInput = InputUtils::CreateInputHandler(fName, inpType, file_descriptor[1]);
   }
 
   fNEvents = fInput->GetNEvents();
 
   // Expect INPUTTYPE:FileLocation(s)
   std::vector<std::string> file_descriptor =
       GeneralUtils::ParseToStr(inputfile, ":");
   if (file_descriptor.size() != 2) {
     ERR(FTL) << "File descriptor had no filetype declaration: \"" << inputfile
              << "\". expected \"FILETYPE:file.root\"" << std::endl;
     throw;
   }
   fInputType = InputUtils::ParseInputType(file_descriptor[0]);
 
   fInputFileName = file_descriptor[1];
   if (EnuMin == 0 && EnuMax == 1.E5) {
     EnuMin = fInput->GetFluxHistogram()->GetBinLowEdge(1);
     EnuMax = fInput->GetFluxHistogram()->GetBinLowEdge(
         fInput->GetFluxHistogram()->GetNbinsX() + 1);
   }
 
   fFluxHist = fInput->GetFluxHistogram();
   fEventHist = fInput->GetEventHistogram();
 }
 
 //***********************************************
 int MeasurementBase::GetInputID() {
   //***********************************************
   return FitBase::GetInputID(fInputFileName);
 }
 
 //***********************************************
 SampleSettings MeasurementBase::LoadSampleSettings(nuiskey samplekey) {
   //***********************************************
   SampleSettings setting = SampleSettings(samplekey);
   fName = setting.GetS("name");
 
   // Used as an initial setup function incase we need to do anything here.
   LOG(SAM) << "Loading Sample : " << setting.GetName() << std::endl;
 
   fEvtRateScaleFactor = 0xdeadbeef;
 
   if (!fIsJoint) {
     SetupInputs(setting.GetS("input"));
 
     fNPOT = samplekey.Has("NPOT") ? samplekey.GetD("NPOT") : 1;
     fFluxIntegralOverride = samplekey.Has("FluxIntegralOverride")
                                 ? samplekey.GetD("FluxIntegralOverride")
                                 : 0xdeadbeef;
     fTargetVolume = samplekey.Has("TargetVolume")
                         ? samplekey.GetD("TargetVolume")
                         : 0xdeadbeef;
     fTargetMaterialDensity = samplekey.Has("TargetMaterialDensity")
                                  ? samplekey.GetD("TargetMaterialDensity")
                                  : 0xdeadbeef;
     if ((fTargetVolume != 0xdeadbeef) &&
         (fTargetMaterialDensity != 0xdeadbeef)) {
       double TargetMass_kg = fTargetVolume * fTargetMaterialDensity;
       double NNucleons = TargetMass_kg / PhysConst::mass_nucleon_kg;
       double NNeutrinos =
           ((fFluxIntegralOverride == 0xdeadbeef) ? TotalIntegratedFlux()
                                                  : fFluxIntegralOverride) *
           fNPOT;
       fEvtRateScaleFactor = NNeutrinos * NNucleons;
 
       QLOG(SAM, "\tEvent rate prediction : ");
       QLOG(SAM, "\t\tTarget volume : " << fTargetVolume << " m^3");
       QLOG(SAM, "\t\tTarget density : " << fTargetMaterialDensity << " kg/m^3");
       QLOG(SAM, "\t\tTarget mass : " << TargetMass_kg << " kg");
       QLOG(SAM, "\t\tNTarget Nucleons : " << NNucleons);
       if ((fNPOT != 1)) {
         QLOG(SAM, "\t\tTotal POT : " << fNPOT);
       }
       QLOG(SAM, "\t\tNNeutrinos : " << NNeutrinos
                                     << ((fNPOT != 1) ? " /cm^2" : " /POT /cm^2"));
       QLOG(SAM, "\t\tXSec -> EvtRate scale factor : " << fEvtRateScaleFactor);
     }
   }
 
   return setting;
 }
 
 //***********************************************
 SampleSettings MeasurementBase::LoadSampleSettings(std::string name,
                                                    std::string input,
                                                    std::string type) {
   //***********************************************
 
   nuiskey samplekey = Config::CreateKey("sample");
   samplekey.SetS("name", name);
   samplekey.SetS("input", input);
   samplekey.SetS("type", type);
 
   return LoadSampleSettings(samplekey);
 }
 
 void MeasurementBase::FinaliseSampleSettings() {
   EnuMin = fSettings.GetD("enu_min");
   EnuMax = fSettings.GetD("enu_max");
 }
 
 //***********************************************
 void MeasurementBase::Reconfigure() {
   //***********************************************
 
   LOG(REC) << " Reconfiguring sample " << fName << std::endl;
 
   // Reset Histograms
   ResetExtraHistograms();
   AutoResetExtraTH1();
   this->ResetAll();
 
   // FitEvent* cust_event = fInput->GetEventPointer();
   int fNEvents = fInput->GetNEvents();
   int countwidth = (fNEvents / 5);
 
   // MAIN EVENT LOOP
   FitEvent* cust_event = fInput->FirstNuisanceEvent();
   int i = 0;
   int npassed = 0;
   while (cust_event) {
     cust_event->RWWeight = fRW->CalcWeight(cust_event);
     cust_event->Weight = cust_event->RWWeight * cust_event->InputWeight;
 
     Weight = cust_event->Weight;
 
     // Initialize
     fXVar = -999.9;
     fYVar = -999.9;
     fZVar = -999.9;
     Signal = false;
     Mode = cust_event->Mode;
 
     // Extract Measurement Variables
     this->FillEventVariables(cust_event);
     Signal = this->isSignal(cust_event);
     if (Signal) npassed++;
 
     GetBox()->SetX(fXVar);
     GetBox()->SetY(fYVar);
     GetBox()->SetZ(fZVar);
     GetBox()->SetMode(Mode);
     // GetBox()->fSignal = Signal;
 
     // Fill Histogram Values
     GetBox()->FillBoxFromEvent(cust_event);
     // this->FillExtraHistograms(GetBox(), Weight);
     this->FillHistogramsFromBox(GetBox(), Weight);
 
     // Print Out
     if (LOG_LEVEL(REC) && countwidth > 0 && !(i % countwidth)) {
       std::stringstream ss("");
       ss.unsetf(std::ios_base::fixed);
       ss << std::setw(7) << std::right << i << "/" << fNEvents << " events ("
-         << std::setw(2) << double(i) / double(fNEvents) * 100. << std::left
+         << std::setw(2) << int(double(i) / double(fNEvents) * 100.)+1 << std::left
          << std::setw(5) << "%) "
          << "[S,X,Y,Z,M,W] = [" << std::fixed << std::setprecision(2)
          << std::right << Signal << ", " << std::setw(5) << fXVar << ", "
          << std::setw(5) << fYVar << ", " << std::setw(5) << fYVar << ", "
          << std::setw(3) << (int)Mode << ", " << std::setw(5) << Weight << "] "
          << std::endl;
       LOG(SAM) << ss.str();
     }
 
     // iterate
     cust_event = fInput->NextNuisanceEvent();
     i++;
   }
 
   LOG(SAM) << npassed << "/" << fNEvents << " passed selection " << std::endl;
   if (npassed == 0) {
     LOG(SAM) << "WARNING: NO EVENTS PASSED SELECTION!" << std::endl;
   }
   LOG(REC) << std::setw(10) << std::right << NSignal << "/" << fNEvents
            << " events passed selection + binning after reweight" << std::endl;
 
   // Finalise Histograms
   fMCFilled = true;
   this->ConvertEventRates();
 }
 
 void MeasurementBase::FillHistogramsFromBox(MeasurementVariableBox* var,
                                             double weight) {
   fXVar = var->GetX();
   fYVar = var->GetY();
   fZVar = var->GetZ();
   Weight = weight;
   fEventVariables = var;
 
   FillHistograms();
   FillExtraHistograms(var, weight);
 }
 
 void MeasurementBase::FillHistograms(double weight) {
   Weight = weight * GetBox()->GetSampleWeight();
   FillHistograms();
   FillExtraHistograms(GetBox(), Weight);
 }
 
 MeasurementVariableBox* MeasurementBase::FillVariableBox(FitEvent* event) {
   GetBox()->Reset();
   Mode = event->Mode;
   Weight = 1.0;  // event->Weight;
 
   this->FillEventVariables(event);
   Signal = this->isSignal(event);
 
   GetBox()->FillBoxFromEvent(event);
 
   GetBox()->SetX(fXVar);
   GetBox()->SetY(fYVar);
   GetBox()->SetZ(fZVar);
   GetBox()->SetMode(event->Mode);
   GetBox()->SetSampleWeight(Weight);
   // GetBox()->fSignal = Signal;
 
   return GetBox();
 }
 
 MeasurementVariableBox* MeasurementBase::GetBox() {
   if (!fEventVariables) fEventVariables = CreateBox();
   return fEventVariables;
 }
 
 //***********************************************
 void MeasurementBase::ReconfigureFast() {
   //***********************************************
   this->Reconfigure();
 }
 
 //***********************************************
 void MeasurementBase::ConvertEventRates() {
   //***********************************************
 
   AutoScaleExtraTH1();
   ScaleExtraHistograms(GetBox());
   this->ScaleEvents();
 
   double normval = fRW->GetSampleNorm(this->fName);
   if (normval < 0.01 or normval > 10.0) {
     ERR(WRN)
         << "Norm Value inside MeasurementBase::ConvertEventRates() looks off!"
         << std::endl;
     ERR(WRN) << "It could have become out of sync with the minimizer norm list."
              << std::endl;
     ERR(WRN) << "Setting it to 1.0" << std::endl;
     normval = 1.0;
   }
   AutoNormExtraTH1(normval);
   NormExtraHistograms(GetBox(), normval);
   this->ApplyNormScale(normval);
 }
 
 //***********************************************
 InputHandlerBase* MeasurementBase::GetInput() {
   //***********************************************
 
   if (!fInput) {
     ERR(FTL) << "MeasurementBase::fInput not set. Please submit your command "
                 "line options and input cardfile with a bug report to: "
                 "nuisance@projects.hepforge.org"
              << std::endl;
     throw;
   }
   return fInput;
 };
 
 //***********************************************
 void MeasurementBase::Renormalise() {
   //***********************************************
 
   // Called when the fitter has changed a measurements normalisation but not any
   // reweight dials
   // Means we don't have to call the time consuming reconfigure when this
   // happens.
   double norm = fRW->GetDialValue(this->fName + "_norm");
 
   if ((this->fCurrentNorm == 0.0 and norm != 0.0) or not fMCFilled) {
     this->ReconfigureFast();
     return;
   }
 
   if (this->fCurrentNorm == norm) return;
 
   this->ApplyNormScale(1.0 / this->fCurrentNorm);
   this->ApplyNormScale(norm);
 
   return;
 };
 
 //***********************************************
 void MeasurementBase::SetSignal(bool sig) {
   //***********************************************
   Signal = sig;
 }
 
 //***********************************************
 void MeasurementBase::SetSignal(FitEvent* evt) {
   //***********************************************
   Signal = this->isSignal(evt);
 }
 
 //***********************************************
 void MeasurementBase::SetWeight(double wght) {
   //***********************************************
   Weight = wght;
 }
 
 //***********************************************
 void MeasurementBase::SetMode(int md) {
   //***********************************************
   Mode = md;
 }
 
 //***********************************************
 std::vector<TH1*> MeasurementBase::GetFluxList() {
   //***********************************************
   return GetInput()->GetFluxList();
 }
 
 //***********************************************
 std::vector<TH1*> MeasurementBase::GetEventRateList() {
   //***********************************************
   return GetInput()->GetEventList();
 }
 
 //***********************************************
 std::vector<TH1*> MeasurementBase::GetXSecList() {
   //***********************************************
   return GetInput()->GetXSecList();
 }
 
 void MeasurementBase::ProcessExtraHistograms(int cmd,
                                              MeasurementVariableBox* vars,
                                              double weight) {
   // This should be overriden if we have extra histograms!!!
   // Add a flag to tell user this...
   return;
 }
 
 void MeasurementBase::FillExtraHistograms(MeasurementVariableBox* vars,
                                           double weight) {
   ProcessExtraHistograms(kCMD_Fill, vars, weight);
 }
 
 void MeasurementBase::ScaleExtraHistograms(MeasurementVariableBox* vars) {
   ProcessExtraHistograms(kCMD_Scale, vars, 1.0);
 }
 void MeasurementBase::ResetExtraHistograms() {
   ProcessExtraHistograms(kCMD_Reset, NULL, 1.0);
 }
 void MeasurementBase::NormExtraHistograms(MeasurementVariableBox* vars,
                                           double norm) {
   ProcessExtraHistograms(kCMD_Norm, vars, norm);
 }
 void MeasurementBase::WriteExtraHistograms() {
   ProcessExtraHistograms(kCMD_Write, NULL, 1.00);
 }
 
 void MeasurementBase::SetAutoProcessTH1(TH1* hist, int c1, int c2, int c3,
                                         int c4, int c5) {
   FakeStack* fake = new FakeStack(hist);
   SetAutoProcessTH1(fake, c1, c2, c3, c4,
                     c5);  // Need to add a destroy command!
 }
 
 void MeasurementBase::SetAutoProcess(TH1* hist, int c1, int c2, int c3, int c4,
                                      int c5) {
   FakeStack* fake = new FakeStack(hist);
   SetAutoProcessTH1(fake, c1, c2, c3, c4,
                     c5);  // Need to add a destroy command!
 }
 
 void MeasurementBase::SetAutoProcess(TGraph* g, int c1, int c2, int c3, int c4,
                                      int c5) {
   FakeStack* fake = new FakeStack(g);
   SetAutoProcessTH1(fake, c1, c2, c3, c4,
                     c5);  // Need to add a destroy command!
 }
 
 void MeasurementBase::SetAutoProcess(TF1* f, int c1, int c2, int c3, int c4,
                                      int c5) {
   FakeStack* fake = new FakeStack(f);
   SetAutoProcessTH1(fake, c1, c2, c3, c4,
                     c5);  // Need to add a destroy command!
 }
 
 void MeasurementBase::SetAutoProcess(StackBase* hist, int c1, int c2, int c3,
                                      int c4, int c5) {
   SetAutoProcessTH1(hist, c1, c2, c3, c4, c5);
 }
 
 void MeasurementBase::SetAutoProcessTH1(StackBase* hist, int c1, int c2, int c3,
                                         int c4, int c5) {
   // Set Defaults
   // int ncommands = kCMD_extraplotflags;
   int givenflags[5];
   givenflags[0] = c1;
   givenflags[1] = c2;
   givenflags[2] = c3;
   givenflags[3] = c4;
   givenflags[4] = c5;
   fExtraTH1s[hist] = std::vector<int>(5, 0);
 
   // Setup a default one.
   if (c1 == -1 && c2 == -1 && c3 == -1 && c4 == -1 && c5 == -1) {
     fExtraTH1s[hist][kCMD_Reset] = 1;
     fExtraTH1s[hist][kCMD_Scale] = 1;
     fExtraTH1s[hist][kCMD_Norm] = 1;
     fExtraTH1s[hist][kCMD_Write] = 1;
   }
 
   for (int i = 0; i < 5; i++) {
     switch (givenflags[i]) {
       // Skip over...
       case -1:
         break;
 
       case kCMD_Reset:
       case kCMD_Scale:
       case kCMD_Norm:
       case kCMD_Write:
         fExtraTH1s[hist][givenflags[i]] = 1;
         break;
 
       case kCMD_Fill:
         ERR(FTL) << "Can't auto fill yet!" << std::endl;
         break;
 
       default:
         break;
     }
   }
 
   // LOG(SAM) << "AutoProcessing " << hist->GetName() << std::endl;
 };
 
 void MeasurementBase::AutoFillExtraTH1() {
   ERR(FTL) << "Can't auto fill yet! it's too inefficent!" << std::endl;
   return;
 }
 
 void MeasurementBase::AutoResetExtraTH1() {
   for (std::map<StackBase*, std::vector<int> >::iterator iter =
            fExtraTH1s.begin();
        iter != fExtraTH1s.end(); iter++) {
     if (!((*iter).second)[kCMD_Reset]) continue;
     (*iter).first->Reset();
   }
 };
 
 void MeasurementBase::AutoScaleExtraTH1() {
   for (std::map<StackBase*, std::vector<int> >::iterator iter =
            fExtraTH1s.begin();
        iter != fExtraTH1s.end(); iter++) {
     if (!((*iter).second)[kCMD_Scale]) continue;
     if (fIsNoWidth) {
       (*iter).first->Scale(fScaleFactor);
     } else {
       (*iter).first->Scale(fScaleFactor, "width");
     }
   }
 };
 
 void MeasurementBase::AutoNormExtraTH1(double norm) {
   double sfactor = 0.0;
   if (norm != 0.0) sfactor = 1.0 / norm;
 
   for (std::map<StackBase*, std::vector<int> >::iterator iter =
            fExtraTH1s.begin();
        iter != fExtraTH1s.end(); iter++) {
     if (!((*iter).second)[kCMD_Norm]) continue;
     (*iter).first->Scale(sfactor);
   }
 };
 
 void MeasurementBase::AutoWriteExtraTH1() {
   for (std::map<StackBase*, std::vector<int> >::iterator iter =
            fExtraTH1s.begin();
        iter != fExtraTH1s.end(); iter++) {
     if (!(((*iter).second)[kCMD_Write])) continue;
     (*iter).first->Write();
   }
 };
diff --git a/src/Reweight/FitWeight.cxx b/src/Reweight/FitWeight.cxx
index 2794e7a..8fced3f 100644
--- a/src/Reweight/FitWeight.cxx
+++ b/src/Reweight/FitWeight.cxx
@@ -1,288 +1,292 @@
 #include "FitWeight.h"
 
 #include "GENIEWeightEngine.h"
 #include "LikelihoodWeightEngine.h"
 #include "ModeNormEngine.h"
 #include "NEUTWeightEngine.h"
 #include "NIWGWeightEngine.h"
 #include "NUISANCEWeightEngine.h"
 #include "NuWroWeightEngine.h"
 #include "OscWeightEngine.h"
 #include "SampleNormEngine.h"
 #include "SplineWeightEngine.h"
 #include "T2KWeightEngine.h"
 
 #ifdef __NOVA_ENABLED__
 #include "NOvARwgtEngine.h"
 #endif
 
 void FitWeight::AddRWEngine(int type) {
   LOG(FIT) << "Adding reweight engine " << type << std::endl;
   switch (type) {
   case kNEUT:
     fAllRW[type] = new NEUTWeightEngine("neutrw");
     break;
 
   case kNUWRO:
     fAllRW[type] = new NuWroWeightEngine("nuwrorw");
     break;
 
   case kGENIE:
     fAllRW[type] = new GENIEWeightEngine("genierw");
     break;
 
   case kNORM:
     fAllRW[type] = new SampleNormEngine("normrw");
     break;
 
   case kLIKEWEIGHT:
     fAllRW[type] = new LikelihoodWeightEngine("likerw");
     break;
 
   case kT2K:
     fAllRW[type] = new T2KWeightEngine("t2krw");
     break;
 
   case kCUSTOM:
     fAllRW[type] = new NUISANCEWeightEngine("nuisrw");
     break;
 
   case kSPLINEPARAMETER:
     fAllRW[type] = new SplineWeightEngine("splinerw");
     break;
 
   case kNIWG:
     fAllRW[type] = new NIWGWeightEngine("niwgrw");
     break;
   case kOSCILLATION:
     fAllRW[type] = new OscWeightEngine();
     break;
   case kMODENORM:
     fAllRW[type] = new ModeNormEngine();
     break;
 #ifdef __NOVA_ENABLED__
   case kNOvARWGT:
     fAllRW[type] = new NOvARwgtEngine();
     break;
 #endif
   default:
     THROW("CANNOT ADD RW Engine for unknown dial type: " << type);
     break;
   }
 }
 
 WeightEngineBase *FitWeight::GetRWEngine(int type) {
   if (HasRWEngine(type)) {
     return fAllRW[type];
   }
   THROW("CANNOT get RW Engine for dial type: " << type);
 }
 
 bool FitWeight::HasRWEngine(int type) {
   switch (type) {
   case kNEUT:
   case kNUWRO:
   case kGENIE:
   case kNORM:
   case kLIKEWEIGHT:
   case kT2K:
   case kCUSTOM:
   case kSPLINEPARAMETER:
   case kNIWG:
   case kOSCILLATION:
 #ifdef __NOVA_ENABLED__
   case kNOvARWGT: {
     return fAllRW.count(type);
   }
 #endif
   default: { THROW("CANNOT get RW Engine for dial type: " << type); }
   }
 }
 
 void FitWeight::IncludeDial(std::string name, std::string type, double val) {
   // Should register the dial here.
   int typeenum = Reweight::ConvDialType(type);
   IncludeDial(name, typeenum, val);
 }
 
 void FitWeight::IncludeDial(std::string name, int dialtype, double val) {
   // Get the dial enum
   int nuisenum = Reweight::ConvDial(name, dialtype);
 
   if (nuisenum == -1) {
-    THROW("NUISENUM == " << nuisenum << " for " << name);
+    ERR(FTL) << "Could not include dial " << name << std::endl;
+    ERR(FTL) << "With dialtype: " << dialtype << std::endl;
+    ERR(FTL) << "With value: " << val << std::endl;
+    THROW("With nuisenum: " << nuisenum);
   }
 
   // Setup RW Engine Pointer
   if (fAllRW.find(dialtype) == fAllRW.end()) {
     AddRWEngine(dialtype);
   }
   WeightEngineBase *rw = fAllRW[dialtype];
 
   // Include the dial
   rw->IncludeDial(name, val);
 
   // Set Dial Value
   if (val != -9999.9) {
     rw->SetDialValue(name, val);
   }
 
   // Sort Maps
   fAllEnums[name] = nuisenum;
   fAllValues[nuisenum] = val;
 
   // Sort Lists
   fNameList.push_back(name);
   fEnumList.push_back(nuisenum);
   fValueList.push_back(val);
 }
 
 void FitWeight::Reconfigure(bool silent) {
   // Reconfigure all added RW engines
   for (std::map<int, WeightEngineBase *>::iterator iter = fAllRW.begin();
        iter != fAllRW.end(); iter++) {
     (*iter).second->Reconfigure(silent);
   }
 }
 
 void FitWeight::SetDialValue(std::string name, double val) {
   // Add extra check, if name not found look for one with name in it.
   int nuisenum = fAllEnums[name];
   SetDialValue(nuisenum, val);
 }
 
 // Allow for name aswell using GlobalList to determine sample name.
 void FitWeight::SetDialValue(int nuisenum, double val) {
   // Conv dial type
   int dialtype = Reweight::GetDialType(nuisenum);
 
   if (fAllRW.find(dialtype) == fAllRW.end()) {
-    THROW("Cannot find RW Engine for dialtype = "
-          << dialtype << ", " << Reweight::RemoveDialType(nuisenum));
+    ERR(FTL) << "Can't find RW engine for parameter " << fNameList[dialtype] << std::endl;
+    ERR(FTL) << "With dialtype " << dialtype << ", " << Reweight::RemoveDialType(nuisenum) << std::endl;
+    THROW("Are you sure you enabled the right engines?");
   }
 
   // Get RW Engine for this dial
   fAllRW[dialtype]->SetDialValue(nuisenum, val);
   fAllValues[nuisenum] = val;
 
   // Update ValueList
   for (size_t i = 0; i < fEnumList.size(); i++) {
     if (fEnumList[i] == nuisenum) {
       fValueList[i] = val;
     }
   }
 }
 
 void FitWeight::SetAllDials(const double *x, int n) {
   for (size_t i = 0; i < (UInt_t)n; i++) {
     int rwenum = fEnumList[i];
     SetDialValue(rwenum, x[i]);
   }
   Reconfigure();
 }
 
 double FitWeight::GetDialValue(std::string name) {
   // Add extra check, if name not found look for one with name in it.
   int nuisenum = fAllEnums[name];
   return GetDialValue(nuisenum);
 }
 
 double FitWeight::GetDialValue(int nuisenum) { return fAllValues[nuisenum]; }
 
 int FitWeight::GetDialPos(std::string name) {
   int rwenum = fAllEnums[name];
   return GetDialPos(rwenum);
 }
 
 int FitWeight::GetDialPos(int nuisenum) {
   for (size_t i = 0; i < fEnumList.size(); i++) {
     if (fEnumList[i] == nuisenum) {
       return i;
     }
   }
   ERR(FTL) << "No Dial Found! " << std::endl;
   throw;
   return -1;
 }
 
 bool FitWeight::DialIncluded(std::string name) {
   return (fAllEnums.find(name) != fAllEnums.end());
 }
 
 bool FitWeight::DialIncluded(int rwenum) {
   return (fAllValues.find(rwenum) != fAllValues.end());
 }
 
 double FitWeight::CalcWeight(BaseFitEvt *evt) {
   double rwweight = 1.0;
   for (std::map<int, WeightEngineBase *>::iterator iter = fAllRW.begin();
        iter != fAllRW.end(); iter++) {
     double w = (*iter).second->CalcWeight(evt);
     rwweight *= w;
   }
   return rwweight;
 }
 
 void FitWeight::UpdateWeightEngine(const double *x) {
   size_t count = 0;
   for (std::vector<int>::iterator iter = fEnumList.begin();
        iter != fEnumList.end(); iter++) {
     SetDialValue((*iter), x[count]);
     count++;
   }
 }
 
 void FitWeight::GetAllDials(double *x, int n) {
   for (int i = 0; i < n; i++) {
     x[i] = GetDialValue(fEnumList[i]);
   }
 }
 
 // bool FitWeight::NeedsEventReWeight(const double* x) {
 //   bool haschange = false;
 //   size_t count = 0;
 
 //   // Compare old to new and decide if RW needed.
 //   for (std::vector<int>::iterator iter = fEnumList.begin();
 //        iter != fEnumList.end(); iter++) {
 //     int nuisenum = (*iter);
 //     int type = (nuisenum / 1000) - (nuisenum % 1000);
 
 //     // Compare old to new
 //     double oldval = GetDialValue(nuisenum);
 //     double newval = x[count];
 //     if (oldval != newval) {
 //       if (fAllRW[type]->NeedsEventReWeight()) {
 //         haschange = true;
 //       }
 //     }
 
 //     count++;
 //   }
 
 //   return haschange;
 // }
 
 double FitWeight::GetSampleNorm(std::string name) {
   if (name.empty())
     return 1.0;
 
   // Find norm dial
   if (fAllEnums.find(name + "_norm") != fAllEnums.end()) {
     if (fAllValues.find(fAllEnums[name + "_norm"]) != fAllValues.end()) {
       return fAllValues[fAllEnums[name + "_norm"]];
     } else {
       return 1.0;
     }
   } else {
     return 1.0;
   }
 }
 
 void FitWeight::Print() {
   LOG(REC) << "Fit Weight State: " << std::endl;
   for (size_t i = 0; i < fNameList.size(); i++) {
     LOG(REC) << " -> Par " << i << ". " << fNameList[i] << " " << fValueList[i]
              << std::endl;
   }
 }