diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiCombinatorialTrackFinderData_xk.h b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiCombinatorialTrackFinderData_xk.h
index 4e709de9d7f9bbdbecc8e3c1dc90b557004a6288..71706769daa1b97253916101335747091ea96885 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiCombinatorialTrackFinderData_xk.h
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiCombinatorialTrackFinderData_xk.h
@@ -88,6 +88,15 @@ namespace InDet {
      */
     bool isInitialized() const;
 
+    //enum used in Track Maker tools for summary statistics table
+    typedef enum summaryStatArraySizes{       
+      kNStatAllTypes = 15,        
+      kNStatEtaTypes = 2,
+      kNSeedTypes = 4,
+      kNRapidityRanges = 8,
+      kNCombStats = 6 
+    } summaryStatArraySizes;     
+
     /**
      * @name Getter methods using references
      */
@@ -102,6 +111,7 @@ namespace InDet {
     int& findtracks();
     int& inittracks();
     int& roadbug();
+    std::array<bool,kNCombStats>& statistic();
     bool& heavyIon();
     int& cosmicTrack();
     int& nclusmin();
@@ -151,6 +161,8 @@ namespace InDet {
     int m_inittracks{0};
     /// Number wrong DE roads
     int m_roadbug{0};
+    /// Switch array
+    std::array<bool,kNCombStats> m_statistic{};
     // Heavy ion flag
     bool m_heavyIon{false};
     /// Is it cosmic track (0 or 1)
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiTrackMakerEventData_xk.h b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiTrackMakerEventData_xk.h
index f8d1c4a8d1963695e2a21708c2e5d338f46d29c4..581edcba438fe0580ecfe04e0a9a3877b75b3f58 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiTrackMakerEventData_xk.h
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/SiSPSeededTrackFinderData/SiTrackMakerEventData_xk.h
@@ -37,7 +37,6 @@ namespace InDet {
 // Class for event dependent data used in SiTrackMaker_xk
 /////////////////////////////////////////////////////////////////////////////////
 
-
   class SiTrackMakerEventData_xk {
   public:
     SiTrackMakerEventData_xk();
@@ -59,6 +58,10 @@ namespace InDet {
     std::list<double>& hadR();
     std::list<double>& hadZ();
     std::array<double, 2>& xybeam();
+
+    std::array<std::array<std::array<int,SiCombinatorialTrackFinderData_xk::kNRapidityRanges>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>,SiCombinatorialTrackFinderData_xk::kNStatEtaTypes>& summaryStatUsedInTrack();
+    std::array<std::array<int,SiCombinatorialTrackFinderData_xk::kNSeedTypes>,SiCombinatorialTrackFinderData_xk::kNStatAllTypes>& summaryStatAll();
+
     SeedToTrackConversionData& conversionData();
     SiCombinatorialTrackFinderData_xk& combinatorialData();
 
@@ -94,6 +97,10 @@ namespace InDet {
     bool m_dbm{false};
     //@}
 
+    /// Counters
+    std::array<std::array<std::array<int,SiCombinatorialTrackFinderData_xk::kNRapidityRanges>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>,SiCombinatorialTrackFinderData_xk::kNStatEtaTypes> m_summaryStatUsedInTrack {};
+    std::array<std::array<int,SiCombinatorialTrackFinderData_xk::kNSeedTypes>,SiCombinatorialTrackFinderData_xk::kNStatAllTypes> m_summaryStatAll {};
+
     /// @name Data members updated only by newEvent method
     //@{
     std::list<double> m_caloF;
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiCombinatorialTrackFinderData_xk.cxx b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiCombinatorialTrackFinderData_xk.cxx
index a512b00034b9879d54b02a4d3b579e191f7d2cf5..850a8392c57a541b9c187701fe2fd3f14d7e2218 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiCombinatorialTrackFinderData_xk.cxx
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiCombinatorialTrackFinderData_xk.cxx
@@ -105,6 +105,10 @@ namespace InDet {
     return m_roadbug;
   }
 
+  std::array<bool,SiCombinatorialTrackFinderData_xk::kNCombStats>& SiCombinatorialTrackFinderData_xk::statistic()  {
+    return m_statistic;
+  }
+
   bool& SiCombinatorialTrackFinderData_xk::heavyIon() {
     return m_heavyIon;
   }
diff --git a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiTrackMakerEventData_xk.cxx b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiTrackMakerEventData_xk.cxx
index cf815c8c3aaa8c423b83736df5878520f3d6f6f8..50b8c9492fac47bb8558d4c60cf23993e6977ad2 100644
--- a/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiTrackMakerEventData_xk.cxx
+++ b/InnerDetector/InDetRecEvent/SiSPSeededTrackFinderData/src/SiTrackMakerEventData_xk.cxx
@@ -38,6 +38,14 @@ namespace InDet {
     return m_nprint;
   }
 
+  std::array<std::array<int,SiCombinatorialTrackFinderData_xk::kNSeedTypes>,SiCombinatorialTrackFinderData_xk::kNStatAllTypes>& SiTrackMakerEventData_xk::summaryStatAll() {
+    return m_summaryStatAll;
+  }
+
+  std::array<std::array<std::array<int,SiCombinatorialTrackFinderData_xk::kNRapidityRanges>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>,SiCombinatorialTrackFinderData_xk::kNStatEtaTypes>& SiTrackMakerEventData_xk::summaryStatUsedInTrack()  {
+    return m_summaryStatUsedInTrack;
+  }
+
   std::multimap<const Trk::PrepRawData*, const Trk::Track*>& SiTrackMakerEventData_xk::clusterTrack() {
     return m_clusterTrack;
   }
diff --git a/InnerDetector/InDetRecTools/InDetRecToolInterfaces/InDetRecToolInterfaces/ISiCombinatorialTrackFinder.h b/InnerDetector/InDetRecTools/InDetRecToolInterfaces/InDetRecToolInterfaces/ISiCombinatorialTrackFinder.h
index 54d787f90b6e02ff974058557bec2d2b06a4b8d6..af76e3c2eb862215fa668d7f7480907a3da43a7a 100644
--- a/InnerDetector/InDetRecTools/InDetRecToolInterfaces/InDetRecToolInterfaces/ISiCombinatorialTrackFinder.h
+++ b/InnerDetector/InDetRecTools/InDetRecToolInterfaces/InDetRecToolInterfaces/ISiCombinatorialTrackFinder.h
@@ -15,6 +15,7 @@
 #include "TrkParameters/TrackParameters.h"
 #include "TrkSpacePoint/SpacePoint.h"
 #include "TrkTrack/Track.h"
+#include "SiSPSeededTrackFinderData/SiTrackMakerEventData_xk.h"
 
 #include "GaudiKernel/AlgTool.h"
 #include "GaudiKernel/EventContext.h"
@@ -97,6 +98,8 @@ namespace InDet {
 
       virtual void endEvent(SiCombinatorialTrackFinderData_xk& data) const =0;
       //@}
+      
+      virtual void fillStatistic(SiCombinatorialTrackFinderData_xk& data, std::array<bool,SiCombinatorialTrackFinderData_xk::kNCombStats>&) const=0;
 
       ///////////////////////////////////////////////////////////////////
       /// @name Print internal tool parameters and status
diff --git a/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinder_xk.h b/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinder_xk.h
index 3e8bae5e3423d4af9ff8547c1f5c34d2700c7488..c27967f6c1ceb6cb4bb61fa33371cc6f122ac930 100644
--- a/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinder_xk.h
+++ b/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinderTool_xk/SiCombinatorialTrackFinder_xk.h
@@ -174,11 +174,23 @@ namespace InDet {
       Trk::MagneticFieldProperties m_fieldprop; //!< Magnetic field properties
       //@}
 
+      ///Array entries for data.statistic counter 
+      typedef enum {
+        TwoCluster,
+        WrongRoad,
+        WrongInit,
+        CantFindTrk,
+        NotNewTrk,
+        BremAttempt,
+        NumberOfStats,
+        Success,
+      } EStat_t;
+
       ///////////////////////////////////////////////////////////////////
       // Methods 
       ///////////////////////////////////////////////////////////////////
 
-      bool findTrack
+      EStat_t findTrack
         (SiCombinatorialTrackFinderData_xk& data,
          const Trk::TrackParameters&, 
 	 const std::vector<const Trk::SpacePoint*>&,
@@ -205,6 +217,7 @@ namespace InDet {
       MsgStream& dumpevent(SiCombinatorialTrackFinderData_xk& data, MsgStream& out) const;
 
       void initializeCombinatorialData(const EventContext& ctx, SiCombinatorialTrackFinderData_xk& data) const;
+      void fillStatistic(SiCombinatorialTrackFinderData_xk& data, std::array<bool,NumberOfStats>& information) const; 
 
     };
 
diff --git a/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/src/SiCombinatorialTrackFinder_xk.cxx b/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/src/SiCombinatorialTrackFinder_xk.cxx
index a066435c3fcb64a8cd079ec3655ebe5c8fb6e82f..aa95b7edc00cf1eb3ab8a2e9cb26ed1b2a9d6801 100644
--- a/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/src/SiCombinatorialTrackFinder_xk.cxx
+++ b/InnerDetector/InDetRecTools/SiCombinatorialTrackFinderTool_xk/src/SiCombinatorialTrackFinder_xk.cxx
@@ -259,7 +259,7 @@ void InDet::SiCombinatorialTrackFinder_xk::newEvent(const EventContext& ctx, SiC
   data.inittracks() = 0;
   data.findtracks() = 0;
   data.roadbug()    = 0;
-
+ 
   // Set track info
   //
   data.trackinfo().setPatternRecognitionInfo(Trk::TrackInfo::SiSPSeededFinder);
@@ -331,8 +331,11 @@ const std::list<Trk::Track*>&  InDet::SiCombinatorialTrackFinder_xk::getTracks
  std::list<const InDetDD::SiDetectorElement*>& DE,
  const TrackQualityCuts& Cuts) const
 {
+
   if (not data.isInitialized()) initializeCombinatorialData(Gaudi::Hive::currentContext(), data);
 
+  data.statistic().fill(false);
+
   data.tools().setBremNoise(false, false);
   data.tracks().erase(data.tracks().begin(), data.tracks().end());
 
@@ -345,8 +348,13 @@ const std::list<Trk::Track*>&  InDet::SiCombinatorialTrackFinder_xk::getTracks
   //
   getTrackQualityCuts(data, Cuts);
   std::multimap<const Trk::PrepRawData*, const Trk::Track*> PT;
-  if (!findTrack(data, Tp, Sp, Gp, DE, PT)) return data.tracks();
+
+  EStat_t FT = findTrack(data, Tp, Sp, Gp, DE, PT);
  
+  if(FT!=Success) {
+    data.statistic()[FT] = true;
+    return data.tracks();
+  }
   data.trajectory().sortStep();
 
   // Trk::Track production
@@ -376,19 +384,28 @@ const std::list<Trk::Track*>& InDet::SiCombinatorialTrackFinder_xk::getTracks
  std::list<const InDetDD::SiDetectorElement*>& DE,
  std::multimap<const Trk::PrepRawData*, const Trk::Track*>& PT) const
 {
+
   if (not data.isInitialized()) initializeCombinatorialData(Gaudi::Hive::currentContext(), data);
 
   data.tools().setBremNoise(false, false);
   data.tracks().erase(data.tracks().begin(), data.tracks().end());
 
+  data.statistic().fill(false);
   ++data.inputseeds();
   if (!m_usePIX && !m_useSCT) {
     return data.tracks();
   }
 
-  if (!findTrack(data, Tp, Sp, Gp, DE, PT)) return data.tracks();
-  if (!data.trajectory().isNewTrack(PT)) return data.tracks();
-
+  EStat_t FT = findTrack(data, Tp, Sp, Gp, DE, PT);
+  if(FT!=Success) {
+    data.statistic()[FT] = true;
+    return data.tracks();
+  }
+  if (!data.trajectory().isNewTrack(PT)) 
+  {
+     data.statistic()[NotNewTrk] = true;
+     return data.tracks();
+  }
   data.trajectory().sortStep();
 
   // Trk::Track production
@@ -422,8 +439,11 @@ const std::list<Trk::Track*>&  InDet::SiCombinatorialTrackFinder_xk::getTracksWi
  std::multimap<const Trk::PrepRawData*, const Trk::Track*>& PT,
  bool isCaloCompatible) const
 {
+
   if (not data.isInitialized()) initializeCombinatorialData(Gaudi::Hive::currentContext(), data);
 
+  data.statistic().fill(false);
+
   // Old information
   //
   int mult = 0;
@@ -438,8 +458,13 @@ const std::list<Trk::Track*>&  InDet::SiCombinatorialTrackFinder_xk::getTracksWi
     return data.tracks();
   }
 
-  bool Q = findTrack(data, Tp, Sp, Gp, DE, PT);
-  if (Q) Q = data.trajectory().isNewTrack(PT);
+  EStat_t FT = findTrack(data,Tp,Sp,Gp,DE,PT);
+  
+  bool Q = (FT==Success);
+  if (Q){
+    Q = data.trajectory().isNewTrack(PT);
+  }
+
   int na = 0;
   if (Q) {
     data.trajectory().sortStep();
@@ -466,9 +491,17 @@ const std::list<Trk::Track*>&  InDet::SiCombinatorialTrackFinder_xk::getTracksWi
  
   // Repeat track finding using electron noise model
   //
+  data.statistic()[BremAttempt] = true;
+
   data.tools().setBremNoise(true,true);
-  if (!findTrack(data, Tp, Sp, Gp, DE, PT)) return data.tracks();
-  if (!data.trajectory().isNewTrack(PT)) return data.tracks();
+  FT = findTrack(data, Tp, Sp, Gp, DE, PT);
+
+  if (FT!=Success) {
+    data.statistic()[FT] = true;
+    return data.tracks();
+  }
+
+  if (!data.trajectory().isNewTrack(PT)) { data.statistic()[NotNewTrk] = true; return data.tracks(); }
   
   int nb = data.trajectory().nclusters();
   if (nb <= na) return data.tracks();
@@ -498,7 +531,7 @@ const std::list<Trk::Track*>&  InDet::SiCombinatorialTrackFinder_xk::getTracksWi
 // Main method for track finding using space points
 ///////////////////////////////////////////////////////////////////
 
-bool InDet::SiCombinatorialTrackFinder_xk::findTrack
+InDet::SiCombinatorialTrackFinder_xk::EStat_t InDet::SiCombinatorialTrackFinder_xk::findTrack
 (SiCombinatorialTrackFinderData_xk& data,
  const Trk::TrackParameters& Tp,
  const std::vector<const Trk::SpacePoint*>& Sp,const std::list<Amg::Vector3D>& Gp,
@@ -534,13 +567,13 @@ bool InDet::SiCombinatorialTrackFinder_xk::findTrack
 
   if (Sp.size() > 1) {
     if (!spacePointsToClusters(Sp,Cl)) {
-      return false;
+      return TwoCluster;
     }
     if (Sp.size()<=2) TWO = true;
   } else if (Gp.size() > 2) {
-    if (!data.trajectory().globalPositionsToClusters(p_pixcontainer, p_sctcontainer, Gp, DEL, PT, Cl)) return false;
+    if (!data.trajectory().globalPositionsToClusters(p_pixcontainer, p_sctcontainer, Gp, DEL, PT, Cl)) return TwoCluster;
   } else {
-    if (!data.trajectory().trackParametersToClusters(p_pixcontainer, p_sctcontainer, Tp, DEL, PT, Cl)) return false;
+    if (!data.trajectory().trackParametersToClusters(p_pixcontainer, p_sctcontainer, Tp, DEL, PT, Cl)) return TwoCluster;
   }
   ++data.goodseeds();
 
@@ -552,13 +585,13 @@ bool InDet::SiCombinatorialTrackFinder_xk::findTrack
   if (!Q && Sp.size() < 2 && Gp.size() > 3) {
 
     Cl.clear();
-    if (!data.trajectory().trackParametersToClusters(p_pixcontainer, p_sctcontainer, Tp, DEL, PT, Cl)) return false;
-    if (!data.trajectory().initialize(m_usePIX, m_useSCT, p_pixcontainer, p_sctcontainer, Tp, Cl, DEL, Qr)) return false;
+    if (!data.trajectory().trackParametersToClusters(p_pixcontainer, p_sctcontainer, Tp, DEL, PT, Cl)) return TwoCluster;
+    if (!data.trajectory().initialize(m_usePIX, m_useSCT, p_pixcontainer, p_sctcontainer, Tp, Cl, DEL, Qr)) return TwoCluster;
     Q = Qr = true;
   }
 
-  if (!Qr) ++data.roadbug();
-  if (!Q) return false;
+  if (!Qr){++data.roadbug(); return WrongRoad;} 
+  if (!Q) return WrongInit;
   ++data.inittracks();
   bool pixseed = data.trajectory().isLastPixel();
   int itmax    = 30;
@@ -568,39 +601,39 @@ bool InDet::SiCombinatorialTrackFinder_xk::findTrack
   // Track finding
   //
   if (pixseed) {      // Strategy for pixel seeds
-    if (!data.trajectory().forwardExtension (false,itmax)) return false;
-    if (!data.trajectory().backwardSmoother (false)      ) return false;
-    if (!data.trajectory().backwardExtension(itmax)      ) return false;
+    if (!data.trajectory().forwardExtension (false,itmax)) return CantFindTrk;
+    if (!data.trajectory().backwardSmoother (false)      ) return CantFindTrk;
+    if (!data.trajectory().backwardExtension(itmax)      ) return CantFindTrk;
 
     if (data.trajectory().difference() > 0) {
-      if (!data.trajectory().forwardFilter()          ) return false;
-      if (!data.trajectory().backwardSmoother (false) ) return false;
+      if (!data.trajectory().forwardFilter()          ) return CantFindTrk;
+      if (!data.trajectory().backwardSmoother (false) ) return CantFindTrk;
     } 
     int na = data.trajectory().nclustersNoAdd();
-    if (data.trajectory().nclusters()+na < data.nclusmin() || data.trajectory().ndf() < data.nwclusmin()) return false;
+    if (data.trajectory().nclusters()+na < data.nclusmin() || data.trajectory().ndf() < data.nwclusmin()) return CantFindTrk;
   } else {      // Strategy for mixed seeds
-    if (!data.trajectory().backwardSmoother(TWO)       ) return false;
-    if (!data.trajectory().backwardExtension(itmax)    ) return false;
-    if (!data.trajectory().forwardExtension(true,itmax)) return false;
+    if (!data.trajectory().backwardSmoother(TWO)       ) return CantFindTrk;
+    if (!data.trajectory().backwardExtension(itmax)    ) return CantFindTrk;
+    if (!data.trajectory().forwardExtension(true,itmax)) return CantFindTrk;
 
     int na = data.trajectory().nclustersNoAdd();
-    if (data.trajectory().nclusters()+na < data.nclusmin() || data.trajectory().ndf() < data.nwclusmin()) return false;
-    if (!data.trajectory().backwardSmoother(false)    ) return false;
+    if (data.trajectory().nclusters()+na < data.nclusmin() || data.trajectory().ndf() < data.nwclusmin()) return CantFindTrk;
+    if (!data.trajectory().backwardSmoother(false)    ) return CantFindTrk;
 
     na     = data.trajectory().nclustersNoAdd();
-    if (data.trajectory().nclusters()+na < data.nclusmin() || data.trajectory().ndf() < data.nwclusmin()) return false;
+    if (data.trajectory().nclusters()+na < data.nclusmin() || data.trajectory().ndf() < data.nwclusmin()) return CantFindTrk;
 
     if (data.trajectory().difference() > 0) {
-      if (!data.trajectory().forwardFilter()         ) return false;
-      if (!data.trajectory().backwardSmoother (false)) return false;
+      if (!data.trajectory().forwardFilter()         ) return CantFindTrk;
+      if (!data.trajectory().backwardSmoother (false)) return CantFindTrk;
     }
   } 
 
-  if (data.trajectory().qualityOptimization()     <           (m_qualityCut*data.nclusmin())    ) return false;
-  if (data.trajectory().pTfirst  () < data.pTmin()     && data.trajectory().nclusters() < data.nclusmin() ) return false;
-  if (data.trajectory().nclusters() < data.nclusminb() || data.trajectory().ndf      () < data.nwclusmin()) return false;
+  if (data.trajectory().qualityOptimization()     <           (m_qualityCut*data.nclusmin())    ) return CantFindTrk;
+  if (data.trajectory().pTfirst  () < data.pTmin()     && data.trajectory().nclusters() < data.nclusmin() ) return CantFindTrk;
+  if (data.trajectory().nclusters() < data.nclusminb() || data.trajectory().ndf      () < data.nwclusmin()) return CantFindTrk;
   
-  return true;
+  return Success;
 }
 
 ///////////////////////////////////////////////////////////////////
@@ -802,3 +835,8 @@ void InDet::SiCombinatorialTrackFinder_xk::initializeCombinatorialData(const Eve
                 &m_fieldprop);
   
 }
+
+void InDet::SiCombinatorialTrackFinder_xk::fillStatistic(SiCombinatorialTrackFinderData_xk& data, std::array<bool,6>& information) const
+{
+   for(int i=0; i!=NumberOfStats; ++i) information[i] = data.statistic()[i];
+}
diff --git a/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/SiTrackMakerTool_xk/SiTrackMaker_xk.h b/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/SiTrackMakerTool_xk/SiTrackMaker_xk.h
index 5897fe4c0ec1fcd5330792986e5a58099ef0dc2c..d33d9e3866807fa4ba85d650e64d2add5484e9f1 100644
--- a/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/SiTrackMakerTool_xk/SiTrackMaker_xk.h
+++ b/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/SiTrackMakerTool_xk/SiTrackMaker_xk.h
@@ -22,6 +22,7 @@
 #include "InDetRecToolInterfaces/ISiDetElementsRoadMaker.h"
 #include "TrkCaloClusterROI/CaloClusterROI_Collection.h"
 #include "TrkGeometry/MagneticFieldProperties.h"
+#include "SiSPSeededTrackFinderData/SiTrackMakerEventData_xk.h"
 
 #include "GaudiKernel/ToolHandle.h"
 
@@ -35,6 +36,7 @@
 #include <iosfwd>
 #include <list>
 #include <vector>
+#include <mutex>
 
 class MsgStream;
 
@@ -169,6 +171,57 @@ namespace InDet{
       Trk::MagneticFieldMode m_fieldModeEnum{Trk::FullField};
       //@}
 
+      ///////////////////////////////////////////////////////////////////             
+      // Counters                                                                     
+      /////////////////////////////////////////////////////////////////////       
+
+      mutable std::mutex            m_counterMutex;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_totalInputSeeds        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<double>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_totalUsedSeeds        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_totalNoTrackPar        ATLAS_THREAD_SAFE; 
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_totalBremSeeds        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_twoClusters           ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_wrongRoad        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_wrongInit        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_noTrack        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_notNewTrack        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_bremAttempt        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_outputTracks        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_extraTracks        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_bremTracks        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<int>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_seedsWithTrack        ATLAS_THREAD_SAFE;
+      mutable std::array<std::atomic<double>,SiCombinatorialTrackFinderData_xk::kNSeedTypes>      m_deSize        ATLAS_THREAD_SAFE;
+
+      mutable std::vector<std::vector<double>>     m_usedSeedsEta          ATLAS_THREAD_SAFE;
+      mutable std::vector<std::vector<double>>     m_seedsWithTracksEta    ATLAS_THREAD_SAFE;
+
+      enum statAllTypes  {
+        kTotalInputSeeds,
+        kTotalUsedSeeds,
+        kTotalNoTrackPar,
+        kTotalBremSeeds,
+        kTwoClusters,
+        kWrongInit,
+        kWrongRoad,
+        kNoTrack,
+        kNotNewTrack,
+        kBremAttempt,
+        kOutputTracks,
+        kExtraTracks,
+        kBremTracks,
+        kDESize,
+        kSeedsWithTracks
+      }; 
+
+      enum kNStatEtaTypes  {
+        kUsedSeedsEta,
+        kSeedsWithTracksEta
+      };
+ 
+      std::vector<statAllTypes> m_indexToEnum {kTwoClusters,kWrongInit,kWrongRoad,kNoTrack,kNotNewTrack,kBremAttempt};
+ 
+      //mutable std::vector<
+ 
       ///////////////////////////////////////////////////////////////////
       // Methods 
       ///////////////////////////////////////////////////////////////////
@@ -191,12 +244,15 @@ namespace InDet{
       void detectorElementsSelection(SiTrackMakerEventData_xk& data,
                                      std::list<const InDetDD::SiDetectorElement*>& DE) const;
       bool newSeed(SiTrackMakerEventData_xk& data, const std::vector<const Trk::SpacePoint*>& Sp) const;
+      int  kindSeed(const std::vector<const Trk::SpacePoint*>& Sp)  const;
+      int  rapidity(const std::vector<const Trk::SpacePoint*>& Sp) const;
       bool isNewTrack(SiTrackMakerEventData_xk& data, Trk::Track* Tr) const;
       bool isCaloCompatible(SiTrackMakerEventData_xk& data) const;
       bool isHadCaloCompatible(SiTrackMakerEventData_xk& data) const;
       bool isDBMSeeds(const Trk::SpacePoint* s) const;
       void clusterTrackMap(SiTrackMakerEventData_xk& data, Trk::Track* Tr) const;
 
+      MsgStream& dumpStatistics(MsgStream &out) const; 
       MsgStream& dumpconditions(MsgStream& out) const;
       MsgStream& dumpevent(SiTrackMakerEventData_xk& data, MsgStream& out) const;
     };
diff --git a/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/src/SiTrackMaker_xk.cxx b/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/src/SiTrackMaker_xk.cxx
index 80aac454a97d706989c386c788b8b936a8bea272..790197d1979eda1eba674a37cdebdeff73ab4a04 100644
--- a/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/src/SiTrackMaker_xk.cxx
+++ b/InnerDetector/InDetRecTools/SiTrackMakerTool_xk/src/SiTrackMaker_xk.cxx
@@ -27,8 +27,26 @@
 
 InDet::SiTrackMaker_xk::SiTrackMaker_xk
 (const std::string& t,const std::string& n,const IInterface* p)
-  : base_class(t, n, p)
+  : base_class(t, n, p),
+    m_totalInputSeeds{ },
+    m_totalUsedSeeds{ },
+    m_totalNoTrackPar{ },
+    m_totalBremSeeds{ }, 
+    m_twoClusters{ },
+    m_wrongRoad{ },
+    m_wrongInit{ },
+    m_noTrack{ },
+    m_notNewTrack{ },
+    m_bremAttempt{ },
+    m_outputTracks{ },
+    m_extraTracks{ },
+    m_bremTracks{ },
+    m_seedsWithTrack{ },
+    m_deSize{ },
+    m_usedSeedsEta( SiCombinatorialTrackFinderData_xk::kNSeedTypes, std::vector<double>(SiCombinatorialTrackFinderData_xk::kNRapidityRanges, 0.) ),
+    m_seedsWithTracksEta( SiCombinatorialTrackFinderData_xk::kNSeedTypes, std::vector<double>(SiCombinatorialTrackFinderData_xk::kNRapidityRanges, 0.) )
 {
+
 }
 
 ///////////////////////////////////////////////////////////////////
@@ -81,6 +99,7 @@ StatusCode InDet::SiTrackMaker_xk::initialize()
 
   m_heavyion = false;
 
+
   // TrackpatternRecoInfo preparation 
   //
   if        (m_patternName == "SiSpacePointsSeedMaker_Cosmic"     )  {
@@ -109,6 +128,25 @@ StatusCode InDet::SiTrackMaker_xk::initialize()
 
   if (m_pTmin < 20.) m_pTmin = 20.;
 
+
+  for (int i=0; i!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++i) {
+    m_totalInputSeeds[i] = 0;
+    m_totalNoTrackPar[i]  = 0;
+    m_totalUsedSeeds[i]  = 0.;
+    m_outputTracks[i]      = 0;
+    m_totalBremSeeds[i]  = 0;
+    m_bremTracks[i]     = 0;
+    m_twoClusters[i]     = 0;
+    m_wrongRoad[i]       = 0;
+    m_wrongInit[i]       = 0;
+    m_noTrack[i]         = 0;
+    m_notNewTrack[i]     = 0;
+    m_bremAttempt[i]     = 0;
+    m_seedsWithTrack[i]        = 0;
+    m_deSize[i]          = 0.;
+    for(int j=0; j!=SiCombinatorialTrackFinderData_xk::kNRapidityRanges ;++j) { m_usedSeedsEta[i][j]=0.; m_seedsWithTracksEta[i][j]=0.;}
+  }
+
   ////////////////////////////////////////////////////////////////////////////////
   ATH_CHECK( m_fieldCondObjInputKey.initialize());
   ////////////////////////////////////////////////////////////////////////////////
@@ -121,6 +159,10 @@ StatusCode InDet::SiTrackMaker_xk::initialize()
 
 StatusCode InDet::SiTrackMaker_xk::finalize()
 {
+  MsgStream &out = msg(MSG::INFO);
+  out << "::finalize() -- statistics:" <<std::endl;
+  dumpStatistics(out);
+  out<<endmsg; 
   return AlgTool::finalize();
 }
 
@@ -128,6 +170,203 @@ StatusCode InDet::SiTrackMaker_xk::finalize()
 // Dumps relevant information into the MsgStream
 ///////////////////////////////////////////////////////////////////
 
+MsgStream& InDet::SiTrackMaker_xk::dumpStatistics(MsgStream &out) const
+{
+
+  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|"
+       <<std::endl;
+  out<<"| Kind of seed         |     PPP      |     PPS      |     PSS      |     SSS      |     ALL      |"
+       <<std::endl;
+  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|"
+       <<std::endl;
+  out<<"| Input  seeds         | "
+     <<std::setw(12)<<m_totalInputSeeds[0]<<" | "
+     <<std::setw(12)<<m_totalInputSeeds[1]<<" | "
+     <<std::setw(12)<<m_totalInputSeeds[2]<<" | "
+     <<std::setw(12)<<m_totalInputSeeds[3]<<" | "
+     <<std::setw(12)<<(m_totalInputSeeds[0]+m_totalInputSeeds[1]+m_totalInputSeeds[2]+m_totalInputSeeds[3])
+     <<" |"<<std::endl;
+
+  out<<"| No track parameters  | "
+     <<std::setw(12)<<m_totalNoTrackPar[0]<<" | " 
+     <<std::setw(12)<<m_totalNoTrackPar[1]<<" | " 
+     <<std::setw(12)<<m_totalNoTrackPar[2]<<" | " 
+     <<std::setw(12)<<m_totalNoTrackPar[3]<<" | " 
+     <<std::setw(12)<<(m_totalNoTrackPar[0]+m_totalNoTrackPar[1]+ m_totalNoTrackPar[2]+m_totalNoTrackPar[3])
+     <<" |"<<std::endl;
+
+  out<<"| Used   seeds         | "
+     <<std::setw(12)<<m_totalUsedSeeds[0]<<" | " 
+     <<std::setw(12)<<m_totalUsedSeeds[1]<<" | " 
+     <<std::setw(12)<<m_totalUsedSeeds[2]<<" | " 
+     <<std::setw(12)<<m_totalUsedSeeds[3]<<" | " 
+     <<std::setw(12)<<(m_totalUsedSeeds[0]+m_totalUsedSeeds[1]+ m_totalUsedSeeds[2]+m_totalUsedSeeds[3])
+     <<" |"<<std::endl;
+
+  out<<"| Used   seeds  brem   | "
+     <<std::setw(12)<<m_totalBremSeeds[0]<<" | " 
+     <<std::setw(12)<<m_totalBremSeeds[1]<<" | " 
+     <<std::setw(12)<<m_totalBremSeeds[2]<<" | " 
+     <<std::setw(12)<<m_totalBremSeeds[3]<<" | " 
+     <<std::setw(12)<<(m_totalBremSeeds[0]+m_totalBremSeeds[1]+m_totalBremSeeds[2]+m_totalBremSeeds[3]) 
+     <<" |"<<std::endl;
+
+  double tdetsize = 0.;
+  int    goodseed = 0;
+  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; i++) {
+    tdetsize+= m_deSize[i];
+    goodseed+= m_totalUsedSeeds[i];
+    if(m_totalUsedSeeds[i] > 0.) m_deSize[i]= m_deSize[i]/m_totalUsedSeeds[i]; 
+  }
+  if(goodseed > 0) tdetsize/=double(goodseed);
+
+  out<<"| Det elements in road | "
+     <<std::setw(12)<<std::setprecision(4)<<m_deSize[0]<<" | " 
+     <<std::setw(12)<<std::setprecision(5)<<m_deSize[1]<<" | " 
+     <<std::setw(12)<<std::setprecision(5)<<m_deSize[2]<<" | " 
+     <<std::setw(12)<<std::setprecision(5)<<m_deSize[3]<<" | " 
+     <<std::setw(12)<<std::setprecision(5)<<tdetsize 
+     <<" |"<<std::endl;
+
+
+  out<<"| Two clusters on DE   | "
+     <<std::setw(12)<<m_twoClusters[0]<<" | " 
+     <<std::setw(12)<<m_twoClusters[1]<<" | " 
+     <<std::setw(12)<<m_twoClusters[2]<<" | " 
+     <<std::setw(12)<<m_twoClusters[3]<<" | " 
+     <<std::setw(12)<<(m_twoClusters[0]+m_twoClusters[1]+m_twoClusters[2]+m_twoClusters[3]) 
+     <<" |"<<std::endl;
+
+  out<<"| Wrong DE road        | "
+     <<std::setw(12)<<m_wrongRoad[0]<<" | " 
+     <<std::setw(12)<<m_wrongRoad[1]<<" | " 
+     <<std::setw(12)<<m_wrongRoad[2]<<" | " 
+     <<std::setw(12)<<m_wrongRoad[3]<<" | " 
+     <<std::setw(12)<<(m_wrongRoad[0]+m_wrongRoad[1]+m_wrongRoad[2]+m_wrongRoad[3]) 
+     <<" |"<<std::endl;
+
+  out<<"| Wrong initialization | "
+     <<std::setw(12)<<m_wrongInit[0]<<" | " 
+     <<std::setw(12)<<m_wrongInit[1]<<" | " 
+     <<std::setw(12)<<m_wrongInit[2]<<" | " 
+     <<std::setw(12)<<m_wrongInit[3]<<" | " 
+     <<std::setw(12)<<(m_wrongInit[0]+m_wrongInit[1]+m_wrongInit[2]+m_wrongInit[3]) 
+     <<" |"<<std::endl;
+
+  out<<"| Can not find track   | "
+     <<std::setw(12)<<m_noTrack[0]<<" | " 
+     <<std::setw(12)<<m_noTrack[1]<<" | " 
+     <<std::setw(12)<<m_noTrack[2]<<" | " 
+     <<std::setw(12)<<m_noTrack[3]<<" | " 
+     <<std::setw(12)<<(m_noTrack[0]+m_noTrack[1]+m_noTrack[2]+m_noTrack[3]) 
+     <<" |"<<std::endl;
+
+  out<<"| It is not new track  | "
+     <<std::setw(12)<<m_notNewTrack[0]<<" | " 
+     <<std::setw(12)<<m_notNewTrack[1]<<" | " 
+     <<std::setw(12)<<m_notNewTrack[2]<<" | " 
+     <<std::setw(12)<<m_notNewTrack[3]<<" | " 
+     <<std::setw(12)<<(m_notNewTrack[0]+m_notNewTrack[1]+m_notNewTrack[2]+m_notNewTrack[3]) 
+     <<" |"<<std::endl;
+
+  out<<"| Attempts brem model  | "
+     <<std::setw(12)<<m_bremAttempt[0]<<" | " 
+     <<std::setw(12)<<m_bremAttempt[1]<<" | " 
+     <<std::setw(12)<<m_bremAttempt[2]<<" | " 
+     <<std::setw(12)<<m_bremAttempt[3]<<" | " 
+     <<std::setw(12)<<(m_bremAttempt[0]+m_bremAttempt[1]+m_bremAttempt[2]+m_bremAttempt[3]) 
+     <<" |"<<std::endl;
+
+  out<<"| Output tracks        | "
+     <<std::setw(12)<<m_outputTracks[0]<<" | "  
+     <<std::setw(12)<<m_outputTracks[1]<<" | " 
+     <<std::setw(12)<<m_outputTracks[2]<<" | "  
+     <<std::setw(12)<<m_outputTracks[3]<<" | "  
+     <<std::setw(12)<<(m_outputTracks[0]+m_outputTracks[1]+m_outputTracks[2]+m_outputTracks[3])
+     <<" |"<<std::endl;
+
+  out<<"| Output extra tracks  | "
+     <<std::setw(12)<<m_extraTracks[0]<<" | "  
+     <<std::setw(12)<<m_extraTracks[1]<<" | " 
+     <<std::setw(12)<<m_extraTracks[2]<<" | "  
+     <<std::setw(12)<<m_extraTracks[3]<<" | "  
+     <<std::setw(12)<<(m_extraTracks[0]+m_extraTracks[1]+m_extraTracks[2]+m_extraTracks[3])
+     <<" |"<<std::endl;
+
+  out<<"| Output tracks brem   | "
+     <<std::setw(12)<<m_bremTracks[0]<<" | "  
+     <<std::setw(12)<<m_bremTracks[1]<<" | " 
+     <<std::setw(12)<<m_bremTracks[2]<<" | "  
+     <<std::setw(12)<<m_bremTracks[3]<<" | "  
+     <<std::setw(12)<<(m_bremTracks[0]+m_bremTracks[1]+m_bremTracks[2]+m_bremTracks[3])
+     <<" |"<<std::endl;
+
+  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|--------------|"
+     <<std::endl;
+   out<<"| Seeds  with  track   | "
+     <<std::setw(12)<<m_seedsWithTrack[0]<<" | "
+     <<std::setw(12)<<m_seedsWithTrack[1]<<" | "
+     <<std::setw(12)<<m_seedsWithTrack[2]<<" | "
+     <<std::setw(12)<<m_seedsWithTrack[3]<<" | "
+     <<std::setw(12)<<(m_seedsWithTrack[0]+m_seedsWithTrack[1]+m_seedsWithTrack[2]+m_seedsWithTrack[3])
+     <<" | Number seeds |"<<std::endl;
+  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|--------------|"
+     <<std::endl;
+
+  std::vector<std::pair<int,std::string>> rapidityTablePrint;
+  //Defining the range values to be printed
+  rapidityTablePrint.push_back(std::make_pair(0,std::string("| Track/Used   0.0-0.5 | ")));
+  rapidityTablePrint.push_back(std::make_pair(1,std::string("|              0.5-1.0 | ")));
+  rapidityTablePrint.push_back(std::make_pair(1,std::string("|              1.0-1.5 | ")));
+  rapidityTablePrint.push_back(std::make_pair(3,std::string("|              1.5-2.0 | ")));
+  rapidityTablePrint.push_back(std::make_pair(4,std::string("|              2.0-2.5 | ")));
+  rapidityTablePrint.push_back(std::make_pair(5,std::string("|              2.5-3.0 | ")));
+  rapidityTablePrint.push_back(std::make_pair(6,std::string("|              3.0-3.5 | ")));
+  rapidityTablePrint.push_back(std::make_pair(7,std::string("|              3.5-4.0 | ")));
+
+
+  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNRapidityRanges; ++i) {
+   
+    std::array<double,SiCombinatorialTrackFinderData_xk::kNSeedTypes+1> pu;
+    pu.fill(0);
+
+    double totalUsedSeedsEta = 0.;
+
+    for(int j = 0; j != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++j){
+
+      if(m_usedSeedsEta[j][i]!=0.) pu[j]=m_seedsWithTracksEta[j][i]/m_usedSeedsEta[j][i];
+      totalUsedSeedsEta += m_usedSeedsEta[j][i];
+
+    } 
+
+    if(totalUsedSeedsEta!=0.) {
+
+      for(int j = 0; j != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++j){
+
+        pu[SiCombinatorialTrackFinderData_xk::kNSeedTypes] += m_seedsWithTracksEta[j][i];
+ 
+      }
+      pu[SiCombinatorialTrackFinderData_xk::kNSeedTypes] /= totalUsedSeedsEta;
+    }
+
+    out<<rapidityTablePrint.at(i).second;
+    out<<std::setw(12)<<std::setprecision(4)<<pu[0]<<" | "  
+       <<std::setw(12)<<std::setprecision(4)<<pu[1]<<" | "  
+       <<std::setw(12)<<std::setprecision(4)<<pu[2]<<" | "  
+       <<std::setw(12)<<std::setprecision(4)<<pu[3]<<" | "  
+       <<std::setw(12)<<std::setprecision(4)<<pu[4]<<" | "
+       <<std::setw(12)<<static_cast<int>(m_seedsWithTracksEta[0][i])+static_cast<int>(m_seedsWithTracksEta[1][i])+static_cast<int>(m_seedsWithTracksEta[2][i])+static_cast<int>(m_seedsWithTracksEta[3][i])
+       <<" |"<<std::endl;
+  }
+
+
+  out<<"|----------------------|--------------|--------------|--------------|--------------|--------------|--------------|"
+     <<std::endl;
+
+  return out;
+
+}
+
 MsgStream& InDet::SiTrackMaker_xk::dump(SiTrackMakerEventData_xk& data, MsgStream& out) const
 {
   out<<std::endl;
@@ -260,6 +499,8 @@ void InDet::SiTrackMaker_xk::newEvent(const EventContext& ctx, SiTrackMakerEvent
   data.inputseeds() = 0;
   data.goodseeds()  = 0;
   data.findtracks() = 0;
+  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNStatAllTypes; ++i) { for(int k = 0; k!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++k) data.summaryStatAll()[i][k]; }
+  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNStatEtaTypes; ++i) { for(int k = 0; k!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++k) { for(int r=0; r!=SiCombinatorialTrackFinderData_xk::kNRapidityRanges; ++r) data.summaryStatUsedInTrack()[i][k][r]; } }  
 
   // Retrieve 
   //
@@ -325,6 +566,9 @@ void InDet::SiTrackMaker_xk::newTrigEvent(const EventContext& ctx, SiTrackMakerE
   data.inputseeds() = 0;
   data.goodseeds()  = 0;
   data.findtracks() = 0;
+  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNStatAllTypes; ++i) { for(int k = 0; k!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++k) data.summaryStatAll()[i][k]; }
+  for(int i=0; i!=SiCombinatorialTrackFinderData_xk::kNStatEtaTypes; ++i) { for(int k = 0; k!=SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++k) { for(int r=0; r!=SiCombinatorialTrackFinderData_xk::kNRapidityRanges; ++r) data.summaryStatUsedInTrack()[i][k][r]; } }
+
 }
 
 ///////////////////////////////////////////////////////////////////
@@ -342,7 +586,36 @@ void InDet::SiTrackMaker_xk::endEvent(SiTrackMakerEventData_xk& data) const
 
   // end event for seed to track tool
   if (m_seedsegmentsWrite) m_seedtrack->endEvent(data.conversionData());
- 
+
+  // fill statistics
+  {
+    std::lock_guard<std::mutex> lock(m_counterMutex);
+
+    for(int K = 0; K != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++K) {
+      for(int r = 0; r != 8; ++r) {
+        m_usedSeedsEta[K][r] += data.summaryStatUsedInTrack()[kUsedSeedsEta][K][r];
+        m_seedsWithTracksEta[K][r] += data.summaryStatUsedInTrack()[kSeedsWithTracksEta][K][r];
+      }
+    }
+  }
+    for (int K = 0; K != SiCombinatorialTrackFinderData_xk::kNSeedTypes; ++K) { 
+      m_totalInputSeeds[K] +=  data.summaryStatAll()[kTotalInputSeeds][K]; 
+      m_totalUsedSeeds[K] = m_totalUsedSeeds[K] + data.summaryStatAll()[kTotalUsedSeeds][K];
+      m_totalNoTrackPar[K] += data.summaryStatAll()[kTotalNoTrackPar][K];
+      m_totalBremSeeds[K] += data.summaryStatAll()[kTotalBremSeeds][K];
+      m_twoClusters[K] += data.summaryStatAll()[kTwoClusters][K];
+      m_wrongRoad[K] += data.summaryStatAll()[kWrongRoad][K];
+      m_wrongInit[K] += data.summaryStatAll()[kWrongInit][K];
+      m_noTrack[K] += data.summaryStatAll()[kNoTrack][K];
+      m_notNewTrack[K] += data.summaryStatAll()[kNotNewTrack][K];
+      m_bremAttempt[K] += data.summaryStatAll()[kBremAttempt][K];
+      m_outputTracks[K] += data.summaryStatAll()[kOutputTracks][K];
+      m_extraTracks[K] += data.summaryStatAll()[kExtraTracks][K];
+      m_bremTracks[K] += data.summaryStatAll()[kBremTracks][K];
+      m_seedsWithTrack[K] += data.summaryStatAll()[kSeedsWithTracks][K];
+      m_deSize[K] = m_deSize[K] + data.summaryStatAll()[kDESize][K];
+
+  }
   // Print event information 
   //
   if (msgLevel()<=0) {
@@ -359,6 +632,12 @@ std::list<Trk::Track*> InDet::SiTrackMaker_xk::getTracks
 (const EventContext& ctx, SiTrackMakerEventData_xk& data, const std::vector<const Trk::SpacePoint*>& Sp) const
 {
   ++data.inputseeds();
+  
+  int K = kindSeed(Sp);     
+  int r = rapidity(Sp); 
+
+  ++data.summaryStatAll()[kTotalInputSeeds][K];
+
   std::list<Trk::Track*> tracks;
   if (!data.pix() && !data.sct()) return tracks;
   
@@ -386,8 +665,12 @@ std::list<Trk::Track*> InDet::SiTrackMaker_xk::getTracks
   const Trk::TrackParameters* Tp = nullptr;
   if (data.dbm()) Tp = getAtaPlaneDBM(fieldCache, data, Sp);
   else Tp = getAtaPlane(fieldCache, data, sss && m_useHClusSeed, Sp);
-  if (!Tp) return tracks;
-  ++data.goodseeds();
+  if (!Tp) 
+  {
+     ++data.summaryStatAll()[kTotalNoTrackPar][K];
+     return tracks;
+  }
+  ++data.goodseeds(); 
 
   // Get detector elements road
   //
@@ -402,20 +685,32 @@ std::list<Trk::Track*> InDet::SiTrackMaker_xk::getTracks
     return tracks;
   }
 
+  data.summaryStatAll()[kDESize][K] += double(DE.size());
+  ++data.summaryStatAll()[kTotalUsedSeeds][K];
+
   std::list<Amg::Vector3D> Gp;
-  
+
+  ++data.summaryStatUsedInTrack()[kUsedSeedsEta][K][r];
+
   // Find possible list of tracks using space points space points information
   //
   if (!m_useBremModel) {
     tracks = m_tracksfinder->getTracks        (data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack());
   } else if (!m_useCaloSeeds) {
+    ++data.summaryStatAll()[kTotalBremSeeds][K];
     tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack(), false);
   } else if (isCaloCompatible(data)) {
+    ++data.summaryStatAll()[kTotalBremSeeds][K];
     tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack(), true);
   } else {
     tracks = m_tracksfinder->getTracks        (data.combinatorialData(), *Tp, Sp, Gp, DE, data.clusterTrack());
   }
-  
+
+  std::array<bool,SiCombinatorialTrackFinderData_xk::kNCombStats> inf{0,0,0,0,0,0};   m_tracksfinder->fillStatistic(data.combinatorialData(),inf);                                      
+  for (size_t p =0; p<inf.size(); ++p){
+    if(inf[p]) ++data.summaryStatAll()[m_indexToEnum[p]][K];
+  } 
+
   if (m_seedsfilter) {
     std::list<Trk::Track*>::iterator t = tracks.begin();
     while (t!=tracks.end()) {
@@ -423,18 +718,27 @@ std::list<Trk::Track*> InDet::SiTrackMaker_xk::getTracks
         delete (*t);
         tracks.erase(t++);
       } else {
+        if((*t)->info().trackProperties(Trk::TrackInfo::BremFit)) ++data.summaryStatAll()[kBremTracks][K];
         clusterTrackMap(data, *t++);
       }
     }
   }
   data.findtracks() += tracks.size();
 
+  if(tracks.size() != 0) {
+    ++data.summaryStatAll()[kSeedsWithTracks][K];
+    ++data.summaryStatUsedInTrack()[kSeedsWithTracksEta][K][r];
+    data.summaryStatAll()[kOutputTracks][K] += tracks.size();
+    data.summaryStatAll()[kExtraTracks][K] += (tracks.size()-1);
+  }                       
+
   // Call seed to track execution
   //
   if (m_seedsegmentsWrite) m_seedtrack->executeSiSPSeedSegments(data.conversionData(), Tp, tracks.size(), Sp);
 
   delete Tp;
   return tracks;
+
 }
 
 ///////////////////////////////////////////////////////////////////
@@ -478,7 +782,7 @@ std::list<Trk::Track*> InDet::SiTrackMaker_xk::getTracks
   if (!m_useBremModel) {
     tracks = m_tracksfinder->getTracks        (data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack());
   } else if (!m_useCaloSeeds) {
-    tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(), false);
+   tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(), false);
   } else if (isCaloCompatible(data)) {
     tracks = m_tracksfinder->getTracksWithBrem(data.combinatorialData(), Tp, Sp, Gp, DE, data.clusterTrack(), true);
   } else {
@@ -801,6 +1105,39 @@ bool InDet::SiTrackMaker_xk::newSeed(SiTrackMakerEventData_xk& data, const std::
   return nt!=n;
 }
 
+///////////////////////////////////////////////////////////////////
+//// Kind of seed calculation 0-PPP, 1-PPS, 2-PSS, 3-SSS another -1
+/////////////////////////////////////////////////////////////////////
+
+
+int InDet::SiTrackMaker_xk::kindSeed(const std::vector<const Trk::SpacePoint*>& Sp) const
+{
+  if(Sp.size()!=3) return 4;
+  
+  std::vector<const Trk::SpacePoint*>::const_iterator s=Sp.begin(),se=Sp.end();
+  
+  int n = 0;
+  for(; s!=se; ++s) {if((*s)->clusterList().second) ++n;}
+  return n;
+}
+
+int InDet::SiTrackMaker_xk::rapidity(const std::vector<const Trk::SpacePoint*>& Sp) const
+{ 
+  if(Sp.size() < 2) return 0;
+
+  //std::vector<const Trk::SpacePoint*>::const_iterator s = Sp.begin();
+  
+  double x = Sp[0]->globalPosition().x(); 
+  double y = Sp[0]->globalPosition().y();
+  double z = Sp[0]->globalPosition().z();
+  //++s;
+  x = Sp[1]->globalPosition().x()-x; 
+  y = Sp[1]->globalPosition().y()-y;
+  z = Sp[1]->globalPosition().z()-z;
+  int n = int(2.*std::abs(log(tan(.5*atan2(sqrt(x*x+y*y),z)))));
+  if(n > 7) n = 7;
+  return n;
+}
 
 ///////////////////////////////////////////////////////////////////
 // Clusters-track multimap production