Calorimeter/CaloCnv/CaloTTDetDescrCnv/src/CaloTTDetDescrCnv_entries.cxx → Calorimeter/CaloCnv/CaloTTDetDescrCnv/src/components/CaloTTDetDescrCnv_entries.cxx

 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
-#include "CaloTTMgrDetDescrCnv.h"
+#include "../CaloTTMgrDetDescrCnv.h"
 
 DECLARE_CONVERTER( CaloTTMgrDetDescrCnv )
 

Calorimeter/CaloCondBlobAlgs/python/CaloCondTools.py

@@ -182,6 +182,14 @@ def iovFromRunLumi(runNum, lbkNum):
     """
     return (int(runNum)<<32) + int(lbkNum)
 
+#
+#____________________________________________________________________
+def runLumiFromIov(iov):
+    """
+    Returns run and lumi block numbers from COOL timeStamp
+    """
+    return (int(iov >> 32), int(iov & 0xFFFFFFFF))
+
 #
 #______________________________________________________________________
 def decodeTimeString(timeString):
@@ -338,6 +346,28 @@ class CaloBlobReader(CaloCondLogger):
             self.log().error("Fetching of systemId=%i failed with exception %s",systemId,e)
             return None
 
+    #____________________________________________________________________
+    def getDBobjsWithinRange(self, chan, point1inTime=(0,0), point2inTime=(2147483647,4294967295), printError=True):
+        """
+        Returns all DB objects for the given COOL channel, within given validity range -- default: [0-Infinity)
+        """
+
+        validityKey1 = getCoolValidityKey(point1inTime,True)
+        validityKey2 = getCoolValidityKey(point2inTime,False)
+
+        #print "Validity keys range is %s - %s" % (validityKey1, validityKey2)
+        self.log().debug("Validity key range is %s - %s", validityKey1,validityKey2)
+
+        objs = None
+        try:
+            dbChanSel = cool.ChannelSelection(chan)
+            #self.log().debug("Fetching blobs from DB: %s" % obj)
+            objs = self.__folder.browseObjects(validityKey1,validityKey2,dbChanSel,self.__tag)
+        except Exception as e:
+            if printError:
+                self.log().error("CaloCondTools.getDBobjsWithinRange(): Fetching of COOL_chan=%i failed with exception %s", chan,e)
+
+        return objs
 
     #____________________________________________________________________
     def folderIsMultiVersion(self):

Calorimeter/CaloCondBlobObjs/CMakeLists.txt

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
 # Declare the package name:
 atlas_subdir( CaloCondBlobObjs )
@@ -12,7 +12,7 @@ atlas_add_library( CaloCondBlobObjs
                    src/*.cxx
                    PUBLIC_HEADERS CaloCondBlobObjs
                    INCLUDE_DIRS ${CORAL_INCLUDE_DIRS}
-                   LINK_LIBRARIES ${CORAL_LIBRARIES} GaudiKernel
+                   LINK_LIBRARIES ${CORAL_LIBRARIES} GaudiKernel CxxUtils
                    PRIVATE_LINK_LIBRARIES AthenaKernel )
 
 atlas_add_dictionary( CaloCondBlobObjsDict
@@ -23,7 +23,7 @@ atlas_add_dictionary( CaloCondBlobObjsDict
 atlas_add_test( CaloCondBlobBase_test
   SOURCES
   test/CaloCondBlobBase_test.cxx src/CaloCondBlobBase.cxx
-  INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
-  LINK_LIBRARIES ${Boost_LIBRARIES} CaloCondBlobObjs CxxUtils
-  POST_EXEC_SCRIPT nopost.sh
+  INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${CORAL_INCLUDE_DIRS}
+  LINK_LIBRARIES ${Boost_LIBRARIES} ${CORAL_LIBRARIES} CaloCondBlobObjs CxxUtils
+  POST_EXEC_SCRIPT noerror.sh
 )

Calorimeter/CaloCondBlobObjs/CaloCondBlobObjs/CaloCondBlobBase.h

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef CALOCONDBLOBOBJS_CALOCONDBLOBBASE_H
@@ -38,6 +38,7 @@
 #include "CoralBase/Blob.h"
 #include "CaloCondBlobObjs/Exception.h"
 #include "CaloCondBlobObjs/CaloCondType.h"
+#include "CxxUtils/get_unaligned.h"
 
 class CaloCondBlobBase{
  public:
@@ -283,8 +284,9 @@ inline uint64_t
 CaloCondBlobBase::getTimeStamp() const 
 {
   if(!getCommentSizeUint32()) return 0;
-  return *(reinterpret_cast<const uint64_t*>(getBlobStart()+getHdrSize() +
-                                             getNObjs()*getObjSizeUint32()));
+  auto p = reinterpret_cast<const uint8_t*>(getBlobStart()+getHdrSize() +
+                                            getNObjs()*getObjSizeUint32());
+  return CxxUtils::get_unaligned64 (p);
 }
 
 #endif

Calorimeter/CaloCondBlobObjs/src/CaloCondBlobBase.cxx

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "CaloCondBlobObjs/CaloCondBlobBase.h"
 #include "CaloCondBlobObjs/CaloCondType.h"
+#include "CxxUtils/set_unaligned.h"
 #include <algorithm>
 #include <ctime>
 
@@ -121,9 +122,8 @@ CaloCondBlobBase::createBlob(uint16_t objType,
   //==== fill comment fields
   if(commentSizeChar){
     if(!timeStamp) timeStamp = ::time(nullptr);
-    uint64_t* pTimeStamp = reinterpret_cast<uint64_t*>(getBlobStart()+dataSizeByte/sizeof(uint32_t));
-    pTimeStamp[0] = timeStamp;
-    char* pChar = reinterpret_cast<char*>(++pTimeStamp); 
+    uint8_t* pChar = reinterpret_cast<uint8_t*> (getBlobStart()+dataSizeByte/sizeof(uint32_t));
+    CxxUtils::set_unaligned<uint64_t> (pChar, timeStamp);
     std::string::const_iterator iStr = author.begin();
     for(; iStr!=author.end(); ++iStr){ *pChar = *iStr; ++pChar; }
     *pChar = 0; 

Calorimeter/CaloCondBlobObjs/test/CaloCondBlobBase_test.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
 #define BOOST_TEST_DYN_LINK
@@ -8,11 +8,10 @@
 #include <boost/test/unit_test.hpp>
 
 namespace utf = boost::unit_test;
-#include "CxxUtils/checker_macros.h"
-ATLAS_NO_CHECK_FILE_THREAD_SAFETY;
 
 #include "CaloCondBlobObjs/CaloCondBlobBase.h"
 #include "CoralBase/Blob.h"
+#include "CxxUtils/set_unaligned.h"
 #include <cstdint>
 #include <sstream> 
 #include <iostream>
@@ -119,13 +118,12 @@ BOOST_AUTO_TEST_CASE(PublicMethods, * utf::expected_failures(1)){
   pDestination[2] = num;
   pDestination[3] = 0x80000000 | (gain << 24) | nChans;
   pDestination[4] = comment.size() / wordSize;
-  uint64_t* pTimeStamp = reinterpret_cast<uint64_t*>(pDestination+dataSizeWord);
+  uint8_t* pChar = reinterpret_cast<uint8_t*>(pDestination+dataSizeWord);
   uint64_t timeStamp{0};
-  pTimeStamp[0] = timeStamp;
-  char* pChar = reinterpret_cast<char*>(++pTimeStamp); 
-  strcpy(pChar, author.c_str());
+  CxxUtils::set_unaligned<uint64_t> (pChar, timeStamp);
+  strcpy(reinterpret_cast<char*>(pChar), author.c_str());
   pChar+=(1+author.size());
-  strcpy(pChar, comment.c_str());
+  strcpy(reinterpret_cast<char*>(pChar), comment.c_str());
   //instantiate the class using this blob
   CaloCondBlobStub blobStub(b);
   //checking...
@@ -156,7 +154,8 @@ Comment:       : Just testing
   BOOST_TEST(representation.str() == expectedString);
   uint32_t gainTooBig{0x80};//gain must be <=0x7F
   pDestination[3] = 0x80000000 | (gainTooBig << 24) | nChans;
-  BOOST_CHECK_THROW(CaloCondBlobStub invalid(b),CaloCond::InvalidBlob);//expect this test to fail
+  // The code is not actually testing for this.
+  //BOOST_CHECK_THROW(CaloCondBlobStub invalid(b),CaloCond::InvalidBlob);//expect this test to fail
   
 }
 BOOST_AUTO_TEST_SUITE_END()

Calorimeter/CaloCondPhysAlgs/python/CaloAddPedShiftConfig.py

+# Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentFactory import CompFactory 
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.MainServicesConfig import MainEvgenServicesCfg
+
+from IOVDbSvc.IOVDbSvcConfig import addFolders
+
+def CaloAddPedShiftCfg(flags,fileName="",output="ped.root"):
+
+    #msg = logging.getLogger("CaloAddPedShiftCfg")
+    result=ComponentAccumulator()
+
+    from LArGeoAlgsNV.LArGMConfig import LArGMCfg
+    result.merge(LArGMCfg(flags))
+    from TileGeoModel.TileGMConfig import TileGMCfg
+    result.merge(TileGMCfg(flags))
+
+    from LArCabling.LArCablingConfig import LArOnOffIdMappingCfg
+    result.merge(LArOnOffIdMappingCfg(flags))
+
+    
+    folder= '/CALO/Ofl/Pedestal/CellPedestal'
+    result.merge(addFolders(flags,folder,'CALO_OFL',className="CondAttrListCollection"))
+
+    result.addEventAlgo(CompFactory.CaloAddCellPedShift(FolderName=folder,inputFile=fileName))
+    
+
+    import os
+    rootfile="ped_data.root"
+    if os.path.exists(rootfile):
+        os.remove(rootfile)
+    result.addService(CompFactory.THistSvc(Output = ["file1 DATAFILE='"+output+"' OPT='RECREATE'"]))
+    result.setAppProperty("HistogramPersistency","ROOT")
+
+    return result
+
+
+if __name__=="__main__":
+    import argparse
+    parser= argparse.ArgumentParser(description="CaloCell Pedestal shift")
+    parser.add_argument('-t', '--globaltag', type=str, help="Global conditions tag ")
+    parser.add_argument('-i','--input', type=str, default="",  help="Input text file")
+    parser.add_argument('-o', '--output',type=str,default="cellped_data.root",help="name for root output files")
+    args = parser.parse_args()
+    print(args)
+
+    from AthenaConfiguration.AllConfigFlags import initConfigFlags
+    flags = initConfigFlags()
+    flags.Input.RunNumbers=[0xFFFFFFE,]
+    flags.Input.Files=[]
+    flags.IOVDb.DatabaseInstance="CONDBR2"
+    from AthenaConfiguration.TestDefaults import defaultGeometryTags, defaultConditionsTags
+    flags.IOVDb.GlobalTag = defaultConditionsTags.RUN3_DATA
+    flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN3
+  
+    if args.globaltag:
+        flags.IOVDb.GlobalTag=args.globaltag
+
+    flags.lock()
+    cfg=MainEvgenServicesCfg(flags)
+    cfg.merge(CaloAddPedShiftCfg(flags,args.input,args.output))
+
+    print("Start running...")
+    cfg.run(1)

Calorimeter/CaloCondPhysAlgs/python/CaloScaleNoiseConfig.py

@@ -76,7 +76,8 @@ if __name__=="__main__":
     parser.add_argument('datestamp',help="time specification like 2007-05-25:14:01:00")
     parser.add_argument('-a', '--absolute', action="store_true", help="Absolute rescaling based on noise derived from MC")
     parser.add_argument('-t', '--globaltag', type=str, help="Global conditions tag ")
-    parser.add_argument('-o', '--output',type=str,default="hvcorr",help="name stub for root and sqlite output files")
+    parser.add_argument('-s', '--sqlite', type=str,help="sqlite with CellNoise and HVCorr folders to be scaled ")
+    parser.add_argument('-o', '--output',type=str,default="cellnoise_data.root",help="name stub for root and sqlite output files")
     args = parser.parse_args()
     print(args)
 
@@ -95,13 +96,15 @@ if __name__=="__main__":
     from LArCalibProcessing.TimeStampToRunLumi import TimeStampToRunLumi
     rlb=TimeStampToRunLumi(TimeStamp_ns)
     if rlb is None:
-        rlb=[0xFFFFFFFF-1,0]
-        print("WARNING: Failed to convert time",TimeStamp_ns,"into a run/lumi number. Using 'infinite' run-number",rlb[0])
+        #rlb=[0x7FFFFFFF-1,0]
+        rlb=[999999,0]
+        print("WARNING: CaloScaleNoise: Failed to convert time",TimeStamp_ns,"into a run/lumi number. Using 'infinite' run-number",rlb[0])
 
 
     from AthenaConfiguration.AllConfigFlags import initConfigFlags
     flags = initConfigFlags()
     flags.Input.RunNumbers=[rlb[0]]
+    print("set the runnumber: ",flags.Input.RunNumbers)
     flags.Input.TimeStamps=[TimeStamp]
     flags.Input.Files=[]
     flags.IOVDb.DatabaseInstance="CONDBR2"
@@ -111,6 +114,10 @@ if __name__=="__main__":
     if args.globaltag:
         flags.IOVDb.GlobalTag=args.globaltag
 
+    if args.sqlite:
+        flags.IOVDb.SqliteInput=args.sqlite
+        flags.IOVDb.SqliteFolders=("/LAR/NoiseOfl/CellNoise","/LAR/ElecCalibFlat/HVScaleCorr",)
+
     flags.lock()
     cfg=MainEvgenServicesCfg(flags)
     cfg.merge(CaloScaleNoiseCfg(flags,absolute=args.absolute,output=args.output))

Calorimeter/CaloCondPhysAlgs/python/LArMinBiasAlgConfig.py

+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentFactory import CompFactory 
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+
+def LArMinBiasAlgCfg(flags, output='ntuple.root', supercell=False,
+                      idlowpt=900311, idhighpt=800831, wlowpt=0.099791, whighpt=0.00209):
+
+    result=ComponentAccumulator()
+
+    from LArGeoAlgsNV.LArGMConfig import LArGMCfg
+    result.merge(LArGMCfg(flags))
+    from TileGeoModel.TileGMConfig import TileGMCfg
+    result.merge(TileGMCfg(flags))
+
+    if(supercell):
+       from LArCabling.LArCablingConfig import LArOnOffIdMappingSCCfg
+       result.merge(LArOnOffIdMappingSCCfg(flags))
+
+       rKey="LArOnOffIdMapSC"
+    else:   
+       from LArCabling.LArCablingConfig import LArOnOffIdMappingCfg
+       result.merge(LArOnOffIdMappingCfg(flags))
+
+       rKey="LArOnOffIdMap"
+
+    result.addCondAlgo(CompFactory.LArMCSymCondAlg("LArMCSymCondAlgSC",SuperCell=supercell,ReadKey=rKey))
+
+    from xAODEventInfoCnv.xAODEventInfoCnvConfig import EventInfoCnvAlgCfg
+    result.merge(EventInfoCnvAlgCfg(flags, disableBeamSpot=True))
+
+    larMinBiasAlg = CompFactory.LArMinBiasAlg() 
+    larMinBiasAlg.datasetID_lowPt=idlowpt
+    larMinBiasAlg.datasetID_highPt=idhighpt
+    # in mc16 files, computed at the beginning: 
+    larMinBiasAlg.weight_lowPt = wlowpt
+    larMinBiasAlg.weight_highPt= whighpt
+    larMinBiasAlg.EvtInfo="EventInfo"
+    larMinBiasAlg.CablingKey=rKey
+    larMinBiasAlg.SuperCell=supercell
+    #larMinBiasAlg.OutputLevel=2
+    
+    result.addEventAlgo(larMinBiasAlg)
+
+    import os
+    if os.path.exists(output):
+        os.remove(output)
+    result.addService(CompFactory.THistSvc(Output = ["file1 DATAFILE='"+output+"' OPT='RECREATE'"]))
+    result.setAppProperty("HistogramPersistency","ROOT")
+
+    return result
+
+def list_of_strings(arg):
+    return arg.split(',')
+
+if __name__=="__main__":
+    import argparse
+    parser= argparse.ArgumentParser(description="Compute LArMinBias  from hits")
+    parser.add_argument('-r', '--run',type=int,default=999999,help="run number")
+    parser.add_argument('-o', '--output',type=str,default="ntuple.root",help="name of th root output file")
+    parser.add_argument('-i', '--input',type=list_of_strings,default=[],help="name of the input files")
+    parser.add_argument('-t', '--globaltag', type=str, help="Global conditions tag ")
+    parser.add_argument( '--idlow',type=int,default=900311,help="ID of lowPt sample")
+    parser.add_argument( '--idhigh',type=int,default=800831,help="ID of highPt sample")
+    parser.add_argument( '--wlow',type=float,default=0.099791,help="weight of lowPt sample")
+    parser.add_argument( '--whigh',type=float,default=0.00209,help="weight of highPt sample")
+    parser.add_argument('-s', '--isSC',default=False,action='store_true',help="running for SC ?")
+    args = parser.parse_args()
+    print(args)
+    print(len(args.input))
+
+    from AthenaConfiguration.AllConfigFlags import initConfigFlags
+    flags = initConfigFlags()
+    flags.Input.RunNumbers=[args.run]
+    print("set the runnumber: ",flags.Input.RunNumbers)
+    flags.Input.Files=args.input
+    flags.IOVDb.DatabaseInstance="OFLP200"
+    from AthenaConfiguration.TestDefaults import defaultGeometryTags
+    flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN3
+  
+    if args.globaltag:
+        flags.IOVDb.GlobalTag=args.globaltag
+
+    #flags.Debug.DumpEvtStore=True
+    #flags.Debug.DumpDetStore=True    
+    #flags.Debug.DumpCondStore=True    
+
+    flags.lock()
+
+    from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+    cfg=MainServicesCfg(flags)
+
+    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+    cfg.merge(PoolReadCfg(flags))
+
+    cfg.merge(LArMinBiasAlgCfg(flags,output=args.output, supercell=args.isSC,
+                               idlowpt=args.idlow, idhighpt=args.idhigh, 
+                                wlowpt=args.wlow, whighpt=args.whigh))
+
+    print("Start running...")
+    cfg.getService("MessageSvc").debugLimit=1000000
+    cfg.run()

Calorimeter/CaloCondPhysAlgs/share/CaloCellPos2Ntuple.py

 #!/bin/env python
-# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentFactory import CompFactory
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
@@ -48,8 +48,9 @@ if __name__=="__main__":
     
     flags.LAr.doHVCorr=False
     flags.Input.RunNumbers=[args.runnumber]
-    flags.IOVDb.GlobalTag="OFLCOND-MC23-SDR-RUN3-05" if args.mc else "CONDBR2-BLKPA-2024-03"
-    from AthenaConfiguration.TestDefaults import defaultGeometryTags
+    from AthenaConfiguration.TestDefaults import defaultGeometryTags, defaultConditionsTags
+    flags.IOVDb.GlobalTag=(defaultConditionsTags.RUN3_MC if args.mc else
+                           defaultConditionsTags.RUN3_DATA)
     flags.GeoModel.AtlasVersion=defaultGeometryTags.RUN3
 
     

Calorimeter/CaloCondPhysAlgs/share/CaloNoise2Ntuple.py

 #!/bin/env python
-# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentFactory import CompFactory
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
@@ -50,8 +50,8 @@ if __name__=="__main__":
     flags.LAr.doAlign=False
     flags.LAr.doHVCorr=False
     flags.Input.RunNumbers=[args.runnumber]
-    flags.IOVDb.GlobalTag="OFLCOND-MC23-SDR-RUN3-05" if args.mc else "CONDBR2-BLKPA-2024-03"
-    from AthenaConfiguration.TestDefaults import defaultGeometryTags
+    from AthenaConfiguration.TestDefaults import defaultConditionsTags, defaultGeometryTags
+    flags.IOVDb.GlobalTag=defaultConditionsTags.RUN3_MC if args.mc else defaultConditionsTags.RUN3_DATA
     flags.GeoModel.AtlasVersion=defaultGeometryTags.RUN3
 
     

Calorimeter/CaloCondPhysAlgs/src/CaloAddCellPedShift.cxx

 /*
-  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "CaloAddCellPedShift.h"
@@ -14,57 +14,17 @@
 #include "CaloCondBlobObjs/CaloCondUtils.h"
 
 
-
-//Constructor
-CaloAddCellPedShift::CaloAddCellPedShift(const std::string& name, ISvcLocator* pSvcLocator):
-  AthAlgorithm(name,pSvcLocator),
-  m_calo_id(nullptr),
-  m_onlineID(nullptr),
-  m_caloCoolIdTool("CaloCoolIdTool"),
-  m_iCool(0),
-  m_SubHash(0),
-  m_Hash(0),
-  m_OffId(0),
-  m_eta(0),
-  m_phi(0),
-  m_layer(0),
-  m_Gain(0),
-  m_bec(0),
-  m_posneg(0),
-  m_FT(0),
-  m_slot(0),
-  m_channel(0),
-  m_ped1(0),
-  m_ped1corr(0),
-  m_ped2(0),
-  m_tree(nullptr)
-
-{
-   declareProperty("inputFile",m_fname);
-   declareProperty("FolderName",m_folderName="/CALO/Pedestal/CellPedestal");
-}
-
-//__________________________________________________________________________
-CaloAddCellPedShift::~CaloAddCellPedShift()
-{
-  ATH_MSG_DEBUG( "CaloAddCellPedShift destructor called"  );
-}
 //__________________________________________________________________________
 StatusCode CaloAddCellPedShift::initialize()
 {
   ATH_MSG_DEBUG ("CaloAddCellPedShift initialize()" );
 
-  const CaloIdManager* mgr = nullptr;
-  ATH_CHECK( detStore()->retrieve( mgr ) );
-  m_calo_id      = mgr->getCaloCell_ID();
-
-  ATH_CHECK( detStore()->regFcn(&CaloAddCellPedShift::updateMap, this, m_noiseAttrListColl, m_folderName) );
-  ATH_MSG_INFO ( " registered a callback for " << m_folderName << " folder " );
-
   ATH_CHECK( m_caloCoolIdTool.retrieve() );
   ATH_CHECK( m_cablingKey.initialize() );
   ATH_CHECK( m_caloMgrKey.initialize() );
+  ATH_CHECK( m_pedKey.initialize() );
   ATH_CHECK( detStore()->retrieve(m_onlineID,"LArOnlineID") );
+  ATH_CHECK( detStore()->retrieve(m_calo_id,"CaloCell_ID") );
   ATH_CHECK( m_thistSvc.retrieve() );
 
   m_tree = new TTree("mytree","Calo Ped ntuple");
@@ -91,42 +51,6 @@ StatusCode CaloAddCellPedShift::initialize()
   return StatusCode::SUCCESS; 
 }
 
-// ===============================================================================
-
-StatusCode CaloAddCellPedShift::updateMap(IOVSVC_CALLBACK_ARGS_K(keys) )
-{
-  msg() << MSG::INFO << " in updateMap ";
-  std::list<std::string>::const_iterator itr;
-  for (itr=keys.begin(); itr!=keys.end(); ++itr) {
-    msg() << *itr << " ";
-  }
-  msg() << endmsg;
-
-  //=== loop over collection (all cool channels)
-  CondAttrListCollection::const_iterator iColl = m_noiseAttrListColl->begin();
-  CondAttrListCollection::const_iterator last  = m_noiseAttrListColl->end();
-  for (; iColl != last; ++iColl) {
-
-    //=== COOL channel number is system id
-    unsigned int sysId = static_cast<unsigned int>(iColl->first);
-
-    //=== delete old CaloCondBlobFlt (which does not own the blob)
-    std::map<unsigned int, const CaloCondBlobFlt*>::iterator iOld = m_noiseBlobMap.find(sysId);
-    if(iOld != m_noiseBlobMap.end()){
-      delete iOld->second;
-    }
-
-    //=== Get new CaloCondBlobFlt instance, interpreting current BLOB
-    const coral::Blob& blob = (iColl->second)["CaloCondBlob16M"].data<coral::Blob>();
-    const CaloCondBlobFlt* flt = CaloCondBlobFlt::getInstance(blob);
-
-    //=== store new pointer in map
-    m_noiseBlobMap[sysId] = flt;
-
-  }//end iColl
-
-  return StatusCode::SUCCESS;
-}
 
 //__________________________________________________________________________
 StatusCode CaloAddCellPedShift::execute()
@@ -150,25 +74,47 @@ StatusCode CaloAddCellPedShift::stop()
      return StatusCode::FAILURE;
   }
 
-  FILE* finput = fopen(m_fname.c_str(),"r");
-  ATH_MSG_INFO ( " opened file " << m_fname );
-  int bec;
-  int pos_neg;
-  int FT;
-  int slot;
-  int channel;
-  float pedShift;
-  while( fscanf(finput,"%d %d %d %d %d %f",&bec,&pos_neg,&FT,&slot,&channel,&pedShift) != EOF  ) {
-    ATH_MSG_INFO ( " read linbe " << bec << " " << pos_neg << " " << FT << " " << slot << " " << channel << " " << pedShift );
-    HWIdentifier hwid = m_onlineID->channel_Id(bec,pos_neg,FT,slot,channel);
-    Identifier id     = cabling->cnvToIdentifier( hwid);
-    IdentifierHash idHash = m_calo_id->calo_cell_hash(id);
-    int ii = (int) (idHash);
-    pedShiftValue[ii] = pedShift;
+
+  SG::ReadCondHandle<CondAttrListCollection> pedHdl{m_pedKey};
+  const CondAttrListCollection* attrListColl=*pedHdl;
+  if (!attrListColl) {
+    ATH_MSG_ERROR("Failed to retrieve CaloPedestal obj with key" << m_pedKey.key());
+    return StatusCode::FAILURE;
   }
-  fclose(finput);
-  ATH_MSG_INFO ( " end of reading file" );
 
+  std::map<unsigned int, const CaloCondBlobFlt*> pedBlobMap;
+  for (auto iColl=pedHdl->begin();iColl!=pedHdl->end();++iColl) {
+    //=== COOL channel number is system id
+    unsigned int sysId = static_cast<unsigned int>(iColl->first);
+    //=== Get new CaloCondBlobFlt instance, interpreting current BLOB
+    const coral::Blob& blob = (iColl->second)["CaloCondBlob16M"].data<coral::Blob>();
+    const CaloCondBlobFlt* flt = CaloCondBlobFlt::getInstance(blob);
+    //=== store new pointer in map
+    pedBlobMap[sysId] = flt;
+  }//end iColl
+  
+  
+
+  if (!m_fname.empty()) {
+    FILE* finput = fopen(m_fname.value().c_str(),"r");
+    ATH_MSG_INFO ( " opened file " << m_fname );
+    int bec;
+    int pos_neg;
+    int FT;
+    int slot;
+    int channel;
+    float pedShift;
+    while( fscanf(finput,"%d %d %d %d %d %f",&bec,&pos_neg,&FT,&slot,&channel,&pedShift) != EOF  ) {
+      ATH_MSG_INFO ( " read linbe " << bec << " " << pos_neg << " " << FT << " " << slot << " " << channel << " " << pedShift );
+      HWIdentifier hwid = m_onlineID->channel_Id(bec,pos_neg,FT,slot,channel);
+      Identifier id     = cabling->cnvToIdentifier( hwid);
+      IdentifierHash idHash = m_calo_id->calo_cell_hash(id);
+      int ii = (int) (idHash);
+      pedShiftValue[ii] = pedShift;
+    }
+    fclose(finput);
+    ATH_MSG_INFO ( " end of reading file" );
+  }
   SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
   ATH_CHECK(caloMgrHandle.isValid());
   const CaloDetDescrManager* calodetdescrmgr = *caloMgrHandle;
@@ -233,7 +179,7 @@ StatusCode CaloAddCellPedShift::stop()
           unsigned int dbGain = CaloCondUtils::getDbCaloGain(gain);
           unsigned int subHash2;
           unsigned int iCool = m_caloCoolIdTool->getCoolChannelId(idHash,subHash2);
-          const CaloCondBlobFlt* const flt = m_noiseBlobMap.find(iCool)->second;
+          const CaloCondBlobFlt* const flt = pedBlobMap.find(iCool)->second;
           float ped1_old= flt->getData(subHash2,dbGain,0);
           float ped2= flt->getData(subHash2,dbGain,1);
 

Calorimeter/CaloCondPhysAlgs/src/CaloAddCellPedShift.h

 /*
-  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */
 
 // CaloAddCellPedShift.h
@@ -9,16 +9,10 @@
 #define CALOCONDPHYSALGS_CALOADDCELLPEDSHIFT_H
 
 #include <string>
-
-// Gaudi includes
-
 #include "AthenaBaseComps/AthAlgorithm.h"
 #include "GaudiKernel/ToolHandle.h"
-#include "CaloIdentifier/CaloIdManager.h"
 #include "CaloDetDescr/CaloDetDescrManager.h"
 #include "CaloIdentifier/CaloCell_ID.h"
-#include "StoreGate/DataHandle.h"  
-#include "AthenaKernel/IOVSvcDefs.h"
 #include "CaloCondBlobObjs/ICaloCoolIdTool.h"
 #include "LArIdentifier/LArOnlineID.h"
 #include "LArCabling/LArOnOffIdMapping.h"
@@ -32,65 +26,57 @@ class CaloCondBlobFlt;
 class CondAttrListCollection;
 
 
-class ATLAS_NOT_THREAD_SAFE /* CallBacks*/CaloAddCellPedShift : public AthAlgorithm {
+class ATLAS_NOT_THREAD_SAFE CaloAddCellPedShift : public AthAlgorithm {
+
+ public:
+
+  using AthAlgorithm::AthAlgorithm;
 
-  public:
-    //Gaudi style constructor and execution methods
-    /** Standard Athena-Algorithm Constructor */
-    CaloAddCellPedShift(const std::string& name, ISvcLocator* pSvcLocator);
-    /** Default Destructor */
-    ~CaloAddCellPedShift();
     
-    /** standard Athena-Algorithm method */
-    virtual StatusCode          initialize() override;
-    /** standard Athena-Algorithm method */
-    virtual StatusCode          execute() override;
-    /** standard Athena-Algorithm method */
-    virtual StatusCode          finalize() override;
-    /** standard Athena-Algorithm method */
-    virtual StatusCode          stop() override;
+  /** standard Athena-Algorithm method */
+  virtual StatusCode          initialize() override;
+  /** standard Athena-Algorithm method */
+  virtual StatusCode          execute() override;
+  /** standard Athena-Algorithm method */
+  virtual StatusCode          finalize() override;
+  /** standard Athena-Algorithm method */
+  virtual StatusCode          stop() override;
     
-  private:
+ private:
 
   //---------------------------------------------------
   // Member variables
   //---------------------------------------------------
-  std::string m_fname;
-  std::string m_folderName;
-
-  ServiceHandle<ITHistSvc> m_thistSvc{this,"THistSvc","THistSvc"};
-
-  SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKey{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};
-  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey{this,"CaloDetDescrManager","CaloDetDescrManager","SG Key for CaloDetDescrManager in the Condition Store" };
-  const CaloCell_ID*       m_calo_id;
-  const LArOnlineID*      m_onlineID;
-
-  virtual StatusCode updateMap(IOVSVC_CALLBACK_ARGS);
-  //=== blob storage
-  const DataHandle<CondAttrListCollection> m_noiseAttrListColl;
-  std::map<unsigned int, const CaloCondBlobFlt*> m_noiseBlobMap;
-
-  ToolHandle<ICaloCoolIdTool> m_caloCoolIdTool;
-
-  int m_iCool;
-  int m_SubHash;
-  int m_Hash;
-  int m_OffId;
-  float m_eta;
-  float m_phi;
-  int m_layer;
-  int m_Gain;
-  int   m_bec;
-  int   m_posneg;
-  int   m_FT;
-  int   m_slot;
-  int   m_channel;
-  float m_ped1;
-  float m_ped1corr;
-  float m_ped2;
-
-  TTree* m_tree;
+    Gaudi::Property<std::string> m_fname{this,"inputFile",""};
   
 
+    ServiceHandle<ITHistSvc> m_thistSvc{this,"THistSvc","THistSvc"};
+    
+    SG::ReadCondHandleKey<LArOnOffIdMapping> m_cablingKey{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};
+    SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey{this,"CaloDetDescrManager","CaloDetDescrManager","SG Key for CaloDetDescrManager in the Condition Store" };
+    SG::ReadCondHandleKey<CondAttrListCollection> m_pedKey{this,"FolderName","/CALO/Pedestal/CellPedestal"};
+  
+    const CaloCell_ID*       m_calo_id=nullptr;
+    const LArOnlineID*      m_onlineID=nullptr;
+
+    ToolHandle<ICaloCoolIdTool> m_caloCoolIdTool{this,"CaloCoolIdTool","CaloCoolIdTool"};
+
+    int m_iCool=0;
+    int m_SubHash=0;
+    int m_Hash=0;
+    int m_OffId=0;
+    float m_eta=0;
+    float m_phi=0;
+    int m_layer=0;
+    int m_Gain=0;
+    int   m_bec=0;
+    int   m_posneg=0;
+    int   m_FT=0;
+    int   m_slot=0;
+    int   m_channel=0;
+    float m_ped1=0;
+    float m_ped1corr=0;
+    float m_ped2=0;
+    TTree* m_tree=nullptr;
 };
 #endif

Calorimeter/CaloCondPhysAlgs/src/CaloRescaleNoise.cxx

@@ -7,6 +7,11 @@
 #include "CaloIdentifier/CaloGain.h"
 #include "CaloEvent/CaloCell.h"
 #include "Identifier/Identifier.h"
+#include "CaloIdentifier/CaloCell_ID.h"
+
+#include "TTree.h"
+#include <cstdio>
+
 
 
 //Constructor
@@ -91,8 +96,7 @@ StatusCode CaloRescaleNoise::stop()
      return StatusCode::FAILURE;
   }
 
-  FILE* fp = fopen("calonoise.txt","w");
-
+  FILE* fp = std::fopen("calonoise.txt","w");
 
   SG::ReadCondHandle<ILArHVScaleCorr> scaleCorr (m_scaleCorrKey, ctx);
   SG::ReadCondHandle<ILArHVScaleCorr> onlineScaleCorr (m_onlineScaleCorrKey, ctx);
@@ -100,7 +104,11 @@ StatusCode CaloRescaleNoise::stop()
   SG::ReadCondHandle<CaloNoise> elecNoise   (m_elecNoiseKey,   ctx);
   SG::ReadCondHandle<CaloNoise> pileupNoise (m_pileupNoiseKey, ctx);
   SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
-  ATH_CHECK(caloMgrHandle.isValid());
+  if( not caloMgrHandle.isValid()){
+    std::fclose(fp);
+    ATH_MSG_ERROR("CaloRescaleNoise::stop: caloMgrHandle invalid.");
+    return StatusCode::FAILURE;
+  }
   const CaloDetDescrManager* calodetdescrmgr = *caloMgrHandle;
 
   int ncell=m_calo_id->calo_cell_hash_max();
@@ -209,7 +217,7 @@ StatusCode CaloRescaleNoise::stop()
 
   }        // loop over cells
 
-  fclose(fp);
+  std::fclose(fp);
   return StatusCode::SUCCESS;
  }
 

Calorimeter/CaloCondPhysAlgs/src/CaloRescaleNoise.h

@@ -8,7 +8,7 @@
 #ifndef CALOCONDPHYSALGS_CALORESCALENOISE_H
 #define CALOCONDPHYSALGS_CALORESCALENOISE_H
 
-#include <string>
+
 
 // Gaudi includes
 
@@ -16,16 +16,17 @@
 #include "GaudiKernel/ToolHandle.h"
 #include "CaloIdentifier/CaloIdManager.h"
 #include "CaloDetDescr/CaloDetDescrManager.h"
-#include "CaloIdentifier/CaloCell_ID.h"
 #include "LArElecCalib/ILArHVScaleCorr.h"
 #include "StoreGate/ReadCondHandleKey.h"  
 
 #include "LArCabling/LArOnOffIdMapping.h"
-
 #include "GaudiKernel/ITHistSvc.h"
-#include "TTree.h"
+
+#include <string>
 
 class CaloNoise;
+class TTree;
+class CaloCell_ID;
 
 class CaloRescaleNoise : public AthAlgorithm {
 
@@ -52,7 +53,7 @@ class CaloRescaleNoise : public AthAlgorithm {
   //---------------------------------------------------
   ServiceHandle<ITHistSvc> m_thistSvc{this,"THistSvc","THistSvc"};
 
-  const CaloCell_ID*       m_calo_id;
+  const CaloCell_ID*       m_calo_id{};
 
   SG::ReadCondHandleKey<CaloNoise> m_totalNoiseKey
     { this, "TotalNoiseKey", "totalNoise", "SG key for total noise" };
@@ -71,19 +72,19 @@ class CaloRescaleNoise : public AthAlgorithm {
   SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey
     { this, "CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store" };
 
-  int m_iCool;
-  int m_SubHash;
-  int m_Hash;
-  int m_OffId;
-  float m_eta;
-  float m_phi;
-  int m_layer;
-  int m_Gain;
-  float m_noise;
-  float m_elecNoise;
-  float m_pileupNoise; 
-  float m_elecNoiseRescaled;
-  TTree* m_tree;
-  bool m_absScaling;
+  int m_iCool{};
+  int m_SubHash{};
+  int m_Hash{};
+  int m_OffId{};
+  float m_eta{};
+  float m_phi{};
+  int m_layer{};
+  int m_Gain{};
+  float m_noise{};
+  float m_elecNoise{};
+  float m_pileupNoise{}; 
+  float m_elecNoiseRescaled{};
+  TTree* m_tree{};
+  bool m_absScaling{};
 };
 #endif

Calorimeter/CaloCondPhysAlgs/src/LArMinBiasAlg.cxx

@@ -8,6 +8,7 @@
 #include "CaloIdentifier/CaloIdManager.h"
 #include "CaloIdentifier/LArEM_ID.h"
 #include "CaloIdentifier/CaloCell_ID.h"
+#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
 
 #include "LArSimEvent/LArHit.h"
 #include "LArSimEvent/LArHitContainer.h"
@@ -67,9 +68,11 @@
 
     const CaloIdManager* mgr = nullptr;
     ATH_CHECK( detStore()->retrieve( mgr ) );
-    m_larem_id   = mgr->getEM_ID();
-    m_calo_id    = mgr->getCaloCell_ID();
-
+    if(m_isSC) {
+       m_calo_id = (const CaloCell_Base_ID*)mgr->getCaloCell_SuperCell_ID();
+    } else {
+       m_calo_id = (const CaloCell_Base_ID*)mgr->getCaloCell_ID();
+    }
 
     ATH_CHECK(m_mcSymKey.initialize());
 
@@ -77,8 +80,15 @@
 
     ATH_CHECK(m_caloMgrKey.initialize());
 
+    ATH_CHECK(m_caloSCMgrKey.initialize(m_isSC));
+
     ATH_CHECK(m_eventInfoKey.initialize());
 
+    ATH_CHECK(m_larHitKeys.assign(m_inputKeys.value()));
+    ATH_CHECK(m_larHitKeys.initialize(!m_inputKeys.empty() ));
+
+    if(m_isSC) ATH_CHECK( m_scidtool.retrieve() );
+
     m_n1=0;
     m_n2=0;
 
@@ -113,8 +123,16 @@
 
     if (m_first) {
 
-      SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
-      ATH_CHECK(caloMgrHandle.isValid());
+      const CaloDetDescrManager_Base *cMgr=nullptr;
+      if(m_isSC){
+         SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloMgrHandle{m_caloSCMgrKey};
+         ATH_CHECK(caloMgrHandle.isValid());
+         cMgr=(const CaloDetDescrManager_Base *)(*caloMgrHandle);
+      } else {
+         SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
+         ATH_CHECK(caloMgrHandle.isValid());
+         cMgr=(const CaloDetDescrManager_Base *)(*caloMgrHandle);
+      }
 
       SG::ReadCondHandle<LArMCSym>  mcsym      (m_mcSymKey, ctx);
       SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl (m_cablingKey, ctx);
@@ -125,6 +143,7 @@
       }
 
       m_ncell = m_calo_id->calo_cell_hash_max();
+      ATH_MSG_DEBUG("Hash max: "<<m_ncell);
 
       ATH_MSG_INFO(" --- first event " << m_ncell);
       m_symCellIndex.resize(m_ncell,-1);
@@ -153,13 +172,15 @@
         // we have already processed this hash => just need to associate cell i to the same symmetric cell
         if (doneCell[i2]>=0) {
            m_symCellIndex[i]=doneCell[i2];
+           ATH_MSG_DEBUG("Adding cell "<<id.get_identifier32().get_compact()<<" to a symmetrized  cell "<<id2.get_identifier32().get_compact());
         }
         // we have not already processed this hash, add an entry for this new symmetric cell
         else {  
+           ATH_MSG_DEBUG("New symmetrized  cell "<<id2.get_identifier32().get_compact());
            doneCell[i2]=nsym;
            m_symCellIndex[i] = nsym; 
            CellInfo cell;
-           const CaloDetDescrElement* calodde = (*caloMgrHandle)->get_element(id);
+           const CaloDetDescrElement* calodde = cMgr->get_element(id);
            cell.eta =  calodde->eta();
            cell.phi = calodde->phi();
            cell.region = m_calo_id->region(id);
@@ -214,21 +235,27 @@
 
    for (int i=0;i<m_ncell;i++) m_eCell[i]=0.;
 
-    std::vector <std::string> HitContainer;
-    HitContainer.emplace_back("LArHitEMB");
-    HitContainer.emplace_back("LArHitEMEC");
-    HitContainer.emplace_back("LArHitHEC");
-    HitContainer.emplace_back("LArHitFCAL");
-    for (unsigned int iHitContainer=0;iHitContainer<HitContainer.size();iHitContainer++)
-    {
-      const LArHitContainer* hit_container ;
-      ATH_CHECK(evtStore()->retrieve(hit_container,HitContainer[iHitContainer]));
-      for (const LArHit* hit : *hit_container)
+   auto hitVectorHandles = m_larHitKeys.makeHandles(ctx);
+   for (auto & inputHits : hitVectorHandles) {
+      if (!inputHits.isValid()) {
+        ATH_MSG_ERROR("BAD HANDLE"); //FIXME improve error here
+        //return StatusCode::FAILURE;
+        continue;
+      }
+
+      for (const LArHit* hit : *inputHits)
       {       
-          Identifier cellID=hit->cellID();
+          Identifier hitCellID=hit->cellID();
           double energy = hit->energy(); 
           double time =hit->time();
+          Identifier cellID;
+          if(m_isSC){
+             cellID=m_scidtool->offlineToSuperCellID(hitCellID);
+          } else {
+             cellID=hitCellID;
+          }
           int index = (int) (m_calo_id->calo_cell_hash(cellID));
+
           if (index < m_ncell && index>=0 && fabs(time)<25.) {
              m_eCell[index] += energy;
         }

Calorimeter/CaloCondPhysAlgs/src/LArMinBiasAlg.h

@@ -19,7 +19,9 @@
 #include "xAODEventInfo/EventInfo.h"
 
 #include "CaloDetDescr/CaloDetDescrManager.h"
+#include "CaloDetDescr/ICaloSuperCellIDTool.h"
 
+#include "LArSimEvent/LArHitContainer.h"
 
 #include "LArCabling/LArOnOffIdMapping.h"
 #include "LArRawConditions/LArMCSym.h"
@@ -68,8 +70,13 @@ class ITHistSvc;
       , "CaloDetDescrManager"
       , "SG Key for CaloDetDescrManager in the Condition Store" };
 
-  const LArEM_ID*        m_larem_id = nullptr;
-  const CaloCell_ID*       m_calo_id = nullptr;
+  SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> m_caloSCMgrKey { this
+      , "CaloSuperCellDetDescrManager"
+      , "CaloSuperCellDetDescrManager"
+      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" };
+
+  const CaloCell_Base_ID*       m_calo_id = nullptr;
+
   std::vector<double> m_eCell;
   
 
@@ -110,5 +117,10 @@ class ITHistSvc;
   float m_first;
   int m_ncell = 0;
   SG::ReadHandleKey<xAOD::EventInfo> m_eventInfoKey{this,"EvtInfo", "EventInfo", "EventInfo name"};
+  StringArrayProperty m_inputKeys{this, "InputHitContainers", {"LArHitEMB", "LArHitEMEC", "LArHitHEC", "LArHitFCAL"}, 
+                                "Name of input hit vectors (default=[LArHitEMB, LArHitEMEC, LArHitHEC, LArHitFCAL])" };
+  SG::ReadHandleKeyArray<LArHitContainer> m_larHitKeys;
+  BooleanProperty m_isSC {this, "SuperCell", false, "Creating for SC ?"};
+  ToolHandle<ICaloSuperCellIDTool>   m_scidtool{this, "CaloSuperCellIDTool", "CaloSuperCellIDTool", "Offline / SuperCell ID mapping tool"};
   };
 #endif

Calorimeter/CaloConditions/CaloConditions/CaloCellFactor.h

-// Dear emacs, this is -*- c++ -*-.
-
-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**
- * @file  CaloCellFactor.h
- * @author Walter Lampl <walter.lampl@cern.ch>
- * @date Dec 21, 2006
- * @brief Container for a cell-level rescaling-factors, typically obtained by Z->ee intercalibration
- */
-
-
-#ifndef CALOREC_CALOCELLSCALE_H
-#define CALOREC_CALOCELLSCALE_H
-
-
-#include "AthenaKernel/CLASS_DEF.h" 
-#include <vector>
-
-namespace CaloRec {
-
-/**
- * @class CaloCellFactor
- * @brief Container for a cell-level rescaling-factors, typically obtained by Z->ee intercalibration
- *
- */
-class CaloCellFactor
-  {
-  public:
-    typedef std::vector<float> contType;
-    typedef contType::size_type size_type;
-
-    //** Default Constructor
-    CaloCellFactor() {};
-
-    //** Standard constructor, resize vector and set elements on 1.0
-    CaloCellFactor(const size_type& size); 
-
-
-    //** non-const access
-    inline float& operator[](const size_type& hashID)
-      {return m_cellFactor[hashID];}
-
-
-    //** const access
-    inline const float& operator[](const size_type& hashID) const 
-      {return m_cellFactor[hashID];}
-
-    //** resize underlying vector (new elements will be 1.0)
-    void resize(const size_type& size);
-        
-    size_type size() const
-    {return m_cellFactor.size();}
-
-  private:
-    contType m_cellFactor;
-
-
-  };//end class
-}// end namespace
-
-CLASS_DEF(CaloRec::CaloCellFactor,206274732,1)
-
-#endif

Calorimeter/CaloConditions/CaloConditions/CaloConditionsDict.h

@@ -6,7 +6,6 @@
 #define CALOCONDITIONSDICT_H
 
 #include "CaloConditions/ToolConstants.h"
-#include "CaloConditions/CaloCellFactor.h"
 #include "CaloConditions/CaloCellPositionShift.h"
 #include "CaloConditions/CaloHadWeight.h"
 #include "CaloConditions/CaloEMFrac.h"

Calorimeter/CaloConditions/CaloConditions/selection.xml

@@ -5,9 +5,6 @@
   <class name="std::map<std::string, CaloRec::Arrayrep>" />
   <class name="std::pair<std::string, CaloRec::Arrayrep>" />
 
-
-  <class name="CaloRec::CaloCellFactor" id="F2906C3B-DB35-4026-8AA4-D57E4B41288D" />
-
   <class name="CaloRec::CaloCellPositionShift" id="3B3CCC72-7238-468E-B25E-6F85BA5C9D64" />
 
   <class name="CaloHadWeight" id="5E5F2C06-92C6-45F2-845C-382C41B55371" />