remove obsolete include files (LArCalibUtils-00-15-47)

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAccumulatedCalibDigitContSplitter.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// ----------------------------------------------------------------------------
+// Splitting AccumulatedCalibDigits container according pulsed calibration line
+//
+// Author: F. Tomasz
+// May 2007
+// ----------------------------------------------------------------------------
+
+#ifndef LARACCUMULATEDCALIBDIGITCONTSPLITTER_H
+#define LARACCUMULATEDCALIBDIGITCONTSPLITTER_H
+
+#include "GaudiKernel/Algorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include <vector>
+#include <string>
+#include <map>
+
+class LArAccumulatedCalibDigitContSplitter : public Algorithm
+{
+ public:
+  LArAccumulatedCalibDigitContSplitter(const std::string & name, ISvcLocator * pSvcLocator);
+  ~LArAccumulatedCalibDigitContSplitter();
+
+  //standard algorithm methods
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode stop();
+  StatusCode finalize(){ return StatusCode::SUCCESS;}
+    
+ private:
+  
+  StatusCode executeWithAccumulatedDigits();
+  
+  std::vector<std::string> m_keylist;
+  std::vector<std::string> m_OutputList;
+
+  bool  m_recAll;
+  unsigned   m_numLine;
+
+  bool m_useDacAndIsPulsedIndex;//used to store different waves for different HEC calib lines
+
+  StoreGateSvc* m_storeGateSvc;
+  
+  unsigned m_event_counter; 
+  
+};  
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAutoCorr.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LARAUTOCORR_H
+#define LARAUTOCORR_H
+/********************************************************************
+ 
+ NAME:     LArAutoCorr.h
+ PACKAGE:  offline/LArCalorimeter/LArCalibUtils
+ 
+ AUTHORS:  M. AHARROUCHE
+ CREATED:  Dec. 16, 2003
+  
+ PURPOSE:  Intermediate object used to handle data
+           to be used for calculation of autocorrelation
+           elements.
+            
+ ********************************************************************/
+// Include files
+#include <string>
+#include <vector>
+#include <math.h>
+
+
+class LArAutoCorr
+{
+ private:
+
+  // Lower bound of window
+  short m_min;
+
+  // Upper bound of window
+  short m_max;
+  
+  // Sum of components
+  std::vector<double> m_sum;
+  
+  // Sum of squares
+  std::vector<double> m_matrix;
+
+  // Autocorrelation matrix
+  std::vector<double>  m_cov;
+  std::vector<double>  m_cov_temp;
+ 
+  // Counter of events
+  int m_nped; 
+  
+ public:
+  
+  // Constructor
+  LArAutoCorr()
+    {
+      m_min = -1;
+      m_max = -1;
+      m_nped = 0;
+    }
+ 
+  // Destructor
+  ~LArAutoCorr(){}
+
+  // Reset m_sum, m_matrix and m_nped
+  void correl_zero();
+
+  // Set lower value
+  void set_min(const short min);
+  
+  // Set upper value
+  void set_max(const short max);
+
+  // Get number of entries
+  int get_nentries() const;
+ 
+  // Get mean value
+  double get_mean() const;
+
+  // Get rms value
+  double get_rms() const;
+ 
+  // Get lower value
+  const short & get_min()const;
+
+  // Get uper value
+  const short & get_max() const;
+  
+  // Fill the m_sum and m_matrix vector 
+  void add(const std::vector<short>& samples, size_t maxnsamples);
+
+  // Compute the autocorrelation elements
+  //MGV implement switch m_normalize to normalize
+  const std::vector<double> & get_cov(int m_normalize, int m_phys) ;
+
+
+};
+ 
+//----------------------------------------------------------------------------
+void  LArAutoCorr::set_min(const short min)
+//----------------------------------------------------------------------------
+{
+  m_min = min;
+}
+
+//----------------------------------------------------------------------------
+void  LArAutoCorr::set_max(const short max)
+//----------------------------------------------------------------------------
+{
+  m_max = max;
+} 
+
+//----------------------------------------------------------------------------
+int LArAutoCorr::get_nentries() const
+//----------------------------------------------------------------------------
+{
+  return m_nped;
+} 
+
+
+//----------------------------------------------------------------------------
+const short & LArAutoCorr::get_min() const
+//----------------------------------------------------------------------------
+{
+  return m_min;
+}
+
+//----------------------------------------------------------------------------
+const short & LArAutoCorr::get_max() const
+//----------------------------------------------------------------------------
+{
+  return m_max;
+}
+
+
+//----------------------------------------------------------------------------
+double  LArAutoCorr::get_mean() const
+//----------------------------------------------------------------------------
+{
+  double mean = 0;
+
+ int nsamples = m_sum.size();
+  for(int i=0; i<nsamples; i++)
+    mean += m_sum[i];
+    mean /= ((double)(nsamples*m_nped));
+
+  return mean;
+}
+
+
+//----------------------------------------------------------------------------
+const  std::vector<double> & LArAutoCorr::get_cov(int m_normalize, int m_phys) 
+//----------------------------------------------------------------------------
+{ 
+  int nsamples = m_sum.size();
+  int k =0;
+  if (m_nped==0) return m_cov;
+  for(int i=0;i<nsamples;i++){
+      for(int j=i;j<nsamples;j++,k++)
+	m_cov_temp[k]= (double)((m_matrix[k]/(m_nped)) - ((m_sum[i]*m_sum[j])/(m_nped*m_nped)));
+  }
+
+  //MGV normalize covariance elements if required
+  if (m_normalize == 1 && m_phys == 0 ){
+    k=0;
+    int si,sj;
+    si=0;
+    for(int i=0;i<nsamples;i++){
+      sj=si;
+      for(int j=i;j<nsamples;j++,k++) {
+	if (m_sum[i]!=.0 && m_sum[j]!=.0) 
+	  m_cov_temp[k]= m_cov_temp[k]/(double)sqrt((m_matrix[si]/(m_nped)-(m_sum[i]*m_sum[i])/(m_nped*m_nped))*(m_matrix[sj]/(m_nped)-(m_sum[j]*m_sum[j])/(m_nped*m_nped)));
+	sj+=nsamples-j;
+      }
+      si+=nsamples-i;
+    }
+  }
+  //MGV
+
+  if (m_phys==0) {
+    double sum;
+    int s;
+    for(int diag =1;diag<nsamples;diag++)
+      {
+        sum =0;
+        s = 0;
+        for(int i=0; i < nsamples-diag;i++)
+	  {	
+	    sum += m_cov_temp[s + diag];
+	    s += nsamples - i;
+	  }
+        sum = sum/(nsamples-diag);
+        m_cov[diag-1]= sum;
+      }
+    return m_cov;
+  }
+  else
+    return m_cov_temp;
+}
+
+//----------------------------------------------------------------------------
+double  LArAutoCorr::get_rms() const
+//----------------------------------------------------------------------------
+{
+  double x=0, y=0;
+  int k = 0;
+  int nsamples = m_sum.size();
+
+  for(int i=0; i<nsamples; i++)
+    {
+      x += m_sum[i];
+      y += m_matrix[k];
+      k += nsamples - i;// Index of diagonal element
+    }
+  
+  x/= (double) (nsamples*m_nped);
+  y/=(double) (nsamples*m_nped);
+  
+  double noise = sqrt(y- x*x);
+  
+  return noise;
+}
+
+//----------------------------------------------------------------------------
+void  LArAutoCorr::add(const std::vector<short>& samples, size_t maxnsamples)
+//----------------------------------------------------------------------------
+{
+  unsigned int nsamples = std::min(samples.size(),maxnsamples);
+  int k=0;
+ 
+  if(m_sum.size()<nsamples)
+    {
+    
+      m_cov.resize(nsamples - 1);
+      m_cov_temp.resize((nsamples*(nsamples+1))/2);
+      m_sum.resize(nsamples);
+      m_matrix.resize((nsamples*(nsamples+1))/2);
+    }
+
+  for(unsigned int i=0; i<nsamples; i++)
+    {
+      for(unsigned int j=i; j<nsamples; j++,k++)
+	m_matrix[k] += ((double)(samples[j]*samples[i]));
+  
+      m_sum[i] += ((double) samples[i]);
+    }
+  m_nped++;
+}
+
+//----------------------------------------------------------------------------
+void  LArAutoCorr::correl_zero()
+//----------------------------------------------------------------------------
+{
+  int j =0;
+  int nsamples = m_sum.size();
+  for(int l=0; l<nsamples; l++)
+    {
+      for(int k=l; k<nsamples; k++,j++)
+	m_matrix[j] = 0;
+      m_sum[l]=0;
+    }
+  m_nped=0;
+}
+
+#endif 
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAutoCorrBuilder.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//Dear emacs, this is -*-c++-*-
+
+#ifndef LARAUTOCORRBUILDER_H
+#define LARAUTOCORRBUILDER_H
+/********************************************************************
+ 
+ NAME:     LArAutoCorrBuilder.h
+ PACKAGE:  offline/LArCalorimeter/LArCalibUtils
+ 
+ AUTHORS:  R. Lafaye
+ CREATED:  Jun. 12, 2008 from LArAutoCorrMaker
+    
+ PURPOSE:  Get the autocorrelation for each cell from LArAccumulatedDigits
+           at each gain and records them in TDS
+
+           In fact only the last (m_nsamples-1) elements of the 
+           first line (or column) of autocorrelation matrix are
+           recovered and stored in TDS, for these reasons:
+           - symetry of autocorrelation matrix
+           - equivalence of autocorrelation elements: 
+             B(n,n+i)\eq B(m,m+i) (eg B12 \eq B23).
+HISTORY:
+          Walter Lampl, 26 Aug 2009:
+          Derive from LArPedestalBuilder 
+                      
+********************************************************************/
+
+// Include files
+#include "GaudiKernel/Algorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "LArCalibUtils/LArPedestalBuilder.h"
+
+#include "LArRawEvent/LArAccumulatedDigitContainer.h"
+
+#include "LArRawConditions/LArAutoCorrComplete.h"
+
+//-----------------------------------------------------------------------
+class LArAutoCorrBuilder : public LArPedestalBuilder
+//-----------------------------------------------------------------------
+{
+ public:
+
+  // Constructor
+  LArAutoCorrBuilder(const std::string & name, ISvcLocator * pSvcLocator);
+
+  // Destructor
+  ~LArAutoCorrBuilder();
+
+  // Algorithm initialization   
+  //StatusCode initialize();  Inherited from LArPedestalBuilder
+
+  // Algorithm execution
+  //StatusCode execute(); Inherited from LArPedestal Builder
+
+  // Algorithm finalization
+  StatusCode stop(); 
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+  
+ private:
+  //MGV Decide whether or not to normalize autocorr elements
+  int m_normalize;
+  std::string m_acContName;
+};
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAutoCorrDecoderTool.h

