Addition of simulation chain elements to select parametrizations based on PDGID, eta dn energy.

Former-commit-id: cdf70a0a

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/CMakeLists.txt

@@ -33,9 +33,18 @@ atlas_add_root_dictionary( ISF_FastCaloSimEvent _dictSource
                            ISF_FastCaloSimEvent/TFCS1DFunctionRegressionTF.h 
                            ISF_FastCaloSimEvent/TFCSParametrizationBase.h 
                            ISF_FastCaloSimEvent/TFCSParametrization.h 
+                           ISF_FastCaloSimEvent/TFCSInitWithEkin.h
                            ISF_FastCaloSimEvent/TFCSParametrizationChain.h 
+                           ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h
+                           ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h
+                           ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h
+                           ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h
+                           ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h
+                           ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h
+                           ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h
                            ISF_FastCaloSimEvent/TFCSEnergyParametrization.h 
                            ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h 
+                           ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h
                            ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h
                            ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h
                            ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitChain.h

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/LinkDef.h

@@ -11,10 +11,19 @@
 
 #include "ISF_FastCaloSimEvent/TFCSParametrizationBase.h"
 #include "ISF_FastCaloSimEvent/TFCSParametrization.h"
+#include "ISF_FastCaloSimEvent/TFCSInitWithEkin.h"
 #include "ISF_FastCaloSimEvent/TFCSParametrizationChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h"
+#include "ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h"
 
 #include "ISF_FastCaloSimEvent/TFCSEnergyParametrization.h"
 #include "ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h"
+#include "ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h"
 
 #include "ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h"
 #include "ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h"
@@ -38,10 +47,19 @@
 
 #pragma link C++ class TFCSParametrizationBase+;
 #pragma link C++ class TFCSParametrization+;
+#pragma link C++ class TFCSInitWithEkin+;
 #pragma link C++ class TFCSParametrizationChain+;
+#pragma link C++ class TFCSParametrizationBinnedChain+;
+#pragma link C++ class TFCSParametrizationFloatSelectChain+;
+#pragma link C++ class TFCSParametrizationPDGIDSelectChain+;
+#pragma link C++ class TFCSParametrizationEbinChain+;
+#pragma link C++ class TFCSParametrizationEkinSelectChain+;
+#pragma link C++ class TFCSParametrizationEtaSelectChain+;
+#pragma link C++ class TFCSParametrizationAbsEtaSelectChain+;
 
 #pragma link C++ class TFCSEnergyParametrization+;
 #pragma link C++ class TFCSPCAEnergyParametrization+;
+#pragma link C++ class TFCSEnergyBinParametrization+;
 
 #pragma link C++ class TFCSLateralShapeParametrization+;
 #pragma link C++ class TFCSLateralShapeParametrizationHitBase+;

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSEnergyBinParametrization_h
+#define ISF_FASTCALOSIMEVENT_TFCSEnergyBinParametrization_h
+
+#include "ISF_FastCaloSimEvent/TFCSEnergyParametrization.h"
+#include<map>
+#include<vector>
+
+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 int n_bins() const {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();};
+
+  /// set_pdgid_Ekin_bin_probability(): format of probability should be a vector of float with probability values, 
+  /// e.g. for equal probability of 5 Ekin bins specify a vector with {0,1,1,1,1,1} or {0,0.2,0.2,0.2,0.2,0.2}
+  /// This would give a probability of 0 for Ekin_bin=0 and a probability of 20% for 1<=Ekin_bin<=5
+  /// the function will normalize probabilities automatically, if the sum of values is not 1
+  /// 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 bool is_match_Ekin_bin(int Ekin_bin) const;
+  
+  void Print(Option_t *option = "") const;
+ private:
+  int m_number_of_Ekin_bins;
+  std::map< int, std::vector< float > > m_pdgid_Ebin_probability;
+  
+  void resize();
+  
+  ClassDef(TFCSEnergyBinParametrization,1)  //TFCSEnergyBinParametrization
+ 
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSEnergyBinParametrization+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSInitWithEkin.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSInitWithEkin_h
+#define ISF_FASTCALOSIMEVENT_TFCSInitWithEkin_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationBase.h"
+
+class TFCSInitWithEkin:public TFCSParametrizationBase {
+public:
+  TFCSInitWithEkin(const char* name=nullptr, const char* title=nullptr);
+
+  virtual bool is_match_Ekin(float /*Ekin*/) const {return true;};
+  virtual bool is_match_eta(float /*eta*/) const {return true;};
+
+  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() const {return true;};
+  virtual bool is_match_all_eta() const {return true;};
+  virtual bool is_match_all_Ekin_bin() const {return true;};
+  virtual bool is_match_all_calosample() const {return true;};
+
+  // Initialize simulstate with the kinetic energy Ekin from truth
+  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+private:
+
+  ClassDef(TFCSInitWithEkin,1)  //TFCSInitWithEkin
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSInitWithEkin+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h

@@ -11,8 +11,11 @@ class TFCSLateralShapeParametrization:public TFCSParametrization {
 public:
   TFCSLateralShapeParametrization(const char* name=nullptr, const char* title=nullptr);
 
-  bool is_match_Ekin_bin(int Ekin_bin) const {return Ekin_bin==m_Ekin_bin;};
+  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;};
+
+  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;};
   
   int Ekin_bin() const {return m_Ekin_bin;};
   void set_Ekin_bin(int bin);
@@ -20,6 +23,8 @@ public:
   int calosample() const {return m_calosample;};
   void set_calosample(int cs);
 
+  virtual void set_pdgid_Ekin_eta_Ekin_bin_calosample(const TFCSLateralShapeParametrization& ref);
+  
   void Print(Option_t *option = "") const;
 private:
   int m_Ekin_bin;

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitBase.h

@@ -5,24 +5,15 @@
 #ifndef TFCSLateralShapeParametrizationHitBase_h
 #define TFCSLateralShapeParametrizationHitBase_h
 
-#include "ISF_FastCaloSimEvent/TFCSParametrization.h"
+#include "ISF_FastCaloSimEvent/TFCSLateralShapeParametrization.h"
 
 class CaloGeometry;
 
-class TFCSLateralShapeParametrizationHitBase:public TFCSParametrization {
+class TFCSLateralShapeParametrizationHitBase:public TFCSLateralShapeParametrization {
 public:
   TFCSLateralShapeParametrizationHitBase(const char* name=nullptr, const char* title=nullptr);
 
-  bool is_match_Ekin_bin(int Ekin_bin) const {return Ekin_bin==m_Ekin_bin;};
-  bool is_match_calosample(int calosample) const {return calosample==m_calosample;};
-  
-  int Ekin_bin() const {return m_Ekin_bin;};
-  void set_Ekin_bin(int bin);
-
-  int calosample() const {return m_calosample;};
-  void set_calosample(int cs);
-
-  /// Call get_number_of_hits() only once per shower simulation, as it could be build with random numbers and give different results each time
+  // Call get_number_of_hits() only once per shower simulation, as it could be build with random numbers and give different results each time
   virtual int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
 
   class Hit
@@ -43,11 +34,7 @@ public:
   /// 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);
-
-  void Print(Option_t *option = "") const;
 private:
-  int m_Ekin_bin;
-  int m_calosample;
 
   ClassDef(TFCSLateralShapeParametrizationHitBase,1)  //TFCSLateralShapeParametrizationHitBase
 };

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSLateralShapeParametrizationHitChain.h

@@ -17,9 +17,11 @@ public:
   virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
 
   virtual void set_geometry(ICaloGeometry* geo);
-  
+
   typedef std::vector< TFCSLateralShapeParametrizationHitBase* > Chain_t;
-  Chain_t::size_type size() const {return m_chain.size();};
+  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];};
   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);};
