diff --git a/src/Logger/FitLogger.cxx b/src/Logger/FitLogger.cxx
index aa6b591..b542568 100644
--- a/src/Logger/FitLogger.cxx
+++ b/src/Logger/FitLogger.cxx
@@ -1,327 +1,326 @@
 // Copyright 2016-2021 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 "FitLogger.h"
 #include <fcntl.h>
 #include <unistd.h>
 
 namespace Logger {
 
 // Logger Variables
 int log_verb = 4;
 bool use_colors = true;
 
 bool showtrace  = true;
 
 std::ostream* __LOG_outstream(&std::cout);
 std::ofstream __LOG_nullstream;
 
 // Error Variables
 int err_verb = 0;
 std::ostream* __ERR_outstream(&std::cerr);
 
 // Extra Variables
 bool external_verb = true;
 
 bool super_rainbow_mode = true;  //!< For when fitting gets boring.
 unsigned int super_rainbow_mode_colour = 0;
 
 std::streambuf* default_cout = std::cout.rdbuf();
 std::streambuf* default_cerr = std::cerr.rdbuf();
 std::ofstream redirect_stream("/dev/null");
 int silentfd = open("/dev/null", O_WRONLY);
 int savedstdoutfd = dup(fileno(stdout));
 int savedstderrfd = dup(fileno(stderr));
 
 int nloggercalls = 0;
 int timelastlog = 0;
 }
 
 // -------- Logging Functions --------- //
 
 bool LOGGING(int level) {
-  // std::cout << "LOGGING : " << __FILENAME__ << " " << __FUNCTION__ <<
-  // std::endl;
   return (Logger::log_verb >=
           (int)__GETLOG_LEVEL(level, __FILENAME__, __FUNCTION__));
 };
 
 int __GETLOG_LEVEL(int level, const char* filename, const char* funct) {
 #ifdef __DEBUG__
   int logfile = FitPar::Config().GetParI("logging." + std::string(filename));
   if (logfile >= DEB and logfile <= EVT) {
     level = logfile;
   }
 
   int logfunc = FitPar::Config().GetParI("logging." + std::string(funct));
   if (logfunc >= DEB and logfunc <= EVT) {
     level = logfunc;
   }
 #endif
 
   return level;
 };
 
 std::ostream& __OUTLOG(int level, const char* filename, const char* funct,
                        int line) {
   if (Logger::log_verb < (int)level &&
       Logger::log_verb != (int)DEB) {
     return (Logger::__LOG_nullstream);
 
   } else {
     if (Logger::use_colors) {
       switch (level) {
         case FIT:
           std::cout << BOLDGREEN;
           break;
         case MIN:
           std::cout << BOLDBLUE;
           break;
         case SAM:
           std::cout << MAGENTA;
           break;
         case REC:
           std::cout << BLUE;
           break;
         case SIG:
           std::cout << GREEN;
           break;
         case DEB:
           std::cout << CYAN;
           break;
         default:
           break;
       }
     }
 
     switch (level) {
       case FIT:
         std::cout << "[LOG Fitter]";
         break;
       case MIN:
         std::cout << "[LOG Minmzr]";
         break;
       case SAM:
         std::cout << "[LOG Sample]";
         break;
       case REC:
         std::cout << "[LOG Reconf]";
         break;
       case SIG:
         std::cout << "[LOG Signal]";
         break;
       case EVT:
-        std::cout << "[LOG Event ]";
+        std::cout << "[LOG Event]";
         break;
       case DEB:
-        std::cout << "[LOG DEBUG ]";
+        std::cout << "[LOG DEBUG]";
         break;
       default:
-        std::cout << "[LOG INFO  ]";
+        std::cout << "[LOG INFO]";
         break;
     }
 
     // Apply indent
     if (true) {
       switch (level) {
         case FIT:
           std::cout << ": ";
           break;
         case MIN:
           std::cout << ":- ";
           break;
         case SAM:
           std::cout << ":-- ";
           break;
         case REC:
           std::cout << ":--- ";
           break;
         case SIG:
           std::cout << ":---- ";
           break;
         case EVT:
           std::cout << ":----- ";
           break;
         case DEB:
           std::cout << ":------ ";
           break;
         default:
           std::cout << " ";
           break;
       }
     }
 
     if (Logger::use_colors) std::cout << RESET;
 
     if (Logger::showtrace) {
       std::cout << " : " << filename << "::" << funct << "[l. " << line
                 << "] : ";
     }
 
     return *(Logger::__LOG_outstream);
   }
 }
 
 void SETVERBOSITY(int level) { Logger::log_verb = level; }
 void SETERRVERBOSITY(int level) { Logger::err_verb = level; }
 
 void SETVERBOSITY(std::string verb) {
   if (!verb.compare("DEB"))
     Logger::log_verb = -1;
   else if (!verb.compare("QUIET"))
     Logger::log_verb = 0;
   else if (!verb.compare("FIT"))
     Logger::log_verb = 1;
   else if (!verb.compare("MIN"))
     Logger::log_verb = 2;
   else if (!verb.compare("SAM"))
     Logger::log_verb = 3;
   else if (!verb.compare("REC"))
     Logger::log_verb = 4;
   else if (!verb.compare("SIG"))
     Logger::log_verb = 5;
   else if (!verb.compare("EVT"))
     Logger::log_verb = 6;
   else
     Logger::log_verb = std::atoi(verb.c_str());
 }
 
 //******************************************
 void SETERRVERBOSITY(std::string verb) {
   //******************************************
   std::cout << "Setting ERROR VERB" << std::endl;
 
   if (!verb.compare("ERRQUIET"))
     Logger::err_verb = 0;
   else if (!verb.compare("FTL"))
     Logger::err_verb = 1;
   else if (!verb.compare("WRN"))
     Logger::err_verb = 2;
   // else Logger::err_verb = GeneralUtils::StrToInt(verb);
 
   std::cout << "Set error verbosity to : " << Logger::err_verb << std::endl;
   return;
 }
 
 /// Set Trace Option
 void SETTRACE(bool val) { Logger::showtrace = val; }
 
 // ------ ERROR FUNCTIONS ---------- //
 std::ostream& __OUTERR(int level, const char* filename, const char* funct,
                        int line) {
-  if (Logger::use_colors) std::cerr << RED;
 
   switch (level) {
     case FTL:
-      std::cerr << "[ERR FATAL ]: ";
+      if (Logger::use_colors) std::cerr << REDBKG WHITE BOLD;
+      std::cerr << "[ERR FATAL]: ";
       break;
     case WRN:
-      std::cerr << "[ERR WARN  ]: ";
+      if (Logger::use_colors) std::cerr << YELLOWBKG BOLD;
+      std::cerr << "[ERR WARN]: ";
       break;
   }
 
   if (Logger::use_colors) std::cerr << RESET;
 
   // Allows enable error debugging trace
   if (true or Logger::showtrace) {
     std::cout << filename << "::" << funct << "[l. " << line << "] : ";
   }
 
   return *(Logger::__ERR_outstream);
 }
 
 // ----------- External Logging ----------- //
 void SETEXTERNALVERBOSITY(int level) { Logger::external_verb = (level > 0); }
 
 void StopTalking() {
   // Check verbosity set correctly
   if (!Logger::external_verb) return;
 
   // Only redirect if we're not debugging
   if (Logger::log_verb == (int)DEB) return;
 
   std::cout.rdbuf(Logger::redirect_stream.rdbuf());
   std::cerr.rdbuf(Logger::redirect_stream.rdbuf());
   shhnuisancepythiaitokay_();
   fflush(stdout);
   fflush(stderr);
   dup2(Logger::silentfd, fileno(stdout));
   dup2(Logger::silentfd, fileno(stderr));
 }
 
 void StartTalking() {
   // Check verbosity set correctly
   if (!Logger::external_verb) return;
 
   std::cout.rdbuf(Logger::default_cout);
   std::cerr.rdbuf(Logger::default_cerr);
   canihaznuisancepythia_();
   fflush(stdout);
   fflush(stderr);
   dup2(Logger::savedstdoutfd, fileno(stdout));
   dup2(Logger::savedstderrfd, fileno(stderr));
 }
 
 //******************************************
 bool LOG_LEVEL(int level) {
   //******************************************
 
   if (Logger::log_verb == (int)DEB) {
     return true;
   }
 
   if (Logger::log_verb < (int)level) {
     return false;
   }
 
   return true;
 }
 
 void SET_TRACE(bool val) { Logger::showtrace = val; }
 
 //******************************************
 std::ostream& _LOG(int level, const char* filename, const char* func, int line)
 //******************************************
 {
   return __OUTLOG(level, filename, func, line);
 }
 
 //******************************************
 std::ostream& _ERR(int level, const char* filename, const char* func, int line)
 //******************************************
 {
   if (Logger::use_colors) std::cerr << RED;
 
   if (Logger::showtrace) {
     std::cout << filename << "::" << func << "[l. " << line << "] : ";
   }
 
   switch (level) {
     case FTL:
       std::cerr << "[ERR FATAL ]: ";
       break;
     case WRN:
       std::cerr << "[ERR WARN  ] : ";
       break;
   }
 
   if (Logger::use_colors) std::cerr << RESET;
 
   return *Logger::__ERR_outstream;
 }