+//Dear emacs, this is -*- C++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef LARCALIBUTILS_LARAUTOCORRDECODERTOOL_H
+#define LARCALIBUTILS_LARAUTOCORRDECODERTOOL_H
+
+#include "LArElecCalib/ILArAutoCorrDecoderTool.h"
+#include "GaudiKernel/IIncidentListener.h"
+
+#include "GaudiKernel/ToolHandle.h"
+
+#include "LArElecCalib/ILArAutoCorr.h"
+#include <Eigen/Dense>
+
+#include "StoreGate/DataHandle.h"
+#include "LArTools/LArCablingService.h"
+#include "LArIdentifier/LArOnlineID.h"
+
+#include "LArRawConditions/LArConditionsContainer.h"
+
+#include "AthenaBaseComps/AthAlgTool.h"
+
+class StoreGateSvc;
+class LArCablingService;
+
+class LArAutoCorrDecoderTool: public AthAlgTool,
+			      virtual public ILArAutoCorrDecoderTool,
+			      public IIncidentListener
+
+{
+ public:
+  
+  // constructor
+  LArAutoCorrDecoderTool(const std::string& type, 
+			 const std::string& name, 
+			 const IInterface* parent); 
+  
+  // destructor 
+  virtual ~LArAutoCorrDecoderTool();
+  
+  // retrieve methods 
+  const Eigen::MatrixXd AutoCorr( const HWIdentifier&  CellID, int gain, unsigned nSamples) const;
+  const Eigen::MatrixXd AutoCorr( const Identifier&  CellID, int gain, unsigned nSamples) const;
+
+  // initialize and finalize methods
+  virtual StatusCode initialize();
+  virtual StatusCode finalize(){return StatusCode::SUCCESS;}
+
+  //IOV Callback functions
+  virtual StatusCode LoadAutoCorr(IOVSVC_CALLBACK_ARGS);
+  virtual void handle(const Incident&);
+
+  static const InterfaceID& interfaceID() { 
+    return ILArAutoCorrDecoderTool::interfaceID();
+  } 
+
+ private:
+
+  unsigned m_decodemode;
+
+  const Eigen::MatrixXd ACDiagonal( const HWIdentifier&  CellID, int gain, unsigned nSamples) const;
+  const Eigen::MatrixXd ACPhysics( const HWIdentifier&  CellID, int gain, unsigned nSamples) const;
+
+  const LArOnlineID*  m_lar_on_id;
+  ToolHandle<LArCablingService> m_cablingService;
+
+  std::string m_keyAutoCorr;
+  bool m_loadAtBegin;
+
+  const DataHandle<ILArAutoCorr> m_AutoCorr;
+
+  mutable bool m_cacheValid;
+
+};
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAutoCorrExtrapolate.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LARAUTOCORRExtrapolate_H
+#define LARAUTOCORRExtrapolate_H
+/********************************************************************
+ 
+ NAME:     LArAutoCorrExtrapolate.h
+ PACKAGE:  offline/LArCalorimeter/LArCalibUtils
+ 
+ AUTHORS:  G.Unal
+ CREATED:  sept 2008
+  
+ PURPOSE:  Extrapolate measured covariance matrix from highest gain in random
+            to all gains
+                      
+********************************************************************/
+
+// Include files
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/StoreGateSvc.h"
+
+class LArOnlineID;
+class ILArBadChanTool;
+
+//-----------------------------------------------------------------------
+class LArAutoCorrExtrapolate : public Algorithm
+//-----------------------------------------------------------------------
+{
+ public:
+
+  // Constructor
+  LArAutoCorrExtrapolate(const std::string & name, ISvcLocator * pSvcLocator);
+
+  // Destructor
+  ~LArAutoCorrExtrapolate();
+
+  // Algorithm initialization   
+  StatusCode initialize(); 
+
+  // Algorithm execution
+  StatusCode execute();
+
+  // Algorithm finalization
+  StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+  
+ private:
+
+  // StoreGate service
+  StoreGateSvc * m_detStore;
+
+  // Container key list
+  std::string m_keyoutput;
+  std::string m_keyPedestal;
+  std::string m_keyinput;
+  std::string  m_keyPedInput;
+  std::string m_keyRamp;
+
+  int m_Nsamples;
+
+  const LArOnlineID*        m_onlineId;
+
+  ToolHandle<ILArBadChanTool> m_badChannelTool;
+  bool m_useBad;
+
+  
+};
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAutoCorrMaker.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//dear emacs, this is -*-c++-*-
+
+#ifndef LARAUTOCORRMAKER_H
+#define LARAUTOCORRMAKER_H
+/********************************************************************
+ 
+ NAME:     LArAutoCorrMaker.h
+ PACKAGE:  offline/LArCalorimeter/LArCalibUtils
+ 
+ AUTHORS:  M. AHARROUCHE
+ CREATED:  Dec. 16, 2003
+  
+ PURPOSE:  Selects the good events and computes the autocorrelation 
+           matrix for each cell. It processes all the gains
+           simultaneously.
+           In fact only the last (m_nsamples-1) elements of the 
+           first line (or column) of autocorrelation matrix are
+           computed and stored in TDS, for these reasons:
+           - symetrie of autocorrelation matrix
+           - equivalence of autocorrelation elements: 
+             B(n,n+i)\eq B(m,m+i) (eg B12 \eq B23).
+                      
+********************************************************************/
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "LArRawEvent/LArAutoCorr.h"
+#include "LArRawConditions/LArConditionsContainer.h"
+
+
+namespace Trig {
+  class IBunchCrossingTool;
+}
+//-----------------------------------------------------------------------
+class LArAutoCorrMaker : public AthAlgorithm
+//-----------------------------------------------------------------------
+{
+ public:
+
+  // Constructor
+  LArAutoCorrMaker(const std::string & name, ISvcLocator * pSvcLocator);
+
+  // Destructor
+  ~LArAutoCorrMaker();
+
+  // Algorithm initialization   
+  StatusCode initialize(); 
+
+  // Algorithm execution
+  StatusCode execute();
+
+  // Algorithm finalization
+  StatusCode stop();
+  StatusCode finalize(){ return StatusCode::SUCCESS;}
+  
+ private:
+
+  ToolHandle<Trig::IBunchCrossingTool> m_bunchCrossingTool;
+
+  int m_bunchCrossingsFromFront;
+
+  // Container key list
+  std::vector<std::string> m_keylist, m_keylistproperty;
+  std::string m_keyoutput;
+  
+  // Grouping type
+  std::string m_groupingType;
+  
+  // Number of events used to define window
+  int m_nref; 
+
+  // Number of sigma
+  int m_rms_cut;
+  int m_nsamples;
+
+  //MGV Decide whether or not to normalize autocorr elements
+  int m_normalize;
+
+  // flag save full N(N+1)/2 matrix   (relevant for pileup)
+   int m_physics;
+  
+  typedef LArConditionsContainer<LArAutoCorr>  LARACMAP;
+  LARACMAP m_autocorr;
+
+
+  //counter for accepted events
+  unsigned m_nEvents;
+};
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArAutoCorrToolToDB.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LArAutoCorrToolToDB_H
+#define LArAutoCorrToolToDB_H
+/********************************************************************
+ 
+ NAME:     LArAutoCorrToolToDB.h
+                      
+********************************************************************/
+
+// Include files
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "LArIdentifier/LArOnlineID.h"
+#include "LArElecCalib/ILArAutoCorrTotalTool.h"
+
+//-----------------------------------------------------------------------
+class LArAutoCorrToolToDB : public Algorithm
+//-----------------------------------------------------------------------
+{
+ public:
+
+  // Constructor
+  LArAutoCorrToolToDB(const std::string & name, ISvcLocator * pSvcLocator);
+
+  // Destructor
+  ~LArAutoCorrToolToDB();
+
+  // Algorithm initialization   
+  StatusCode initialize(); 
+
+  // Algorithm execution
+  StatusCode execute();
+
+  // Algorithm stop
+  StatusCode stop();
+ 
+  // Algorithm finalization
+  StatusCode finalize();
+  
+ private:
+
+  // StoreGate service
+  StoreGateSvc * m_storeGateSvc;
+  StoreGateSvc * m_detStore;
+  const LArOnlineID * m_onlineHelper;
+
+  ToolHandle<ILArAutoCorrTotalTool> m_autocorrTool;
+
+  // Grouping type
+  std::string m_groupingType;
+
+  // key
+  std::string m_acContName;
+  
+  
+};
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCaliWaveAverage.h

