MultChanContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

// $Id: MultChanContainer.h,v 1.8 2009-03-13 10:14:59 dwhittin Exp $
 
#ifndef TRTCONDITIONSDATA_MULTCHANNELCONTAINERDEFAULT_H
#define TRTCONDITIONSDATA_MULTCHANNELCONTAINERDEFAULT_H
 
#include "AthenaPoolUtilities/CondMultChanCollection.h"
#include "TRT_ConditionsData/NestedContainer.h"
#include "AthenaKernel/getMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
#include <cxxabi.h>
#include <algorithm>
#include <stdexcept>
 
namespace TRTCond
{

  template <class DaughterContainer>
  class MultChanContainer : public CondMultChanCollection<DaughterContainer>
  {
  public:
    MultChanContainer() {}

    MultChanContainer(const MultChanContainer& rhs) ;
    MultChanContainer& operator=(const MultChanContainer& rhs) ;
 
    StatusCode initialize();
 
    
    size_t channelId( const ExpandedIdentifier& x ) const ;

    size_t layerwheelindex( size_t channelid ) const ;

    size_t barrelecindex( size_t channelid ) const ;
    
    DaughterContainer* findContainer(const ExpandedIdentifier& id)  ;
    DaughterContainer* findContainer(size_t chanid) ;
    
    const DaughterContainer* getContainer(size_t chanid) const ;
    
    void set( const ExpandedIdentifier& id, const typename DaughterContainer::value_type& t) ;
    
    const typename DaughterContainer::value_type& get( const ExpandedIdentifier& id ) const ;

    const typename DaughterContainer::value_type& get( const ExpandedIdentifier& id , size_t& resolvelevel ) const ;
    
    typedef std::pair< const DaughterContainer*, const typename DaughterContainer::value_type*> ContainerWithValue ;
    ContainerWithValue getWithContainer( const ExpandedIdentifier& id ) const ;
    
    void clear() ;
    
    size_t footprint() const ;
    
    void crunch() ;

    void print() const ;
    
    size_t numObjects() const ;
    
    void getall( typename DaughterContainer::FlatContainer& entries ) const ;
    
   
  private:
    static const size_t m_defaultschannelid = 0 ;
    std::vector<const DaughterContainer*> m_channelmap ;
    const typename DaughterContainer::value_type& dummyVal() const;
  } ;
 
 
 
  // Dummy Value for empty DaughterContainer
  template <class DaughterContainer>
  inline const typename DaughterContainer::value_type&
  MultChanContainer<DaughterContainer>::dummyVal() const
  {
    static typename DaughterContainer::value_type dummyVal;
    return dummyVal;
  }
  
  template <class DaughterContainer>
  MultChanContainer<DaughterContainer>::MultChanContainer(const MultChanContainer<DaughterContainer>& rhs) 
  {
    *this = rhs;
  }
 
template <class DaughterContainer>
  MultChanContainer<DaughterContainer>& 
  MultChanContainer<DaughterContainer>::operator=(const MultChanContainer<DaughterContainer>& rhs) 
  {
    clear() ;
    typename CondMultChanCollection<DaughterContainer>::chan_const_iterator rhschanit = rhs.chan_begin() ;
    typename CondMultChanCollection<DaughterContainer>::const_iterator rhsit = rhs.begin() ; 
    for(  ;  rhsit !=  rhs.end(); ++rhsit, ++ rhschanit) {
      DaughterContainer* lhscontainer = findContainer( *rhschanit ) ;
      *lhscontainer = **rhsit ;
    }
    return *this ;
  }
  
 
  template <class DaughterContainer>
  inline size_t
  MultChanContainer<DaughterContainer>::channelId( const ExpandedIdentifier& x) const
  {
    return x.level() >=ExpandedIdentifier::LAYERWHEEL ?
      1 + x.index(ExpandedIdentifier::BARRELEC) + 4 * x.index(ExpandedIdentifier::LAYERWHEEL) :
      m_defaultschannelid ;
  }
 
 
  template <class DaughterContainer>
  inline size_t
  MultChanContainer<DaughterContainer>::layerwheelindex( size_t channelid ) const 
  {
    return channelid!=m_defaultschannelid ? (channelid-1)/4 : 99 ;
  }
 
 
  template <class DaughterContainer>
  inline size_t
  MultChanContainer<DaughterContainer>::barrelecindex( size_t channelid ) const 
  {
    return channelid!=m_defaultschannelid ? (channelid-1)%4 : 99 ;
  }
 
  
  template <class DaughterContainer>
  inline DaughterContainer* MultChanContainer<DaughterContainer>::findContainer(const ExpandedIdentifier& id)  
  {
    // on the first call, we insert a container for the default. the default is always the first container.
    if(  id.level()==ExpandedIdentifier::BARRELEC ) {
      MsgStream log(Athena::getMessageSvc(),"TRTCond::MultChanContainer");
      log << MSG::WARNING << "Sorry:  cannot store containers at BARREL_EC granularity" << endmsg ;
    }
    return findContainer( channelId( id ) ) ;
  }
 
 
  template <class DaughterContainer>
  inline DaughterContainer* MultChanContainer<DaughterContainer>::findContainer(size_t chanid)
  {
    // on the first call, we insert a container for the default. the default is always the first container.
    if(this->size()==0) {
      this->push_back( new DaughterContainer() ) ;
      this->add(m_defaultschannelid);
    }
    typename CondMultChanCollection<DaughterContainer>::chan_const_iterator chanit = 
      std::find( this->chan_begin(), this->chan_end(), chanid ) ;
    auto chanindex = std::distance(this->chan_begin(),chanit) ;
    if(chanit==this->chan_end()) {
      // add a new container
      this->push_back( new DaughterContainer() ) ;
      this->add(chanid);
      chanindex = this->size()-1 ; //std::distance(chan_begin(),chan_end())-1 ;
      // make sure to clear the cache
      m_channelmap.clear() ;
    }
    if (chanindex < 0 or chanindex >= std::ssize(*this)){
      throw std::out_of_range("MultiChanContainer::findContainer chanindex out of range");
    }
    return this->operator[]( chanindex ) ;
  }
 
 
  template <class DaughterContainer>
  inline const DaughterContainer* MultChanContainer<DaughterContainer>::getContainer(size_t chanid) const
  {
    //in the const-version to get the container we rely on the m_channelmap per-filled by initialize 
    //(to be thread-seafe)
    return chanid < m_channelmap.size() ? m_channelmap[chanid] : nullptr ;
  }
   
