diff --git a/src/InputHandler/GENIEInputHandler.cxx b/src/InputHandler/GENIEInputHandler.cxx
index cc08849..240611c 100644
--- a/src/InputHandler/GENIEInputHandler.cxx
+++ b/src/InputHandler/GENIEInputHandler.cxx
@@ -1,548 +1,580 @@
 // 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/>.
 *******************************************************************************/
 #ifdef __GENIE_ENABLED__
 #include "GENIEInputHandler.h"
 
 #pragma push_macro("LOG")
 #undef LOG
 #pragma push_macro("ERROR")
 #undef ERROR
 #ifdef GENIE_PRE_R3
 #include "Messenger/Messenger.h"
 #else
 #include "Framework/Messenger/Messenger.h"
 #endif
 #pragma pop_macro("LOG")
 #pragma pop_macro("ERROR")
 
 
 #include "InputUtils.h"
 
 GENIEGeneratorInfo::~GENIEGeneratorInfo() { DeallocateParticleStack(); }
 
 void GENIEGeneratorInfo::AddBranchesToTree(TTree* tn) {
   tn->Branch("GenieParticlePDGs", &fGenieParticlePDGs, "GenieParticlePDGs/I");
 }
 
 void GENIEGeneratorInfo::SetBranchesFromTree(TTree* tn) {
   tn->SetBranchAddress("GenieParticlePDGs", &fGenieParticlePDGs);
 }
 
 void GENIEGeneratorInfo::AllocateParticleStack(int stacksize) {
   fGenieParticlePDGs = new int[stacksize];
 }
 
 void GENIEGeneratorInfo::DeallocateParticleStack() {
   delete fGenieParticlePDGs;
 }
 
 void GENIEGeneratorInfo::FillGeneratorInfo(NtpMCEventRecord* ntpl) {
   Reset();
 
   // Check for GENIE Event
   if (!ntpl) return;
   if (!ntpl->event) return;
 
   // Cast Event Record
   GHepRecord* ghep = static_cast<GHepRecord*>(ntpl->event);
   if (!ghep) return;
 
   // Fill Particle Stack
   GHepParticle* p = 0;
   TObjArrayIter iter(ghep);
 
   // Loop over all particles
   int i = 0;
   while ((p = (dynamic_cast<genie::GHepParticle*>((iter).Next())))) {
     if (!p) continue;
 
     // Get PDG
     fGenieParticlePDGs[i] = p->Pdg();
     i++;
   }
 }
 
 void GENIEGeneratorInfo::Reset() {
   for (int i = 0; i < kMaxParticles; i++) {
     fGenieParticlePDGs[i] = 0;
   }
 }
 
 GENIEInputHandler::GENIEInputHandler(std::string const& handle,
                                      std::string const& rawinputs) {
   LOG(SAM) << "Creating GENIEInputHandler : " << handle << std::endl;
 
   genie::Messenger::Instance()->SetPriorityLevel("GHepUtils", pFATAL);
 
   // Run a joint input handling
   fName = handle;
 
   // Setup the TChain
   fGENIETree = new TChain("gtree");
   fSaveExtra = FitPar::Config().GetParB("SaveExtraGenie");
   fCacheSize = FitPar::Config().GetParI("CacheSize");
   fMaxEvents = FitPar::Config().GetParI("MAXEVENTS");
 
   // Are we running with NOvA weights
   fNOvAWeights = FitPar::Config().GetParB("NOvA_Weights");
   MAQEw = 1.0;
   NonResw = 1.0;
   RPAQEw = 1.0;
   RPARESw = 1.0;
   MECw = 1.0;
   DISw = 1.0;
   NOVAw = 1.0;
 
   // 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(
       InputUtils::ExpandInputDirectories(inputs[inp_it]).c_str(), "READ");
   if (!inp_file or inp_file->IsZombie()) {
       THROW("GENIE 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("nuisance_flux");
     TH1D* eventhist = (TH1D*)inp_file->Get("nuisance_events");
     if (!fluxhist or !eventhist) {
       ERROR(FTL, "Input File Contents: " << inputs[inp_it]);
       inp_file->ls();
       THROW("GENIE FILE doesn't contain flux/xsec info."
             << std::endl
             << "Try running the app PrepareGENIE first on :" << inputs[inp_it]
             << std::endl
             << "$ PrepareGENIE -h");
     }
 
     // Get N Events
     TTree* genietree = (TTree*)inp_file->Get("gtree");
     if (!genietree) {
       ERROR(FTL, "gtree not located in GENIE file: " << inputs[inp_it]);
       THROW("Check your inputs, they may need to be completely regenerated!");
       throw;
     }
 
     int nevents = genietree->GetEntries();
     if (nevents <= 0) {
       THROW("Trying to a TTree with "
             << nevents << " to TChain from : " << inputs[inp_it]);
     }
 
     // Check for precomputed weights
     TTree *weighttree = (TTree*)inp_file->Get("nova_wgts");
     if (fNOvAWeights) {
       if (!weighttree) {
         THROW("Did not find nova_wgts tree in file " << inputs[inp_it] << " but you specified it" << std::endl);
       } else {
         LOG(FIT) << "Found nova_wgts tree in file " << inputs[inp_it] << std::endl;
       }
     }
 
     // Register input to form flux/event rate hists
     RegisterJointInput(inputs[inp_it], nevents, fluxhist, eventhist);
 
     // Add To TChain
     fGENIETree->AddFile(inputs[inp_it].c_str());
     if (weighttree != NULL) fGENIETree->AddFriend(weighttree);
   }
 
   // Registor all our file inputs
   SetupJointInputs();
 
   // Assign to tree
   fEventType = kGENIE;
   fGenieNtpl = NULL;
   fGENIETree->SetBranchAddress("gmcrec", &fGenieNtpl);
 
   // Set up the custom weights
   if (fNOvAWeights) {
     fGENIETree->SetBranchAddress("MAQEwgt", &MAQEw);
     fGENIETree->SetBranchAddress("nonResNormWgt", &NonResw);
     fGENIETree->SetBranchAddress("RPAQEWgt", &RPAQEw);
     fGENIETree->SetBranchAddress("RPARESWgt", &RPARESw);
     fGENIETree->SetBranchAddress("MECWgt", &MECw);
     fGENIETree->SetBranchAddress("DISWgt", &DISw);
     fGENIETree->SetBranchAddress("nova2018CVWgt", &NOVAw);
   }
 
   // Libraries should be seen but not heard...
   StopTalking();
   fGENIETree->GetEntry(0);
   StartTalking();
 
   // Create Fit Event
   fNUISANCEEvent = new FitEvent();
   fNUISANCEEvent->SetGenieEvent(fGenieNtpl);
 
   if (fSaveExtra) {
     fGenieInfo = new GENIEGeneratorInfo();
     fNUISANCEEvent->AddGeneratorInfo(fGenieInfo);
   }
 
   fNUISANCEEvent->HardReset();
 };
 
 GENIEInputHandler::~GENIEInputHandler() {
   // if (fGenieGHep) delete fGenieGHep;
   // if (fGenieNtpl) delete fGenieNtpl;
   // if (fGENIETree) delete fGENIETree;
   // if (fGenieInfo) delete fGenieInfo;
 }
 
 void GENIEInputHandler::CreateCache() {
   if (fCacheSize > 0) {
     // fGENIETree->SetCacheEntryRange(0, fNEvents);
     fGENIETree->AddBranchToCache("*", 1);
     fGENIETree->SetCacheSize(fCacheSize);
   }
 }
 
 void GENIEInputHandler::RemoveCache() {
   // fGENIETree->SetCacheEntryRange(0, fNEvents);
   fGENIETree->AddBranchToCache("*", 0);
   fGENIETree->SetCacheSize(0);
 }
 
 FitEvent* GENIEInputHandler::GetNuisanceEvent(const UInt_t entry, const bool lightweight) {
   if (entry >= (UInt_t)fNEvents) return NULL;
 
   // Clear the previous event (See Note 1 in ROOT TClonesArray documentation)
   if (fGenieNtpl) {
     fGenieNtpl->Clear();
   }
 
   // Read Entry from TTree to fill NEUT Vect in BaseFitEvt;
   fGENIETree->GetEntry(entry);
 
   // Run NUISANCE Vector Filler
   if (!lightweight) {
     CalcNUISANCEKinematics();
   }
 #ifdef __PROB3PP_ENABLED__
   else {
     // Check for GENIE Event
     if (!fGenieNtpl) return NULL;
     if (!fGenieNtpl->event) return NULL;
 
     // Cast Event Record
     fGenieGHep = static_cast<GHepRecord*>(fGenieNtpl->event);
     if (!fGenieGHep) return NULL;
 
     TObjArrayIter iter(fGenieGHep);
     genie::GHepParticle* p;
     while ((p = (dynamic_cast<genie::GHepParticle*>((iter).Next())))) {
       if (!p) {
         continue;
       }
 
       // Get Status
       int state = GetGENIEParticleStatus(p, fNUISANCEEvent->Mode);
       if (state != genie::kIStInitialState) {
         continue;
       }
       fNUISANCEEvent->probe_E = p->E() * 1.E3;
       fNUISANCEEvent->probe_pdg = p->Pdg();
       break;
     }
   }
 #endif
 
   // Setup Input scaling for joint inputs
   fNUISANCEEvent->InputWeight = GetInputWeight(entry);
 
   return fNUISANCEEvent;
 }
 
 int GENIEInputHandler::GetGENIEParticleStatus(genie::GHepParticle* p, int mode) {
   /*
      kIStUndefined                  = -1,
      kIStInitialState               =  0,   / generator-level initial state /
      kIStStableFinalState           =  1,   / generator-level final state:
      particles to be tracked by detector-level MC /
      kIStIntermediateState          =  2,
      kIStDecayedState               =  3,
      kIStCorrelatedNucleon          = 10,
      kIStNucleonTarget              = 11,
      kIStDISPreFragmHadronicState   = 12,
      kIStPreDecayResonantState      = 13,
      kIStHadronInTheNucleus         = 14,   / hadrons inside the nucleus: marked
      for hadron transport modules to act on /
      kIStFinalStateNuclearRemnant   = 15,   / low energy nuclear fragments
      entering the record collectively as a 'hadronic blob' pseudo-particle /
      kIStNucleonClusterTarget       = 16,   // for composite nucleons before
      phase space decay
      */
 
   int state = kUndefinedState;
   switch (p->Status()) {
     case genie::kIStNucleonTarget:
     case genie::kIStInitialState:
     case genie::kIStCorrelatedNucleon:
     case genie::kIStNucleonClusterTarget:
       state = kInitialState;
       break;
 
     case genie::kIStStableFinalState:
       state = kFinalState;
       break;
 
     case genie::kIStHadronInTheNucleus:
       if (abs(mode) == 2)
         state = kInitialState;
       else
         state = kFSIState;
       break;
 
     case genie::kIStPreDecayResonantState:
     case genie::kIStDISPreFragmHadronicState:
     case genie::kIStIntermediateState:
       state = kFSIState;
       break;
 
     case genie::kIStFinalStateNuclearRemnant:
     case genie::kIStUndefined:
     case genie::kIStDecayedState:
     default:
       break;
   }
 
   // Flag to remove nuclear part in genie
   if (p->Pdg() > 1000000) {
     if (state == kInitialState)
       state = kNuclearInitial;
     else if (state == kFinalState)
       state = kNuclearRemnant;
   }
 
   return state;
 }
 #endif
 
 #ifdef __GENIE_ENABLED__
 int GENIEInputHandler::ConvertGENIEReactionCode(GHepRecord* gheprec) {
   // Electron Scattering
   if (gheprec->Summary()->ProcInfo().IsEM()) {
     if (gheprec->Summary()->InitState().ProbePdg() == 11) {
       if (gheprec->Summary()->ProcInfo().IsQuasiElastic())
         return 1;
       else if (gheprec->Summary()->ProcInfo().IsMEC())
         return 2;
       else if (gheprec->Summary()->ProcInfo().IsResonant())
         return 13;
       else if (gheprec->Summary()->ProcInfo().IsDeepInelastic())
         return 26;
       else {
         ERROR(WRN,
             "Unknown GENIE Electron Scattering Mode!"
             << std::endl
             << "ScatteringTypeId = "
             << gheprec->Summary()->ProcInfo().ScatteringTypeId() << " "
             << "InteractionTypeId = "
             << gheprec->Summary()->ProcInfo().InteractionTypeId()
             << std::endl
             << genie::ScatteringType::AsString(
               gheprec->Summary()->ProcInfo().ScatteringTypeId())
             << " "
             << genie::InteractionType::AsString(
               gheprec->Summary()->ProcInfo().InteractionTypeId())
             << " " << gheprec->Summary()->ProcInfo().IsMEC());
         return 0;
       }
     }
 
     // Weak CC
   } else if (gheprec->Summary()->ProcInfo().IsWeakCC()) {
     // CC MEC
     if (gheprec->Summary()->ProcInfo().IsMEC()) {
       if (pdg::IsNeutrino(gheprec->Summary()->InitState().ProbePdg()))
         return 2;
       else if (pdg::IsAntiNeutrino(gheprec->Summary()->InitState().ProbePdg()))
         return -2;
 
       // CC OTHER
     } else {
       return utils::ghep::NeutReactionCode(gheprec);
     }
 
     // Weak NC
   } else if (gheprec->Summary()->ProcInfo().IsWeakNC()) {
     // NC MEC
     if (gheprec->Summary()->ProcInfo().IsMEC()) {
       if (pdg::IsNeutrino(gheprec->Summary()->InitState().ProbePdg()))
         return 32;
       else if (pdg::IsAntiNeutrino(gheprec->Summary()->InitState().ProbePdg()))
         return -32;
 
       // NC OTHER
     } else {
       return utils::ghep::NeutReactionCode(gheprec);
     }
   }
 
   return 0;
 }
 
 void GENIEInputHandler::CalcNUISANCEKinematics() {
   // Reset all variables
   fNUISANCEEvent->ResetEvent();
 
   // Check for GENIE Event
   if (!fGenieNtpl) return;
   if (!fGenieNtpl->event) return;
 
   // Cast Event Record
   fGenieGHep = static_cast<GHepRecord*>(fGenieNtpl->event);
   if (!fGenieGHep) return;
 
   // Convert GENIE Reaction Code
   fNUISANCEEvent->Mode = ConvertGENIEReactionCode(fGenieGHep);
 
   // Set Event Info
   fNUISANCEEvent->fEventNo = 0.0;
   fNUISANCEEvent->fTotCrs = fGenieGHep->XSec();
+  // Have a bool storing if interaction happened on free or bound nucleon
+  bool IsFree = false;
   // Set the TargetPDG
   if (fGenieGHep->TargetNucleus() != NULL) {
     fNUISANCEEvent->fTargetPDG = fGenieGHep->TargetNucleus()->Pdg();
-  // Sometimes GENIE scatters off free nucleons electrons
+    IsFree = false;
+  // Sometimes GENIE scatters off free nucleons, electrons, photons 
+  // In which TargetNucleus is NULL and we need to find the initial state particle
   } else {
-    // Check the particle is an initial state particle (GHepRecord::TargetNucleusPosition but doesn't do check on pdg::IsIon)
+    // Check the particle is an initial state particle 
+    // Follows GHepRecord::TargetNucleusPosition but doesn't do check on pdg::IsIon
     GHepParticle *p = fGenieGHep->Particle(1);
+    // Check that particle 1 actually exists
     if (!p) {
       ERR(FTL) << "Can't find particle 1 for GHepRecord" << std::endl;
       throw;
     }
+    // If not an ion but is an initial state particle
     if (!pdg::IsIon(p->Pdg()) && 
         p->Status() == kIStInitialState) {
+      IsFree = true;
       fNUISANCEEvent->fTargetPDG = p->Pdg();
+    // Catch if something strange happens: 
+    // Here particle 1 is not an initial state particle OR
+    // particle 1 is an ion OR
+    // both
     } else {
       if (pdg::IsIon(p->Pdg())) {
         ERR(FTL) << "Particle 1 in GHepRecord stack is an ion but isn't an initial state particle" << std::endl;
         throw;
       } else {
         ERR(FTL) << "Particle 1 in GHepRecord stack is not an ion but is an initial state particle" << std::endl;
         throw;
       }
     }
   }
   // Set the A and Z and H from the target PDG
-  fNUISANCEEvent->fTargetA = TargetUtils::GetTargetAFromPDG(fNUISANCEEvent->fTargetPDG);
-  fNUISANCEEvent->fTargetZ = TargetUtils::GetTargetZFromPDG(fNUISANCEEvent->fTargetPDG);
-  fNUISANCEEvent->fTargetH = 0;
-  fNUISANCEEvent->fBound = (fNUISANCEEvent->fTargetA != 1);
+  // Depends on if we scattered off a free or bound nucleon
+  if (!IsFree) {
+    fNUISANCEEvent->fTargetA = TargetUtils::GetTargetAFromPDG(fNUISANCEEvent->fTargetPDG);
+    fNUISANCEEvent->fTargetZ = TargetUtils::GetTargetZFromPDG(fNUISANCEEvent->fTargetPDG);
+    fNUISANCEEvent->fTargetH = 0;
+  } else {
+    // If free proton scattering
+    if (fNUISANCEEvent->fTargetPDG == 2212) {
+      fNUISANCEEvent->fTargetA = 1;
+      fNUISANCEEvent->fTargetZ = 1;
+      fNUISANCEEvent->fTargetH = 1;
+      // If free neutron scattering
+    } else if (fNUISANCEEvent->fTargetPDG == 2112) {
+      fNUISANCEEvent->fTargetA = 0;
+      fNUISANCEEvent->fTargetZ = 1;
+      fNUISANCEEvent->fTargetH = 0;
+      // If neither
+    } else {
+      fNUISANCEEvent->fTargetA = 0;
+      fNUISANCEEvent->fTargetZ = 0;
+      fNUISANCEEvent->fTargetH = 0;
+    }
+  }
+  fNUISANCEEvent->fBound = !IsFree;
   fNUISANCEEvent->InputWeight = 1.0;  //(1E+38 / genie::units::cm2) * fGenieGHep->XSec();
 
   // And the custom weights
   if (fNOvAWeights) {
     fNUISANCEEvent->CustomWeight = NOVAw;
     fNUISANCEEvent->CustomWeightArray[0] = MAQEw;
     fNUISANCEEvent->CustomWeightArray[1] = NonResw;
     fNUISANCEEvent->CustomWeightArray[2] = RPAQEw;
     fNUISANCEEvent->CustomWeightArray[3] = RPARESw;
     fNUISANCEEvent->CustomWeightArray[4] = MECw;
     fNUISANCEEvent->CustomWeightArray[5] = NOVAw;
   } else {
     fNUISANCEEvent->CustomWeight = 1.0;
     fNUISANCEEvent->CustomWeightArray[0] = 1.0;
     fNUISANCEEvent->CustomWeightArray[1] = 1.0;
     fNUISANCEEvent->CustomWeightArray[2] = 1.0;
     fNUISANCEEvent->CustomWeightArray[3] = 1.0;
     fNUISANCEEvent->CustomWeightArray[4] = 1.0;
     fNUISANCEEvent->CustomWeightArray[5] = 1.0;
   }
 
   // Get N Particle Stack
   unsigned int npart = fGenieGHep->GetEntries();
   unsigned int kmax = fNUISANCEEvent->kMaxParticles;
   if (npart > kmax) {
     ERR(WRN) << "GENIE has too many particles, expanding stack." << std::endl;
     fNUISANCEEvent->ExpandParticleStack(npart);
   }
 
   // Fill Particle Stack
   GHepParticle* p = 0;
   TObjArrayIter iter(fGenieGHep);
   fNUISANCEEvent->fNParticles = 0;
 
   // Loop over all particles
   while ((p = (dynamic_cast<genie::GHepParticle*>((iter).Next())))) {
     if (!p) continue;
 
     // Get Status
     int state = GetGENIEParticleStatus(p, fNUISANCEEvent->Mode);
 
     // Remove Undefined
     if (kRemoveUndefParticles && state == kUndefinedState) continue;
 
     // Remove FSI
     if (kRemoveFSIParticles && state == kFSIState) continue;
 
     if (kRemoveNuclearParticles &&
         (state == kNuclearInitial || state == kNuclearRemnant))
       continue;
 
     // Fill Vectors
     int curpart = fNUISANCEEvent->fNParticles;
     fNUISANCEEvent->fParticleState[curpart] = state;
 
     // Mom
     fNUISANCEEvent->fParticleMom[curpart][0] = p->Px() * 1.E3;
     fNUISANCEEvent->fParticleMom[curpart][1] = p->Py() * 1.E3;
     fNUISANCEEvent->fParticleMom[curpart][2] = p->Pz() * 1.E3;
     fNUISANCEEvent->fParticleMom[curpart][3] = p->E() * 1.E3;
 
     // PDG
     fNUISANCEEvent->fParticlePDG[curpart] = p->Pdg();
 
     // Add to N particle count
     fNUISANCEEvent->fNParticles++;
 
     // Extra Check incase GENIE fails.
     if ((UInt_t)fNUISANCEEvent->fNParticles == kmax) {
       ERR(WRN) << "Number of GENIE Particles exceeds maximum!" << std::endl;
       ERR(WRN) << "Extend kMax, or run without including FSI particles!"
         << std::endl;
       break;
     }
   }
 
   // Fill Extra Stack
   if (fSaveExtra) fGenieInfo->FillGeneratorInfo(fGenieNtpl);
 
   // 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 GENIEInputHandler::Print() {}
 
 #endif
diff --git a/src/Utils/TargetUtils.cxx b/src/Utils/TargetUtils.cxx
index 8de3172..c1fe844 100644
--- a/src/Utils/TargetUtils.cxx
+++ b/src/Utils/TargetUtils.cxx
@@ -1,74 +1,74 @@
 #include "TargetUtils.h"
 
 std::vector<int> TargetUtils::ParseTargetsToIntVect(std::string targets) {
 
-	std::vector<std::string> splittgt = GeneralUtils::ParseToStr(targets, ",");
-	std::vector<int> convtgt;
+  std::vector<std::string> splittgt = GeneralUtils::ParseToStr(targets, ",");
+  std::vector<int> convtgt;
 
-	for (size_t i = 0; i < splittgt.size(); i++) {
-		std::string type = splittgt[i];
-		convtgt.push_back( GetTargetPDGFromString( type ) );
-	}
+  for (size_t i = 0; i < splittgt.size(); i++) {
+    std::string type = splittgt[i];
+    convtgt.push_back( GetTargetPDGFromString( type ) );
+  }
 
-	return convtgt;
+  return convtgt;
 }
 
 
 int TargetUtils::GetTargetPDGFromString(std::string target){
 
-	if      (!target.compare("H")) return 1000010010;
-	else if (!target.compare("C")) return 1000060120;
-	else if (!target.compare("O")) return 1000080160;
-	else {
-		int conv = GeneralUtils::StrToInt(target);
-		if (abs(conv) > 1) return conv;
-	}
-	return 0;
+  if      (!target.compare("H")) return 1000010010;
+  else if (!target.compare("C")) return 1000060120;
+  else if (!target.compare("O")) return 1000080160;
+  else {
+    int conv = GeneralUtils::StrToInt(target);
+    if (abs(conv) > 1) return conv;
+  }
+  return 0;
 }
 
 int TargetUtils::GetTargetPDGFromZA(int Z, int A){
-	return 1000000000 + A*10 + Z*10000;
+  return 1000000000 + A*10 + Z*10000;
 }
 
 int TargetUtils::GetTargetAFromPDG(int PDG){
   return ((PDG%10000))/10;
 }
 
 int TargetUtils::GetTargetZFromPDG(int PDG){
   return (PDG%1000000000 - PDG%10000)/10000;
 }
 
 
 ///____________________________________________________________________________
 void TargetUtils::ListTargetIDs(){
 
   // Keep in sync with ConvertTargetIDs
   LOG(FIT) << "Possible Target IDs: \n"
-			 << "\n H  : " << TargetUtils::ConvertTargetIDs("H")
-                         << "\n C  : " << TargetUtils::ConvertTargetIDs("C")
-			 << "\n CH  : " << TargetUtils::ConvertTargetIDs("CH")
-			 << "\n CH2 : " << TargetUtils::ConvertTargetIDs("CH2")
-			 << "\n H2O : " << TargetUtils::ConvertTargetIDs("H2O")
-			 << "\n Fe  : " << TargetUtils::ConvertTargetIDs("Fe")
-			 << "\n Pb  : " << TargetUtils::ConvertTargetIDs("Pb")
-			 << "\n D2  : " << TargetUtils::ConvertTargetIDs("D2")
-			 << "\n D2-free : " << TargetUtils::ConvertTargetIDs("D2-free");
+    << "\n H  : " << TargetUtils::ConvertTargetIDs("H")
+    << "\n C  : " << TargetUtils::ConvertTargetIDs("C")
+    << "\n CH  : " << TargetUtils::ConvertTargetIDs("CH")
+    << "\n CH2 : " << TargetUtils::ConvertTargetIDs("CH2")
+    << "\n H2O : " << TargetUtils::ConvertTargetIDs("H2O")
+    << "\n Fe  : " << TargetUtils::ConvertTargetIDs("Fe")
+    << "\n Pb  : " << TargetUtils::ConvertTargetIDs("Pb")
+    << "\n D2  : " << TargetUtils::ConvertTargetIDs("D2")
+    << "\n D2-free : " << TargetUtils::ConvertTargetIDs("D2-free");
 }
 
 
 //____________________________________________________________________________
 std::string TargetUtils::ConvertTargetIDs(std::string id){
 
   if (!id.compare("H")) return "1000010010";
   else if  (!id.compare("C")) return "1000060120";
   else if  (!id.compare("CH"))  return "13,1000060120[0.9231],1000010010[0.0769]";
   else if  (!id.compare("CH2")) return "14,1000060120[0.8571],1000010010[0.1429]";
   else if  (!id.compare("H2O")) return "18,1000080160[0.8888],1000010010[0.1111]";
   else if  (!id.compare("Fe"))  return "1000260560";
   else if  (!id.compare("Pb"))  return "1000822070";
   else if  (!id.compare("D2"))  return "1000010020";
   else if  (!id.compare("D2-free")) return "2,1000010010[0.5],1000000010[0.5]";
   else return "";
 
 };