diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h
index a7a1445d13f162346ddb37c92c815322e78b3718..426fdf0c55fd6a724b746829db2fd77bed73b5a4 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h
@@ -14,12 +14,12 @@ class TFCSEnergyBinParametrization:public TFCSEnergyParametrization
  public:
   TFCSEnergyBinParametrization(const char* name=nullptr, const char* title=nullptr);
 
-  virtual void set_pdgid(int id);
-  virtual void set_pdgid(const std::set< int > &ids);
-  virtual void add_pdgid(int id);
-  virtual void clear_pdgid();
+  virtual void set_pdgid(int id) override;
+  virtual void set_pdgid(const std::set< int > &ids) override;
+  virtual void add_pdgid(int id) override;
+  virtual void clear_pdgid() override;
   
-  virtual int n_bins() const {return m_number_of_Ekin_bins;};
+  virtual int n_bins() const override {return m_number_of_Ekin_bins;};
 
   /// current convention is to start Ekin_bin counting at 1, to be updated to start counting with 0
   void set_number_of_Ekin_bins(int n_Ekin_bin) {m_number_of_Ekin_bins=n_Ekin_bin;resize();};
@@ -31,18 +31,18 @@ class TFCSEnergyBinParametrization:public TFCSEnergyParametrization
   /// current convention is to start Ekin_bin counting at 1, to be updated to start counting with 0
   virtual void set_pdgid_Ekin_bin_probability(int id,std::vector< float > prob);
   
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  virtual bool is_match_Ekin_bin(int Ekin_bin) const;
+  virtual bool is_match_Ekin_bin(int Ekin_bin) const override;
   
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
  private:
   int m_number_of_Ekin_bins;
   std::map< int, std::vector< float > > m_pdgid_Ebin_probability;
   
   void resize();
   