  template <class DaughterContainer>
  inline void MultChanContainer<DaughterContainer>::set( const ExpandedIdentifier& id, const typename DaughterContainer::value_type& t ) 
  {
    if( id.level()==ExpandedIdentifier::DETECTOR ) { 
      // set the default value. don't use the id, since it will only confuse the container
      findContainer(id)->set( t ) ; 
    } else if( id.level()==ExpandedIdentifier::BARRELEC ) {
      MsgStream log(Athena::getMessageSvc(),"TRTCond::MultChanContainer");
      log << MSG::WARNING << "Sorry: cannot store containers at BARREL_EC granularity" << endmsg;
    } else {  
      findContainer(id)->set( id, t ) ;
    }
  }
  
  template <class DaughterContainer>
  inline const typename DaughterContainer::value_type& 
  MultChanContainer<DaughterContainer>::get( const ExpandedIdentifier& id ) const 
  {
    if( id.level() >= ExpandedIdentifier::LAYERWHEEL ) {
      const DaughterContainer* container = getContainer( channelId(id) ) ;
      if( container ) {
    const typename DaughterContainer::value_type& rc = container->get( id ) ;
    if( DaughterContainer::trait_type::isvalid(rc) ) return rc ;
      }
    }
    // Throw error if the container is empty.
    if ( this->size() == 0 ) {
      size_t len;
      int s;
      char* tmp = abi::__cxa_demangle(typeid(this).name(),0,&len,&s);
      std::string error = std::string(tmp) + std::string(" is empty!!");
      throw std::runtime_error( error );
    }
    return this->front()->get() ;
    //return operator[]( 0 )->set( t ) ;// m_default ;
  }
 
  template <class DaughterContainer>
  inline const typename DaughterContainer::value_type& 
  MultChanContainer<DaughterContainer>::get( const ExpandedIdentifier& id , size_t& resolvelevel) const 
  {
    if( id.level() >= ExpandedIdentifier::LAYERWHEEL ) {
      const DaughterContainer* container = getContainer( channelId(id) ) ;
      if( container ) {
    const typename DaughterContainer::value_type& rc = container->get( id , resolvelevel) ;
    if( DaughterContainer::trait_type::isvalid(rc) ) return rc ;
      }
    }
    // Throw error if the container is empty.
    if ( this->size() == 0 ) {
      size_t len;
      int s;
      char* tmp = abi::__cxa_demangle(typeid(this).name(),0,&len,&s);
      std::string error = std::string(tmp) + std::string(" is empty!!");
      throw std::runtime_error( error );
      return dummyVal();
    }
      return  this->front()->get(id,resolvelevel) ;
  }