@@ -30,6 +32,16 @@ public:
   virtual int get_number_of_hits(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol) const;
 
   void Print(Option_t *option = "") const;
+
+#if defined(__FastCaloSimStandAlone__)
+  /// Update outputlevel
+  virtual void setLevel(int level,bool recursive=false) {
+    TFCSLateralShapeParametrization::setLevel(level,recursive);
+    if(recursive) if(m_number_of_hits_simul) m_number_of_hits_simul->setLevel(level,recursive);
+  }
+#endif
+
+
 private:
   Chain_t m_chain;
   TFCSLateralShapeParametrizationHitBase* m_number_of_hits_simul;

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSPCAEnergyParametrization.h

@@ -27,6 +27,8 @@ class TFCSPCAEnergyParametrization:public TFCSEnergyParametrization
 
   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;};
   
   void P2X(TVectorD*, TVectorD* , TMatrixD* , int, double* , double* , int);
   void loadInputs(TFile* file);

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrization.h

@@ -12,10 +12,15 @@ public:
   TFCSParametrization(const char* name=nullptr, const char* title=nullptr);
   void clear();
 
-  virtual bool is_match_pdgid(int id) const {return m_pdgid.find(id)!=m_pdgid.end();};
+  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;};
@@ -24,17 +29,30 @@ public:
   double eta_min() const {return m_eta_min;};
   double eta_max() const {return m_eta_max;};
 