-  ClassDef(TFCSEnergyBinParametrization,1)  //TFCSEnergyBinParametrization
+  ClassDefOverride(TFCSEnergyBinParametrization,1)  //TFCSEnergyBinParametrization
  
 };
 
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationLinear.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationLinear.h
index 863f1fef0dc8c2700696c143c751f1c8aeb4822c..863d4265c38d1638700cb116b4ff3cf68dd686c5 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationLinear.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationLinear.h
@@ -11,23 +11,23 @@ class TFCSEnergyInterpolationLinear:public TFCSParametrization {
 public:
   TFCSEnergyInterpolationLinear(const char* name=nullptr, const char* title=nullptr);
 
-  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const {return true;};
-  virtual bool is_match_calosample(int /*calosample*/) const {return true;};
+  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const override {return true;};
+  virtual bool is_match_calosample(int /*calosample*/) const override {return true;};
   
   void set_slope(float slope) {m_slope=slope;};
   void set_offset(float offset) {m_offset=offset;};
 
   // Initialize simulstate with the mean reconstructed energy in the calorimater expeted from the true kinetic energy
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  void Print(Option_t *option="") const;
+  void Print(Option_t *option="") const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
 private:
   float m_slope;
   float m_offset;
 
-  ClassDef(TFCSEnergyInterpolationLinear,1)  //TFCSEnergyInterpolationLinear
+  ClassDefOverride(TFCSEnergyInterpolationLinear,1)  //TFCSEnergyInterpolationLinear
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationSpline.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationSpline.h
index 8dbd11647b858164b11411eb3c35806b51a3a496..dab7cf0e8009fca1aa74df36b06b28f3eebedf01 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationSpline.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyInterpolationSpline.h
@@ -14,8 +14,8 @@ class TFCSEnergyInterpolationSpline:public TFCSParametrization {
 public:
   TFCSEnergyInterpolationSpline(const char* name=nullptr, const char* title=nullptr);
 
-  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const {return true;};
-  virtual bool is_match_calosample(int /*calosample*/) const {return true;};
+  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const override {return true;};
+  virtual bool is_match_calosample(int /*calosample*/) const override {return true;};
   
   ///Initialize interpolation from spline
   ///x values should be log(Ekin), y values should <E(reco)/Ekin(true)>
@@ -32,15 +32,15 @@ public:
   const TSpline3& spline() const {return m_spline;};
 
   ///Initialize simulstate with the mean reconstructed energy in the calorimater expeted from the true kinetic energy
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  void Print(Option_t *option="") const;
+  void Print(Option_t *option="") const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr,TGraph* grspline=nullptr);
 private:
   TSpline3 m_spline;
 
-  ClassDef(TFCSEnergyInterpolationSpline,1)  //TFCSEnergyInterpolationSpline
+  ClassDefOverride(TFCSEnergyInterpolationSpline,1)  //TFCSEnergyInterpolationSpline
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyParametrization.h
index 265a4fe64236be178ac472ba824da265018b3226..35c19369c324fe251128aa3e145be4d019c3c96c 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyParametrization.h
@@ -11,15 +11,15 @@ class TFCSEnergyParametrization:public TFCSParametrization {
 public:
   TFCSEnergyParametrization(const char* name=nullptr, const char* title=nullptr);
 
-  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const {return true;};
-  virtual bool is_match_calosample(int /*calosample*/) const {return true;};
+  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const override {return true;};
+  virtual bool is_match_calosample(int /*calosample*/) const override {return true;};
 
   // return number of energy parametrization bins
   virtual int n_bins() const {return 0;};
 
 private:
 
-  ClassDef(TFCSEnergyParametrization,1)  //TFCSEnergyParametrization
+  ClassDefOverride(TFCSEnergyParametrization,1)  //TFCSEnergyParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHistoLateralShapeParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHistoLateralShapeParametrization.h
index e7c96829bc327e389ca701700f62074c66559fe5..6066bad3d8f24b58b8ec4a9609d8d9fe69bb1d5c 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHistoLateralShapeParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHistoLateralShapeParametrization.h
@@ -30,12 +30,12 @@ public:
   float get_number_of_expected_hits() const {return m_nhits;};
 
   /// default for this class is to simulate poisson(integral histogram) hits
-  int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
+  int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const override;
 
   /// simulated one hit position with weight that should be put into simulstate
   /// sometime later all hit weights should be resacled such that their final sum is simulstate->E(sample)
   /// someone also needs to map all hits into cells
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
   /// Init from histogram. The integral of the histogram is used as number of expected hits to be generated
   bool Initialize(TH2* hist);
@@ -44,13 +44,13 @@ public:
   TFCS2DFunctionHistogram& histogram() {return m_hist;};
   const TFCS2DFunctionHistogram& histogram() const {return m_hist;};
   
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
 private:
   /// Histogram to be used for the shape simulation
   TFCS2DFunctionHistogram m_hist;
   float m_nhits;
 
-  ClassDef(TFCSHistoLateralShapeParametrization,1)  //TFCSHistoLateralShapeParametrization
+  ClassDefOverride(TFCSHistoLateralShapeParametrization,1)  //TFCSHistoLateralShapeParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMapping.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMapping.h
index 7620f5f311e6da8f69159c2f7605e02714dfba7d..1e0a68ec68b6052289023fb0b6189fe9ba910b40 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMapping.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMapping.h
@@ -13,18 +13,19 @@ class TFCSHitCellMapping:public TFCSLateralShapeParametrizationHitBase {
 public:
   TFCSHitCellMapping(const char* name=nullptr, const char* title=nullptr, ICaloGeometry* geo=nullptr);
   
-  void set_geometry(ICaloGeometry* geo) {m_geo=geo;};
+  virtual void set_geometry(ICaloGeometry* geo) override {m_geo=geo;};
   ICaloGeometry* get_geometry() {return m_geo;};
 
   /// fills all hits into calorimeter cells
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  void Print(Option_t *option) const;
+  void Print(Option_t *option) const override;
 
 protected:
   ICaloGeometry* m_geo; //! do not persistify
+
 private:
-  ClassDef(TFCSHitCellMapping,1)  //TFCSHitCellMapping
+  ClassDefOverride(TFCSHitCellMapping, 1) //TFCSHitCellMapping
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingFCal.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingFCal.h
index 4aee99d8e7e95e5167162f201ee1bcefce9283a5..8e66c2d04cd0a3a6f6dbe60aa6ba2d1cfefa4eff 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingFCal.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingFCal.h
@@ -13,10 +13,10 @@ class TFCSHitCellMappingFCal:public TFCSHitCellMapping {
 public:
   TFCSHitCellMappingFCal(const char* name=nullptr, const char* title=nullptr, ICaloGeometry* geo=nullptr):TFCSHitCellMapping(name,title,geo){}
   
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
 private:
-  ClassDef(TFCSHitCellMappingFCal,1)  //TFCSHitCellMapping
+  ClassDefOverride(TFCSHitCellMappingFCal,1)  //TFCSHitCellMapping
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggle.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggle.h
index d0e009f515f973594b6b463d15e16a9828e5c511..59374d81bb3af36ef281911bdb811b10ddbe02f2 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggle.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggle.h
@@ -32,9 +32,9 @@ public:
 
   /// modify one hit position to emulate the LAr accordeon shape
   /// and then fills all hits into calorimeter cells
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  void Print(Option_t *option="") const;
+  void Print(Option_t *option="") const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, TFCSExtrapolationState* extrapol=nullptr);
 
@@ -44,7 +44,7 @@ private:
   std::vector< const TFCS1DFunction* > m_functions = {nullptr};
   std::vector< float > m_bin_low_edge = {0,static_cast<float>(init_eta_max)};
 
-  ClassDef(TFCSHitCellMappingWiggle,1)  //TFCSHitCellMappingWiggle
+  ClassDefOverride(TFCSHitCellMappingWiggle,1)  //TFCSHitCellMappingWiggle
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggleEMB.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggleEMB.h
index 70e4d56c1ff0366d47747d36e9a5ad1bc57d4e40..1624d6a19d6fa6352c7301de8f18719aa413b02e 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggleEMB.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSHitCellMappingWiggleEMB.h
@@ -13,7 +13,7 @@ public:
 
   /// modify one hit position to emulate the LAr accordeon shape
   /// and then fills all hits into calorimeter cells
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 private:
   //** Array for the hit-to-cell assignment accordion structure fix (wiggle)  **//
   //** To be moved to the conditions database at some point **//
@@ -23,7 +23,7 @@ private:
 
   double doWiggle();
 
-  ClassDef(TFCSHitCellMappingWiggleEMB,1)  //TFCSHitCellMappingWiggleEMB
+  ClassDefOverride(TFCSHitCellMappingWiggleEMB,1)  //TFCSHitCellMappingWiggleEMB
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInitWithEkin.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInitWithEkin.h
index b782795dbd60cb62021625a0a146bf6143a01439..f3b267ecb4751ea2ee95285c248e786b2465dd92 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInitWithEkin.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInitWithEkin.h
@@ -11,16 +11,16 @@ class TFCSInitWithEkin:public TFCSParametrization {
 public:
   TFCSInitWithEkin(const char* name=nullptr, const char* title=nullptr);
 
-  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const {return true;};
-  virtual bool is_match_calosample(int /*calosample*/) const {return true;};
-  virtual bool is_match_all_Ekin_bin() const {return true;};
-  virtual bool is_match_all_calosample() const {return true;};
+  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const override {return true;};
+  virtual bool is_match_calosample(int /*calosample*/) const override {return true;};
+  virtual bool is_match_all_Ekin_bin() const override {return true;};
+  virtual bool is_match_all_calosample() const override {return true;};
 
   // Initialize simulstate with the kinetic energy Ekin from truth
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 private:
 
-  ClassDef(TFCSInitWithEkin,1)  //TFCSInitWithEkin
+  ClassDefOverride(TFCSInitWithEkin,1)  //TFCSInitWithEkin
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInvisibleParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInvisibleParametrization.h
index cac15460c1802a7a9c9a5dbc6aa282115c44a6ef..ee16a395a9a9765253db856bf414991f9281ec2d 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInvisibleParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInvisibleParametrization.h
@@ -11,13 +11,13 @@ class TFCSInvisibleParametrization:public TFCSParametrization {
 public:
   TFCSInvisibleParametrization(const char* name=nullptr, const char* title=nullptr):TFCSParametrization(name,title) {};
 
-  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const {return true;};
-  virtual bool is_match_calosample(int /*calosample*/) const {return true;};
+  virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const override {return true;};
+  virtual bool is_match_calosample(int /*calosample*/) const override {return true;};
 
-  void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 private:
 
-  ClassDef(TFCSInvisibleParametrization,1)  //TFCSInvisibleParametrization
+  ClassDefOverride(TFCSInvisibleParametrization,1)  //TFCSInvisibleParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h
index 743523ec8d8e779c3b7be9ee83ec6bf44b9bfe92..5dd736368d6528f17487ffab52d31d9245c82967 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h
@@ -11,11 +11,11 @@ class TFCSLateralShapeParametrization:public TFCSParametrization {
 public:
   TFCSLateralShapeParametrization(const char* name=nullptr, const char* title=nullptr);
 
-  bool is_match_Ekin_bin(int bin) const {if(Ekin_bin()==-1) return true;return bin==Ekin_bin();};
-  bool is_match_calosample(int calosample) const {return calosample==m_calosample;};
+  bool is_match_Ekin_bin(int bin) const override {if(Ekin_bin()==-1) return true;return bin==Ekin_bin();};
+  bool is_match_calosample(int calosample) const override {return calosample==m_calosample;};
 
-  virtual bool is_match_all_Ekin_bin() const {if(Ekin_bin()==-1) return true;return false;};
-  virtual bool is_match_all_calosample() const {return false;};
+  virtual bool is_match_all_Ekin_bin() const override {if(Ekin_bin()==-1) return true;return false;};
+  virtual bool is_match_all_calosample() const override {return false;};
   
   int Ekin_bin() const {return m_Ekin_bin;};
   void set_Ekin_bin(int bin);
@@ -25,12 +25,12 @@ public:
 
   virtual void set_pdgid_Ekin_eta_Ekin_bin_calosample(const TFCSLateralShapeParametrization& ref);
   
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
 private:
   int m_Ekin_bin;
   int m_calosample;
 
-  ClassDef(TFCSLateralShapeParametrization,1)  //TFCSLateralShapeParametrization
+  ClassDefOverride(TFCSLateralShapeParametrization,1)  //TFCSLateralShapeParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h
index f53cbc785e794d77b4b8e15463a172e7443dbc62..cd5221c268fa42f847cf242e1672b76e5648c9ed 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h
@@ -59,10 +59,10 @@ public:
   /// simulated one hit position with some energy. As last step in TFCSLateralShapeParametrizationHitChain::simulate, 
   /// the hit should be mapped into a cell and this cell recorded in simulstate. 
   /// All hits/cells should be resacled such that their final sum is simulstate->E(sample)
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
 private:
 
-  ClassDef(TFCSLateralShapeParametrizationHitBase,1)  //TFCSLateralShapeParametrizationHitBase
+  ClassDefOverride(TFCSLateralShapeParametrizationHitBase,1)  //TFCSLateralShapeParametrizationHitBase
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitChain.h
index c101ba418a291147858d53af9e92777c3205ecae..4a912ace0c96c4d832a4fd45f0fb5a54b1b9111a 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitChain.h
@@ -14,14 +14,14 @@ public:
   TFCSLateralShapeParametrizationHitChain(const char* name=nullptr, const char* title=nullptr);
   TFCSLateralShapeParametrizationHitChain(TFCSLateralShapeParametrizationHitBase* hitsim);
 
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  virtual void set_geometry(ICaloGeometry* geo);
+  virtual void set_geometry(ICaloGeometry* geo) override;
 
   typedef std::vector< TFCSLateralShapeParametrizationHitBase* > Chain_t;
-  virtual unsigned int size() const {return m_chain.size();};
-  virtual const TFCSParametrizationBase* operator[](unsigned int ind) const {return m_chain[ind];};
-  virtual TFCSParametrizationBase* operator[](unsigned int ind) {return m_chain[ind];};
+  virtual unsigned int size() const override {return m_chain.size();};
+  virtual const TFCSParametrizationBase* operator[](unsigned int ind) const override {return m_chain[ind];};
+  virtual TFCSParametrizationBase* operator[](unsigned int ind) override {return m_chain[ind];};
   const Chain_t& chain() const {return m_chain;};
   Chain_t& chain() {return m_chain;};
   void push_back( const Chain_t::value_type& value ) {m_chain.push_back(value);};
@@ -31,11 +31,11 @@ public:
   /// Call get_number_of_hits() only once, as it could contain a random number
   virtual int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
 
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
 
 #if defined(__FastCaloSimStandAlone__)
   /// Update outputlevel
-  virtual void setLevel(int level,bool recursive=false) {
+  virtual void setLevel(int level,bool recursive=false) override {
     TFCSLateralShapeParametrization::setLevel(level,recursive);
     if(recursive) if(m_number_of_hits_simul) m_number_of_hits_simul->setLevel(level,recursive);
   }
@@ -45,7 +45,7 @@ public:
 private:
   Chain_t m_chain;
   TFCSLateralShapeParametrizationHitBase* m_number_of_hits_simul;
-  ClassDef(TFCSLateralShapeParametrizationHitChain,1)  //TFCSLateralShapeParametrizationHitChain
+  ClassDefOverride(TFCSLateralShapeParametrizationHitChain,1)  //TFCSLateralShapeParametrizationHitChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitNumberFromE.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitNumberFromE.h
index 1a43b160857533e81fe61b32e6bddafaa707167c..ec4ef2f20d365d47f7485adadb87b4c8014ff7e1 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitNumberFromE.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitNumberFromE.h
@@ -27,15 +27,15 @@ public:
   ///    constant=0.035;
   TFCSLateralShapeParametrizationHitNumberFromE(const char* name=nullptr, const char* title=nullptr,double stochastic=0.1,double constant=0);
 
-  int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
+  int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const override;
 
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
 private:
   // simple shape information should be stored as private member variables here
   double m_stochastic;
   double m_constant;
 
-  ClassDef(TFCSLateralShapeParametrizationHitNumberFromE,1)  //TFCSLateralShapeParametrizationHitNumberFromE
+  ClassDefOverride(TFCSLateralShapeParametrizationHitNumberFromE,1)  //TFCSLateralShapeParametrizationHitNumberFromE
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h
index 1f9f9d9ce5a723f7e73d7503df5689dfdae643bc..c9556bdf6cae84a7e3152fc5899a68b9dfbbd06f 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h
@@ -19,24 +19,24 @@ class TFCSPCAEnergyParametrization:public TFCSEnergyParametrization
  public:
   TFCSPCAEnergyParametrization(const char* name=nullptr, const char* title=nullptr);
 
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
   
   int n_pcabins() const { return m_numberpcabins; };
-  virtual int n_bins() const {return m_numberpcabins;};
+  virtual int n_bins() const override {return m_numberpcabins;};
   const std::vector<int>& get_layers() const { return m_RelevantLayers; };
 
-  virtual bool is_match_Ekin_bin(int Ekin_bin) const;
-  virtual bool is_match_calosample(int calosample) const;
-  virtual bool is_match_all_Ekin_bin() const {return true;};
-  virtual bool is_match_all_calosample() const {return false;};
+  virtual bool is_match_Ekin_bin(int Ekin_bin) const override;
+  virtual bool is_match_calosample(int calosample) const override;
+  virtual bool is_match_all_Ekin_bin() const override {return true;};
+  virtual bool is_match_all_calosample() const override {return false;};
   
   void P2X(TVectorD*, TVectorD* , TMatrixD* , int, double* , double* , int);
   bool loadInputs(TFile* file);
   bool loadInputs(TFile* file,std::string);
   void clean();
   
-  void Print(Option_t *option = "") const;
-  
+  void Print(Option_t *option = "") const override;
+
   int                       do_rescale;
   
  private:
@@ -52,7 +52,7 @@ class TFCSPCAEnergyParametrization:public TFCSEnergyParametrization
   
   int m_numberpcabins;
   
-  ClassDef(TFCSPCAEnergyParametrization,1)  //TFCSPCAEnergyParametrization
+  ClassDefOverride(TFCSPCAEnergyParametrization,1)  //TFCSPCAEnergyParametrization
  
 };
 
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrization.h
index e94934f98ff9e1c6519ec64cb5bfa9d37efe51e5..df7e3b95be06781655ff4efb7855d987419794e6 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrization.h
@@ -12,22 +12,22 @@ public:
   TFCSParametrization(const char* name=nullptr, const char* title=nullptr);
   void clear();
 
-  virtual bool is_match_pdgid(int id) const {return TestBit(kMatchAllPDGID) || m_pdgid.find(id)!=m_pdgid.end();};
-  virtual bool is_match_Ekin(float Ekin) const {return (Ekin>=m_Ekin_min) && (Ekin<m_Ekin_max);};
-  virtual bool is_match_eta(float eta) const {return (eta>=m_eta_min) && (eta<m_eta_max);};
-
-  virtual bool is_match_all_Ekin() const {return Ekin_min()==init_Ekin_min && Ekin_max()==init_Ekin_max;};
-  virtual bool is_match_all_eta() const {return eta_min()==init_eta_min && eta_max()==init_eta_max;};
-  virtual bool is_match_all_Ekin_bin() const {return true;};
-  virtual bool is_match_all_calosample() const {return true;};
-
-  const std::set< int > &pdgid() const {return m_pdgid;};
-  double Ekin_nominal() const {return m_Ekin_nominal;};
-  double Ekin_min() const {return m_Ekin_min;};
-  double Ekin_max() const {return m_Ekin_max;};
-  double eta_nominal() const {return m_eta_nominal;};
-  double eta_min() const {return m_eta_min;};
-  double eta_max() const {return m_eta_max;};
+  virtual bool is_match_pdgid(int id) const override {return TestBit(kMatchAllPDGID) || m_pdgid.find(id)!=m_pdgid.end();};
+  virtual bool is_match_Ekin(float Ekin) const override {return (Ekin>=m_Ekin_min) && (Ekin<m_Ekin_max);};
+  virtual bool is_match_eta(float eta) const override {return (eta>=m_eta_min) && (eta<m_eta_max);};
+
+  virtual bool is_match_all_Ekin() const override {return Ekin_min()==init_Ekin_min && Ekin_max()==init_Ekin_max;};
+  virtual bool is_match_all_eta() const override {return eta_min()==init_eta_min && eta_max()==init_eta_max;};
+  virtual bool is_match_all_Ekin_bin() const override {return true;};
+  virtual bool is_match_all_calosample() const override {return true;};
+
+  const std::set< int > &pdgid() const override {return m_pdgid;};
+  double Ekin_nominal() const override {return m_Ekin_nominal;};
+  double Ekin_min() const override {return m_Ekin_min;};
+  double Ekin_max() const override {return m_Ekin_max;};
+  double eta_nominal() const override {return m_eta_nominal;};
+  double eta_min() const override {return m_eta_min;};
+  double eta_max() const override {return m_eta_max;};
 
   virtual void set_pdgid(int id);
   virtual void set_pdgid(const std::set< int > &ids);
@@ -51,7 +51,7 @@ private:
   double m_Ekin_nominal,m_Ekin_min,m_Ekin_max;
   double m_eta_nominal,m_eta_min,m_eta_max;
 
-  ClassDef(TFCSParametrization,1)  //TFCSParametrization
+  ClassDefOverride(TFCSParametrization,1)  //TFCSParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h
index 553a729dc114a9db37418d43d4c07a692b82a6fc..d80dc3421cba5e4359e2bf804a4f2041655bdc44 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h
@@ -14,14 +14,14 @@ public:
 
   //selects on |extrapol->IDCaloBoundary_eta()|
   //return -1 if outside range
-  virtual int get_bin(TFCSSimulationState&,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
-  virtual const std::string get_bin_text(int bin) const;
+  virtual int get_bin(TFCSSimulationState&,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const override;
+  virtual const std::string get_bin_text(int bin) const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, TFCSExtrapolationState* extrapol=nullptr);
 
 private:
 
-  ClassDef(TFCSParametrizationAbsEtaSelectChain,1)  //TFCSParametrizationAbsEtaSelectChain
+  ClassDefOverride(TFCSParametrizationAbsEtaSelectChain,1)  //TFCSParametrizationAbsEtaSelectChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBase.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBase.h
index 55eb9659969e856ed57097f59ff8001f898a1643..5d11ae369f132fcf724d8f6f4d7ea9997c46eabd 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBase.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBase.h
@@ -73,6 +73,15 @@ Several basic types of parametrization exists:
 - a special case of TFCSLateralShapeParametrization is TFCSLateralShapeParametrizationHitBase for hit level shape simulation through the simulate_hit method. Hit level simulation is controlled through the special chain TFCSLateralShapeParametrizationHitChain.
 */
 
+///Return codes for the simulate function
+enum FCSReturnCode {
+  FCSFatal = 0,
+  FCSSuccess = 1,
+  FCSRetry = 2
+};
+
+#define FCS_RETRY_COUNT 3
+
 class TFCSParametrizationBase:public TNamed {
 public:
   TFCSParametrizationBase(const char* name=nullptr, const char* title=nullptr);
@@ -122,7 +131,7 @@ public:
   virtual TFCSParametrizationBase* operator[](unsigned int /*ind*/) {return nullptr;};
 
   ///Method in all derived classes to do some simulation
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
 
   ///Print object information. 
   void Print(Option_t *option = "") const;
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h
index b6a6adbb164f750c76f22032ee9877d72ab5d2d1..720a5a64fc5bbf3a8ab2884b62cc37ef38e09f91 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h
@@ -25,9 +25,9 @@ public:
   ///print the range of a bin; for bin -1, print the allowed range
   virtual const std::string get_bin_text(int bin) const;
 
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
   
   static void unit_test(TFCSSimulationState* simulstate=nullptr,const TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
 
@@ -41,7 +41,7 @@ protected:
 
 private:
 
-  ClassDef(TFCSParametrizationBinnedChain,1)  //TFCSParametrizationBinnedChain
+  ClassDefOverride(TFCSParametrizationBinnedChain,1)  //TFCSParametrizationBinnedChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.h
index 78eb717a7d31ce80c22dd19df227ee03b2c6426a..6d97dc41bc6049cd82d9669b5ec2cdb7830b8112 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.h
@@ -13,19 +13,19 @@ public:
   TFCSParametrizationChain(const TFCSParametrizationChain& ref):TFCSParametrization(ref.GetName(),ref.GetTitle()),m_chain(ref.chain()) {};
 
   typedef std::vector< TFCSParametrizationBase* > Chain_t;
-  virtual unsigned int size() const {return m_chain.size();};
-  virtual const TFCSParametrizationBase* operator[](unsigned int ind) const {return m_chain[ind];};
-  virtual TFCSParametrizationBase* operator[](unsigned int ind) {return m_chain[ind];};
+  virtual unsigned int size() const override {return m_chain.size();};
+  virtual const TFCSParametrizationBase* operator[](unsigned int ind) const override {return m_chain[ind];};
+  virtual TFCSParametrizationBase* operator[](unsigned int ind) override {return m_chain[ind];};
   const Chain_t& chain() const {return m_chain;};
   Chain_t& chain() {return m_chain;};
   void push_back(const Chain_t::value_type& param) {m_chain.push_back(param);recalc();};
 
-  virtual bool is_match_Ekin_bin(int Ekin_bin) const;
-  virtual bool is_match_calosample(int calosample) const;
+  virtual bool is_match_Ekin_bin(int Ekin_bin) const override;
+  virtual bool is_match_calosample(int calosample) const override;
 
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
-  void Print(Option_t *option = "") const;
+  void Print(Option_t *option = "") const override;
 protected:
   void recalc_pdgid_intersect();
   void recalc_pdgid_union();
@@ -40,12 +40,17 @@ protected:
   
   ///Default is to call recalc_pdgid_intersect() and recalc_Ekin_eta_intersect()
   virtual void recalc();
+
+  FCSReturnCode simulate_and_retry(TFCSParametrizationBase* parametrization, TFCSSimulationState& simulstate, const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+
 private:  
   Chain_t m_chain;
 
-  ClassDef(TFCSParametrizationChain,1)  //TFCSParametrizationChain
+  ClassDefOverride(TFCSParametrizationChain,1)  //TFCSParametrizationChain
 };
 
+#include "ISF_FastCaloSimEvent/TFCSParametrizationChain.icc"
+
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
 #pragma link C++ class TFCSParametrizationChain+;
 #endif
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.icc b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.icc
new file mode 100644
index 0000000000000000000000000000000000000000..dbc515fe1ad2d6c0764bb15f3f2f5bdd521ad940
--- /dev/null
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.icc
@@ -0,0 +1,23 @@
+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ISF_FastCaloSimEvent/TFCSParametrization.h"
+
+inline FCSReturnCode TFCSParametrizationChain::simulate_and_retry(TFCSParametrizationBase* parametrization, TFCSSimulationState& simulstate, const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+{
+  for (int i = 0; i <= FCS_RETRY_COUNT; i++) {
+    if (i > 0) ATH_MSG_WARNING("TFCSParametrizationChain::simulate(): Retry simulate call " << i << "/" << FCS_RETRY_COUNT);
+
+    FCSReturnCode status = parametrization->simulate(simulstate, truth, extrapol);
+
+    if (status == FCSSuccess)
+      return FCSSuccess;
+    else if (status == FCSFatal)
+      return FCSFatal;
+  }
+
+  ATH_MSG_FATAL("TFCSParametrizationChain::simulate(): Simulate call failed after " << FCS_RETRY_COUNT << "retries");
+
+  return FCSFatal;
+}
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h
index 15aef2976fadcbcfeff6fa01f07194c375a81067..75c6be70555d5b585593c405007b4008fe04d3be 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h
@@ -14,13 +14,13 @@ public:
   TFCSParametrizationEbinChain(const TFCSParametrizationEbinChain& ref):TFCSParametrizationBinnedChain(ref) {};
 
   /// current convention is to start Ebin counting at 1, to be updated to start counting with 0
-  virtual int get_bin(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const {return simulstate.Ebin();};
-  virtual const std::string get_variable_text(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const;
+  virtual int get_bin(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const override {return simulstate.Ebin();};
+  virtual const std::string get_variable_text(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,const TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
 private:
 
-  ClassDef(TFCSParametrizationEbinChain,1)  //TFCSParametrizationEbinChain
+  ClassDefOverride(TFCSParametrizationEbinChain,1)  //TFCSParametrizationEbinChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h
index 04cefb369498113173a7c0e645c8a4d551992970..ce0378346c025854fe118d884ae6972f1212d7ac 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h
@@ -26,18 +26,18 @@ public:
   virtual void push_back_in_bin(TFCSParametrizationBase* param);
   //selects on truth->Ekin()
   //return -1 if outside range
-  virtual int get_bin(TFCSSimulationState&,const TFCSTruthState* truth, const TFCSExtrapolationState*) const;
-  virtual const std::string get_variable_text(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const;
-  virtual const std::string get_bin_text(int bin) const;
+  virtual int get_bin(TFCSSimulationState&,const TFCSTruthState* truth, const TFCSExtrapolationState*) const override;
+  virtual const std::string get_variable_text(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const override;
+  virtual const std::string get_bin_text(int bin) const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
 
 protected:
-  void recalc();
+  virtual void recalc() override;
 
 private:
 
-  ClassDef(TFCSParametrizationEkinSelectChain,1)  //TFCSParametrizationEkinSelectChain
+  ClassDefOverride(TFCSParametrizationEkinSelectChain,1)  //TFCSParametrizationEkinSelectChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h
index 577e28759c6ac7fb17fda3458c39ef93b8c36c42..c7924a8e8464a605efc7d6b2dfb8bc8d4a85d9ae 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h
@@ -16,18 +16,18 @@ public:
   virtual void push_back_in_bin(TFCSParametrizationBase* param);
   //selects on extrapol->IDCaloBoundary_eta()
   //return -1 if outside range
-  virtual int get_bin(TFCSSimulationState&,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
-  virtual const std::string get_variable_text(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const;
-  virtual const std::string get_bin_text(int bin) const;
+  virtual int get_bin(TFCSSimulationState&,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const override;
+  virtual const std::string get_variable_text(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const override;
+  virtual const std::string get_bin_text(int bin) const override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, TFCSExtrapolationState* extrapol=nullptr);
 
 protected:
-  void recalc();
+  virtual void recalc() override;
 
 private:
 
-  ClassDef(TFCSParametrizationEtaSelectChain,1)  //TFCSParametrizationEtaSelectChain
+  ClassDefOverride(TFCSParametrizationEtaSelectChain,1)  //TFCSParametrizationEtaSelectChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h
index 844944e67a0fb73e1f40de59d537890e6e9cfce9..1d7d2a498d6112f22db6ec43abfde9575529a72a 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h
@@ -14,7 +14,7 @@ public:
 
   virtual int push_back_in_bin(TFCSParametrizationBase* param, float low, float up);
   ///Should not be used unless the bin boundaries are already defined!
-  virtual void push_back_in_bin(TFCSParametrizationBase* param, unsigned int bin);
+  virtual void push_back_in_bin(TFCSParametrizationBase* param, unsigned int bin) override;
 
   //return -1 if outside range
   int val_to_bin(float val) const;
@@ -29,7 +29,7 @@ protected:
 
 private:
 
-  ClassDef(TFCSParametrizationFloatSelectChain,1)  //TFCSParametrizationFloatSelectChain
+  ClassDefOverride(TFCSParametrizationFloatSelectChain,1)  //TFCSParametrizationFloatSelectChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h
index 56d8d978ef656925376f7fb6e21cdad5241819d0..766f4bf415fbfd8c412d4efa8ee4610ae20ef904 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h
@@ -21,15 +21,15 @@ public:
   void set_SimulateOnlyOnePDGID() {SetBit(kSimulateOnlyOnePDGID);};
   void reset_SimulateOnlyOnePDGID() {ResetBit(kSimulateOnlyOnePDGID);};
 
-  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
   static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr,TFCSExtrapolationState* extrapol=nullptr);
 protected:
-  virtual void recalc();
+  virtual void recalc() override;
 
 private:
 
-  ClassDef(TFCSParametrizationPDGIDSelectChain,1)  //TFCSParametrizationPDGIDSelectChain
+  ClassDefOverride(TFCSParametrizationPDGIDSelectChain,1)  //TFCSParametrizationPDGIDSelectChain
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyBinParametrization.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyBinParametrization.cxx
index 22a8252772fd55263b2670dc15d039d8d5ff4eed..ba3db006ec7baa9a30349d5ce2d1b5adcbada951 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyBinParametrization.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyBinParametrization.cxx
@@ -99,24 +99,27 @@ void TFCSEnergyBinParametrization::Print(Option_t *option) const
   }  
 }
 
-void TFCSEnergyBinParametrization::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* /*extrapol*/)
+FCSReturnCode TFCSEnergyBinParametrization::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* /*extrapol*/)
 {
   int pdgid=truth->pdgid();
   if(!is_match_pdgid(pdgid)) {
     ATH_MSG_ERROR("TFCSEnergyBinParametrization::simulate(): cannot simulate pdgid="<<pdgid);
-    return;
+    return FCSFatal;
   }
   float searchRand=gRandom->Rndm();
   int chosenBin=TMath::BinarySearch(n_bins()+1, m_pdgid_Ebin_probability[pdgid].data(), searchRand)+1;
   if(chosenBin<1 || chosenBin>n_bins()) {
     ATH_MSG_ERROR("TFCSEnergyBinParametrization::simulate(): cannot simulate bin="<<chosenBin);
+    ATH_MSG_ERROR("  This error could probably be retried.");
     if(msgLvl(MSG::ERROR)) {
       ATH_MSG(ERROR)<<"in "<<GetName()<<": E="<<simulstate.E()<<" Ebin="<<chosenBin<<" rnd="<<searchRand<<" array=";
       for(int iEbin=0;iEbin<=n_bins();++iEbin) msg()<<m_pdgid_Ebin_probability[pdgid][iEbin]<<" ";
       msg()<<std::endl;
     }  
-    return;
+    return FCSFatal;
   }
   simulstate.set_Ebin(chosenBin);
   ATH_MSG_DEBUG("Ebin="<<chosenBin);
+
+  return FCSSuccess;
 }
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationLinear.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationLinear.cxx
index 9744d1a9eb82df21e4502af90bb43b6e3c6404eb..a3a25cc8bf47da5337a8839cb7f1b0baf6a804c8 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationLinear.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationLinear.cxx
@@ -19,12 +19,14 @@ TFCSEnergyInterpolationLinear::TFCSEnergyInterpolationLinear(const char* name, c
 {
 }
 
-void TFCSEnergyInterpolationLinear::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState*)
+FCSReturnCode TFCSEnergyInterpolationLinear::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState*)
 {
   float Emean=m_slope*truth->Ekin()+m_offset;
 
   ATH_MSG_DEBUG("set E="<<Emean<<" for true Ekin="<<truth->Ekin());
   simulstate.set_E(Emean);
+
+  return FCSSuccess;
 }
 
 void TFCSEnergyInterpolationLinear::Print(Option_t *option) const
@@ -67,7 +69,9 @@ void TFCSEnergyInterpolationLinear::unit_test(TFCSSimulationState* simulstate,TF
   for(float Ekin=1000;Ekin<=100000;Ekin*=1.1) {
     //Init LorentzVector for truth. For photon Ekin=E
     truth->SetPxPyPzE(Ekin,0,0,Ekin);
-    test.simulate(*simulstate,truth,extrapol);
+    if (test.simulate(*simulstate,truth,extrapol) != FCSSuccess) {
+      return;
+    }
     gr->SetPoint(ip,Ekin,simulstate->E()/Ekin);
     ++ip;
   }  
@@ -79,4 +83,3 @@ void TFCSEnergyInterpolationLinear::unit_test(TFCSSimulationState* simulstate,TF
   c->SetLogx();
   #endif
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationSpline.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationSpline.cxx
index f996139e679fef553d6491139da5643ad1715d77..bb5b4f1b136b77ce8871ed6800b71c1737e17305 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationSpline.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyInterpolationSpline.cxx
@@ -34,7 +34,7 @@ void TFCSEnergyInterpolationSpline::InitFromArrayInEkin(Int_t np, Double_t Ekin[
   InitFromArrayInLogEkin(np,logEkin.data(),response,opt,valbeg,valend);
 }
 
-void TFCSEnergyInterpolationSpline::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState*)
+FCSReturnCode TFCSEnergyInterpolationSpline::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState*)
 {
   float Emean;
   float logEkin=TMath::Log(truth->Ekin());
@@ -50,6 +50,8 @@ void TFCSEnergyInterpolationSpline::simulate(TFCSSimulationState& simulstate,con
 
   ATH_MSG_DEBUG("set E="<<Emean<<" for true Ekin="<<truth->Ekin());
   simulstate.set_E(Emean);
+
+  return FCSSuccess;
 }
 
 void TFCSEnergyInterpolationSpline::Print(Option_t *option) const
@@ -130,7 +132,9 @@ void TFCSEnergyInterpolationSpline::unit_test(TFCSSimulationState* simulstate,TF
   for(float Ekin=test.Ekin_min()*0.25;Ekin<=test.Ekin_max()*4;Ekin*=1.05) {
     //Init LorentzVector for truth. For photon Ekin=E
     truth->SetPxPyPzE(Ekin,0,0,Ekin);
-    test.simulate(*simulstate,truth,extrapol);
+    if (test.simulate(*simulstate,truth,extrapol) != FCSSuccess) {
+      return;
+    }
     gr->SetPoint(ip,Ekin,simulstate->E()/Ekin);
     ++ip;
   }  
@@ -143,4 +147,3 @@ void TFCSEnergyInterpolationSpline::unit_test(TFCSSimulationState* simulstate,TF
   c->SetLogx();
   #endif
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHistoLateralShapeParametrization.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHistoLateralShapeParametrization.cxx
index 44e7119aa3d9e2c951f815e56b165baead60d7b4..d726ffd45729fcb4c5ad8f836113011127b71036 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHistoLateralShapeParametrization.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHistoLateralShapeParametrization.cxx
@@ -37,7 +37,7 @@ void TFCSHistoLateralShapeParametrization::set_number_of_hits(float nhits)
   m_nhits=nhits;
 }
 
-void TFCSHistoLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSHistoLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
 {
   const int cs=calosample();
   const double center_eta=0.5*( extrapol->eta(cs, CaloSubPos::SUBPOS_ENT) + extrapol->eta(cs, CaloSubPos::SUBPOS_EXT) );
@@ -67,6 +67,9 @@ void TFCSHistoLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationS
     ATH_MSG_ERROR("  Histogram: "<<m_hist.get_HistoBordersx().size()-1<<"*"<<m_hist.get_HistoBordersy().size()-1<<" bins, #hits="<<m_nhits<<" alpha="<<alpha<<" r="<<r<<" rnd1="<<rnd1<<" rnd2="<<rnd2);
     alpha=0;
     r=0.001;
+
+    ATH_MSG_ERROR("  This error could probably be retried");
+    return FCSFatal;
   }
   
   const float delta_eta_mm = r * cos(alpha);
@@ -82,6 +85,8 @@ void TFCSHistoLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationS
   hit.phi() = center_phi + delta_phi;
 
   ATH_MSG_DEBUG("HIT: E="<<hit.E()<<" cs="<<cs<<" eta="<<hit.eta()<<" phi="<<hit.phi()<<" r="<<r<<" alpha="<<alpha);
+
+  return FCSSuccess;
 }
 
 
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMapping.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMapping.cxx
index bd66e0925dca69577d568f7fe7bd1e2b72eb52e9..ce5eac7bc731de0cf8f32ecbd8cd53f76e66b400 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMapping.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMapping.cxx
@@ -17,15 +17,17 @@ TFCSHitCellMapping::TFCSHitCellMapping(const char* name, const char* title, ICal
   set_match_all_pdgid();
 }
 
-void TFCSHitCellMapping::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
+FCSReturnCode TFCSHitCellMapping::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
 {
   int cs=calosample();
   const CaloDetDescrElement* cellele=m_geo->getDDE(cs,hit.eta(),hit.phi());
   ATH_MSG_DEBUG("HIT: cellele="<<cellele<<" E="<<hit.E()<<" cs="<<cs<<" eta="<<hit.eta()<<" phi="<<hit.phi());
   if(cellele) {
     simulstate.deposit(cellele,hit.E());
+    return FCSSuccess;
   } else {
     ATH_MSG_ERROR("TFCSLateralShapeParametrizationHitCellMapping::simulate_hit: cellele="<<cellele<<" E="<<hit.E()<<" cs="<<cs<<" eta="<<hit.eta()<<" phi="<<hit.phi());
+    return FCSFatal;
   }
 }
 
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingFCal.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingFCal.cxx
index 7f493482b30e213507d36a4309abf37033e3c3e3..cc7fc671085e771257646586793cfa4fb150b502 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingFCal.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingFCal.cxx
@@ -11,7 +11,7 @@
 //=============================================
 
 
-void TFCSHitCellMappingFCal::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
+FCSReturnCode TFCSHitCellMappingFCal::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
 {
   int cs=calosample();
   const CaloDetDescrElement* cellele=m_geo->getFCalDDE(cs,hit.x(),hit.y(),hit.z());
@@ -20,5 +20,8 @@ void TFCSHitCellMappingFCal::simulate_hit(Hit& hit,TFCSSimulationState& simulsta
     simulstate.deposit(cellele,hit.E());
   } else {
     ATH_MSG_ERROR("TFCSLateralShapeParametrizationHitCellMapping::simulate_hit: cellele="<<cellele<<" E="<<hit.E()<<" cs="<<cs<<" eta="<<hit.eta()<<" phi="<<hit.phi());
+    return FCSFatal;
   }
+
+  return FCSSuccess;
 }
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggle.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggle.cxx
index fbfa4cac92847be9b219de625207329bf2e27ea2..70f8cf2f0e779933b8bde30b34f08cf939790236 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggle.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggle.cxx
@@ -85,12 +85,11 @@ void TFCSHitCellMappingWiggle::initialize(const std::vector< const TH1* > histog
   initialize(functions,bin_low_edges);
 }
 
-void TFCSHitCellMappingWiggle::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSHitCellMappingWiggle::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
 {
   float eta=fabs(hit.eta());
   if(eta<m_bin_low_edge[0] || eta>=m_bin_low_edge[get_number_of_bins()]) {
-    TFCSHitCellMapping::simulate_hit(hit,simulstate,truth,extrapol);
-    return;
+    return TFCSHitCellMapping::simulate_hit(hit,simulstate,truth,extrapol);
   }  
   
   auto it = std::upper_bound(m_bin_low_edge.begin(),m_bin_low_edge.end(),eta);
@@ -108,7 +107,7 @@ void TFCSHitCellMappingWiggle::simulate_hit(Hit& hit,TFCSSimulationState& simuls
     hit.phi()=TVector2::Phi_mpi_pi(hit_phi_shifted);
   }  
 
-  TFCSHitCellMapping::simulate_hit(hit,simulstate,truth,extrapol);
+  return TFCSHitCellMapping::simulate_hit(hit,simulstate,truth,extrapol);
 }
 
 void TFCSHitCellMappingWiggle::Print(Option_t *option) const
@@ -170,4 +169,3 @@ void TFCSHitCellMappingWiggle::unit_test(TFCSSimulationState* simulstate,TFCSTru
 #endif
 
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggleEMB.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggleEMB.cxx
index bee8b904784af5fc1d769711d5f2dd3edb789d5b..b817853ee81ad3e37eaf1b0d4bc4570f5e7e7a1b 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggleEMB.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHitCellMappingWiggleEMB.cxx
@@ -73,7 +73,7 @@ double TFCSHitCellMappingWiggleEMB::doWiggle()
  return wiggle;
 }
 
-void TFCSHitCellMappingWiggleEMB::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSHitCellMappingWiggleEMB::simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
 {
   int cs=calosample();
 
@@ -85,5 +85,5 @@ void TFCSHitCellMappingWiggleEMB::simulate_hit(Hit& hit,TFCSSimulationState& sim
   double hit_phi_shifted=hit.phi()-wiggle;
   hit.phi()=TVector2::Phi_mpi_pi(hit_phi_shifted);
 
-  TFCSHitCellMapping::simulate_hit(hit,simulstate,truth,extrapol);
+  return TFCSHitCellMapping::simulate_hit(hit,simulstate,truth,extrapol);
 }
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInitWithEkin.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInitWithEkin.cxx
index 5eeed2cd5cb05c30f0d38083bc7875921dfff2d6..74980f736e3a2b365d94450fb853071eaa43bf33 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInitWithEkin.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInitWithEkin.cxx
@@ -15,10 +15,9 @@ TFCSInitWithEkin::TFCSInitWithEkin(const char* name, const char* title):TFCSPara
   set_match_all_pdgid();
 }
 
-void TFCSInitWithEkin::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState*)
+FCSReturnCode TFCSInitWithEkin::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState*)
 {
   ATH_MSG_DEBUG("set E to Ekin="<<truth->Ekin());
   simulstate.set_E(truth->Ekin());
+  return FCSSuccess;
 }
-
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInvisibleParametrization.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInvisibleParametrization.cxx
index 2e0bd47d8ce829c0540dafdaaca2e64d9b745a6d..a2d4f8d1cf59e31da144a281c59b71973f22aef9 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInvisibleParametrization.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSInvisibleParametrization.cxx
@@ -8,8 +8,8 @@
 //======= TFCSInvisibleParametrization =========
 //=============================================
 
-void TFCSInvisibleParametrization::simulate(TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
+FCSReturnCode TFCSInvisibleParametrization::simulate(TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
 {
   ATH_MSG_VERBOSE("now in TFCSInvisibleParametrization::simulate(). Don't do anything for invisible");
+  return FCSSuccess;
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitBase.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitBase.cxx
index 8692fbc5f4dcfc34961d8ea585854a54e217d4c3..ace709d6cc37beff91c039906f7a6ea15db0fe88 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitBase.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitBase.cxx
@@ -21,9 +21,11 @@ int TFCSLateralShapeParametrizationHitBase::get_number_of_hits(TFCSSimulationSta
   return -1;
 }
 
-void TFCSLateralShapeParametrizationHitBase::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSLateralShapeParametrizationHitBase::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
 {
   int cs=calosample();
   hit.eta()=0.5*( extrapol->eta(cs, CaloSubPos::SUBPOS_ENT) + extrapol->eta(cs, CaloSubPos::SUBPOS_EXT) );
   hit.phi()=0.5*( extrapol->phi(cs, CaloSubPos::SUBPOS_ENT) + extrapol->phi(cs, CaloSubPos::SUBPOS_EXT) );
+
+  return FCSSuccess;
 }
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitChain.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitChain.cxx
index aeb539de5f3a51492495d0896126f0ee46f87b3f..798689be0fd32219b3700e00c8dccc9cde50da9f 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitChain.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSLateralShapeParametrizationHitChain.cxx
@@ -42,32 +42,44 @@ int TFCSLateralShapeParametrizationHitChain::get_number_of_hits(TFCSSimulationSt
   return 1;
 }
 
-void TFCSLateralShapeParametrizationHitChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSLateralShapeParametrizationHitChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
 {
   // Call get_number_of_hits() only once, as it could contain a random number
   int nhit=get_number_of_hits(simulstate,truth,extrapol);
   float Ehit=simulstate.E(calosample())/nhit;
-  
-  if(msgLvl(MSG::DEBUG)) {
+
+  bool debug = msgLvl(MSG::DEBUG);
+  if (debug) {
     ATH_MSG_DEBUG("E("<<calosample()<<")="<<simulstate.E(calosample())<<" #hits="<<nhit);
-    for(int i=0;i<nhit;++i) {
-      TFCSLateralShapeParametrizationHitBase::Hit hit; 
-      hit.E()=Ehit;
-      for(TFCSLateralShapeParametrizationHitBase* hitsim : m_chain) {
-        if(i<2) hitsim->setLevel(MSG::DEBUG);
-         else hitsim->setLevel(MSG::INFO);
-        hitsim->simulate_hit(hit,simulstate,truth,extrapol);
-      } 
-    }  
-  } else {
-    for(int i=0;i<nhit;++i) {
-      TFCSLateralShapeParametrizationHitBase::Hit hit; 
-      hit.E()=Ehit;
-      for(TFCSLateralShapeParametrizationHitBase* hitsim : m_chain) {
-        hitsim->simulate_hit(hit,simulstate,truth,extrapol);
-      } 
-    }  
-  }  
+  }
+
+  for (int i = 0; i < nhit; ++i) {
+    TFCSLateralShapeParametrizationHitBase::Hit hit; 
+    hit.E()=Ehit;
+    for(TFCSLateralShapeParametrizationHitBase* hitsim : m_chain) {
+      if (debug) {
+        if (i < 2) hitsim->setLevel(MSG::DEBUG);
+        else hitsim->setLevel(MSG::INFO);
+      }
+
+      for (int i = 0; i <= FCS_RETRY_COUNT; i++) {
+        if (i > 0) ATH_MSG_WARNING("TFCSLateralShapeParametrizationHitChain::simulate(): Retry simulate_hit call " << i << "/" << FCS_RETRY_COUNT);
+  
+        FCSReturnCode status = hitsim->simulate_hit(hit, simulstate, truth, extrapol);
+
+        if (status == FCSSuccess)
+          break;
+        else if (status == FCSFatal)
+          return FCSFatal;
+
+        if (i == FCS_RETRY_COUNT) {
+          ATH_MSG_ERROR("TFCSLateralShapeParametrizationHitChain::simulate(): simulate_hit call failed after " << FCS_RETRY_COUNT << "retries");
+        }
+      }
+    }
+  }
+
+  return FCSSuccess;
 }
 
 void TFCSLateralShapeParametrizationHitChain::Print(Option_t *option) const
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSPCAEnergyParametrization.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSPCAEnergyParametrization.cxx
index bf3695b474dcfc300ea31d6a24d7215518233c31..29a2e44b841f7b65bd9d93f9ce65f9665f38ae10 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSPCAEnergyParametrization.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSPCAEnergyParametrization.cxx
@@ -58,7 +58,7 @@ void TFCSPCAEnergyParametrization::Print(Option_t *option) const
   }  
 }
 
-void TFCSPCAEnergyParametrization::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
+FCSReturnCode TFCSPCAEnergyParametrization::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
 {
 
   int pcabin=simulstate.Ebin();
@@ -134,6 +134,7 @@ void TFCSPCAEnergyParametrization::simulate(TFCSSimulationState& simulstate,cons
   delete [] input_data;
   delete [] simdata;
 
+  return FCSSuccess;
 }
 
 void TFCSPCAEnergyParametrization::P2X(TVectorD* SigmaValues, TVectorD* MeanValues, TMatrixD *EV, int gNVariables, double *p, double *x, int nTest)
@@ -262,4 +263,3 @@ void TFCSPCAEnergyParametrization::clean()
  for(unsigned int i=0;i<m_EV.size();i++)
   delete m_EV[i];
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBase.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBase.cxx
index 9d9723d1095b86e1f17e40cced8769f8ab64f55f..2b5ec52785edecab66065bca78eb0f43532888b0 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBase.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBase.cxx
@@ -35,9 +35,10 @@ void TFCSParametrizationBase::set_geometry(ICaloGeometry* geo)
 ///Result should be returned in simulstate.
 ///Simulate all energies in calo layers for energy parametrizations.
 ///Simulate cells for shape simulation.
-void TFCSParametrizationBase::simulate(TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
+FCSReturnCode TFCSParametrizationBase::simulate(TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* /*extrapol*/)
 {
   ATH_MSG_ERROR("now in TFCSParametrizationBase::simulate(). This should normally not happen");
+  return FCSFatal;
 }
 
 ///If called with argument "short", only a one line summary will be printed
@@ -74,4 +75,3 @@ void TFCSParametrizationBase::Print(Option_t *option) const
     ATH_MSG_INFO(optprint<<GetTitle());
   }
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBinnedChain.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBinnedChain.cxx
index 5bbcafad86342b1a9e84dbfe0b68b9bbcfffca38..7f3b87389be0e9537750d9b7ad4d42a3e614dd8b 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBinnedChain.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationBinnedChain.cxx
@@ -57,18 +57,22 @@ const std::string TFCSParametrizationBinnedChain::get_bin_text(int bin) const
   return std::string(Form("bin %d",bin));
 }
 
-void TFCSParametrizationBinnedChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSParametrizationBinnedChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
 {
   for(unsigned int ichain=0;ichain<m_bin_start[0];++ichain) {
     ATH_MSG_DEBUG("now run for all bins: "<<chain()[ichain]->GetName());
-    chain()[ichain]->simulate(simulstate,truth,extrapol);
+    if (simulate_and_retry(chain()[ichain], simulstate, truth, extrapol) != FCSSuccess) {
+      return FCSFatal;
+    }
   }
   if(get_number_of_bins()>0) {
     int bin=get_bin(simulstate,truth,extrapol);
     if(bin>=0 && bin<(int)get_number_of_bins()) {
       for(unsigned int ichain=m_bin_start[bin];ichain<m_bin_start[bin+1];++ichain) {
         ATH_MSG_DEBUG("for "<<get_variable_text(simulstate,truth,extrapol)<<" run "<<get_bin_text(bin)<<": "<<chain()[ichain]->GetName());
-        chain()[ichain]->simulate(simulstate,truth,extrapol);
+        if (simulate_and_retry(chain()[ichain], simulstate, truth, extrapol) != FCSSuccess) {
+          return FCSFatal;
+        }
       }
     } else {
       ATH_MSG_WARNING("for "<<get_variable_text(simulstate,truth,extrapol)<<": "<<get_bin_text(bin));
@@ -78,8 +82,12 @@ void TFCSParametrizationBinnedChain::simulate(TFCSSimulationState& simulstate,co
   }  
   for(unsigned int ichain=m_bin_start.back();ichain<size();++ichain) {
     ATH_MSG_DEBUG("now run for all bins: "<<chain()[ichain]->GetName());
-    chain()[ichain]->simulate(simulstate,truth,extrapol);
+    if (simulate_and_retry(chain()[ichain], simulstate, truth, extrapol) != FCSSuccess) {
+      return FCSFatal;
+    }
   }
+
+  return FCSSuccess;
 }
 
 void TFCSParametrizationBinnedChain::Print(Option_t *option) const
@@ -164,4 +172,3 @@ void TFCSParametrizationBinnedChain::unit_test(TFCSSimulationState* simulstate,c
   chain.simulate(*simulstate,truth,extrapol);
   std::cout<<"==================================="<<std::endl<<std::endl;
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationChain.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationChain.cxx
index 34d26f82a518d83580dafde06feca76d9120aad4..0fa9806b76e5fe45af8253935bcf4cf77741b794 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationChain.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationChain.cxx
@@ -125,11 +125,15 @@ bool TFCSParametrizationChain::is_match_calosample(int calosample) const
   return true;
 }
 
-void TFCSParametrizationChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSParametrizationChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
 {
   for(auto param: m_chain) {
-    param->simulate(simulstate,truth,extrapol);
+    if (simulate_and_retry(param, simulstate, truth, extrapol) != FCSSuccess) {
+      return FCSFatal;
+    }
   }
+
+  return FCSSuccess;
 }
 
 void TFCSParametrizationChain::Print(Option_t *option) const
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationPDGIDSelectChain.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationPDGIDSelectChain.cxx
index 92f95764f7d00e1fd53d77873ef06edc66d44ebf..4fe3ddddc13d1088ec082e094df1230302aebe38 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationPDGIDSelectChain.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSParametrizationPDGIDSelectChain.cxx
@@ -24,15 +24,21 @@ void TFCSParametrizationPDGIDSelectChain::recalc()
   chain().shrink_to_fit();
 }
 
-void TFCSParametrizationPDGIDSelectChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSParametrizationPDGIDSelectChain::simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol)
 {
   for(auto param: chain()) {
     if(param->is_match_pdgid(truth->pdgid())) {
       ATH_MSG_DEBUG("pdgid="<<truth->pdgid()<<", now run: "<<param->GetName()<< ((SimulateOnlyOnePDGID()==true) ? ", abort PDGID loop afterwards" : ", continue PDGID loop afterwards"));
-      param->simulate(simulstate,truth,extrapol);
+
+      if (simulate_and_retry(param, simulstate,truth,extrapol) != FCSSuccess) {
+        return FCSFatal;
+      }
+
       if(SimulateOnlyOnePDGID()) break;
     }  
   }
+
+  return FCSSuccess;
 }
 
 void TFCSParametrizationPDGIDSelectChain::unit_test(TFCSSimulationState* simulstate,TFCSTruthState* truth,TFCSExtrapolationState* extrapol)
@@ -104,4 +110,3 @@ void TFCSParametrizationPDGIDSelectChain::unit_test(TFCSSimulationState* simulst
   chain.simulate(*simulstate,truth,extrapol);
   
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSNNLateralShapeParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSNNLateralShapeParametrization.h
index 172791c4b47a8cc9f9b749c92e8e6c449091e69d..d68ea1bf2c1702163eb3189a39467c5c88c370ef 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSNNLateralShapeParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSNNLateralShapeParametrization.h
@@ -14,11 +14,11 @@ public:
   // simulated one hit position with weight that should be put into simulstate
   // sometime later all hit weights should be resacled such that their final sum is simulstate->E(sample)
   // someone also needs to map all hits into cells
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 private:
   // NN shape information should be stored as private member variables here
 
-  ClassDef(TFCSNNLateralShapeParametrization,1)  //TFCSNNLateralShapeParametrization
+  ClassDefOverride(TFCSNNLateralShapeParametrization,1)  //TFCSNNLateralShapeParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSSimpleLateralShapeParametrization.h b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSSimpleLateralShapeParametrization.h
index ba5e6920061671b8a644a2689b0c5ec7ea7d41b8..9b2ff0a30540fb3179dd3c62080e4561047b0fea 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSSimpleLateralShapeParametrization.h
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/ISF_FastCaloSimParametrization/TFCSSimpleLateralShapeParametrization.h
@@ -20,7 +20,7 @@ public:
   // simulated one hit position with weight that should be put into simulstate
   // sometime later all hit weights should be resacled such that their final sum is simulstate->E(sample)
   // someone also needs to map all hits into cells
-  virtual void simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+  virtual FCSReturnCode simulate_hit(Hit& hit,TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) override;
 
   // Init and fill sigma
   bool Initialize(const char* filepath, const char* histname);
@@ -45,7 +45,7 @@ private:
   TRandom3 *m_rnd;
 
 
-  ClassDef(TFCSSimpleLateralShapeParametrization,1)  //TFCSSimpleLateralShapeParametrization
+  ClassDefOverride(TFCSSimpleLateralShapeParametrization,1)  //TFCSSimpleLateralShapeParametrization
 };
 
 #if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSNNLateralShapeParametrization.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSNNLateralShapeParametrization.cxx
index eb3959990df0f8905941372740d66e12cca4fde2..08400981503fd020b3991c859f15731369a8d147 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSNNLateralShapeParametrization.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSNNLateralShapeParametrization.cxx
@@ -14,10 +14,11 @@ TFCSNNLateralShapeParametrization::TFCSNNLateralShapeParametrization(const char*
 {
 }
 
-void TFCSNNLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSNNLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
 {
   int cs=calosample();
   hit.eta()=0.5*( extrapol->eta(cs, CaloSubPos::SUBPOS_ENT) + extrapol->eta(cs, CaloSubPos::SUBPOS_EXT) );
   hit.phi()=0.5*( extrapol->phi(cs, CaloSubPos::SUBPOS_ENT) + extrapol->phi(cs, CaloSubPos::SUBPOS_EXT) );
-}
 
+  return FCSSuccess;
+}
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSSimpleLateralShapeParametrization.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSSimpleLateralShapeParametrization.cxx
index f3524186d16a8909c722d6b115408e5cbeb5e1fb..fcd88efcdcc8ddc6b28548bd977dd4e923b6de3c 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSSimpleLateralShapeParametrization.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimParametrization/Root/TFCSSimpleLateralShapeParametrization.cxx
@@ -26,7 +26,7 @@ TFCSSimpleLateralShapeParametrization::~TFCSSimpleLateralShapeParametrization()
 }
 
 
-void TFCSSimpleLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
+FCSReturnCode TFCSSimpleLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulationState& /*simulstate*/,const TFCSTruthState* /*truth*/, const TFCSExtrapolationState* extrapol)
 {
   int cs=calosample();
   hit.eta()=0.5*( extrapol->eta(cs, CaloSubPos::SUBPOS_ENT) + extrapol->eta(cs, CaloSubPos::SUBPOS_EXT) );
@@ -42,6 +42,8 @@ void TFCSSimpleLateralShapeParametrization::simulate_hit(Hit& hit,TFCSSimulation
 
   hit.eta() += delta_eta;
   hit.phi() += delta_phi;
+
+  return FCSSuccess;
 }
 
 
@@ -138,4 +140,3 @@ void TFCSSimpleLateralShapeParametrization::getHitXY(double &x, double &y)
     y = m_rnd->Gaus(0, m_sigmaY);
 
 }
-
diff --git a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/src/FastCaloSimSvcV2.cxx b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/src/FastCaloSimSvcV2.cxx
index 7111db031accce387f600437507b5842df53728b..4513a725306d2909a7e5d4afad30def11fedac1e 100644
--- a/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/src/FastCaloSimSvcV2.cxx
+++ b/Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/src/FastCaloSimSvcV2.cxx
@@ -219,7 +219,10 @@ StatusCode ISF::FastCaloSimSvcV2::simulate(const ISF::ISFParticle& isfp)
   m_FastCaloSimCaloExtrapolation->extrapolate(extrapol,&truth);
   TFCSSimulationState simulstate;
 
-  m_param->simulate(simulstate, &truth, &extrapol);
+  FCSReturnCode status = m_param->simulate(simulstate, &truth, &extrapol);
+  if (status != FCSSuccess) {
+    return StatusCode::FAILURE;
+  }
 
   ATH_MSG_INFO("Energy returned: " << simulstate.E());
   ATH_MSG_INFO("Energy fraction for layer: ");