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