-  void set_pdgid(int id);
-  void set_pdgid(const std::set< int > &ids);
-  void add_pdgid(int id);
-  void clear_pdgid();
-
-  void set_Ekin_nominal(double min);
-  void set_Ekin_min(double min);
-  void set_Ekin_max(double max);
-  void set_eta_nominal(double min);
-  void set_eta_min(double min);
-  void set_eta_max(double max);
+  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_Ekin_nominal(double min);
+  virtual void set_Ekin_min(double min);
+  virtual void set_Ekin_max(double max);
+  virtual void set_eta_nominal(double min);
+  virtual void set_eta_min(double min);
+  virtual void set_eta_max(double max);
+  
+  virtual void set_Ekin(const TFCSParametrizationBase& ref);
+  virtual void set_eta(const TFCSParametrizationBase& ref);
+  virtual void set_Ekin_eta(const TFCSParametrizationBase& ref);
+  virtual void set_pdgid_Ekin_eta(const TFCSParametrizationBase& ref);
+
+protected:
+  const double init_Ekin_nominal=0;
+  const double init_Ekin_min=0;
+  const double init_Ekin_max=14000000;
+  const double init_eta_nominal=0;
+  const double init_eta_min=-100;
+  const double init_eta_max=100;
 
 private:
   std::set< int > m_pdgid;

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationAbsEtaSelectChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationAbsEtaSelectChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationAbsEtaSelectChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h"
+
+class TFCSParametrizationAbsEtaSelectChain:public TFCSParametrizationEtaSelectChain {
+public:
+  TFCSParametrizationAbsEtaSelectChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationEtaSelectChain(name,title) {};
+  TFCSParametrizationAbsEtaSelectChain(const TFCSParametrizationAbsEtaSelectChain& ref):TFCSParametrizationEtaSelectChain(ref) {};
+
+  //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;
+
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, TFCSExtrapolationState* extrapol=nullptr);
+
+private:
+
+  ClassDef(TFCSParametrizationAbsEtaSelectChain,1)  //TFCSParametrizationAbsEtaSelectChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationAbsEtaSelectChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBase.h

