L1CaloCondSvc.icc

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGT1CALOCONDSVC_L1CALOCONDSVC_ICC
#define TRIGT1CALOCONDSVC_L1CALOCONDSVC_ICC
 
#include "AthenaKernel/IOVRange.h"
#include "AthenaKernel/StorableConversions.h"
 
#include  "AthenaPoolUtilities/AthenaAttributeList.h"
#include  "AthenaPoolUtilities/CondAttrListCollection.h"
 
#include <iostream>
 
#include "CxxUtils/checker_macros.h"
ATLAS_NO_CHECK_FILE_THREAD_SAFETY;  // obsolete, replaced by L1CaloCondAlg
 
template <typename T>
StatusCode L1CaloCondSvc::store(const T*& pobj, const std::string& key, const std::string& folder, const std::string& tag) const {
  /*  ======================================================================
      The object pobj must implement the IL1CaloPersistenceCapable interface
      ====================================================================== */
 
  ATH_MSG_VERBOSE( "*** L1CaloCondSvc::store() ***" );
  ATH_MSG_VERBOSE(key <<" "<< folder <<" "<< tag );
 
  // create persistent object (either AthenaAttributeList or CondAttrListCollection) from the transient one
  // the new object is not registered in the TDS
  ATH_MSG_VERBOSE( "*** pobj->makePersistent() ***" );
  DataObject* newConditions = pobj->makePersistent();
 
  // Declare a pointer to point to the final CondAttrListCollection (or AthenaAttributeList)
  // containing the updated conditions merged with the old ones from COOL
  DataObject* finalConditions = 0;
 
  // Setting up a new IOV range
  IOVTime start, end;
 
  if(m_bUseTimeStamp) {
    start = IOVTime(m_iovBeginTime);
    end = IOVTime(m_iovEndTime);
  } else {
    start = IOVTime(m_iovBeginRun, m_iovBeginLB);
    end = IOVTime(m_iovEndRun, m_iovEndLB);
  }
 
  // range is used later to setup the IOV range of the updated conditions
  IOVRange range(start, end);
 
  ATH_MSG_VERBOSE( "*** get old conditions ***" );
  if(newConditions) {
 
    std::string conditionType = pobj->conditionType();
    if(conditionType=="CondAttrListCollection") {
 
      // cast pobj to a CondAttrListCollection
      CondAttrListCollection* attrListCollection = dynamic_cast<CondAttrListCollection*>(newConditions);
      if (!attrListCollection) {
        ATH_MSG_ERROR( "Could not cast to CondAttrListCollection" );
        return StatusCode::FAILURE;
      }
 
      if(m_bWriteNewChannels) {
        ATH_MSG_VERBOSE( "*** m_bWriteNewChannels TRUE ***" );
   
        // New channels can only be written to cool is their AttributeList match exactly the destination folder one
        // OR if the channels are written to a empty new folder.
        // In such a case there is no need to do any merging as all attributes in the destination folder are defined.
 
        CondAttrListCollection* newAttrListCollection = new CondAttrListCollection(!m_bUseTimeStamp);
 
        CondAttrListCollection::const_iterator it_attrList = attrListCollection->begin();
        for(;it_attrList!=attrListCollection->end();++it_attrList) {
          CondAttrListCollection::ChanNum channelNumber = it_attrList->first;
          const CondAttrListCollection::AttributeList& attrList = it_attrList->second;
 
          newAttrListCollection->add(channelNumber, attrList);
          newAttrListCollection->add(channelNumber, range);
        }
 
        ATH_CHECK(  m_detStore->record(newAttrListCollection, key) );
 
      } else {
 
        ATH_MSG_VERBOSE( "*** m_bWriteNewChannels FALSE ***" );
 
        // In this case we are updating a subset of channel attributes from an already filled cool folder
        // The non-defined attributes information is retrieved from COOL, so All channels that will be updated must already exist
        // in the source COOL folder
 
        // Now we retrieve the latest valid CondAttrListCollection (the full folder) from the TES or from COOL (if not already in the TES)
        const CondAttrListCollection* pConstCOOLCondAttrListCollection = 0;
        ATH_CHECK( m_detStore->retrieve(pConstCOOLCondAttrListCollection, key) );
 
        // create a new CondAttrListCollection to merge the new data from attrListCollection with the old ones from pConstCOOLCondAttrListCollection
        // CondAttrListCollection(false) will use TimeStamp
        // CondAttrListCollection(true) will use Run/Lumi blocks
        CondAttrListCollection* mergedAttrListCollection = new CondAttrListCollection(!m_bUseTimeStamp);
 
        // do the merging
        // only the channels present in attrListCollection are copied & merged to the new CondAttrListCollection
        // so non-updated channels will not be recorded to COOL
 
        CondAttrListCollection::const_iterator it_attrList = attrListCollection->begin();
        for(;it_attrList!=attrListCollection->end();++it_attrList) {
          CondAttrListCollection::ChanNum channelNumber = it_attrList->first;
          const CondAttrListCollection::AttributeList& attrList = it_attrList->second;
 
          CondAttrListCollection::const_iterator it_coolAttrList = pConstCOOLCondAttrListCollection->chanAttrListPair(channelNumber);
          if(it_coolAttrList!=pConstCOOLCondAttrListCollection->end()) {
            // a corresponding channel is already defined in the COOL folder
            // the new attributes are merged with the old ones
            //CondAttrListCollection::AttributeList* coolAttrList = new CondAttrListCollection::AttributeList(it_coolAttrList->second);
            CondAttrListCollection::AttributeList coolAttrList;
            coolAttrList.merge(it_coolAttrList->second);
            coolAttrList.merge(attrList);
 
            mergedAttrListCollection->add(channelNumber, coolAttrList);
            mergedAttrListCollection->add(channelNumber, range);
 
          } else {
            // the current channel does not exist in the COOL folder -> 2 cases
            ATH_MSG_WARNING( "Trying to update channel "<< channelNumber << ", which does not already exist in the COOL folder for the specified IOV (WriteNewChannel is switched off)");
 
            /*
              if(m_bWriteNewChannels) {
              // if ALL the COOL attributes are defined/updated by the transient object we can add this new channel to the new collection to be stored in COOL
              // (this is the case when populating a new folder from scratch)
              mergedAttrListCollection->add(channelNumber, attrList);
              mergedAttrListCollection->add(channelNumber, range);
              } else {
              // the transient object only defines/updates a subset of the COOL folder attributes.
              // (ie we are adding a new channel to an already filled folder)
              // We don't know how to initialize the other attribute, so this channel is not added to the new collection to be stored in COOL
              ATH_MSG_WARNING(g to update channel "<< channelNumber << ", which does not already exist in the COOL folder (WriteNewChannel is switched off)");
              }
            */
          }
        }
 
        finalConditions  = SG::asStorable(mergedAttrListCollection);
 
        //-------------------------------------------
        // replace the 'old' collection retrieved from COOL by the one updated with new attributes values
 
        //retrieve the proxy of the CondAttrListCollection retrieved from COOL
        SG::DataProxy* proxy = m_detStore->proxy(m_detStore->clid(key), key);
 
        // we reset the proxy to delete the old conditions
        proxy->reset();
 
        // we add the new updated conditions to the proxy
        proxy->setObject(finalConditions);
 
      }
      /*
        ATH_MSG_INFO("====================================================================================================" );
        it_attrList = mergedAttrListCollection->begin();
        for(;it_attrList!=mergedAttrListCollection->end();++it_attrList) {
        CondAttrListCollection::ChanNum channelNumber = it_attrList->first;
        CondAttrListCollection::AttributeList attrList = it_attrList->second;
        //log<<MSG::INFO<<"atributeList : "<<attrList.toOutputStream(log)<<endmsg;
        std::cout <<channelNumber<<" "<< attrList.toOutputStream(std::cout) <<std::endl;
        }
      */
 
    } else if(conditionType=="AthenaAttributeList") {
      /*
        AthenaAttributeList* attributeList = dynamic_cast<AthenaAttributeList*>(newConditions);
 
        // Now we retrieve the latest valid CondAttrListCollection (the full folder) from the TES or from COOL (if not already in the TES)
        const AthenaAttributeList* pConstCOOLAthenaAttributeList = 0;
        ATH_CHECK(  m_detStore->retrieve(pConstCOOLAthenaAttributeList, key) );
 
        // create a new CondAttrListCollection to merge the new data from attrListCollection with the old ones from pConstCOOLCondAttrListCollection
        AthenaAttributeList* mergedAthenaAttributeList = new AthenaAttributeList(*pConstCOOLAthenaAttributeList);
        mergedAthenaAttributeList->merge(*attributeList);
 
        finalConditions  = SG::asStorable(mergedAthenaAttributeList);
      */
 
    } else {
      ATH_MSG_ERROR( "Condition type " << conditionType<< "not recognized by L1CaloCondSvc" );
      return StatusCode::FAILURE;
    }
 
 
 
    //-------------------------------------------
    // register attrListCollection to IOVDB
    if(m_bUseTimeStamp) {
      ATH_MSG_DEBUG( "use timestamp" );
      ATH_CHECK( m_regSvc->registerIOV(pobj->conditionType(), key, folder, tag, m_iovBeginTime, m_iovEndTime) );
    } else {
      ATH_MSG_DEBUG( "use run/lumi" );
      ATH_CHECK( m_regSvc->registerIOV(pobj->conditionType(), key, folder, tag, m_iovBeginRun, m_iovEndRun, m_iovBeginLB, m_iovEndLB) );
    }
 
 
    ATH_MSG_DEBUG( "Registered "<< pobj->conditionType() <<" to condition DB in folder "<< folder <<" with tag " << tag );
 
  } else {
    ATH_MSG_ERROR( "Could not create persistant collection");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 
template <typename T>
StatusCode L1CaloCondSvc::retrieve( T*& pobj, const std::string& key /*= ""*/) {
  /*  ======================================================================
      The object pobj must implement the IL1CaloPersistenceCapable interface
      ====================================================================== */
  ATH_MSG_VERBOSE( "*** L1CaloCondSvc::retrieve() ***" );
  ATH_MSG_VERBOSE( " -> Key: "<< key );
 
  if (m_detStore->contains<T>(key)) {
    ATH_MSG_DEBUG( "Container already existing in DetStore with key:"<< key );
    ATH_CHECK( m_detStore->retrieve(pobj, key) );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG( "Container not found in DetStore. Trying to retrieve it from the condition DB.");
   
  pobj = new T;
  if(!pobj) {
    ATH_MSG_ERROR( "Could not create transient container" );
    return StatusCode::FAILURE;
  }
   
  return this->retrieveImpl(pobj, key);
}
 
template <typename T, typename FolderMapping>
StatusCode L1CaloCondSvc::retrieve(T*& pobj, const FolderMapping& folderKeyMap, const std::string& key /*= ""*/) {
  /*  ======================================================================
      The object pobj must implement the IL1CaloPersistenceCapable interface
      ====================================================================== */
  ATH_MSG_VERBOSE(  "*** L1CaloCondSvc::retrieve() ***" );
  ATH_MSG_VERBOSE(  " -> Key: "<< key );
 
  if (m_detStore->contains<T>(key)) {
    ATH_MSG_DEBUG(  "Container already existing in DetStore with key:"<< key );
    ATH_CHECK( m_detStore->retrieve(pobj, key) );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG(  "Container not found in DetStore. Trying to retrieve it from the condition DB.");
   
  pobj = new T(folderKeyMap);
  if(!pobj) {
    ATH_MSG_ERROR( "Could not create transient container" );
    return StatusCode::FAILURE;
  }
   
  return this->retrieveImpl(pobj, key);
}
 
 
template <typename T>
StatusCode L1CaloCondSvc::retrieveImpl( T*& pobj, const std::string& key) {
  // common parts of the two public retrieve methods. pobj must be a valid object.
  ATH_MSG_VERBOSE(  "*** L1CaloCondSvc::retrieveImpl() ***" );
  ATH_MSG_VERBOSE(  " -> Key: "<< key );
 
  // store objects without key.
  // contains<T>("") somehow returns false as soon as more than one object is stored
  // and none of them has key ""
  //    std::string sgKey;
  //    if(key=="") {
  //       //if no key is provided, the default object's key, which should be the COOL folder path, is taken.
  //       //coolKey = pobj->storeGateKey();
  //       sgKey = pobj->coolOutputKey();
  //    } else {
  //       sgKey = key;
  //    }
   
  //sc = this->registerCondition(coolKey, pobj);
  ATH_CHECK( this->registerCondition(pobj,key) );
   
  //register object to storegate
  ATH_CHECK( m_detStore->record(pobj, key) );
  ATH_MSG_DEBUG(  "Stored Container in DetStore, key: "<< key );
  return StatusCode::SUCCESS;
}
 
template <typename T>
StatusCode L1CaloCondSvc::registerCondition(T*& pObj, const std::string& mykey) {
  ATH_MSG_DEBUG(  "L1CaloCondSvc::registerCondition(T*& pObj))" );
  ATH_MSG_DEBUG(  " -> Specified key: "<< mykey );
  if(!pObj) {
    ATH_MSG_ERROR(  "IL1CaloPersistenceCapable* pObj is NULL in L1CaloCondSvc::registerCondition()" );
    return StatusCode::FAILURE;
  }
 
  std::string conditionType = pObj->conditionType();
 
  if(conditionType=="CondAttrListCollection") {
 
    // we retrieve the keys (ie cool folder paths) needed by the condition object
    std::vector<std::string> vCoolInputKeys = pObj->coolInputKeys();
    
    // Check if we specified some new key
    // Used for L1Calo Overlay where we have both data and MC databases
    
    // Update for PprChanCalib
    if (!mykey.empty() && mykey.find("PprChanCalib")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for PprChanCalib that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    }
    
    // Update for PprChanDefaults
    if (!mykey.empty() && mykey.find("PprChanDefaults")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for PprChanDefaults that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    }    
    
    // Update for DisabledTowers
    if (!mykey.empty() && mykey.find("DisabledTowers")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for DisabledTowers that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    } 
    
    // Update for PpmDeadChannels
    if (!mykey.empty() && mykey.find("PpmDeadChannels")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for PpmDeadChannels that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    }      
 
    //Check if we specified some new key
    
    // Update for PprChanCalib
    if (!mykey.empty() && mykey.find("PprChanCalib")!=std::string::npos){
    ATH_MSG_INFO("Overriding default keys for PprChanCalib that were:");
    for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
    vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    }
    
    // Update for PprChanDefaults
    if (!mykey.empty() && mykey.find("PprChanDefaults")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for PprChanDefaults that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    }    
    
    // Update for DisabledTowers
    if (!mykey.empty() && mykey.find("DisabledTowers")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for DisabledTowers that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    } 
    
    // Update for PpmDeadChannels
    if (!mykey.empty() && mykey.find("PpmDeadChannels")!=std::string::npos){
        ATH_MSG_INFO("Overriding default keys for PpmDeadChannels that were:");
        for (auto it=vCoolInputKeys.begin();it!=vCoolInputKeys.end();++it) {ATH_MSG_INFO(*it);}
        //Now set to specified key only
        vCoolInputKeys.clear(); vCoolInputKeys.push_back(mykey);
    }     
 
    // this list is required to call updateConditions() later on
    std::list<std::string> lKeys;
 
    // loop over the keys to register a callback to L1CaloCondSvc::updateConditions
    for (const std::string& key : vCoolInputKeys) {
      lKeys.push_back(key);
      ATH_MSG_DEBUG("Adding keys to maps: "<<key);
 
      m_mConditions[key].push_back(pObj);
      m_map_conditions2key[pObj].push_back(key);
      
      std::map<std::string, const DataHandle<CondAttrListCollection>* >::const_iterator it_dh = m_mDataHandleAttrListColl.find(key);
      if(it_dh==m_mDataHandleAttrListColl.end()) {
 
        // creat a new datahandle for the CondAttrListCollection and keep track of it
        m_mDataHandleAttrListColl[key] = new DataHandle<CondAttrListCollection>();
        const DataHandle<CondAttrListCollection>& dh = *m_mDataHandleAttrListColl[key];
 
        // set the callback but do not trigger it immediately. updateConditions() is called only once all
        // the CondAttrListCollection the condition is depending on have been registered
        ATH_CHECK( m_detStore->regFcn(&L1CaloCondSvc::updateConditions, this, dh, key, false) );
 
        ATH_MSG_DEBUG("Added "<<key<<" to m_mDataHandleAttrListColl");
      }
    }
 
    // Now we call updateConditions() to populate pObj
    int n = lKeys.size();
    StatusCode scUpdate = this->updateConditions(n, lKeys);
    if (scUpdate.isFailure()) 
      ATH_MSG_WARNING(  "updateConditions failed to populate pObj" );
 
  } else if(conditionType=="AthenaAttributeList"){
    /*
      m_mConditions[key] = pObj;
      m_mDataHandleAttrList[key] = new DataHandle<AthenaAttributeList>();
 
      const DataHandle<AthenaAttributeList>& dh = *m_mDataHandleAttrList[key];
      StatusCode sc = m_detStore->regFcn(&L1CaloCondSvc::updateConditions, this, dh, key, true);
      if(sc.isFailure()) {
      log << MSG::ERROR << "failed to regFcn datahandle to L1CaloCondSvc::updateConditions()" << endmsg;
      return StatusCode::FAILURE;
      }
    */
  } else {
    ATH_MSG_ERROR(  "Condition type " << conditionType << "not recognized by L1CaloCondSvc" );
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
 
}
 
#endif