TOPASICChannel.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <TObject.h>
#include <top/dbobjects/TOPASICPedestals.h>
#include <top/dbobjects/TOPASICGains.h>
#include <vector>
 
namespace Belle2 {
  class TOPASICChannel: public TObject {
  public:
 
    TOPASICChannel()
    {
    }
 
    TOPASICChannel(int moduleID, unsigned channel, int numWindows):
      m_moduleID(moduleID), m_channel(channel)
    {
      for (int i = 0; i < numWindows; i++) m_pedestals.push_back(NULL);
    }
 
    TOPASICChannel(const TOPASICChannel& chan): TObject()
    {
      *this = chan;
    }
 
    TOPASICChannel& operator=(const TOPASICChannel& chan)
    {
      if (this != &chan) {
        m_moduleID = chan.getModuleID();
        m_channel = chan.getChannel();
        for (auto& pedestals : m_pedestals) {
          if (pedestals) delete pedestals;
        }
        m_pedestals = chan.getPedestals();
        for (auto& pedestals : m_pedestals) {
          if (pedestals) pedestals = new TOPASICPedestals(*pedestals);
        }
        for (auto& gains : m_gains) {
          if (gains) delete gains;
        }
        m_gains = chan.getGains();
        for (auto& gains : m_gains) {
          if (gains) gains = new TOPASICGains(*gains);
        }
      }
      return *this;
    }
 
    ~TOPASICChannel()
    {
      for (auto& window : m_pedestals) {
        if (window) delete window;
      }
      for (auto& window : m_gains) {
        if (window) delete window;
      }
    }
 
    bool setPedestals(const TOPASICPedestals& pedestals)
    {
      unsigned i = pedestals.getASICWindow();
      if (i < m_pedestals.size()) {
        if (m_pedestals[i]) {
          *m_pedestals[i] = pedestals;
        } else {
          m_pedestals[i] = new TOPASICPedestals(pedestals);
        }
        return true;
      }
      return false;
    }
 
    bool setGains(const TOPASICGains& gains)
    {
      if (m_gains.empty()) {
        for (unsigned i = 0; i < m_pedestals.size(); i++) m_gains.push_back(NULL);
      }
      unsigned i = gains.getASICWindow();
      if (i < m_gains.size()) {
        if (m_gains[i]) {
          *m_gains[i] = gains;
        } else {
          m_gains[i] = new TOPASICGains(gains);
        }
        return true;
      }
      return false;
    }
 
    int getModuleID() const {return m_moduleID;}
 
    unsigned getChannel() const {return m_channel;}
 
    unsigned getNumofWindows() const
    {
      return m_pedestals.size();
    }
 
    const TOPASICPedestals* getPedestals(unsigned window) const
    {
      if (window < m_pedestals.size()) return m_pedestals[window];
      return NULL;
    }
 
    const std::vector<TOPASICPedestals*>& getPedestals() const {return m_pedestals;}
 
    const TOPASICGains* getGains(unsigned window) const
    {
      if (window < m_gains.size()) return m_gains[window];
      if (window < m_pedestals.size()) return &m_defaultGain;
      return NULL;
    }
 
    const std::vector<TOPASICGains*>& getGains() const {return m_gains;}
 
    unsigned getNumofGoodWindows() const
    {
      unsigned n = 0;
      for (auto& pedestal : m_pedestals) if (pedestal) n++;
      return n;
    }
 
 
  private:
 
    int m_moduleID = 0;                         
    unsigned m_channel = 0;                     
    std::vector<TOPASICPedestals*> m_pedestals; 
    std::vector<TOPASICGains*> m_gains;         
    TOPASICGains m_defaultGain;                 
    ClassDef(TOPASICChannel, 4); 
  };
 
} // end namespace Belle2