+//Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef LARCALIWAVEAVERAGE_H
+#define LARCALIWAVEAVERAGE_H
+
+#include "GaudiKernel/Algorithm.h"
+
+#include "StoreGate/StoreGateSvc.h"
+#include "LArTools/LArCablingService.h"
+#include "CaloIdentifier/CaloIdManager.h"
+#include "CaloIdentifier/LArEM_ID.h"
+#include "Identifier/HWIdentifier.h"
+#include "LArRawConditions/LArCaliWave.h"
+
+#include <string>
+
+class LArCaliWaveAverage:public Algorithm {
+
+public:
+
+  LArCaliWaveAverage (const std::string& name, ISvcLocator* pSvcLocator);
+  ~LArCaliWaveAverage();
+  
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+
+private:
+
+  StoreGateSvc*      m_detStore;
+  LArCablingService* m_larCablingSvc;
+  const LArOnlineID* m_onlineHelper;
+  
+  const LArEM_ID*    m_emId;
+  const LArHEC_ID*   m_hecId;
+  const LArFCAL_ID*  m_fcalId;
+
+  std::string m_keyInput;
+  std::string m_keyOutputCorr;
+  std::string m_keyOutputSymm;
+  std::string m_groupingType;
+  
+  //std::vector<HWIdentifier> m_chids;
+  std::vector<unsigned> m_chids;
+
+  std::vector<HWIdentifier> SymmetricChannels(HWIdentifier ChID,std::vector<unsigned> ChannelsNotToUse );
+  LArCaliWave WaveAverage(std::vector<LArCaliWave> ToBeAveraged);
+
+};
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCaliWaveBuilder.h

