LArConditionsSubset.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARRAWCONDITIONS_LARCONDITIONSSUBSET_H
#define LARRAWCONDITIONS_LARCONDITIONSSUBSET_H
 
#include <vector>
#include <map>
#include <algorithm>
#include "LArRawConditions/LArConditionsContainerBase.h"
 
template <class T>
class LArConditionsSubsetTraits
{
public:
  typedef unsigned int                                 FebId; 
 
  typedef T&                                           Reference;
  typedef const T&                                     ConstReference;
  typedef T*                                           Pointer;
  typedef const T*                                     ConstPointer;
  typedef typename std::vector<T>                      ChannelVector; 
  typedef const typename std::vector<T>                ConstChannelVector; 
  typedef ChannelVector*                               ChannelVectorPointer;
  typedef typename std::pair<FebId, ChannelVector>     FebPair;
  typedef FebPair&                                     FebPairReference;
  typedef typename std::vector<FebPair>                SubsetVector;
 
  static const T& empty()
  {
    static const T dum {};
    return dum;
  }
 
 
  template <class OTHERIT, class COPIER>
  static void copySubset (OTHERIT otherBeg,
                          OTHERIT otherEnd,
                          SubsetVector& to,
                          COPIER copier);
};
 
 
template <class T>
template <class OTHERIT, class COPIER>
void LArConditionsSubsetTraits<T>::copySubset (OTHERIT otherBeg,
                                               OTHERIT otherEnd,
                                               SubsetVector& to,
                                               COPIER copier)
{
  to.reserve (std::distance (otherBeg, otherEnd));
  for (; otherBeg != otherEnd; ++otherBeg) {
    ChannelVector v (otherBeg->second.size());
    for (size_t i = 0; i < otherBeg->second.size(); i++) {
      copier (otherBeg->second[i], v[i]);
    }
    to.emplace_back (otherBeg->first, std::move (v));
  }
}
 
 
template<class T> 
class LArConditionsSubset
{
public: 
 
    typedef          LArConditionsSubsetTraits<T>        Traits;
    typedef typename Traits::FebId                       FebId;
    typedef typename Traits::ChannelVector               ChannelVector;
    typedef typename Traits::ConstChannelVector          ConstChannelVector;
    typedef typename Traits::FebPair                     FebPair;
    typedef typename Traits::FebPairReference            FebPairReference;
    typedef typename Traits::SubsetVector                SubsetVector;
    typedef typename SubsetVector::const_iterator        ConstSubsetIt;
    typedef typename SubsetVector::iterator              SubsetIt;
    typedef typename Traits::Reference                   Reference;
    typedef typename Traits::ConstReference              ConstReference;
    typedef typename Traits::Pointer                     Pointer;
    typedef typename Traits::ConstPointer                ConstPointer;
 
    typedef T             Payload;
    typedef unsigned int  ChannelId; 
    typedef typename std::pair<ChannelId, T>             CorrectionPair;
    typedef typename std::vector<CorrectionPair>         CorrectionVec;
    typedef typename CorrectionVec::const_iterator       ConstCorrectionVecIt;
    typedef typename CorrectionVec::iterator             CorrectionVecIt;
    typedef typename CorrectionVec::size_type            size_type;
 
    LArConditionsSubset( );
 
    LArConditionsSubset(unsigned int gain);
 
    LArConditionsSubset(const std::vector<FebId>&  ids, unsigned int gain);
 
 
    template <class U, class COPIER>
    void assign (const LArConditionsSubset<U>& other,
                 COPIER copier);
    
 
    virtual ~LArConditionsSubset();
 
 
    ConstSubsetIt           findChannelVector(FebId  febId) const;
 
    SubsetIt                findChannelVector(FebId  febId);
 
    ConstSubsetIt           subsetBegin() const;
    ConstSubsetIt           subsetEnd()  const;
    SubsetIt                subsetBegin();
    SubsetIt                subsetEnd();
 
    size_type               subsetSize() const;
    
 
    ConstCorrectionVecIt    findConditionsObj(ChannelId  id) const;
 
    ConstCorrectionVecIt    correctionVecBegin() const;
    ConstCorrectionVecIt    correctionVecEnd()   const;
 
    size_type               correctionVecSize() const;
    
 
    unsigned int            gain() const; 
 
    unsigned int            channel() const;
 
    unsigned int            groupingType() const;
 
    unsigned int            nConditions() const;
 
    void                    initialize (const std::vector<FebId>&  ids, 
                    unsigned int gain);
 
    void shrink_to_fit();
 
 
    void                    setGain(unsigned int gain); 
 
    void                    setChannel(unsigned int channel);
 
    void                    setGroupingType(unsigned int type);
 
    void                    insertCorrection (ChannelId id, const T& cond);
 
    void                    insertCorrections (CorrectionVec&& corrs);
 
