LArConditionsContainer.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef LARRAWCONDITIONS_LARCONDITIONSCONTAINER_H
#define LARRAWCONDITIONS_LARCONDITIONSCONTAINER_H
 
// LAr classes
#include "LArRawConditions/LArConditionsSubset.h"
#include "LArRawConditions/LArConditionsContainerBase.h"
#include "AthenaPoolUtilities/CondMultChanCollection.h"
#include "LArRawConditions/LArConditionsContainerDB.h"
#include "Identifier/HWIdentifier.h"
#include "Identifier/IdentifierHash.h"
 
 
template<class T> 
class LArConditionsContainer : 
    public LArConditionsContainerBase,
    public CondMultChanCollection<LArConditionsSubset<T> >
{
 
public: 
 
    typedef T                                                    LArCondObj;
    typedef unsigned int                                         FebId; 
    typedef LArConditionsSubset<T>                               Subset; 
    typedef typename LArConditionsSubset<T>::Traits              Traits;
    typedef typename Subset::ChannelVector                       ChannelVector; 
    typedef typename Subset::FebPairReference                    FebPairReference;
    typedef typename ChannelVector::const_iterator               ChannelVectorIterator; 
    typedef typename Subset::size_type                           size_type; 
    typedef typename Subset::ConstCorrectionVecIt                ConstCorrectionIt;
    typedef typename Subset::Reference                           Reference;
    typedef typename Subset::ConstReference                      ConstReference;
    typedef typename Subset::Pointer                             Pointer;
    typedef typename Subset::ConstPointer                        ConstPointer;
    
    typedef LArConditionsContainerDB<T>                          ConditionsMap;
    typedef typename ConditionsMap::const_iterator               ConstConditionsMapIterator; 
    typedef typename ConditionsMap::iterator                     ConditionsMapIterator; 
    typedef typename std::map<unsigned int,  ConditionsMap >     GainMap;
    typedef typename std::pair<unsigned int, ConditionsMap >     GainPair;
    typedef typename GainMap::const_iterator                     ConstGainMapIterator; 
    typedef typename GainMap::iterator                           GainMapIterator; 

    typedef CondMultChanCollection<Subset>                       MultChanCollection;
    typedef typename MultChanCollection::chan_const_iterator     chan_const_iterator;
    typedef typename MultChanCollection::iov_const_iterator      iov_const_iterator;
    typedef typename MultChanCollection::chan_size_type          chan_size_type;
    typedef typename MultChanCollection::iov_size_type           iov_size_type;
 

    LArConditionsContainer();

    LArConditionsContainer(GroupingType type);

    virtual ~LArConditionsContainer();
 

    void                setPdata(const HWIdentifier id, 
                 const T& payload, 
                 unsigned int gain=0 );

    ConstReference      get     (const HWIdentifier id, 
                 unsigned int gain=0) const; 

    Reference           get     (const HWIdentifier id, 
                 unsigned int gain=0); 

    unsigned int        coolChannel (const HWIdentifier id,
                     unsigned int gain=0) const; 
 
 

    unsigned int        groupingType() const;

    std::string         groupingTypeToString() const;
 

    unsigned int        groupNumber(unsigned int coolChannel) const;

    unsigned int        nGroups() const;

    unsigned int        minGain() const;
    
    unsigned int        nGains() const;

    chan_const_iterator chan_begin() const;
    chan_const_iterator chan_end  () const;

    chan_size_type      chan_size() const;
    
    iov_const_iterator  iov_begin() const;
    iov_const_iterator  iov_end  () const;
    
    iov_size_type       iov_size() const;

    unsigned int        conditionsPerChannel(unsigned int coolChannel) const;

    unsigned int        conditionsPerGroup(unsigned int group) const;

    unsigned int        conditionsPerGain(unsigned int gain) const;

    unsigned int        totalNumberOfConditions() const;

    unsigned int        totalNumberOfCorrections() const;

    bool                correctionsApplied() const;

    StatusCode          applyCorrections();
    
    StatusCode          undoCorrections();
    

  /*  
 
  The following methods are commented out because they don't work any more and/or don't
  make sense any more since we have now the option to store corrections in the same subsets
  as the regular data. (And not used anywhere anyway).
 

    ConstCorrectionIt   findCorrection   (HWIdentifier channelId,
                      unsigned int gain) const;
    ConstCorrectionIt   findCorrectionEnd() const;

    void                correctionIndexes(unsigned int gain,
                                          std::vector<unsigned int>& indexes) const;

    ConstCorrectionIt   correctionsBegin(unsigned int index) const;
    ConstCorrectionIt   correctionsEnd  (unsigned int index) const;

    size_type           correctionsSize(unsigned int gain) const;
 

    void                removeCorrections();
  */
 

    StatusCode          insertCorrection (HWIdentifier id, 
                      const T& cond, 
                      unsigned int gain,
                      bool corrChannel = true);
 

    ConstCorrectionIt   undoCorrBegin(unsigned int gain) const;
    ConstCorrectionIt   undoCorrEnd(unsigned int gain) const;

    ConstConditionsMapIterator  begin(unsigned int gain) const ; 
    ConditionsMapIterator       begin(unsigned int gain); 

    ConstConditionsMapIterator  begin(unsigned int gain,
                      const std::vector<FebId>& febIds) const ; 
    ConditionsMapIterator       begin(unsigned int gain,
                                      const std::vector<FebId>& febIds); 

    ConstConditionsMapIterator  begin(unsigned int gain,
                      const HWIdentifier& febId) const ; 
    ConditionsMapIterator       begin(unsigned int gain,
                      const HWIdentifier& febId) ; 

    ConstConditionsMapIterator  end  (unsigned int gain) const ; 
    ConditionsMapIterator       end  (unsigned int gain); 

    void                removeConditions();

    void                removeConditionsChannel(unsigned int coolChannel);
 

    //Returns the COOL channel numbers that have been added
    std::vector<unsigned> completeCorrectionChannels();
 

    virtual StatusCode  initialize();
 
    //Merge in data from another conditions container of the same type
    bool merge(const LArConditionsContainer<T>& other);
    
 
protected:

    ConstReference        empty() const;

    GainMap               m_cached; 
 
 
private:
    ConstCorrectionIt m_dummyCorrIt;

    StatusCode            updateConditionsMap(FebId id, 
                          unsigned int gain, 
                          ConditionsMap& conditionsMap);
    void                  sortSubsets();
 
 
    class SubsetSort 
    {
    public:
    bool operator () (const LArConditionsSubset<T>* x, const LArConditionsSubset<T>* y) 
        {
        return (x->channel() < y->channel());
        }
    };
    
// Hide some types from Reflex so they do not get generated in the
// dictionary
#ifndef __REFLEX__
    typedef typename std::vector<ConstPointer>              TVector; 
    typedef typename TVector::const_iterator                TVectorIterator; 
    typedef typename std::map<unsigned int, TVector>        TVectorMap ; 
    typedef typename TVectorMap::const_iterator             TVectorMapIterator      ; 
    typedef typename Subset::CorrectionPair                 CorrectionPair;
    typedef typename Subset::CorrectionVec                  CorrectionVector;
    typedef typename Subset::ConstCorrectionVecIt           ConstCorrectionVecIt;
    typedef typename std::vector<CorrectionVector>          CorrectionVectors;
    typedef DataVector<Subset>                              SubsetDV;
    typedef typename SubsetDV::const_iterator               const_iterator;
    typedef typename SubsetDV::iterator                     iterator;
    
 
    /*mutable*/ CorrectionVectors    m_correctionsUndo;
  /*mutable*/ bool                 m_correctionsApplied;
    CorrectionVector             m_emptyCorrectionVec;
#endif 
};
 
 
#ifndef __REFLEX__
#include "LArConditionsContainer.icc"
#endif 
 
#endif