@@ -66,14 +66,25 @@ class TFCSParametrizationBase:public TNamed {
 public:
   TFCSParametrizationBase(const char* name=nullptr, const char* title=nullptr);
 
-  virtual bool is_match_pdgid(int /*id*/) const {return false;};
+  enum FCSStatusBits {
+     /// Set this bit in the TObject bit field if valid for all PDGID
+     kMatchAllPDGID = BIT(14)
+  };
+
+  virtual bool is_match_pdgid(int /*id*/) const {return TestBit(kMatchAllPDGID);};
   virtual bool is_match_Ekin(float /*Ekin*/) const {return false;};
   virtual bool is_match_eta(float /*eta*/) const {return false;};
 
   virtual bool is_match_Ekin_bin(int /*Ekin_bin*/) const {return false;};
   virtual bool is_match_calosample(int /*calosample*/) const {return false;};
 
-  virtual const std::set< int > &pdgid() const {return m_no_pdgid;};
+  virtual bool is_match_all_pdgid() const {return TestBit(kMatchAllPDGID);};
+  virtual bool is_match_all_Ekin() const {return false;};
+  virtual bool is_match_all_eta() const {return false;};
+  virtual bool is_match_all_Ekin_bin() const {return false;};
+  virtual bool is_match_all_calosample() const {return false;};
+
+  virtual const std::set< int > &pdgid() const {return s_no_pdgid;};
   virtual double Ekin_nominal() const {return 0;};
   virtual double Ekin_min() const {return 0;};
   virtual double Ekin_max() const {return 0;};
@@ -81,11 +92,20 @@ public:
   virtual double eta_min() const {return 100;};
   virtual double eta_max() const {return 100;};
 
-  virtual void set_geometry(ICaloGeometry*) {};
+  virtual void set_match_all_pdgid() {SetBit(kMatchAllPDGID);};
+  virtual void reset_match_all_pdgid() {ResetBit(kMatchAllPDGID);};
+
+  virtual void set_geometry(ICaloGeometry* geo);
+  
+  ///Some derived classes have daughter instances of TFCSParametrizationBase objects
+  /// The size() and operator[] methods give general access to these daughters
+  virtual unsigned int size() const {return 0;};
+  virtual const TFCSParametrizationBase* operator[](unsigned int /*ind*/) const {return nullptr;};
+  virtual TFCSParametrizationBase* operator[](unsigned int /*ind*/) {return nullptr;};
 
   // Do some simulation. Result should be returned in simulstate
   // Simulate all energies in calo layers for energy parametrizations
-  // Simulate one HIT for later shape parametrizations (TO BE DISCUSSED!)
+  // Simulate cells for shape simulation
   virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
 
   void Print(Option_t *option = "") const;
@@ -93,10 +113,11 @@ public:
 #if defined(__FastCaloSimStandAlone__)
 public:
   /// Update outputlevel
-  void setLevel(int level) {
+  virtual void setLevel(int level,bool recursive=false) {
     level = (level >= MSG::NUM_LEVELS) ?
       MSG::ALWAYS : (level<MSG::NIL) ? MSG::NIL : level;
     m_level = MSG::Level(level);
+    if(recursive) for(unsigned int i=0;i<size();++i) (*this)[i]->setLevel(m_level,recursive);
   }
   /// Retrieve output level
   MSG::Level level() const {return m_level;}
@@ -128,7 +149,7 @@ private:
 #endif  
   
 private:
-  static std::set< int > m_no_pdgid;
+  static std::set< int > s_no_pdgid;
 
   ClassDef(TFCSParametrizationBase,1)  //TFCSParametrizationBase
 };

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationBinnedChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationBinnedChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationChain.h"
+
+class TFCSParametrizationBinnedChain:public TFCSParametrizationChain {
+public:
+  TFCSParametrizationBinnedChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationChain(name,title),m_bin_start(1,0) {};
+  TFCSParametrizationBinnedChain(const TFCSParametrizationBinnedChain& ref):TFCSParametrizationChain(ref),m_bin_start(ref.m_bin_start) {};
+
+  virtual void push_before_first_bin(TFCSParametrizationBase* param);
+  virtual void push_back_in_bin(TFCSParametrizationBase* param, unsigned int bin);
+  
+  virtual unsigned int get_number_of_bins() const {return m_bin_start.size()-1;};
+
+  ///this method should determine in derived classes which bin to simulate, so that the simulate method 
+  ///can call the appropriate TFCSParametrizationBase simulations
+  ///return -1 if no bin matches
+  virtual int get_bin(TFCSSimulationState& simulstate,const TFCSTruthState*, const TFCSExtrapolationState*) const;
+  virtual const std::string get_variable_text(TFCSSimulationState&,const TFCSTruthState*, const TFCSExtrapolationState*) const;
+  ///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);
+
+  void Print(Option_t *option = "") const;
+  
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,const TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
+
+protected:
+  /// Contains the index where the TFCSParametrizationBase* instances to run for a given bin start. 
+  /// The last entry of the vector correponds to the index from where on TFCSParametrizationBase* objects 
+  /// should be run again for all bins. 
+  /// This way one can loop over some instances for all bins, then only specific ones for one bin 
+  /// and at the end again over some for all bins
+  std::vector< unsigned int > m_bin_start;
+
+private:
+
+  ClassDef(TFCSParametrizationBinnedChain,1)  //TFCSParametrizationBinnedChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationBinnedChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationChain.h

@@ -13,23 +13,35 @@ public:
   TFCSParametrizationChain(const TFCSParametrizationChain& ref):TFCSParametrization(ref.GetName(),ref.GetTitle()),m_chain(ref.chain()) {};
 
   typedef std::vector< TFCSParametrizationBase* > Chain_t;
-  Chain_t::size_type size() const {return m_chain.size();};
+  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];};
   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 void set_geometry(ICaloGeometry* geo);