+//Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef LARCALIWAVEBUILDER_H
+#define LARCALIWAVEBUILDER_H
+
+#include "GaudiKernel/ToolHandle.h"
+#include "AthenaBaseComps/AthAlgorithm.h"
+
+
+#include <vector>
+#include <string>
+#include <map>
+
+#include "LArRawConditions/LArCaliWaveContainer.h"
+
+
+class ILArPedestal;
+class LArCablingService;
+
+class LArCaliWaveBuilder : public AthAlgorithm
+{
+ public:
+  LArCaliWaveBuilder(const std::string & name, ISvcLocator * pSvcLocator);
+  ~LArCaliWaveBuilder();
+
+  StatusCode initialize();
+  StatusCode execute();
+  virtual StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+    
+ private:
+  
+  bool       m_useAccumulatedDigits;
+  StatusCode executeWithAccumulatedDigits();
+  StatusCode executeWithStandardDigits();
+  
+  std::vector<std::string> m_keylist;
+  std::vector<std::string> m_keylistproperty;
+  std::string m_keyoutput ;
+  std::string m_groupingType;
+
+  // Intermediate caching objects
+  typedef std::map<int, LArCaliWave>      WaveMap;
+  typedef LArConditionsContainer<WaveMap> WaveContainer;
+  WaveContainer m_waves;
+
+  // Pedestal subtraction
+  const DataHandle<ILArPedestal> m_larPedestal;
+  bool                m_pedSub;
+  //const ILArPedestal* m_larPedestal;
+  unsigned            m_baseline;
+  
+  //used to store different waves for different HEC calib lines
+  bool m_useDacAndIsPulsedIndex;
+
+  // Saturation check
+  int              m_ADCsatur;
+
+  // Empty phases (missing files) check
+  bool            m_checkEmptyPhases;
+
+  const LArOnlineID*   m_onlineID;
+  ToolHandle<LArCablingService> m_cablingSvc;
+  
+  unsigned m_event_counter; 
+  int      m_NStep;
+  float    m_SamplingPeriod;
+  float    m_dt;
+
+  uint16_t m_fatalFebErrorPattern;
+  
+};  
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCaliWaveBuilderXtalk.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/************************************************************
+
+ This algorithm produces a LArCaliWaveContainer
+ out of a LArCalibDigitContainer. They key of the
+ containers that are to be processed  is defined 
+ by the jobOption 'KeyList'. The resulting 
+ containers are put in the DetectorStore with the 
+ same keys. 
+
+ This algorithm was largely inspired from the LArCaliWaveBuilder
+ algorithm; it however allows to reconstruct channels
+ that were not pulsed,in order to study cross talk
+ The definition of the desired pattern is given in the job
+ options
+
+ Different calibration pattern are available : 
+  - EM Barrel : StripSingle[1-4] / MiddleSingle[1-8] / BackSingle[1-4]
+  - EM Endcap : StripSingle[1-4] / MiddleSingle[1-4] / BackSingle[1-4]
+    and MiddleSingle[1-4] / BackSingle[1-4] for inner wheel
+ For EM endcap special crates studies, set SpecialCrate to true and
+ SpecialRegion to InnerWheel or OuterWheel.
+
+ FeedthroughPul is used to find the relevant calibration pattern. Empty
+ ntuples/histograms may be produced with badly set FeedthroughPul, or if
+ there are bad channels or disconnected FEBs in FeedthroughPul.
+
+
+ NB.
+ Currently the calibration patterns are tested for one particular channel,
+ hard-coded in initializeCabling(), and taken in the feed-through FeedthroughPul.
+ The algorithm should be runnned for each calibration pattern and each
+ subdetectors.
+ This could, for example, be improved by:
+  (1) Using directly calibration line channels to detect the pattern. This 
+      would avoid to specify, and look at, a particular feed-through.
+      One could also set dynamicaly the different patterns, with job options
+      (for example in the same way that they are set for calibration runs: 
+      four words of 32 bits).
+  (2) Create one LArCaliWaveContainer per pattern (gathered inside a vector 
+      for exemple). This should permit to reconstruct all patterns in one pass.
+
+
+************************************************************/
+
+#ifndef LARCALIWAVEBUILDERXTALK_H
+#define LARCALIWAVEBUILDERXTALK_H
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/MsgStream.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "LArRawEvent/LArAccumulatedCalibDigitContainer.h"
+#include "LArRawConditions/LArCaliWaveContainer.h"
+#include "LArIdentifier/LArOnlineID.h"
+
+#include "LArTools/LArCablingService.h"
+#include "LArElecCalib/ILArPedestal.h"
+#include "CaloIdentifier/LArEM_ID.h"
+
+#include <vector>
+#include <string>
+#include <map>
+
+class LArCaliWaveBuilderXtalk : public Algorithm
+{
+ public:
+  LArCaliWaveBuilderXtalk(const std::string & name, ISvcLocator * pSvcLocator);
+  ~LArCaliWaveBuilderXtalk();
+
+  //standard algorithm methods
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode stop();
+  StatusCode finalize(){ return StatusCode::SUCCESS;}
+
+ private:
+
+  StatusCode initializeCabling();
+  
+  std::vector<std::string> m_keylist;
+  std::vector<std::string> m_keylistproperty;
+  std::string m_keyoutput;
+  std::string m_groupingType;
+
+  // Intermediate caching objects
+  typedef std::map<int, LArCaliWave>      WaveMap;
+  typedef LArConditionsContainer<WaveMap> WaveContainer;
+  WaveContainer   m_waves;
+
+  StoreGateSvc* m_storeGateSvc;
+  const LArOnlineID*   m_onlineHelper;
+  ToolHandle<LArCablingService> m_larCablingSvc;
+
+  std::vector<HWIdentifier> m_CalibLineHW;
+
+  int 	   m_feedthroughNumber;	// FT which is used to check the calibration pattern
+  int 	   m_posOrNeg;		// A/C side
+  int 	   m_barrelEndcap;	// Barrel / Endcap
+
+  std::string m_calibPattern;  
+  std::string m_partition;
+
+  bool m_isSpecialCrate;		// for special crates
+  std::string m_emecSpecialRegion;	// OuterWheel / InnerWheel
+  bool m_isInnerWheel;			// for EMEC inner wheel
+
+  unsigned m_event_counter; 
+  int	   m_NStep; 
+  float    m_SamplingPeriod;
+  float    m_dt;
+  int	   m_ADCsatur;		// Saturation check
+
+  int	   m_cutOnSample;	// Cut waves (0 = no cut)
+};  
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCaliWaveMerger.h