    //Get channelVectorSize()
    unsigned                channelVectorSize() const;
 
    // This is also called from a ROOT read rule after an object is read.
    // (Nominally private, but needs to be public to be callable
    // from a ROOT read rule.)
    void                    fillMap(); 
 
private:
 
    class PairSort 
    {
    public:
    bool operator () (const CorrectionPair& x, const CorrectionPair& y) {
        return (x.first < y.first);
    }
    };
 
    typedef typename std::map<FebId, unsigned int>  SubsetMap;
 
    SubsetMap               m_subsetMap;
    SubsetVector            m_subset;
    unsigned int            m_gain; 
    unsigned int            m_channel;
    unsigned int            m_groupingType;
    CorrectionVec           m_correctionVec;
};
 
 
// INLINE FUNCTIONS
 
template<class T> 
inline 
void
LArConditionsSubset<T>::fillMap()
{
    // Fill map from subset
    m_subsetMap.clear();
 
//     std::cout << "fillMap: subset size, map size "
//        << m_subset.size() << " " << m_subsetMap.size()
//        << std::endl; 
 
    for (unsigned int i = 0; i < m_subset.size(); ++i) {
    m_subsetMap[m_subset[i].first] = i;
    }
 
//     std::cout << "fillMap: subset size, map size "
//        << m_subset.size() << " " << m_subsetMap.size()
//        << std::endl; 
}
 
 
template<class T> 
inline 
LArConditionsSubset<T>::LArConditionsSubset( )
    :
    m_gain(0),
    m_channel(0),
    m_groupingType(0)
{}
 
template<class T> 
inline 
LArConditionsSubset<T>::LArConditionsSubset(unsigned int gain)
    :
    m_gain(gain),
    m_channel(0),
    m_groupingType(0)
{}
 
template<class T>
inline 
LArConditionsSubset<T>::LArConditionsSubset(const std::vector<FebId>&  ids,
                        unsigned int gain)
    :
    m_subset(ids.size()),
    m_gain(gain),
    m_channel(0),
    m_groupingType(0)
 
{
 
//     std::cout << "LArConditionsSubset: ids size, gain "
//        << ids.size() << " " << gain
//        << std::endl; 
 
    // Loop over fed id list, insert id and resize channel vector
    for (unsigned int i = 0; i < ids.size(); ++i) {
    m_subset[i].first = ids[i];
    // NOTE: we move the resize of the channel vector for each feb
    // to the non-const find method below. This allows to keep the
    // overall subset size to a minimum for non-full subsets..
    //m_subset[i].second.resize(channelVectorSize());
    }
    // Fill map for future lookups
    fillMap();
}
 
 
template<class T>
template <class U, class COPIER>
void LArConditionsSubset<T>::assign (const LArConditionsSubset<U>& other,
                                     COPIER copier)
{
  m_subsetMap.clear();
  m_gain = other.gain();
  m_channel = other.channel();
  m_groupingType = other.groupingType();
 
  Traits::copySubset (other.subsetBegin(), other.subsetEnd(), m_subset, copier);
 
  size_t corrsz = other.correctionVecSize();
  auto otherCorr = other.correctionVecBegin();
  m_correctionVec.resize (corrsz);
  for (size_t i = 0; i < corrsz; i++) {
    m_correctionVec[i].first = otherCorr[i].first;
    copier (otherCorr[i].second, m_correctionVec[i].second);
  }
 
  fillMap();
}
 
 
template<class T>
inline 
LArConditionsSubset<T>::~LArConditionsSubset()
{}
 
 
template<class T>
inline 
typename LArConditionsSubset<T>::SubsetIt
LArConditionsSubset<T>::findChannelVector(FebId  febID) 
{
 
//     std::cout << "findChannelVector:  febid, size "
//        << febID << " " << m_subsetMap.size()
//        << std::endl; 
 
 
    typename SubsetMap::const_iterator  it = m_subsetMap.find(febID);
    if (it != m_subsetMap.end()) {
    unsigned int index = (*it).second;
    if (index < m_subset.size()) {
        // check that channel vector has been resized already
        if (m_subset[index].second.size() == 0) {
        m_subset[index].second.resize(channelVectorSize());
        }
        return (m_subset.begin() + index);
    }
    }
    return (m_subset.end());
}
 
 
template<class T>
inline 
typename LArConditionsSubset<T>::ConstSubsetIt
LArConditionsSubset<T>::findChannelVector(FebId  febID) const
{
    typename SubsetMap::const_iterator  it = m_subsetMap.find(febID);
    if (it != m_subsetMap.end()) {
    unsigned int index = (*it).second;
    if (index < m_subset.size()) {
        return (m_subset.begin() + index);
    }
    }
    return (m_subset.end());
}
 
 
template<class T>
inline 
typename LArConditionsSubset<T>::ConstSubsetIt        
LArConditionsSubset<T>::subsetBegin() const
{
    return (m_subset.begin());
}
 