-  
   virtual bool is_match_Ekin_bin(int Ekin_bin) const;
   virtual bool is_match_calosample(int calosample) const;
 
   virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
 
   void Print(Option_t *option = "") const;
-private:
-  Chain_t m_chain;
+protected:
+  void recalc_pdgid_intersect();
+  void recalc_pdgid_union();
+
+  void recalc_Ekin_intersect();
+  void recalc_eta_intersect();
+  void recalc_Ekin_eta_intersect();
+
+  void recalc_Ekin_union();
+  void recalc_eta_union();
+  void recalc_Ekin_eta_union();
   
-  void recalc();
+  ///Default is to call recalc_pdgid_intersect() and recalc_Ekin_eta_intersect()
+  virtual void recalc();
+private:  
+  Chain_t m_chain;
 
   ClassDef(TFCSParametrizationChain,1)  //TFCSParametrizationChain
 };

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEbinChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationEbinChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationEbinChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h"
+#include "ISF_FastCaloSimEvent/TFCSSimulationState.h"
+
+class TFCSParametrizationEbinChain:public TFCSParametrizationBinnedChain {
+public:
+  TFCSParametrizationEbinChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationBinnedChain(name,title) {};
+  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;
+
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,const TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
+private:
+
+  ClassDef(TFCSParametrizationEbinChain,1)  //TFCSParametrizationEbinChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationEbinChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEkinSelectChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationEkinSelectChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationEkinSelectChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h"
+#include "ISF_FastCaloSimEvent/TFCSSimulationState.h"
+
+class TFCSParametrizationEkinSelectChain:public TFCSParametrizationFloatSelectChain {
+public:
+  TFCSParametrizationEkinSelectChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationFloatSelectChain(name,title) {};
+  TFCSParametrizationEkinSelectChain(const TFCSParametrizationEkinSelectChain& ref):TFCSParametrizationFloatSelectChain(ref) {};
+
+  using TFCSParametrizationFloatSelectChain::push_back_in_bin;
+  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;
+
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
+
+protected:
+  void recalc();
+
+private:
+
+  ClassDef(TFCSParametrizationEkinSelectChain,1)  //TFCSParametrizationEkinSelectChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationEkinSelectChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationEtaSelectChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationEtaSelectChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationEtaSelectChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h"
+
+class TFCSParametrizationEtaSelectChain:public TFCSParametrizationFloatSelectChain {
+public:
+  TFCSParametrizationEtaSelectChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationFloatSelectChain(name,title) {};
+  TFCSParametrizationEtaSelectChain(const TFCSParametrizationEtaSelectChain& ref):TFCSParametrizationFloatSelectChain(ref) {};
+
+  using TFCSParametrizationFloatSelectChain::push_back_in_bin;
+  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;
+
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, TFCSExtrapolationState* extrapol=nullptr);
+
+protected:
+  void recalc();
+
+private:
+
+  ClassDef(TFCSParametrizationEtaSelectChain,1)  //TFCSParametrizationEtaSelectChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationEtaSelectChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationFloatSelectChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationFloatSelectChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationFloatSelectChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationBinnedChain.h"
+
+class TFCSParametrizationFloatSelectChain:public TFCSParametrizationBinnedChain {
+public:
+  TFCSParametrizationFloatSelectChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationBinnedChain(name,title),m_bin_low_edge(1,0) {};
+  TFCSParametrizationFloatSelectChain(const TFCSParametrizationFloatSelectChain& ref):TFCSParametrizationBinnedChain(ref),m_bin_low_edge(1,0) {};
+
+  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);
+
+  //return -1 if outside range
+  int val_to_bin(float val) const;
+
+  virtual double get_bin_low_edge(int bin) const {return m_bin_low_edge[bin];};
+  virtual double get_bin_up_edge(int bin) const {return m_bin_low_edge[bin+1];};
+
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr, const TFCSExtrapolationState* extrapol=nullptr);
+
+protected:
+  std::vector< float > m_bin_low_edge;
+
+private:
+
+  ClassDef(TFCSParametrizationFloatSelectChain,1)  //TFCSParametrizationFloatSelectChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationFloatSelectChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/ISF_FastCaloSimEvent/TFCSParametrizationPDGIDSelectChain.h

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ISF_FASTCALOSIMEVENT_TFCSParametrizationPDGIDSelectChain_h
+#define ISF_FASTCALOSIMEVENT_TFCSParametrizationPDGIDSelectChain_h
+
+#include "ISF_FastCaloSimEvent/TFCSParametrizationChain.h"
+
+class TFCSParametrizationPDGIDSelectChain:public TFCSParametrizationChain {
+public:
+  TFCSParametrizationPDGIDSelectChain(const char* name=nullptr, const char* title=nullptr):TFCSParametrizationChain(name,title) {};
+  TFCSParametrizationPDGIDSelectChain(const TFCSParametrizationPDGIDSelectChain& ref):TFCSParametrizationChain(ref) {};
+
+  virtual void simulate(TFCSSimulationState& simulstate,const TFCSTruthState* truth, const TFCSExtrapolationState* extrapol);
+
+  static void unit_test(TFCSSimulationState* simulstate=nullptr,TFCSTruthState* truth=nullptr,TFCSExtrapolationState* extrapol=nullptr);
+protected:
+  virtual void recalc();
+
+private:
+
+  ClassDef(TFCSParametrizationPDGIDSelectChain,1)  //TFCSParametrizationPDGIDSelectChain
+};
+
+#if defined(__ROOTCLING__) && defined(__FastCaloSimStandAlone__)
+#pragma link C++ class TFCSParametrizationPDGIDSelectChain+;
+#endif
+
+#endif

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSEnergyBinParametrization.cxx

+/*
+  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ISF_FastCaloSimEvent/TFCSEnergyBinParametrization.h"
+#include "ISF_FastCaloSimEvent/TFCSTruthState.h"
+#include "ISF_FastCaloSimEvent/TFCSSimulationState.h"
+#include "TMath.h"
+#include "TRandom.h"
+
+//=============================================
+//======= TFCSSelectEnergyBin =========
+//=============================================
+
+TFCSEnergyBinParametrization::TFCSEnergyBinParametrization(const char* name, const char* title):TFCSEnergyParametrization(name,title)
+{
+  m_number_of_Ekin_bins=1;
+}
+
+bool TFCSEnergyBinParametrization::is_match_Ekin_bin(int Ekin_bin) const 
+{
+  if(Ekin_bin>=1 && Ekin_bin<=n_bins()) return true;
+  return false;
+}
+
+void TFCSEnergyBinParametrization::resize()
+{
+  for (std::set<int>::iterator itid=pdgid().begin(); itid!=pdgid().end(); ++itid) {
+	  ATH_MSG_VERBOSE("PDGid="<<*itid<<" resize to "<<n_bins()+1);
+    m_pdgid_Ebin_probability[*itid].resize(n_bins()+1);
+  }
+  for (auto it=m_pdgid_Ebin_probability.begin(); it!=m_pdgid_Ebin_probability.end(); ++it) {
+    if(!is_match_pdgid(it->first)) {
+      m_pdgid_Ebin_probability.erase(it);
+      it=m_pdgid_Ebin_probability.begin();
+    }
+  }    
+}
+
+void TFCSEnergyBinParametrization::set_pdgid(int id)
+{
+  TFCSEnergyParametrization::set_pdgid(id);
+  resize();
+}
+
+void TFCSEnergyBinParametrization::set_pdgid(const std::set< int > &ids)
+{
+  TFCSEnergyParametrization::set_pdgid(ids);
+  resize();
+}
+
+void TFCSEnergyBinParametrization::add_pdgid(int id)
+{
+  TFCSEnergyParametrization::add_pdgid(id);
+  resize();
+}
+
+void TFCSEnergyBinParametrization::clear_pdgid()
+{
+  TFCSEnergyParametrization::clear_pdgid();
+  resize();
+}
+
+void TFCSEnergyBinParametrization::set_pdgid_Ekin_bin_probability(int id,std::vector< float > prob)
+{
+  set_pdgid(id);
+  if(prob.size()!=m_pdgid_Ebin_probability[id].size()) {
+    ATH_MSG_ERROR("TFCSEnergyBinParametrization::set_pdgid_Ekin_bin_probability(): size of vectors does not match! in.size()="<<prob.size()<<" instance="<<m_pdgid_Ebin_probability[id].size());
+    return;
+  }
+  float ptot=0;
+  for(int iEbin=0;iEbin<=n_bins();++iEbin) ptot+=prob[iEbin];
+  float p=0;
+  for(int iEbin=0;iEbin<=n_bins();++iEbin) {
+    p+=prob[iEbin]/ptot;
+    m_pdgid_Ebin_probability[id][iEbin]=p;
+  }
+}
+  
+void TFCSEnergyBinParametrization::Print(Option_t *option) const
+{
+  TString opt(option);
+  bool shortprint=opt.Index("short")>=0;
+  bool longprint=msgLvl(MSG::DEBUG) || (msgLvl(MSG::INFO) && !shortprint);
+  TString optprint=opt;optprint.ReplaceAll("short","");
+  TFCSEnergyParametrization::Print(option);
+  if(longprint) {
+    for (std::set<int>::iterator it=pdgid().begin(); it!=pdgid().end(); ++it) {
+      ATH_MSG(INFO) <<optprint<< "  PDGID="<< *it<<" : ";
+      float p=0;
+      for(int iEbin=0;iEbin<=n_bins();++iEbin) {
+        if(iEbin>0) std::cout <<", ";
+        auto mapit=m_pdgid_Ebin_probability.find(*it);
+        msg() <<"b"<<iEbin<<"="<<(mapit->second[iEbin]-p)/mapit->second.back()*100<<"%";
+        p=mapit->second[iEbin];
+      }
+      msg() <<endmsg;
+    }  
+  }  
+}
+
+void 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;
+  }
+  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);
+    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;
+  }
+  simulstate.set_Ebin(chosenBin);
+  ATH_MSG_DEBUG("Ebin="<<chosenBin);
+}

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimEvent/src/TFCSHistoLateralShapeParametrization.cxx

@@ -91,8 +91,10 @@ bool TFCSHistoLateralShapeParametrization::Initialize(const char* filepath, cons
 void TFCSHistoLateralShapeParametrization::Print(Option_t *option) const
 {
   TString opt(option);
-  if(!opt.IsWhitespace()) opt="";
+  bool shortprint=opt.Index("short")>=0;
+  bool longprint=msgLvl(MSG::DEBUG) || (msgLvl(MSG::INFO) && !shortprint);
+  TString optprint=opt;optprint.ReplaceAll("short","");
   TFCSLateralShapeParametrizationHitBase::Print(option);
 
-  ATH_MSG_INFO(opt <<"  Histo: "<<m_hist->GetName()<<" : "<<m_hist->GetTitle()<<" ptr="<<m_hist);
+  if(longprint) ATH_MSG_INFO(optprint <<"  Histo: "<<m_hist->GetName()<<" : "<<m_hist->GetTitle()<<" ptr="<<m_hist);
 }