LArCompactSubset.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#ifndef LARRAWCONDITIONS_LARCOMPACTSUBSET_H
#define LARRAWCONDITIONS_LARCOMPACTSUBSET_H
 
#include "LArElecCalib/ILArShape.h"
#include "LArElecCalib/ILArOFC.h"
#include <cstddef>
 
 
class LArCompactSubsetVector;
class LAr2DWaveBase;
 
 
//==========================================================================
 
 
class LArCompactSubsetConstChannelProxy
{
public:
  LArCompactSubsetConstChannelProxy();
 
 
  LArCompactSubsetConstChannelProxy (unsigned int chan,
                                     const LArCompactSubsetVector& subset);
 
 
  bool isValid() const;
 
 
  float timeOffset() const;
 
 
  float timeBinWidth() const;
 
 
  size_t getSize () const;
 
 
  LArVectorProxy getData (unsigned int which, size_t tbin) const;
 
 
  //=== LArShapeP2 interface.  The two wave types are shape and derivative.
 
  size_t shapeSize() const;
  size_t shapeDerSize() const;
  ILArShape::ShapeRef_t shape (size_t tbin) const;
  ILArShape::ShapeRef_t shapeDer (size_t tbin) const;
 
  //=== LArOFCP1 interface.  The two wave types are OFC A and B coeffiecients.
 
  size_t OFC_aSize() const;
  size_t OFC_bSize() const;
  ILArOFC::OFCRef_t OFC_a (size_t tbin) const;
  ILArOFC::OFCRef_t OFC_b (size_t tbin) const;
 
 
protected:
  unsigned int m_chan;
 
  const LArCompactSubsetVector* m_subset;
};
 
 
class LArCompactSubsetChannelProxy
  : public LArCompactSubsetConstChannelProxy
{
public:
  LArCompactSubsetChannelProxy();
 
 
  LArCompactSubsetChannelProxy (unsigned int chan,
                                LArCompactSubsetVector& subset);
 
 
  LArCompactSubsetChannelProxy& operator= (const LAr2DWaveBase& other);
 
 
  void assign (const LAr2DWaveBase& other);
 
 
private:
  LArCompactSubsetVector* m_subset_nc;
};
 
 
//==========================================================================
 
 
class LArCompactSubsetChannelPointer
  : public LArCompactSubsetChannelProxy
{
public:
  LArCompactSubsetChannelPointer (const LArCompactSubsetChannelProxy* p);
 
 
  LArCompactSubsetChannelProxy operator*() const;
 
 
  operator bool() const;
};
 
 
//==========================================================================
 
 
class LArCompactSubsetChannelVector
{
public:
  class const_iterator
  {
  public:
    const_iterator();
 
 
    const_iterator (unsigned int chan, const LArCompactSubsetVector& subset);
 
 
    LArCompactSubsetConstChannelProxy operator*() const;
 
 
    bool operator== (const const_iterator& other) const;
 
 
    bool operator!= (const const_iterator& other) const;
 
 
    const_iterator& operator++();
 
 
    const_iterator operator- (size_t delta) const;
 
 
    long operator- (const const_iterator& other) const;
 
 
  private:
    unsigned int m_chan;
 
    const LArCompactSubsetVector* m_subset;
  };
 
 
  typedef const_iterator iterator;
 
 
  LArCompactSubsetChannelVector (size_t febIndex,
                                 LArCompactSubsetVector* subset);
 
 
  size_t size() const;
 
 
  LArCompactSubsetChannelProxy operator[] (size_t i);
 
 
  LArCompactSubsetConstChannelProxy operator[] (size_t i) const;
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  void resize (size_t sz);
 
 
protected:
  size_t m_febIndex;
 
  LArCompactSubsetVector* m_subset;
};
 
 
class LArCompactSubsetConstChannelVector
{
public:
  LArCompactSubsetConstChannelVector (size_t febIndex,
                                      const LArCompactSubsetVector* subset);
 
 
  size_t size() const;
 
 
  LArCompactSubsetConstChannelProxy operator[] (size_t i) const;
 
 
protected:
  size_t m_febIndex;
 