  template <class DaughterContainer>
  inline typename MultChanContainer<DaughterContainer>::ContainerWithValue
  MultChanContainer<DaughterContainer>::getWithContainer( const ExpandedIdentifier& id) const 
  {
    if( id.level() >= ExpandedIdentifier::LAYERWHEEL ) {
      const DaughterContainer* container = getContainer( channelId(id) ) ;
      if( container ) {
    const typename DaughterContainer::value_type& value = container->get( id ) ;
    if( DaughterContainer::trait_type::isvalid(value) ) return ContainerWithValue(container,&value) ;
      }
    }
    // Throw error if the container is empty.
    if ( this->size() == 0 ) {
      size_t len;
      int s;
      char* tmp = abi::__cxa_demangle(typeid(this).name(),0,&len,&s);
      std::string error = std::string(tmp) + std::string(" is empty!!");
      throw std::runtime_error( error );
    }
    return ContainerWithValue(this->front(),&(this->front()->get())) ;
  }
 
 
  template <class DaughterContainer>
  inline void MultChanContainer<DaughterContainer>::clear() 
  {
    for( typename CondMultChanCollection<DaughterContainer>::iterator it = this->begin() ;
     it != this->end(); ++it) (*it)->clear() ;
  }
 
  
  template <class DaughterContainer>
  inline size_t MultChanContainer<DaughterContainer>::footprint() const {
    size_t total=0; //= Trait::footprint(m_default) ;
    for( typename CondMultChanCollection<DaughterContainer>::const_iterator it = this->begin() ; 
     it != this->end(); ++it) total += (*it)->footprint() ;
    return total ;
  }
 
  
  template <class DaughterContainer>
  inline void MultChanContainer<DaughterContainer>::crunch() {
    for( typename CondMultChanCollection<DaughterContainer>::iterator it = this->begin() ; 
     it != this->end(); ++it) (*it)->crunch() ;
  }
 
 
  template <class DaughterContainer>
  size_t MultChanContainer<DaughterContainer>::numObjects() const {
    size_t rc(0) ;
    for( typename CondMultChanCollection<DaughterContainer>::const_iterator it = this->begin() ; 
     it != this->end(); ++it) rc += (*it)->numObjects() ;
    return rc ;
  }
 
  
  template <class DaughterContainer>
  inline void MultChanContainer<DaughterContainer>::getall( typename DaughterContainer::FlatContainer& entries ) const { 
    typename CondMultChanCollection<DaughterContainer>::chan_const_iterator chanit = this->chan_begin() ;
    typename CondMultChanCollection<DaughterContainer>::const_iterator dauit = this->begin() ; 
    for( ; dauit != this->end(); ++dauit, ++chanit) {
      // get the entries in this subcontainer
      typename DaughterContainer::FlatContainer newentries ;
      (*dauit)->getall(newentries) ;
      // update the identifiers
      if( dauit == this->begin() ) {
    // deal with the default value
    for( typename DaughterContainer::FlatContainer::iterator it = newentries.begin() ; it!= newentries.end(); ++it)
      it->first= ExpandedIdentifier(0,0,0,0,0,ExpandedIdentifier::DETECTOR) ;
      } else {
    for( typename DaughterContainer::FlatContainer::iterator it = newentries.begin() ; it!= newentries.end(); ++it) {
      it->first.index(ExpandedIdentifier::BARRELEC) = barrelecindex( *chanit) ;
      it->first.index(ExpandedIdentifier::LAYERWHEEL) = layerwheelindex( *chanit) ;
    }
      }
      entries.insert( entries.end(), newentries.begin(), newentries.end() ) ;
    }
  }
  
 
  template <class DaughterContainer>
  inline void MultChanContainer<DaughterContainer>::print() const {
    typename CondMultChanCollection<DaughterContainer>::chan_const_iterator chanit = this->chan_begin() ;
    typename CondMultChanCollection<DaughterContainer>::const_iterator dauit = this->begin() ; 
    for( ; dauit != this->end(); ++dauit, ++chanit) {
      std::cout << "Now printing channel " << *chanit << " layer/becindex: " << layerwheelindex(*chanit) << " " << barrelecindex(*chanit) << std::endl ;
      (*dauit)->print() ;
    }
  }
  
 
 
  template <class DaughterContainer>
    StatusCode MultChanContainer<DaughterContainer>::initialize() {
 
    // sanity check to test we have added a default value
    if( this->size()>0 && *(this->chan_begin()) != m_defaultschannelid ) {
      MsgStream log(Athena::getMessageSvc(),"TRTCond::MultChanContainer");
      log << MSG::ERROR << " first channel id is not defaults channel id!" << endmsg ;
    }
 
    // first get the max channel id
    auto maxchan=std::max_element(this->chan_begin(),this->chan_end());
    const size_t maxchanid= maxchan==this->chan_end() ? 0 : *maxchan;
    
    // now allocate the map and fill it
    m_channelmap.clear() ;
    m_channelmap.resize( maxchanid + 1, nullptr ) ;
    //typename CondMultChanCollection<DaughterContainer>::const_iterator dauit = this->begin() ; 
    auto dauit = this->begin() ; 
    for( auto chanit = this->chan_begin();chanit != this->chan_end(); ++chanit, ++dauit ) {
      m_channelmap[*chanit] = *dauit ;
    } 
    return StatusCode::SUCCESS;
  }
}
#endif