diff --git a/cmake/GENIESetup.cmake b/cmake/GENIESetup.cmake
index 8bde310..fe49732 100644
--- a/cmake/GENIESetup.cmake
+++ b/cmake/GENIESetup.cmake
@@ -1,186 +1,186 @@
 # 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/>.
 ################################################################################
 
 # TODO
 # check system for libxml2
 # check whether we need the includes
 # check if we can use a subset of the GENIE libraries
 
 ################################################################################
 #                            Check Dependencies
 ################################################################################
 
 #################################  GENIE  ######################################
 if(GENIE STREQUAL "")
   cmessage(FATAL_ERROR "Variable GENIE is not defined. "
     "The location of a pre-built GENIE install must be defined either as"
     " $ cmake -DGENIE=/path/to/GENIE or as and environment vairable"
     " $ export GENIE=/path/to/GENIE")
 endif()
 
 if (BUILD_GEVGEN)
   cmessage(STATUS "Building custom gevgen")
   LIST(APPEND EXTRA_CXX_FLAGS -D__GEVGEN_ENABLED__)
 endif()
 
 if(GENIE_EMPMEC_REWEIGHT)
   cmessage(STATUS "Enable EMPMEC dials")
   LIST(APPEND EXTRA_CXX_FLAGS -D__GENIE_EMP_MECRW_ENABLED)
 endif()
 
 # Extract GENIE VERSION
 if (GENIE_VERSION STREQUAL "AUTO")
    execute_process (COMMAND ${CMAKE_SOURCE_DIR}/cmake/getgenieversion.sh ${GENIE}
    OUTPUT_VARIABLE GENIE_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
 endif()
 
 execute_process (COMMAND genie-config
   --libs OUTPUT_VARIABLE GENIE_LD_FLAGS_STR OUTPUT_STRIP_TRAILING_WHITESPACE)
 execute_process (COMMAND genie-config
   --topsrcdir OUTPUT_VARIABLE GENIE_INCLUDES_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 string(REGEX MATCH "-L\([^ ]+\) \(.*\)$" PARSE_GENIE_LIBS_MATCH ${GENIE_LD_FLAGS_STR})
 
 cmessage(DEBUG "genie-config --libs: ${GENIE_LD_FLAGS_STR}")
 
 if(NOT PARSE_GENIE_LIBS_MATCH)
   cmessage(FATAL_ERROR "Expected to be able to parse the result of genie-config --libs to a lib directory and a list of libraries to include, but got: \"${GENIE_LD_FLAGS_STR}\"")
 endif()
 
 set(GENIE_LIB_DIR ${CMAKE_MATCH_1})
 set(GENIE_LIBS_RAW ${CMAKE_MATCH_2})
 string(REPLACE "-l" "" GENIE_LIBS_STRIPED "${GENIE_LIBS_RAW}")
 
 cmessage(STATUS "GENIE version : ${GENIE_VERSION}")
 cmessage(STATUS "GENIE libdir  : ${GENIE_LIB_DIR}")
 cmessage(STATUS "GENIE libs    : ${GENIE_LIBS_STRIPED}")
 
 string(REGEX MATCH "ReinSeghal" WASMATCHED ${GENIE_LIBS_STRIPED})
 if(WASMATCHED AND GENIE_VERSION STREQUAL "210")
   set(GENIE_SEHGAL ${GENIE_LIBS_STRIPED})
   STRING(REPLACE "ReinSeghal" "ReinSehgal" GENIE_LIBS_STRIPED ${GENIE_SEHGAL})
   cmessage(DEBUG "Fixed inconsistency in library naming: ${GENIE_LIBS_STRIPED}")
 endif()
 
 string(REGEX MATCH "ReWeight" WASMATCHED ${GENIE_LIBS_STRIPED})
 if(NOT WASMATCHED)
   set(GENIE_LIBS_STRIPED "GReWeight ${GENIE_LIBS_STRIPED}")
   cmessage(DEBUG "Force added ReWeight library: ${GENIE_LIBS_STRIPED}")
 endif()
 
-string(REPLACE " " ";" GENIE_LIBS_LIST "-Wl,--start-group ${GENIE_LIBS_STRIPED} -Wl,--end-group")
+string(REPLACE " " ";" GENIE_LIBS_LIST "-Wl,--no-as-needed -Wl,--start-group ${GENIE_LIBS_STRIPED} -Wl,--end-group")
 cmessage(DEBUG "genie-config --libs -- MATCH1: ${CMAKE_MATCH_1}")
 cmessage(DEBUG "genie-config --libs -- MATCH2: ${CMAKE_MATCH_2}")
 cmessage(DEBUG "genie-config --libs -- libs stripped: ${GENIE_LIBS_STRIPED}")
 cmessage(DEBUG "genie-config --libs -- libs list: ${GENIE_LIBS_LIST}")
 
 ################################  LHAPDF  ######################################
 if(LHAPDF_LIB STREQUAL "")
   cmessage(FATAL_ERROR "Variable LHAPDF_LIB is not defined. The location of a pre-built lhapdf install must be defined either as $ cmake -DLHAPDF_LIB=/path/to/LHAPDF_libraries or as and environment vairable $ export LHAPDF_LIB=/path/to/LHAPDF_libraries")
 endif()
 
 if(LHAPDF_INC STREQUAL "")
   cmessage(FATAL_ERROR "Variable LHAPDF_INC is not defined. The location of a pre-built lhapdf install must be defined either as $ cmake -DLHAPDF_INC=/path/to/LHAPDF_includes or as and environment vairable $ export LHAPDF_INC=/path/to/LHAPDF_includes")
 endif()
 
 if(LHAPATH STREQUAL "")
   cmessage(FATAL_ERROR "Variable LHAPATH is not defined. The location of a the LHAPATH directory must be defined either as $ cmake -DLHAPATH=/path/to/LHAPATH or as and environment variable $ export LHAPATH=/path/to/LHAPATH")
 endif()
 
 ################################  LIBXML  ######################################
 if(LIBXML2_LIB STREQUAL "")
   # Check for xml2-config
   find_program(LIBXMLCFGLIBS xml2-config)
   if(NOT LIBXMLCFGLIBS STREQUAL "LIBXMLLIBS-NOTFOUND")
     execute_process (COMMAND ${LIBXMLCFGLIBS} --libs
       OUTPUT_VARIABLE LIBXML2_LIB OUTPUT_STRIP_TRAILING_WHITESPACE)
   else()
     message(FATAL_ERROR "Variable LIBXML2_LIB is not defined and could not find xml2-config. The location of a pre-built libxml2 install must be defined either as $ cmake -DLIBXML2_LIB=/path/to/LIBXML2_libraries or as and environment vairable $ export LIBXML2_LIB=/path/to/LIBXML2_libraries")
   endif()
 endif()
 
 if(LIBXML2_INC STREQUAL "")
   # Check for xml2-config
   find_program(LIBXMLCFGINCS xml2-config)
   if(NOT LIBXMLCFGINCS STREQUAL "LIBXMLINCS-NOTFOUND")
     execute_process (COMMAND ${LIBXMLCFGINCS} --cflags
       OUTPUT_VARIABLE LIBXML2_INC OUTPUT_STRIP_TRAILING_WHITESPACE)
   else()
     message(FATAL_ERROR "Variable LIBXML2_INC is not defined and could not find xml2-config. The location of a pre-built libxml2 install must be defined either as $ cmake -DLIBXML2_INC=/path/to/LIBXML2_libraries or as and environment vairable $ export LIBXML2_INC=/path/to/LIBXML2_libraries")
   endif()
 endif()
 
 ###############################  log4cpp  ######################################
 if(LOG4CPP_LIB STREQUAL "")
   find_program(LOG4CPPCFG log4cpp-config)
   if(NOT LOG4CPPCFG STREQUAL "LOG4CPPCFG-NOTFOUND")
     execute_process (COMMAND ${LOG4CPPCFG}
       --pkglibdir OUTPUT_VARIABLE LOG4CPP_LIB OUTPUT_STRIP_TRAILING_WHITESPACE)
   else()
     message(FATAL_ERROR "Variable LOG4CPP_LIB is not defined. The location of a pre-built log4cpp install must be defined either as $ cmake -DLOG4CPP_LIB=/path/to/LOG4CPP_libraries or as and environment vairable $ export LOG4CPP_LIB=/path/to/LOG4CPP_libraries")
   endif()
 endif()
 
 if(LOG4CPP_INC  STREQUAL "")
   find_program(LOG4CPPCFG log4cpp-config)
   if(NOT LOG4CPPCFG STREQUAL "LOG4CPPCFG-NOTFOUND")
     execute_process (COMMAND ${LOG4CPPCFG}
     --pkgincludedir OUTPUT_VARIABLE LOG4CPP_INC OUTPUT_STRIP_TRAILING_WHITESPACE)
   else()
     message(FATAL_ERROR "Variable LOG4CPP_INC is not defined. The location of a pre-built log4cpp install must be defined either as $ cmake -DGENIE_LOG4CPP_INC=/path/to/LOG4CPP_includes or as and environment vairable $ export LOG4CPP_INC=/path/to/LOG4CPP_includes")
   endif()
 endif()
 ################################################################################
 
 LIST(APPEND EXTRA_CXX_FLAGS -D__GENIE_ENABLED__ -D__GENIE_VERSION__=${GENIE_VERSION})
 
 LIST(APPEND RWENGINE_INCLUDE_DIRECTORIES
   ${GENIE_INCLUDES_DIR}
   ${GENIE_INCLUDES_DIR}/GHEP
   ${GENIE_INCLUDES_DIR}/Ntuple
   ${GENIE_INCLUDES_DIR}/ReWeight
   ${GENIE_INCLUDES_DIR}/Apps
   ${GENIE_INCLUDES_DIR}/FluxDrivers
   ${GENIE_INCLUDES_DIR}/EVGDrivers
   ${LHAPDF_INC}
   ${LIBXML2_INC}
   ${LOG4CPP_INC})
 
 SAYVARS()
 
 LIST(APPEND EXTRA_LINK_DIRS
   ${GENIE_LIB_DIR}
   ${LHAPDF_LIB}
   ${LIBXML2_LIB}
   ${LOG4CPP_LIB})
 
 LIST(APPEND EXTRA_LIBS ${GENIE_LIBS_LIST})
 
 LIST(APPEND EXTRA_LIBS LHAPDF xml2 log4cpp)
 
 if(USE_PYTHIA8)
   set(NEED_PYTHIA8 TRUE)
   set(NEED_ROOTPYTHIA8 TRUE)
 else()
   set(NEED_PYTHIA6 TRUE)
   set(NEED_ROOTPYTHIA6 TRUE)
 endif()
 set(NEED_ROOTEVEGEN TRUE)
 
 SET(USE_GENIE TRUE CACHE BOOL "Whether to enable GENIE (reweight) support. Requires external libraries. <FALSE>" FORCE)
diff --git a/cmake/c++CompilerSetup.cmake b/cmake/c++CompilerSetup.cmake
index 9b95a37..bc6b473 100644
--- a/cmake/c++CompilerSetup.cmake
+++ b/cmake/c++CompilerSetup.cmake
@@ -1,117 +1,121 @@
 # Copyright 2016 L. Pickering, P Stowell, R. Terri, C. Wilkinson, C. Wret
 
 ################################################################################
 #    This file is part of NUISANCE.
 #
 #    NUISANCE is free software: you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
 #    the Free Software Foundation, either version 3 of the License, or
 #    (at your option) any later version.
 #
 #    NUISANCE is distributed in the hope that it will be useful,
 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #    GNU General Public License for more details.
 #
 #    You should have received a copy of the GNU General Public License
 #    along with NUISANCE.  If not, see <http://www.gnu.org/licenses/>.
 ################################################################################
 
 if(USE_OMP)
   LIST(APPEND EXTRA_CXX_FLAGS -fopenmp)
 endif()
 
 if(USE_DYNSAMPLES)
   LIST(APPEND EXTRA_LIBS dl)
   LIST(APPEND EXTRA_CXX_FLAGS -D__USE_DYNSAMPLES__)
 endif()
 
 set(CXX_WARNINGS -Wall )
 
 cmessage(DEBUG "EXTRA_CXX_FLAGS: ${EXTRA_CXX_FLAGS}")
 string(REPLACE ";" " " STR_EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${STR_EXTRA_CXX_FLAGS} ${CXX_WARNINGS}")
   set(CMAKE_Fortran_FLAGS_RELEASE "-fPIC")
 
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")
 
 if(USE_DYNSAMPLES)
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fPIC")
   set(CMAKE_Fortran_FLAGS_DEBUG "-fPIC")
 endif()
 
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fPIC -O3")
 
 if(CMAKE_BUILD_TYPE MATCHES DEBUG)
   set(CURRENT_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_DEBUG})
 elseif(CMAKE_BUILD_TYPE MATCHES RELEASE)
   set(CURRENT_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_RELEASE})
 else()
   cmessage(FATAL_ERROR "[ERROR]: Unknown CMAKE_BUILD_TYPE (\"${CMAKE_BUILD_TYPE}\"): Should be \"DEBUG\" or \"RELEASE\".")
 endif()
 
 
 SET(STR_EXTRA_LINK_DIRS)
 if(NOT EXTRA_LINK_DIRS STREQUAL "")
   string(REPLACE ";" " -L" STR_EXTRA_LINK_DIRS "-L${EXTRA_LINK_DIRS}")
 endif()
 
 SET(STR_EXTRA_LIBS)
 if(NOT EXTRA_LIBS STREQUAL "")
   SET(STR_EXTRA_LIBS_NO_SCRUB_LINKOPTS)
   string(REPLACE ";" " -l" STR_EXTRA_LIBS_NO_SCRUB_LINKOPTS "-l${EXTRA_LIBS}")
   string(REPLACE "-l-" "-" STR_EXTRA_LIBS ${STR_EXTRA_LIBS_NO_SCRUB_LINKOPTS})
 endif()
 
 SET(STR_EXTRA_SHAREDOBJS)
 if(NOT EXTRA_SHAREDOBJS STREQUAL "")
   string(REPLACE ";" " " STR_EXTRA_SHAREDOBJS "${EXTRA_SHAREDOBJS}")
 endif()
 
 SET(STR_EXTRA_LINK_FLAGS)
 if(NOT EXTRA_LINK_FLAGS STREQUAL "")
   string(REPLACE ";" " " STR_EXTRA_LINK_FLAGS "${EXTRA_LINK_FLAGS}")
 endif()
 
 cmessage(DEBUG "EXTRA_LINK_DIRS: ${STR_EXTRA_LINK_DIRS}")
 cmessage(DEBUG "EXTRA_LIBS: ${STR_EXTRA_LIBS}")
 cmessage(DEBUG "EXTRA_SHAREDOBJS: ${STR_EXTRA_SHAREDOBJS}")
 cmessage(DEBUG "EXTRA_LINK_FLAGS: ${STR_EXTRA_LINK_FLAGS}")
 
 if(NOT STR_EXTRA_LINK_DIRS STREQUAL "" AND NOT STR_EXTRA_LIBS STREQUAL "")
   SET(CMAKE_DEPENDLIB_FLAGS "${STR_EXTRA_LINK_DIRS} ${STR_EXTRA_LIBS}")
 endif()
 
 if(NOT EXTRA_SHAREDOBJS STREQUAL "")
-  SET(CMAKE_DEPENDLIB_FLAGS "${CMAKE_DEPENDLIB_FLAGS} ${EXTRA_SHAREDOBJS}")
-endif()
-
-if(NOT EXTRA_SHAREDOBJS STREQUAL "")
   if(NOT STR_EXTRA_LINK_FLAGS STREQUAL "")
     SET(STR_EXTRA_LINK_FLAGS "${STR_EXTRA_SHAREDOBJS} ${STR_EXTRA_LINK_FLAGS}")
   else()
     SET(STR_EXTRA_LINK_FLAGS "${STR_EXTRA_SHAREDOBJS}")
   endif()
 endif()
 
 if(NOT EXTRA_LINK_FLAGS STREQUAL "")
   if(NOT CMAKE_LINK_FLAGS STREQUAL "")
     SET(CMAKE_LINK_FLAGS "${CMAKE_LINK_FLAGS} ${STR_EXTRA_LINK_FLAGS}")
   else()
     SET(CMAKE_LINK_FLAGS "${STR_EXTRA_LINK_FLAGS}")
   endif()
 endif()
 
 if(USE_OMP)
   cmessage(FATAL_ERROR "No OMP features currently enabled so this is a FATAL_ERROR to let you know that you don't gain anything with this declaration.")
 endif()
 
 
+
+string(STRIP ${CMAKE_CXX_FLAGS} CMAKE_CXX_FLAGS)
+string(STRIP ${CMAKE_CXX_FLAGS_RELEASE} CMAKE_CXX_FLAGS_RELEASE)
+string(STRIP ${CMAKE_CXX_FLAGS_DEBUG} CMAKE_CXX_FLAGS_DEBUG)
+
+string(STRIP ${CMAKE_LINK_FLAGS} CMAKE_LINK_FLAGS)
+string(STRIP ${CMAKE_DEPENDLIB_FLAGS} CMAKE_DEPENDLIB_FLAGS)
+
 if (VERBOSE)
   cmessage (STATUS "C++ Compiler      : ${CXX_COMPILER_NAME}")
   cmessage (STATUS "    flags         : ${CMAKE_CXX_FLAGS}")
   cmessage (STATUS "    Release flags : ${CMAKE_CXX_FLAGS_RELEASE}")
   cmessage (STATUS "    Debug flags   : ${CMAKE_CXX_FLAGS_DEBUG}")
   cmessage (STATUS "    Link Flags    : ${CMAKE_LINK_FLAGS}")
   cmessage (STATUS "    Lib Flags     : ${CMAKE_DEPENDLIB_FLAGS}")
 endif()
diff --git a/src/InputHandler/NEUTInputHandler.cxx b/src/InputHandler/NEUTInputHandler.cxx
index 8e3d5a2..7df81d1 100644
--- a/src/InputHandler/NEUTInputHandler.cxx
+++ b/src/InputHandler/NEUTInputHandler.cxx
@@ -1,499 +1,503 @@
 #ifdef __NEUT_ENABLED__
 #include "NEUTInputHandler.h"
 #include "InputUtils.h"
 
 
 NEUTGeneratorInfo::~NEUTGeneratorInfo() { DeallocateParticleStack(); }
 
 void NEUTGeneratorInfo::AddBranchesToTree(TTree* tn) {
   tn->Branch("NEUTParticleN", fNEUTParticleN, "NEUTParticleN/I");
   tn->Branch("NEUTParticleStatusCode", fNEUTParticleStatusCode,
              "NEUTParticleStatusCode[NEUTParticleN]/I");
   tn->Branch("NEUTParticleAliveCode", fNEUTParticleAliveCode,
              "NEUTParticleAliveCode[NEUTParticleN]/I");
 }
 
 void NEUTGeneratorInfo::SetBranchesFromTree(TTree* tn) {
   tn->SetBranchAddress("NEUTParticleN", &fNEUTParticleN);
   tn->SetBranchAddress("NEUTParticleStatusCode", &fNEUTParticleStatusCode);
   tn->SetBranchAddress("NEUTParticleAliveCode", &fNEUTParticleAliveCode);
 }
 
 void NEUTGeneratorInfo::AllocateParticleStack(int stacksize) {
   fNEUTParticleN = 0;
   fNEUTParticleStatusCode = new int[stacksize];
   fNEUTParticleStatusCode = new int[stacksize];
 }
 
 void NEUTGeneratorInfo::DeallocateParticleStack() {
   delete fNEUTParticleStatusCode;
   delete fNEUTParticleAliveCode;
 }
 
 void NEUTGeneratorInfo::FillGeneratorInfo(NeutVect* nevent) {
   Reset();
   for (int i = 0; i < nevent->Npart(); i++) {
     fNEUTParticleStatusCode[i] = nevent->PartInfo(i)->fStatus;
     fNEUTParticleAliveCode[i] = nevent->PartInfo(i)->fIsAlive;
     fNEUTParticleN++;
   }
 }
 
 void NEUTGeneratorInfo::Reset() {
   for (int i = 0; i < fNEUTParticleN; i++) {
     fNEUTParticleStatusCode[i] = -1;
     fNEUTParticleAliveCode[i] = 9;
   }
   fNEUTParticleN = 0;
 }
 
 NEUTInputHandler::NEUTInputHandler(std::string const& handle,
                                    std::string const& rawinputs) {
   LOG(SAM) << "Creating NEUTInputHandler : " << handle << std::endl;
 
   // Run a joint input handling
   fName = handle;
 
   // Setup the TChain
   fNEUTTree = new TChain("neuttree");
   fSaveExtra = FitPar::Config().GetParB("SaveExtraNEUT");
   fCacheSize = FitPar::Config().GetParI("CacheSize");
   fMaxEvents = FitPar::Config().GetParI("MAXEVENTS");
 
   // Loop over all inputs and grab flux, eventhist, and nevents
   std::vector<std::string> inputs = InputUtils::ParseInputFileList(rawinputs);
   for (size_t inp_it = 0; inp_it < inputs.size(); ++inp_it) {
     // Open File for histogram access
     TFile* inp_file = new TFile(inputs[inp_it].c_str(), "READ");
     if (!inp_file or inp_file->IsZombie()) {
       THROW("NEUT File IsZombie() at : '"
             << inputs[inp_it] << "'" << std::endl
             << "Check that your file paths are correct and the file exists!"
             << std::endl
             << "$ ls -lh " << inputs[inp_it]);
     }
 
     // Get Flux/Event hist
     TH1D* fluxhist = (TH1D*)inp_file->Get(
         (PlotUtils::GetObjectWithName(inp_file, "flux")).c_str());
     TH1D* eventhist = (TH1D*)inp_file->Get(
         (PlotUtils::GetObjectWithName(inp_file, "evt")).c_str());
     if (!fluxhist or !eventhist) {
       ERROR(FTL, "Input File Contents: " << inputs[inp_it]);
       inp_file->ls();
       THROW(
           "NEUT FILE doesn't contain flux/xsec info. You may have to "
           "regenerate your MC!");
     }
 
     // Get N Events
     TTree* neuttree = (TTree*)inp_file->Get("neuttree");
     if (!neuttree) {
       ERROR(FTL, "neuttree not located in NEUT file: " << inputs[inp_it]);
       THROW("Check your inputs, they may need to be completely regenerated!");
       throw;
     }
     int nevents = neuttree->GetEntries();
     if (nevents <= 0) {
       THROW("Trying to a TTree with "
             << nevents << " to TChain from : " << inputs[inp_it]);
     }
 
     // Register input to form flux/event rate hists
     RegisterJointInput(inputs[inp_it], nevents, fluxhist, eventhist);
 
     // Add To TChain
     fNEUTTree->AddFile(inputs[inp_it].c_str());
   }
 
   // Registor all our file inputs
   SetupJointInputs();
 
   // Assign to tree
   fEventType = kNEUT;
   fNeutVect = NULL;
   fNEUTTree->SetBranchAddress("vectorbranch", &fNeutVect);
   fNEUTTree->GetEntry(0);
 
   // Create Fit Event
   fNUISANCEEvent = new FitEvent();
   fNUISANCEEvent->SetNeutVect(fNeutVect);
 
   if (fSaveExtra) {
     fNeutInfo = new NEUTGeneratorInfo();
     fNUISANCEEvent->AddGeneratorInfo(fNeutInfo);
   }
 
   fNUISANCEEvent->HardReset();
 };
 
 NEUTInputHandler::~NEUTInputHandler(){
     //  if (fNEUTTree) delete fNEUTTree;
     //  if (fNeutVect) delete fNeutVect;
     //  if (fNeutInfo) delete fNeutInfo;
 };
 
 void NEUTInputHandler::CreateCache() {
   if (fCacheSize > 0) {
     // fNEUTTree->SetCacheEntryRange(0, fNEvents);
     fNEUTTree->AddBranchToCache("vectorbranch", 1);
     fNEUTTree->SetCacheSize(fCacheSize);
   }
 }
 
 void NEUTInputHandler::RemoveCache() {
   // fNEUTTree->SetCacheEntryRange(0, fNEvents);
   fNEUTTree->AddBranchToCache("vectorbranch", 0);
   fNEUTTree->SetCacheSize(0);
 }
 
 FitEvent* NEUTInputHandler::GetNuisanceEvent(const UInt_t entry,
                                              const bool lightweight) {
   // Catch too large entries
   if (entry >= (UInt_t)fNEvents) return NULL;
 
   // Read Entry from TTree to fill NEUT Vect in BaseFitEvt;
   fNEUTTree->GetEntry(entry);
 
   // Run NUISANCE Vector Filler
   if (!lightweight) {
     CalcNUISANCEKinematics();
   }
 #ifdef __PROB3PP_ENABLED__
   else {
 
     UInt_t npart = fNeutVect->Npart();
     for (size_t i = 0; i < npart; i++) {
       NeutPart* part = fNUISANCEEvent->fNeutVect->PartInfo(i);
       if ((part->fIsAlive == false) && (part->fStatus == -1) &&
           std::count(PhysConst::pdg_neutrinos, PhysConst::pdg_neutrinos + 4,
                      part->fPID)) {
         fNUISANCEEvent->probe_E = part->fP.T();
         fNUISANCEEvent->probe_pdg = part->fPID;
         break;
       } else {
         continue;
       }
     }
   }
 #endif
 
   // Setup Input scaling for joint inputs
   fNUISANCEEvent->InputWeight = GetInputWeight(entry);
 
   // Return event pointer
   return fNUISANCEEvent;
 }
 
 // From NEUT neutclass/neutpart.h
 //          Bool_t         fIsAlive; // Particle should be tracked or not
 //                          ( in the detector simulator )
 //
 //         Int_t          fStatus;  // Status flag of this particle
 //                            -2: Non existing particle
 //                            -1: Initial state particle
 //                             0: Normal
 //                             1: Decayed to the other particle
 //                             2: Escaped from the detector
 //                             3: Absorped
 //                             4: Charge exchanged
 //                             5: Pauli blocked
 //                             6: N/A
 //                             7: Produced child particles
 //                             8: Inelastically scattered
 //
 int NEUTInputHandler::GetNeutParticleStatus(NeutPart* part) {
   // State
   int state = kUndefinedState;
 
   // Remove Pauli blocked events, probably just single pion events
   if (part->fStatus == 5) {
     state = kFSIState;
 
   // fStatus == -1 means initial  state
   } else if (part->fIsAlive == false && part->fStatus == -1) {
     state = kInitialState;
 
     // NEUT has a bit of a strange convention for fIsAlive and fStatus
     // combinations
     // for NC and neutrino particle isAlive true/false and status 2 means
     // final state particle
     // for other particles in NC status 2 means it's an FSI particle
     // for CC it means it was an FSI particle
   } else if (part->fStatus == 2) {
     // NC case is a little strange... The outgoing neutrino might be alive or
     // not alive. Remaining particles with status 2 are FSI particles that
     // reinteracted
     if (abs(fNeutVect->Mode) > 30 &&
         (abs(part->fPID) == 16 || abs(part->fPID) == 14 || abs(part->fPID) == 12)) {
       state = kFinalState;
       // The usual CC case
     } else if (part->fIsAlive == true) {
       state = kFSIState;
     }
 
   } else if (part->fIsAlive == true && part->fStatus == 2 &&
       (abs(part->fPID) == 16 || abs(part->fPID) == 14 || abs(part->fPID) == 12)) {
         state = kFinalState;
 
   } else if (part->fIsAlive == true && part->fStatus == 0) {
     state = kFinalState;
 
   } else if (!part->fIsAlive && (part->fStatus == 1 || part->fStatus == 3 || part->fStatus == 4 || part->fStatus == 7 || part->fStatus == 8)) {
     state = kFSIState;
 
     // There's one hyper weird case where fStatus = -3. This apparently corresponds to a nucleon being ejected via pion FSI when there is "data available"
   } else if (!part->fIsAlive && (part->fStatus == -3)) {
     state = kUndefinedState;
     // NC neutrino outgoing
   } else if (!part->fIsAlive && part->fStatus == 0 && (abs(part->fPID) == 16 || abs(part->fPID) == 14 || abs(part->fPID) == 12)) {
     state = kFinalState;
 
   // Warn if we still find alive particles without classifying them
   } else if (part->fIsAlive == true) {
     ERR(WRN) << "Undefined NEUT state "
       << " Alive: " << part->fIsAlive << " Status: " << part->fStatus
       << " PDG: " << part->fPID << std::endl;
     throw;
     // Warn if we find dead particles that we haven't classified
   } else {
     ERR(WRN) << "Undefined NEUT state "
       << " Alive: " << part->fIsAlive << " Status: " << part->fStatus
       << " PDG: " << part->fPID << std::endl;
     throw;
   }
 
 
   return state;
 }
 
 void NEUTInputHandler::CalcNUISANCEKinematics() {
   // Reset all variables
   fNUISANCEEvent->ResetEvent();
 
   // Fill Globals
   fNUISANCEEvent->Mode = fNeutVect->Mode;
   fNUISANCEEvent->fEventNo = fNeutVect->EventNo;
   fNUISANCEEvent->fTargetA = fNeutVect->TargetA;
   fNUISANCEEvent->fTargetZ = fNeutVect->TargetZ;
   fNUISANCEEvent->fTargetH = fNeutVect->TargetH;
   fNUISANCEEvent->fBound = bool(fNeutVect->Ibound);
 
   if (fNUISANCEEvent->fBound) {
     fNUISANCEEvent->fTargetPDG = TargetUtils::GetTargetPDGFromZA(
         fNUISANCEEvent->fTargetZ, fNUISANCEEvent->fTargetA);
   } else {
     fNUISANCEEvent->fTargetPDG = 1000010010;
   }
 
   // Check Particle Stack
   UInt_t npart = fNeutVect->Npart();
   UInt_t kmax = fNUISANCEEvent->kMaxParticles;
   if (npart > kmax) {
     ERR(FTL) << "NEUT has too many particles. Expanding stack." << std::endl;
     fNUISANCEEvent->ExpandParticleStack(npart);
     throw;
   }
 
   // Fill Particle Stack
   for (size_t i = 0; i < npart; i++) {
     // Get Current Count
     int curpart = fNUISANCEEvent->fNParticles;
 
     // Get NEUT Particle
     NeutPart* part = fNeutVect->PartInfo(i);
 
     // State
     int state = GetNeutParticleStatus(part);
 
     // Remove Undefined
     if (kRemoveUndefParticles && state == kUndefinedState) continue;
 
     // Remove FSI
     if (kRemoveFSIParticles && state == kFSIState) continue;
 
     // Remove Nuclear
     if (kRemoveNuclearParticles &&
         (state == kNuclearInitial || state == kNuclearRemnant))
       continue;
 
     // State
     fNUISANCEEvent->fParticleState[curpart] = state;
 
     // Mom
     fNUISANCEEvent->fParticleMom[curpart][0] = part->fP.X();
     fNUISANCEEvent->fParticleMom[curpart][1] = part->fP.Y();
     fNUISANCEEvent->fParticleMom[curpart][2] = part->fP.Z();
     fNUISANCEEvent->fParticleMom[curpart][3] = part->fP.T();
 
     // PDG
     fNUISANCEEvent->fParticlePDG[curpart] = part->fPID;
 
     // Add up particle count
     fNUISANCEEvent->fNParticles++;
   }
 
   // Save Extra Generator Info
   if (fSaveExtra) {
     fNeutInfo->FillGeneratorInfo(fNeutVect);
   }
 
   // Run Initial, FSI, Final, Other ordering.
   fNUISANCEEvent->OrderStack();
 
   FitParticle* ISNeutralLepton =
     fNUISANCEEvent->GetHMISParticle(PhysConst::pdg_neutrinos);
   if (ISNeutralLepton) {
     fNUISANCEEvent->probe_E = ISNeutralLepton->E();
     fNUISANCEEvent->probe_pdg = ISNeutralLepton->PDG();
   }
 
   return;
 }
 
 void NEUTUtils::FillNeutCommons(NeutVect* nvect) {
   // WARNING: This has only been implemented for a neuttree and not GENIE
   // This should be kept in sync with T2KNIWGUtils::GetNIWGEvent(TTree)
 
   // NEUT version info.  Can't get it to compile properly with this yet
   // neutversion_.corev  =   nvect->COREVer;
   // neutversion_.nucev  =   nvect->NUCEVer;
   // neutversion_.nuccv  =   nvect->NUCCVer;
 
   // Documentation: See nework.h
   nework_.modene = nvect->Mode;
   nework_.numne = nvect->Npart();
 
+#ifdef NEUT_COMMON_QEAV
+  nemdls_.mdlqeaf = nvect->QEAVForm;
+#else
   nemdls_.mdlqeaf = nvect->QEVForm;
+#endif
   nemdls_.mdlqe = nvect->QEModel;
   nemdls_.mdlspi = nvect->SPIModel;
   nemdls_.mdldis = nvect->DISModel;
   nemdls_.mdlcoh = nvect->COHModel;
   neutcoh_.necohepi = nvect->COHModel;
 
   nemdls_.xmaqe = nvect->QEMA;
   nemdls_.xmvqe = nvect->QEMV;
   nemdls_.kapp = nvect->KAPPA;
 
   // nemdls_.sccfv = SCCFVdef;
   // nemdls_.sccfa = SCCFAdef;
   // nemdls_.fpqe = FPQEdef;
 
   nemdls_.xmaspi = nvect->SPIMA;
   nemdls_.xmvspi = nvect->SPIMV;
   nemdls_.xmares = nvect->RESMA;
   nemdls_.xmvres = nvect->RESMV;
 
   neut1pi_.xmanffres = nvect->SPIMA;
   neut1pi_.xmvnffres = nvect->SPIMV;
   neut1pi_.xmarsres = nvect->RESMA;
   neut1pi_.xmvrsres = nvect->RESMV;
   neut1pi_.neiff = nvect->SPIForm;
   neut1pi_.nenrtype = nvect->SPINRType;
   neut1pi_.rneca5i = nvect->SPICA5I;
   neut1pi_.rnebgscl = nvect->SPIBGScale;
 
   nemdls_.xmacoh = nvect->COHMA;
   nemdls_.rad0nu = nvect->COHR0;
   // nemdls_.fa1coh = nvect->COHA1err;
   // nemdls_.fb1coh = nvect->COHb1err;
 
   // neutdis_.nepdf = NEPDFdef;
   // neutdis_.nebodek = NEBODEKdef;
 
   neutcard_.nefrmflg = nvect->FrmFlg;
   neutcard_.nepauflg = nvect->PauFlg;
   neutcard_.nenefo16 = nvect->NefO16;
   neutcard_.nemodflg = nvect->ModFlg;
   // neutcard_.nenefmodl = 1;
   // neutcard_.nenefmodh = 1;
   // neutcard_.nenefkinh = 1;
   // neutpiabs_.neabspiemit = 1;
 
   nenupr_.iformlen = nvect->FormLen;
 
   neutpiless_.ipilessdcy = nvect->IPilessDcy;
   neutpiless_.rpilessdcy = nvect->RPilessDcy;
 
   neutpiless_.ipilessdcy = nvect->IPilessDcy;
   neutpiless_.rpilessdcy = nvect->RPilessDcy;
 
   neffpr_.fefqe = nvect->NuceffFactorPIQE;
   neffpr_.fefqeh = nvect->NuceffFactorPIQEH;
   neffpr_.fefinel = nvect->NuceffFactorPIInel;
   neffpr_.fefabs = nvect->NuceffFactorPIAbs;
   neffpr_.fefcx = nvect->NuceffFactorPICX;
   neffpr_.fefcxh = nvect->NuceffFactorPICXH;
 
   neffpr_.fefcoh = nvect->NuceffFactorPICoh;
   neffpr_.fefqehf = nvect->NuceffFactorPIQEHKin;
   neffpr_.fefcxhf = nvect->NuceffFactorPICXKin;
   neffpr_.fefcohf = nvect->NuceffFactorPIQELKin;
 
   for (int i = 0; i < nework_.numne; i++) {
     nework_.ipne[i] = nvect->PartInfo(i)->fPID;
     nework_.pne[i][0] =
       (float)nvect->PartInfo(i)->fP.X() / 1000;  // VC(NE)WORK in M(G)eV
     nework_.pne[i][1] =
       (float)nvect->PartInfo(i)->fP.Y() / 1000;  // VC(NE)WORK in M(G)eV
     nework_.pne[i][2] =
       (float)nvect->PartInfo(i)->fP.Z() / 1000;  // VC(NE)WORK in M(G)eV
   }
   // fsihist.h
 
   // neutroot fills a dummy object for events with no FSI to prevent memory leak
   // when
   // reading the TTree, so check for it here
 
   if ((int)nvect->NfsiVert() ==
       1) {  // An event with FSI must have at least two vertices
     //    if (nvect->NfsiPart()!=1 || nvect->Fsiprob!=-1)
     //      ERR(WRN) << "T2KNeutUtils::fill_neut_commons(TTree) NfsiPart!=1 or
     //      Fsiprob!=-1 when NfsiVert==1" << std::endl;
 
     fsihist_.nvert = 0;
     fsihist_.nvcvert = 0;
     fsihist_.fsiprob = 1;
   } else {  // Real FSI event
     fsihist_.nvert = (int)nvect->NfsiVert();
     for (int ivert = 0; ivert < fsihist_.nvert; ivert++) {
       fsihist_.iflgvert[ivert] = nvect->FsiVertInfo(ivert)->fVertID;
       fsihist_.posvert[ivert][0] = (float)nvect->FsiVertInfo(ivert)->fPos.X();
       fsihist_.posvert[ivert][1] = (float)nvect->FsiVertInfo(ivert)->fPos.Y();
       fsihist_.posvert[ivert][2] = (float)nvect->FsiVertInfo(ivert)->fPos.Z();
     }
 
     fsihist_.nvcvert = nvect->NfsiPart();
     for (int ip = 0; ip < fsihist_.nvcvert; ip++) {
       fsihist_.abspvert[ip] = (float)nvect->FsiPartInfo(ip)->fMomLab;
       fsihist_.abstpvert[ip] = (float)nvect->FsiPartInfo(ip)->fMomNuc;
       fsihist_.ipvert[ip] = nvect->FsiPartInfo(ip)->fPID;
       fsihist_.iverti[ip] = nvect->FsiPartInfo(ip)->fVertStart;
       fsihist_.ivertf[ip] = nvect->FsiPartInfo(ip)->fVertEnd;
       fsihist_.dirvert[ip][0] = (float)nvect->FsiPartInfo(ip)->fDir.X();
       fsihist_.dirvert[ip][1] = (float)nvect->FsiPartInfo(ip)->fDir.Y();
       fsihist_.dirvert[ip][2] = (float)nvect->FsiPartInfo(ip)->fDir.Z();
     }
     fsihist_.fsiprob = nvect->Fsiprob;
   }
 
   neutcrscom_.crsx = nvect->Crsx;
   neutcrscom_.crsy = nvect->Crsy;
   neutcrscom_.crsz = nvect->Crsz;
   neutcrscom_.crsphi = nvect->Crsphi;
   neutcrscom_.crsq2 = nvect->Crsq2;
 
   neuttarget_.numbndn = nvect->TargetA - nvect->TargetZ;
   neuttarget_.numbndp = nvect->TargetZ;
   neuttarget_.numfrep = nvect->TargetH;
   neuttarget_.numatom = nvect->TargetA;
   posinnuc_.ibound = nvect->Ibound;
 
   // put empty nucleon FSI history (since it is not saved in the NeutVect
   // format)
   // Comment out as NEUT does not have the necessary proton FSI information yet
   //  nucleonfsihist_.nfnvert = 0;
   //  nucleonfsihist_.nfnstep = 0;
 }
 
 #endif