diff --git a/src/Logger/FitLogger.h b/src/Logger/FitLogger.h
index e812eae..929db5c 100644
--- a/src/Logger/FitLogger.h
+++ b/src/Logger/FitLogger.h
@@ -1,202 +1,209 @@
 // Copyright 2016-2021 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/>.
  *******************************************************************************/
 #ifndef FITLOGGER_HPP
 #define FITLOGGER_HPP
 /*!
  *  \addtogroup FitBase
  *  @{
  */
 
 #include <fstream>
 #include <iosfwd>
 #include <iostream>
 #include <sstream>
 
 #include "TRandom3.h"
 
 #include "Initialiser.h"
 
 #include "NuisConfig.h"
 
 #define RESET "\033[0m"
 #define BLACK "\033[30m"              /* Black */
 #define RED "\033[31m"                /* Red */
 #define GREEN "\033[32m"              /* Green */
 #define YELLOW "\033[33m"             /* Yellow */
 #define BLUE "\033[34m"               /* Blue */
 #define MAGENTA "\033[35m"            /* Magenta */
 #define CYAN "\033[36m"               /* Cyan */
 #define WHITE "\033[37m"              /* White */
-#define BOLDBLACK "\033[1m\033[30m"   /* Bold Black */
-#define BOLDRED "\033[1m\033[31m"     /* Bold Red */
-#define BOLDGREEN "\033[1m\033[32m"   /* Bold Green */
-#define BOLDYELLOW "\033[1m\033[33m"  /* Bold Yellow */
-#define BOLDBLUE "\033[1m\033[34m"    /* Bold Blue */
-#define BOLDMAGENTA "\033[1m\033[35m" /* Bold Magenta */
-#define BOLDCYAN "\033[1m\033[36m"    /* Bold Cyan */
-#define BOLDWHITE "\033[1m\033[37m"   /* Bold White */
+
+#define BOLD "\033[1m"                /* Bold */
+
+#define REDBKG "\033[41m"             /* Red background */
+#define YELLOWBKG "\033[43m"          /* Yellow background */
+
+#define BOLDBLACK BOLD BLACK
+#define BOLDRED BOLD RED
+#define BOLDGREEN BOLD GREEN
+#define BOLDYELLOW BOLD YELLOW
+#define BOLDBLUE BOLD BLUE
+#define BOLDMAGENTA BOLD MAGENTA
+#define BOLDCYAN BOLD CYAN
+#define BOLDWHITE BOLD WHITE
+
 
 namespace Logger {
 extern int log_verb; //!< Current VERBOSITY
 extern int err_verb; //!< Current ERROR VERBOSITY
 extern bool external_verb;
 extern bool use_colors;         //!< Use BASH Terminal Colors Flag
 extern bool super_rainbow_mode; //!< For when fitting gets boring.
 extern unsigned int super_rainbow_mode_colour;
 
 extern bool showtrace; // Quick Tracing for debugging
 extern int nloggercalls;
 extern int timelastlog;
 extern std::streambuf
     *default_cout; //!< Where the STDOUT stream is currently directed
 extern std::streambuf
     *default_cerr; //!< Where the STDERR stream is currently directed
 extern std::ofstream
     redirect_stream; //!< Where should unwanted messages be thrown
 } // namespace Logger
 
 /// Returns full path to file currently in
 #define __FILENAME__                                                           \
   (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 
 // ------ LOGGER FUNCTIONS ------------ //
 namespace Logger {
 /// NULL Output Stream
 extern std::ofstream __LOG_nullstream;
 
 /// Logging Stream
 extern std::ostream *__LOG_outstream;
 } // namespace Logger
 
 /// Fitter VERBOSITY Enumerations
 /// These go through the different depths of the fitter.
 ///
 /// 0 QUIET - Little output.
 /// 1 FIT - Top Level Minimizer Status
 /// 2 MIN - Output from the FCN Minimizer Functions
 /// 3 SAM - Output from each of the samples during setup etc
 /// 4 REC - Output during each reconfigure. Percentage progress etc.
 /// 5 SIG - Output during every signal event that is found.
 /// 6 EVT - Output during every event.
 /// 7 DEB - Will print only debugging info wherever a NUIS_LOG(DEB) statement
 /// was made
 enum __LOG_levels { QUIET = 0, FIT, MIN, SAM, REC, SIG, EVT, DEB };
 
 /// Returns log level for a given file/function
 int __GETLOG_LEVEL(int level, const char *filename, const char *funct);
 
 bool LOG_LEVEL(int level);
 
 /// Actually runs the logger
 std::ostream &__OUTLOG(int level, const char *filename, const char *funct,
                        int line);
 
 /// Global Logging Definitions
 #define NUIS_LOGN(level, stream)                                               \
   {                                                                            \
     if (LOG_LEVEL(level)) {                                                    \
       __OUTLOG(level, __FILENAME__, __FUNCTION__, __LINE__) << stream;         \
     }                                                                          \
   };
 
 /// Global Logging Definitions
 #define NUIS_LOG(level, stream) NUIS_LOGN(level, stream << std::endl)
 
 #define BREAK(level)                                                           \
   {                                                                            \
     \ if (LOG_LEVEL(level)) {                                                  \
       __OUTLOG(level, __FILENAME__, __FUNCTION__, __LINE__) << std::endl;      \
     }                                                                          \
   };
 
 /// Return whether logging level is valid
 bool LOGGING(int level);
 
 /// Set Global Verbosity
 void SETVERBOSITY(int level);
 
 /// Set Global Verbosity from String
 void SETVERBOSITY(std::string verb);
 
 /// Set Global Verbosity
 void SETERRVERBOSITY(int level);
 
 /// Set Global Verbosity from String
 void SETERRVERBOSITY(std::string verb);
 
 /// Set Trace Option
 void SETTRACE(bool val);
 
 // ----------- ERROR FUNCTIONS ---------- //
 
 /// Error Stream
 extern std::ostream *__ERR_outstream;
 
 /// Fitter ERROR VERBOSITY Enumerations
 ///
 /// 0 QUIET - No Error Output
 /// 1 FTL - Show errors only if fatal
 /// 2 WRN - Show Warning messages
 enum __ERR_levels { ERRQUIET = 0, FTL, WRN };
 
 /// Actually runs the error messager
 std::ostream &__OUTERR(int level, const char *filename, const char *funct,
                        int line);
 
 /// Error Logging Function
 #define NUIS_ERR(level, stream)                                                \
   {                                                                            \
     __OUTERR(level, __FILENAME__, __FUNCTION__, __LINE__)                      \
         << stream << std::endl;                                                \
   };
 
 // ----------- ERROR HANDLING ------------- //
 /// Exit the program with given error message stream
 #define NUIS_ABORT(stream)                                                     \
   {                                                                            \
     __OUTERR(FTL, __FILENAME__, __FUNCTION__, __LINE__)                        \
         << stream << std::endl;                                                \
     __OUTERR(FTL, __FILENAME__, __FUNCTION__, __LINE__)                        \
         << "Attempting to save output file." << std::endl;                     \
     if (Config::Get().out && Config::Get().out->IsOpen()) {                    \
       Config::Get().out->Write();                                              \
       Config::Get().out->Close();                                              \
       __OUTERR(FTL, __FILENAME__, __FUNCTION__, __LINE__)                      \
           << "Done." << std::endl;                                             \
     } else {                                                                   \
       __OUTERR(FTL, __FILENAME__, __FUNCTION__, __LINE__)                      \
           << "No output file set." << std::endl;                               \
     }                                                                          \
     __OUTERR(FTL, __FILENAME__, __FUNCTION__, __LINE__)                        \
         << "Exiting!" << std::endl;                                            \
     std::abort();                                                              \
   }
 
 // ----------- External Logging ----------- //
 void SETEXTERNALVERBOSITY(int level);
 
 void StopTalking();
 void StartTalking();
 
 extern "C" {
 void shhnuisancepythiaitokay_(void);
 void canihaznuisancepythia_(void);
 }
 
 #endif