template<class T>
inline 
typename LArConditionsSubset<T>::ConstSubsetIt        
LArConditionsSubset<T>::subsetEnd()  const
{
    return (m_subset.end());
}
 
template<class T>
inline 
typename LArConditionsSubset<T>::SubsetIt             
LArConditionsSubset<T>::subsetBegin() 
{
    return (m_subset.begin());
}
 
template<class T>
inline 
typename LArConditionsSubset<T>::SubsetIt             
LArConditionsSubset<T>::subsetEnd()  
{
    return (m_subset.end());
}
 
template<class T>
inline 
typename LArConditionsSubset<T>::size_type
LArConditionsSubset<T>::subsetSize() const
{
    return (m_subset.size());
}
 
template<class T>
typename LArConditionsSubset<T>::ConstCorrectionVecIt    
LArConditionsSubset<T>::findConditionsObj(ChannelId  id) const
{
    ConstCorrectionVecIt result =  (std::lower_bound(m_correctionVec.begin(), 
                             m_correctionVec.end(), 
                             CorrectionPair(id, T()),
                             PairSort()));
    if ( m_correctionVec.end() != result && id != result->first ) {
    result = m_correctionVec.end();
    }
    return (result);
}
 
template<class T>
typename LArConditionsSubset<T>::ConstCorrectionVecIt
LArConditionsSubset<T>::correctionVecBegin() const
{
    return (m_correctionVec.begin());
}
 
template<class T>
typename LArConditionsSubset<T>::ConstCorrectionVecIt       
LArConditionsSubset<T>::correctionVecEnd()   const
{
    return (m_correctionVec.end());
}
 
 
 
template<class T>
typename LArConditionsSubset<T>::size_type
LArConditionsSubset<T>::correctionVecSize() const
{
    return (m_correctionVec.size());
}
    
    
template<class T>
inline 
unsigned int                  
LArConditionsSubset<T>::gain() const
{
    return (m_gain);
}
 
template<class T>
inline 
unsigned int                  
LArConditionsSubset<T>::channel() const
{
    return (m_channel);
}
 
 
template<class T>
inline 
unsigned int                  
LArConditionsSubset<T>::groupingType() const
{
    return (m_groupingType);
}
 
template<class T>
inline 
unsigned int                  
LArConditionsSubset<T>::nConditions() const
{
    unsigned int tot = 0;
    for (unsigned int i = 0; i < m_subset.size(); ++i) {
    tot += m_subset[i].second.size();
    }
    return (tot);
}
 
 
 
template<class T>
inline 
void                 
LArConditionsSubset<T>::initialize (const std::vector<FebId>&  ids, unsigned int gain)
{
    m_correctionVec.clear();
 
    // resize the subset
    m_subset.resize(ids.size());
    m_gain = gain;
    
    // Loop over fed id list, insert id and resize channel vector
    for (unsigned int i = 0; i < ids.size(); ++i) {
    m_subset[i].first = ids[i];
    m_subset[i].second.resize(channelVectorSize());
    }
 
    // Fill map for future lookups
    fillMap();
}
 
template<class T>
inline 
void                 
LArConditionsSubset<T>::shrink_to_fit()
{
  m_subset.shrink_to_fit();
}
 
 
template<class T>
inline 
void                 
LArConditionsSubset<T>::setGain(unsigned int gain)
{
    m_gain = gain;
}
 
template<class T>
inline 
void                 
LArConditionsSubset<T>::setChannel(unsigned int channel)
{
    m_channel = channel;
}
 
template<class T>
inline 
void                 
LArConditionsSubset<T>::setGroupingType(unsigned int type)
{
    m_groupingType = type;
}
 
template<class T>
inline 
void 
LArConditionsSubset<T>::insertCorrection (ChannelId id, const T& cond)
{
    m_correctionVec.push_back(CorrectionPair(id,cond));
    std::sort(m_correctionVec.begin(), m_correctionVec.end(), PairSort());
}
 
 
template<class T>
inline 
void 
LArConditionsSubset<T>::insertCorrections (CorrectionVec&& corrs)
{
  if (m_correctionVec.empty()) {
    m_correctionVec = std::move (corrs);
  }
  else {
    m_correctionVec.insert (m_correctionVec.end(), corrs.begin(), corrs.end());
    std::sort(m_correctionVec.begin(), m_correctionVec.end(), PairSort());
  }
}
 
 
template<class T>
inline 
unsigned
LArConditionsSubset<T>::channelVectorSize() const
{
 //SuperCells have 320 channels per FEB, the regular readout has 128.
  return m_groupingType == LArConditionsContainerBase::SuperCells ? 320 : 128;
}
 
 
 
#endif // LARRAWCONDITIONS_LARCONDITIONSSUBSET_H