+//Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef LARCALIWAVEMERGER_H
+#define LARCALIWAVEMERGER_H
+
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/MsgStream.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "LArRawConditions/LArCaliWaveContainer.h"
+#include <string>
+
+class LArCaliWaveMerger : public Algorithm
+{
+
+ public:
+
+  LArCaliWaveMerger(const std::string & name, ISvcLocator * pSvcLocator);
+  ~LArCaliWaveMerger();
+
+  //standard algorithm methods
+  StatusCode initialize() { return StatusCode::SUCCESS ; } 
+  StatusCode execute()    { return StatusCode::SUCCESS ; } 
+  StatusCode stop();
+  StatusCode finalize()   { return StatusCode::SUCCESS ; }
+  
+ private:
+    
+  std::vector<std::string> m_keylist ; 
+  std::string m_keyout ;
+  std::string m_groupingType;
+
+};
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCaliWaveSelector.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// ----------------------------------------------------------------------------
+// Selecting a LArCaliWave according DAC
+//
+// Author: P. Strizenec
+// September 2008
+// ----------------------------------------------------------------------------
+
+#ifndef LARCALIWAVESELECTOR_H
+#define LArCALIWAVESELECTOR_H
+
+#include "GaudiKernel/Algorithm.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include <vector>
+#include <string>
+#include <map>
+
+typedef std::pair< std::pair<int,int>, int> DetGain;
+
+class LArOnlineID;
+class CaloCell_ID;
+class LArOnOffIdMap;
+
+class LArCaliWaveSelector : public Algorithm
+{
+ public:
+  LArCaliWaveSelector(const std::string & name, ISvcLocator * pSvcLocator);
+  ~LArCaliWaveSelector();
+
+  StatusCode initialize();
+  StatusCode execute() { return StatusCode::SUCCESS;};
+  StatusCode stop();
+  StatusCode finalize(){ return StatusCode::SUCCESS;}
+    
+ private:
+
+  void parseSelection(MsgStream *log);
+
+  const CaloCell_ID *m_cellID;
+
+  std::map<DetGain, int> m_mapDAC;
+  unsigned short m_gmask;
+
+  std::vector<std::string> m_keyList;
+  std::vector<std::string> m_selectionList;
+  std::string m_outputKey;
+  std::string m_groupingType;
+
+};  
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCalibCopyAlg.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//Dear emacs, this is -*-c++-*-
+
+/**
+ * @file LArCalibCopyAlg.h
+ * @author Walter Lampl <walter.lampl @cern.ch>
+ * @date Feb 2008
+ * @brief Algorithm to copy LAr Electronic Calibration constants to a new container with a different grouping
+ */
+
+
+#ifndef LARCALIBCOPYALG_H
+#define LARCALIBCOPYALG_H
+ 
+#include <vector>
+#include <string>
+ 
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "LArRecConditions/ILArBadChanTool.h"
+#include "LArRecConditions/ILArBadChannelMasker.h"
+#include "LArRawConditions/LArMphysOverMcalComplete.h"
+#include "LArRawConditions/LArRampComplete.h"
+#include "LArRawConditions/LArOFCComplete.h"
+#include "LArRawConditions/LArDAC2uAMC.h"
+#include "LArRawConditions/LArTdriftComplete.h"
+#include "LArRawConditions/LArPedestalComplete.h"
+
+
+/** 
+  * @class LArCalibValidationAlg
+  * @brief Algorithm to copy LAr elec. calibration constants to a different conatiner (different grouping)
+  *
+  */
+
+
+template<class CONDITIONSCONTAINER>
+class LArCalibCopyAlg:public Algorithm {
+ 
+public:
+  /**
+   * @brief regular Algorithm constructor
+   */
+  LArCalibCopyAlg (const std::string& name, ISvcLocator* pSvcLocator);
+
+  /**
+   * @brief Destructor
+   */
+  ~LArCalibCopyAlg();
+
+  /**
+   * @brief Initialize method.
+   * @return Gaudi status code.
+   * Analyzes and verifies the jobOption settings
+   */
+  StatusCode initialize();
+
+  /**
+   * @brief Empty Execute method
+   */
+  StatusCode execute() {return StatusCode::SUCCESS;}
+
+   /**
+   * @brief stop(() method.
+   * @return Gaudi status code.
+   * All the job is done here
+   */
+  StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+
+private:
+
+  typedef typename CONDITIONSCONTAINER::ConstConditionsMapIterator CONTIT;
+  typedef typename CONDITIONSCONTAINER::LArCondObj LArCondObj;
+  typedef typename CONDITIONSCONTAINER::ConstCorrectionIt CORRIT;
+
+  //Generic case
+  //StatusCode setSymlink(const CONDITIONSCONTAINER*  ) const {return StatusCode::SUCCESS;}
+  StatusCode setSymlink(const LArPhysWaveContainer* ) const {return StatusCode::SUCCESS;}
+  
+  //Specialized methods to set symlinks for the different types
+  StatusCode setSymlink(const LArRampComplete* ramp) const;
+  StatusCode setSymlink(const LArPedestalComplete* ramp) const;
+  StatusCode setSymlink(const LArOFCComplete* ofc) const;
+  StatusCode setSymlink(const LArMphysOverMcalComplete* mpmc) const;
+  StatusCode setSymlink(const LArDAC2uAMC* ramp) const;
+  StatusCode setSymlink(const LArTdriftComplete* obj) const;
+
+  
+  
+  StoreGateSvc* m_detStore;    
+  MsgStream* m_log;
+
+  std::string m_inputName;
+  std::string m_outputName;
+  std::string  m_groupingType;
+  bool m_useCorrChannel;
+
+};
+
+#include "LArCalibCopyAlg.icc"
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCalibCopyAlg.icc

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//Dear emacs, this is -*-c++-*-
+
+template<class CONDITIONSCONTAINER>
+LArCalibCopyAlg<CONDITIONSCONTAINER>::LArCalibCopyAlg (const std::string& name, ISvcLocator* pSvcLocator) : 
+  Algorithm(name,pSvcLocator),
+  m_detStore(0),
+  m_log(NULL),
+  m_groupingType("ExtendedSubDetector"),
+  m_useCorrChannel(true)
+ {		
+  declareProperty("GroupingType",    m_groupingType); 	
+  declareProperty("InputKey",        m_inputName); 	
+  declareProperty("OutputKey",       m_outputName);
+  declareProperty("UseCorrChannels", m_useCorrChannel,
+		  "True: Use separate correction COOL channel, False: Correction + data in the same channel");
+
+}
+
+template<class CONDITIONSCONTAINER>
+LArCalibCopyAlg<CONDITIONSCONTAINER>::~LArCalibCopyAlg() {
+  delete m_log;
+}
+
+
+template<class CONDITIONSCONTAINER>
+StatusCode LArCalibCopyAlg<CONDITIONSCONTAINER>::initialize() {
+  m_log=new MsgStream(msgSvc(),name());
+
+  // Get Detector store
+  StatusCode sc = service("DetectorStore", m_detStore);
+  if (sc.isFailure()) {
+    (*m_log) << MSG::ERROR << "Cannot locate DetectorStore " << endreq;
+    return StatusCode::FAILURE;
+  } 
+
+  //Block correction application
+  bool setFlag =   LArConditionsContainerBase::applyCorrectionsAtInit(true, false);
+  (*m_log) << MSG::INFO << "LArConditionsContainerBase::applyCorrectionsAtInit set to " << setFlag << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+template<class CONDITIONSCONTAINER>
+StatusCode LArCalibCopyAlg<CONDITIONSCONTAINER>::stop() {
+  (*m_log) << MSG::INFO << "Entering LArCalibCopyAlg" << endreq;
+
+  const CONDITIONSCONTAINER* input=0;
+  StatusCode sc=m_detStore->retrieve(input,m_inputName);
+  if (sc.isFailure()) {
+    (*m_log) << MSG::ERROR << "Failed to load input container with name " << m_inputName << " from DetectorStore." << endreq;
+    return sc;
+  }
+
+  CONDITIONSCONTAINER* output=new CONDITIONSCONTAINER();
+  sc=output->setGroupingType(m_groupingType,(*m_log));
+  if (sc.isFailure()) {
+    (*m_log) << MSG::ERROR << "Failed to set groupingType for ouptut container" << endreq;
+    return sc;
+  }
+  sc=output->initialize(); 
+  if (sc.isFailure()) {
+    (*m_log) << MSG::ERROR << "Failed initialize output container" << endreq;
+    return sc;
+  }
+  
+  sc=m_detStore->record(output,m_outputName);
+  if (sc.isFailure()) {
+    (*m_log) << MSG::ERROR << "Failed to record object with key " << m_outputName
+	     << " to DetectorStore." << endreq;
+    return StatusCode::FAILURE;
+  }
+
+  //Make symlink ....
+  if (setSymlink(output).isFailure()) return sc;
+   
+  (*m_log) << MSG::INFO << "Loaded input container " << m_inputName 
+	   << ", write to new container " << m_outputName << endreq;
+
+
+  //Start copying data ...
+
+  unsigned nDataChans=0;
+
+  for (unsigned igain=CaloGain::LARHIGHGAIN;igain<CaloGain::LARNGAIN ; ++igain ) {
+    CONTIT it=input->begin(igain);
+    CONTIT it_e=input->end(igain);
+    for (;it!=it_e;it++) {
+      const HWIdentifier chid = it.channelId();
+      const LArCondObj& payload=*it;
+      output->setPdata(chid,payload,igain);
+      ++nDataChans;
+    }//end loop over channels
+
+  } // end loop over gains
+  
+  //Same with correction channels:
+  unsigned nCorrChans=0;
+  for ( unsigned igain=CaloGain::LARHIGHGAIN;igain<CaloGain::LARNGAIN ; ++igain ) {
+    CORRIT it=input->undoCorrBegin(igain);
+    CORRIT it_e=input->undoCorrEnd(igain);
+    for (;it!=it_e;it++) {
+      const HWIdentifier chid(it->first);
+      const LArCondObj& payload=it->second;
+      sc=output->insertCorrection(chid,payload,igain,m_useCorrChannel); 
+      if (sc.isFailure()) {
+	(*m_log) << MSG::ERROR << "Failed to insert correction channel" << endreq;
+	return StatusCode::FAILURE;
+      }
+    } // end loop over channels
+    ++nCorrChans;
+  } //end loop over gains
+
+
+  (*m_log) << MSG::INFO << "Copied " << nDataChans << " data channels and " << nCorrChans << " correction channels from container '" 
+	   << m_inputName << "' to container '" << m_outputName << "'" << endreq;
+
+  return StatusCode::SUCCESS;
+}
+
+
+template<class CONDITIONSCONTAINER>
+StatusCode  LArCalibCopyAlg<CONDITIONSCONTAINER>::setSymlink(const LArRampComplete* ramp) const {
+  StatusCode sc=m_detStore->symLink(ramp, (ILArRamp*)ramp);
+  if (sc.isFailure()) 
+    (*m_log) << MSG::ERROR << "Failed to symlink LArRampComplete to ILArRamp" << endreq;
+  return sc;
+}
+
+template<class CONDITIONSCONTAINER>
+StatusCode  LArCalibCopyAlg<CONDITIONSCONTAINER>::setSymlink(const LArPedestalComplete* pedestal) const {
+  StatusCode sc=m_detStore->symLink(pedestal, (ILArPedestal*)pedestal);
+  if (sc.isFailure()) 
+    (*m_log) << MSG::ERROR << "Failed to symlink LArPedestalComplete to ILArPedestal" << endreq;
+  return sc;
+}
+
+template<class CONDITIONSCONTAINER>
+StatusCode  LArCalibCopyAlg<CONDITIONSCONTAINER>::setSymlink(const LArDAC2uAMC* obj) const {
+  StatusCode sc=m_detStore->symLink(obj, (ILArDAC2uA*)obj);
+  if (sc.isFailure()) 
+    (*m_log) << MSG::ERROR << "Failed to symlink LArDAC2uAMC to ILArDAC2uA" << endreq;
+  else
+    (*m_log) << MSG::INFO << "Successfully symlinked LArDAC2uAMC to ILArDAC2uA" << endreq;
+  return sc;
+}
+
+template<class CONDITIONSCONTAINER>
+StatusCode  LArCalibCopyAlg<CONDITIONSCONTAINER>::setSymlink(const LArTdriftComplete* obj) const {
+  StatusCode sc=m_detStore->symLink(obj, (ILArTdrift*)obj);
+  if (sc.isFailure()) 
+    (*m_log) << MSG::ERROR << "Failed to symlink LArTdriftComplete to ILArTdrift" << endreq;
+  else
+    (*m_log) << MSG::INFO << "Successfully symlinked LArTdriftComplete to ILArTdrift" << endreq;
+  return sc;
+}
+
+template<class CONDITIONSCONTAINER>
+StatusCode  LArCalibCopyAlg<CONDITIONSCONTAINER>::setSymlink(const LArOFCComplete* ofc) const {
+  StatusCode sc=m_detStore->symLink(ofc, (ILArOFC*)ofc);
+  if (sc.isFailure()) 
+    (*m_log) << MSG::ERROR << "Failed to symlink LArOFCComplete to ILArOFC" << endreq;
+  return sc;
+}
+
+
+template<class CONDITIONSCONTAINER>
+StatusCode  LArCalibCopyAlg<CONDITIONSCONTAINER>::setSymlink(const LArMphysOverMcalComplete* mpmc) const {
+  StatusCode sc=m_detStore->symLink(mpmc, (ILArMphysOverMcal*)mpmc);
+  if (sc.isFailure()) 
+    (*m_log) << MSG::ERROR << "Failed to symlink LArMphysOverMcalComplete to ILArMphysOverMcal" << endreq;
+  return sc;
+}
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCalibDigitMaker.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef LARCALIBDIGITMAKER
+#define LARCALIBDIGITMAKER
+#include "GaudiKernel/Algorithm.h"
+//#include "GaudiKernel/MsgStream.h"
+#include  "StoreGate/StoreGateSvc.h"
+#include "LArRawEvent/LArDigitContainer.h"
+#include "GaudiKernel/ToolHandle.h"	// Modif J. Labbe from JF Marchand - Nov. 2009
+#include "LArTools/LArCablingService.h"
+#include "CaloIdentifier/LArEM_ID.h"
+#include <fstream>
+
+class LArCalibDigitMaker : public Algorithm
+{
+ public:
+  LArCalibDigitMaker(const std::string & name, ISvcLocator * pSvcLocator);
+
+  ~LArCalibDigitMaker();
+
+  //standart algorithm methods
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+ private:
+  StoreGateSvc *m_storeGateSvc, *m_detStore;
+  ToolHandle<LArCablingService> m_larCablingSvc; //   LArCablingService *m_larCablingSvc; 	// Modif J. Labbe from JF Marchand - Nov. 2009
+  //const LArOnlineID* m_onlineHelper;
+  //JobOpts:
+  std::vector<std::string> m_keylist;
+  //std::string m_key;
+  std::vector<unsigned> m_vPattern;
+  std::vector<unsigned> m_vDAC;
+  std::vector<unsigned> m_vDelay;
+  std::vector<unsigned> m_vBoardIDs;
+  unsigned m_nTrigger;
+  double m_delayScale;
+  bool m_dontRun;
+};
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCalibPatchingAlg.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//Dear emacs, this is -*-c++-*-
+
+/**
+ * @file LArCalibPatchingAlg.h
+ * @author Walter Lampl <walter.lampl @cern.ch>
+ * @date Feb 2008
+ * @brief Algorithm to patch LAr elec. calibration constants for channels with broken calibration line
+ */
+
+
+#ifndef LARCALIBPATCHINGALG_H
+#define LARCALIBPATCHINGALG_H
+ 
+#include <vector>
+#include <string>
+ 
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "LArRecConditions/ILArBadChanTool.h"
+#include "LArRecConditions/ILArBadChannelMasker.h"
+#include "LArRawConditions/LArMphysOverMcalComplete.h"
+#include "LArRawConditions/LArRampComplete.h"
+#include "LArRawConditions/LArOFCComplete.h"
+
+
+/** 
+  * @class LArCalibValidationAlg
+  * @brief Algorithm to patch LAr elec. calibration constants for channels with broken calibration line
+  *
+  * Loops over all channels in an LArConditionsContainer and checks their status in the bad-channel database.
+  * Constants for 'bad' channels are patched,by one of the follwoing methods (steered by jobOptions): @n
+  * - Neighboring FEB channel @n
+  * - Neighbor in Phi @n
+  * - Average over all channels with the same phi @n
+  *
+  * The @c LArBadChannelMasker tool is used to determine what types of problems should be patched.
+  * The patched value is added to the LArConditionsContainer as correction. The neighbor-patching is templated,
+  * and works for any kind of payload object while the averaging needs knowledge about the payload object and
+  * is implemented a specialized method @c getAverage. 
+  */
+
+
+template<class CONDITIONSCONTAINER>
+class LArCalibPatchingAlg:public Algorithm {
+ 
+public:
+  /**
+   * @brief regular Algorithm constructor
+   */
+  LArCalibPatchingAlg (const std::string& name, ISvcLocator* pSvcLocator);
+
+  /**
+   * @brief Destructor
+   */
+  ~LArCalibPatchingAlg();
+
+  /**
+   * @brief Initialize method.
+   * @return Gaudi status code.
+   * Analyzes and verifies the jobOption settings
+   */
+  StatusCode initialize();
+
+  /**
+   * @brief Empty Execute method
+   */
+  StatusCode execute() {return StatusCode::SUCCESS;}
+
+   /**
+   * @brief Finalize method.
+   * @return Gaudi status code.
+   * All the job is done here
+   */
+  StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+
+private:
+
+  typedef typename CONDITIONSCONTAINER::ConstConditionsMapIterator CONTIT;
+  typedef typename CONDITIONSCONTAINER::LArCondObj LArCondObj;
+  
+ /**
+   * @brief patch method 
+   * @return bool to tell if patching suceeded
+   * This method is called for every channel with broken calibration line
+   */
+  bool patch(const HWIdentifier chid, const int gain); 
+
+    
+ /**
+   * @brief Specialized method to average Ramps over a phi-ring
+   * @param chid Online identifier of the channel to be patched
+   * @param gain Gain in question
+   * @patch [OUT] Reference to be filled by the average
+   */
+  bool getAverage(const HWIdentifier chid, const int gain, LArRampP1& patch, bool isphi=true); 
+
+  /**
+   * @brief Specialized method to average OFCs over a phi-ring
+   * @param chid Online identifier of the channel to be patched
+   * @param gain Gain in question
+   * @patch [OUT] Reference to be filled by the average
+   */
+  bool getAverage(const HWIdentifier chid, const int gain, LArOFCP1& patch, bool isphi=true); 
+
+
+
+
+
+  //The following #ifdef-logic is to make this package compile against 13.2.0. as well as 14.X.0
+  //since the payload object of LArMphysOverMcal has changed from LArMphysOverMcalP1 to LArSingleFloatP
+
+
+#ifdef LARRAWCONDITIONS_LARMPHYSOVERMCALP
+  /**
+   * @brief Specialized method to average MphysOverMcal over a phi-ring
+   * @param chid Online identifier of the channel to be patched
+   * @param gain Gain in question
+   * @patch [OUT] Reference to be filled by the average
+   */
+
+  //For backward compatiblity only!!! Will be removed at some point
+  bool getAverage(const HWIdentifier chid, const int gain, LArMphysOverMcalP1& patch, bool isphi=true);
+#endif
+
+
+#ifdef LARRAWCONDITIONS_LARSINGLEFLOATP
+  /**
+   * @brief Specialized method to average any single-float object over a phi-ring
+   * @param chid Online identifier of the channel to be patched
+   * @param gain Gain in question
+   * @patch [OUT] Reference to be filled by the average
+   */
+  bool getAverage(const HWIdentifier chid, const int gain, LArSingleFloatP& patch, bool isphi=true);
+#endif
+
+
+
+
+  //bool getAverage(const HWIdentifier chid, const int gain, LArShape& shape);
+  bool getAverage(const HWIdentifier,const int, LArCaliWaveVec&, bool isphi=true) ;
+/*
+  bool getAverage(const HWIdentifier,const int, LArCaliWaveVec&) {
+    //Not implementend and should never be called.
+    assert(0);
+    return false;
+  };
+*/
+   /**
+   * @brief Helper method to get a phi-ring
+   * @return Reference to a vector of HWIdentfiers
+   * @param chid Identifier of the channel to be patched
+   * @param distance Step-with in phi. 1..every channel, 2..every second channel, etc.
+   * Probably meaningless for the FCAL
+   */ 
+  std::vector<HWIdentifier>& getPhiRing(const HWIdentifier chid, unsigned distance=1);
+  
+  /* Get list of channels in the same FEB. Used for FEBAverage method */
+  std::vector<HWIdentifier>& getFEBChans(const HWIdentifier chid);
+
+  StatusCode setSymlink(const LArRampComplete* ramp) const;
+  StatusCode setSymlink(const LArOFCComplete* ofc) const;
+  StatusCode setSymlink(const LArMphysOverMcalComplete* ramp) const;
+  StatusCode setSymlink(const LArCaliWaveContainer* ) const 
+  {return StatusCode::SUCCESS;};
+
+  enum patchMethod{
+    FEBNeighbor,
+    PhiNeighbor,
+    PhiAverage,
+    FEBAverage
+  };
+
+  StoreGateSvc* m_detStore;    
+  MsgStream* m_log;
+  ToolHandle<ILArBadChanTool> m_badChannelTool;
+  ToolHandle<ILArBadChannelMasker> m_maskingTool;
+  ToolHandle<LArCablingService> m_larCablingSvc;  
+
+  bool m_useCorrChannel;
+  bool m_patchAllMissing;
+  bool m_unlock;
+
+  const LArOnlineID* m_onlineHelper;
+  const LArEM_ID   * m_emId;
+  const LArHEC_ID  * m_hecId;
+  const LArFCAL_ID * m_fcalId;
+  const CaloCell_ID* m_caloId;
+
+  const CONDITIONSCONTAINER* m_contIn;  
+  CONDITIONSCONTAINER* m_contOut;  
+
+  patchMethod    m_patchMethod;
+  std::string    m_containerKey;
+  std::string    m_newContainerKey;
+  std::string    m_patchMethodProp;
+
+  std::vector<HWIdentifier> m_idList;
+
+};
+
+#include "LArCalibPatchingAlg.icc"
+
+#endif
+

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArCalibShortCorrector.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//Dear emacs, this is -*-c++-*-
+#ifndef LARCALIBSHORTCORRECTOR_H
+#define LARCALIBSHORTCORRECTOR_H
+
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/MsgStream.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include "LArTools/LArCablingService.h"
+#include "LArElecCalib/ILArPedestal.h"
+
+#include <vector>
+
+class LArAccumulatedCalibDigit;
+class ILArBadChanTool;
+class CaloCell_ID;
+class LArOnlineID;
+class LArCablingService;
+class HWIdentifier;
+
+
+class LArCalibShortCorrector : public Algorithm//, public IIncidentListener 
+{
+ public:
+  LArCalibShortCorrector(const std::string & name, ISvcLocator * pSvcLocator);
+  ~LArCalibShortCorrector();
+
+  //standard algorithm methods
+  StatusCode initialize();
+  StatusCode execute();
+  StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+
+
+ private:
+
+  StatusCode findShortedNeighbors();
+
+  StoreGateSvc*       m_storeGateSvc;
+  StoreGateSvc*       m_detStore;
+
+  ToolHandle<LArCablingService> m_larCablingSvc;
+  ToolHandle<ILArBadChanTool> m_badChannelTool;
+
+  const LArOnlineID*  m_onlineId;
+  const CaloCell_ID*  m_caloCellId;
+  
+  const DataHandle<ILArPedestal> m_larPedestal;
+
+  //Algorithm-Properties:
+  std::vector<std::string> m_keylist;
+  std::string m_pedKey;
+
+  //private members
+  std::vector<std::pair<HWIdentifier,HWIdentifier> > m_shortedNeighbors;
+  typedef std::vector<std::pair<HWIdentifier,HWIdentifier> >::const_iterator SHORT_IT;
+ 
+  MsgStream* m_log;
+  bool m_shortsCached;
+};
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArDeltaRespPredictor.h

+//Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef LARDELTARESPPREDICTOR_H
+#define LARDELTARESPPREDICTOR_H
+
+#include "GaudiKernel/Algorithm.h"
+#include "GaudiKernel/MsgStream.h"
+
+#include "StoreGate/StoreGateSvc.h"
+#include "LArRawConditions/LArWFParams.h"
+#include "LArRawConditions/LArCaliWave.h"
+
+#include "LArCalibUtils/LArWFParamTool.h"
+#include "LArCalibUtils/LArDeltaRespTool.h" 
+
+#include <vector>
+#include <string>
+
+class LArDeltaRespPredictor : public Algorithm
+{
+ public:
+ 
+  LArDeltaRespPredictor(const std::string & name, ISvcLocator * pSvcLocator);
+
+  ~LArDeltaRespPredictor();
+
+  //standard algorithm methods
+  StatusCode initialize() ; 
+  StatusCode execute() {return StatusCode::SUCCESS;} //empty method
+  StatusCode stop();
+  StatusCode finalize(){return StatusCode::SUCCESS;}
+ 
+ private:
+
+  std::vector<std::string> m_keylist;
+
+};
+
+#endif

LArCalorimeter/LArCalibUtils/LArCalibUtils/LArDeltaRespTool.h

+//Dear emacs, this is -*- c++ -*-
+
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef LARDELTARESPTOOL_H
+#define LARDELTARESPTOOL_H
+
+#include "GaudiKernel/AlgTool.h"
+#include "GaudiKernel/MsgStream.h"
+
+#include "LArRawConditions/LArWFParams.h"
+#include "LArRawConditions/LArCaliWave.h"
+#include "LArRawConditions/LArWaveHelper.h"
+
+static const InterfaceID IID_LArDeltaRespTool("LArDeltaRespTool", 1 , 0); 
+
+class LArDeltaRespTool : public AlgTool
+{
+ public: 
+
+  // Retrieve interface ID
+  static const InterfaceID& interfaceID() { return IID_LArDeltaRespTool; }
+
+  // constructor
+   LArDeltaRespTool(const std::string& type, const std::string& name, const IInterface* parent ) ;
+
+  // destructor 
+  virtual ~LArDeltaRespTool(); 
+
+  virtual StatusCode initialize(){return StatusCode::SUCCESS;}
+  virtual StatusCode finalize(){return StatusCode::SUCCESS;}
+
+  LArCaliWave makeLArDeltaResp(const LArWFParams &, const LArCaliWave &);
+
+ private:
+  
+  static const int DEFAULT;
+  
+  LArCaliWave m_gCali, m_gDelta;
+  
+  bool m_injPointCorr, m_normalizeCali, m_timeOriginShift, m_subtractBaseline;
+  
+  double   m_Tdrift, m_Fstep, m_Tcal, m_Omega0, m_Taur;
+  unsigned m_Tstart;
+
+  void compute_deltaresp();
+
+  LArWave deltaResp( const LArWave & ) const ;  
+  LArWave deltaCorr() const;
+  double  deltaCorr( double t ) const;
+
+  LArWave injResp (LArWave w) const;
+  LArWave injCorr() const;
+  double injCorr ( double t ) const;
+
+};
+
+#endif