  const LArCompactSubsetVector* m_subset;
};
 
 
//==========================================================================
 
 
class LArCompactSubsetChannelVectorPointer
  : public LArCompactSubsetChannelVector
{
public:
  LArCompactSubsetChannelVectorPointer();
 
 
  LArCompactSubsetChannelVectorPointer(const LArCompactSubsetChannelVector* p);
 
 
  LArCompactSubsetChannelVector operator*();
 
 
  LArCompactSubsetConstChannelVector operator*() const;
 
 
  const LArCompactSubsetChannelVector* operator->() const;
};
 
 
//==========================================================================
 
 
class LArCompactSubsetFebPair
{
public:
  typedef unsigned int FebId;
 
 
  LArCompactSubsetFebPair (size_t febIndex,
                           LArCompactSubsetVector& subset);
 
 
  FebId& first;
  LArCompactSubsetChannelVector second;
};
 
 
class LArCompactSubsetConstFebPair
{
public:
  typedef unsigned int FebId;
 
 
  LArCompactSubsetConstFebPair (size_t febIndex,
                                const LArCompactSubsetVector& subset);
 
 
  const FebId& first;
  LArCompactSubsetConstChannelVector second;
};
 
 
//==========================================================================
 
 
class LArCompactSubsetVector
{
public:
  static const unsigned int nWaves = 2;
 
  typedef unsigned int FebId;
 
 
  class iterator
  {
  public:
    typedef long difference_type;
 
 
    iterator (size_t febIndex,
              LArCompactSubsetVector& subset);
 
 
    LArCompactSubsetFebPair operator*();
 
 
    bool operator== (const iterator& other) const;
 
 
    bool operator!= (const iterator& other) const;
 
 
    iterator& operator++();
 
 
    iterator operator+ (size_t delta);
 
 
    difference_type operator- (const iterator& other);
 
 
  private:
    size_t m_febIndex;
 
    LArCompactSubsetVector& m_subset;
  };
 
 
  class const_iterator
  {
  public:
    typedef long difference_type;
 
 
    const_iterator (size_t febIndex,
                    const LArCompactSubsetVector& subset);
 
 
    LArCompactSubsetConstFebPair operator*();
 
 
    bool operator== (const const_iterator& other) const;
 
 
    bool operator!= (const const_iterator& other) const;
 
 
    const_iterator& operator++();
 
 
    const_iterator operator+ (size_t delta) const;
 
 
    difference_type operator- (const const_iterator& other) const;
 
 
  private:
    size_t m_febIndex;
 
    const LArCompactSubsetVector& m_subset;
  };
 
 
  LArCompactSubsetVector (size_t nfeb = 0);
 
 
 
  size_t size() const;
 
 
  LArCompactSubsetFebPair operator[] (size_t i);
 
 
  const LArCompactSubsetConstFebPair operator[] (size_t i) const;
 
 
  iterator begin();
 
 
  iterator end();
 
 
  const_iterator begin() const;
 
 
  const_iterator end() const;
 
 
  void resize (size_t sz);
 
 
  //======
  // Functions used by P->T conversion.
 
  void shrink_to_fit();
 
 
  //======
  // Functions used by LArCompactSubsetFebPair
 
  FebId& febIdRef (size_t febIndex);
 
 
  const FebId& febIdRef (size_t febIndex) const;
 
 
  //======
  // Functions used by LArCompactSubsetChannelVector
 
  size_t febSize (unsigned int febIndex) const;
 
 
  unsigned int chanIndex (unsigned int febIndex) const;
 
 
  void resizeChanVec (size_t febIndex, size_t sz);
 
 
  //======
  // Functions used by LArCompactSubsetChannelProxy.
 
 
  size_t getChanSize() const;
 
 
  size_t getSize (unsigned int chan) const;
 
 
  float timeOffset (unsigned int chan) const;
 
 
  float timeBinWidth (unsigned int chan) const;
 
 
  LArVectorProxy getData (unsigned int which, unsigned int chan, size_t tbin)
    const;
 
 
  void setTimings (unsigned int chan, float timeOffset, float timeBinWidth);
 
 
  void setData (unsigned int which,
                unsigned int chan,
                size_t tbin,
                size_t chanSize,
                const LArVectorProxy& from);
 
 
  template <class T, class OTHERIT, class COPIER>
  static void copySubset (OTHERIT otherBeg,
                          OTHERIT otherEnd,
                          LArCompactSubsetVector& to,
                          COPIER copier);
 
 
private:
  unsigned int m_chanSize;
 
  unsigned int m_nSamples;
 
  float m_timeOffset;
  float m_timeBinWidth;
 
  // The length of this gives the length of the subset `vector'.
  // Indexed by febIndex.
  std::vector<FebId> m_febids;
 
  // Channel index of the start of data for the corresponding FebId.
  // An extra entry at the end gives the total channel count.
  std::vector<unsigned int> m_indices;
 
  // Indexed by channel and time bin numbers, chan*m_chanSize + tbin.
  // Gives the slot corresponding to this channel/time bin, or -1 if
  // it's empty.
  std::vector<int> m_slots;
 
  // This is divided into slots, each containing nWaves * m_nSamples words.
  // (All wave types for one time bin for one channel.)
  std::vector<float> m_data;
};
 
 
#include "LArRawConditions/LArCompactSubset.icc"
 
 
#endif // not LARRAWCONDITIONS_LARCOMPACTSUBSET_H