CaloPDChannelInfo.h

Go to the documentation of this file.

/*
 * CaloPDChannelInfo.h
 *
 *  Created on: 06 Aug. 2020
 *      Author: Lorenzo Pacini
 */
 
#ifndef HERD_CALOPDCHANNELINFO_H_
#define HERD_CALOPDCHANNELINFO_H_
 
#include "herd/analysis/common/AxesArray.h"
#include "herd/analysis/dataobjects/Point.h"
 
#include <vector>
 
#ifdef HS_USE_ROOT
#include "Rtypes.h"
#endif
 
namespace Herd {
 
struct CaloPDChannelInfo {
 
  CaloPDChannelInfo() { SetNChannels(0); };
 
  CaloPDChannelInfo(unsigned int nChannels) { SetNChannels(nChannels); };
 
  virtual ~CaloPDChannelInfo() = default;
 
  void SetNChannels(size_t nChannels) {
    _MIPvalues.resize(nChannels);
    _SiLpdMIPvalues.resize(nChannels);
    _SiSpdMIPvalues.resize(nChannels);
    _SiLpdMIPvar.resize(nChannels);
    _SiSpdMIPvar.resize(nChannels);
    _HGnoises.resize(nChannels);
    _LGnoises.resize(nChannels);
    _gainRatios.resize(nChannels);
    _maxHGADCvalues.resize(nChannels);
    _maxLGADCvalues.resize(nChannels);
    _pedestals.resize(nChannels);
  };
 
  [[nodiscard]] float MIPvalue(unsigned int volID) const { return _MIPvalues[volID]; };
 
  [[nodiscard]] float SiLpdMIPvalue(unsigned int volID) const { return _SiLpdMIPvalues[volID]; };
 
  [[nodiscard]] float SiSpdMIPvalue(unsigned int volID) const { return _SiSpdMIPvalues[volID]; };
 
  [[nodiscard]] float SiLpdMipVar(unsigned int volID) const { return _SiLpdMIPvar[volID]; };
 
  [[nodiscard]] float SiSpdMipVar(unsigned int volID) const { return _SiSpdMIPvar[volID]; };
 
  [[nodiscard]] const std::vector<float> &MIPvalues() const { return _MIPvalues; };
 
  [[nodiscard]] const std::vector<float> &SiLpdMIPvalues() const { return _SiLpdMIPvalues; };
 
  [[nodiscard]] const std::vector<float> &SiSpdMIPvalues() const { return _SiSpdMIPvalues; };
 
  [[nodiscard]] const std::vector<float> &SiLpdMopVar() const { return _SiLpdMIPvar; };
 
  [[nodiscard]] const std::vector<float> &SiSpdMipVar() const { return _SiSpdMIPvar; };
 
  [[nodiscard]] float HighGainNoise(unsigned int volID) const { return _HGnoises[volID]; };
 
  [[nodiscard]] const std::vector<float> &HighGainNoises() const { return _HGnoises; };
 
  [[nodiscard]] float LowGainNoise(unsigned int volID) const { return _LGnoises[volID]; };
 
  [[nodiscard]] const std::vector<float> &LowGainNoises() const { return _LGnoises; };
 
  [[nodiscard]] float GainRatio(unsigned int volID) const { return _gainRatios[volID]; };
 
  [[nodiscard]] const std::vector<float> &GainRatios() const { return _gainRatios; };
 
  [[nodiscard]] float MaximumHighGainSignal(unsigned int volID) const { return _maxHGADCvalues[volID]; };
 
  [[nodiscard]] const std::vector<float> &MaximumHighGainSignals() const { return _maxHGADCvalues; };
 
  [[nodiscard]] float MaximumLowGainSignal(unsigned int volID) const { return _maxLGADCvalues[volID]; };
 
  [[nodiscard]] const std::vector<float> &MaximumLowGainSignals() const { return _maxLGADCvalues; };
 
  [[nodiscard]] float Pedestal(unsigned int volID) const { return _pedestals[volID]; };
 
  [[nodiscard]] const std::vector<float> &Pedestals() const { return _pedestals; };
 
  [[nodiscard]] unsigned int NChannels() const { return _MIPvalues.size(); };
 
  void SetMIPvalue(unsigned int volID, float MIPvalue) { _MIPvalues.at(volID) = MIPvalue; };
 
  void SetSiLpdMipValue(unsigned int volID, float MIPvalue) { _SiLpdMIPvalues.at(volID) = MIPvalue; };
 
  void SetSiSpdMipValue(unsigned int volID, float MIPvalue) { _SiSpdMIPvalues.at(volID) = MIPvalue; };
 
  void SetSiLPDMIPvar(unsigned int volID, float MIPvar) { _SiLpdMIPvar.at(volID) = MIPvar; };
 
  void SetSiSPDMIPvar(unsigned int volID, float MIPvar) { _SiSpdMIPvar.at(volID) = MIPvar; };
 
  void SetHighGainNoise(unsigned int volID, float HGnoise) { _HGnoises.at(volID) = HGnoise; };
 
  void SetLowGainNoise(unsigned int volID, float LGnoise) { _LGnoises.at(volID) = LGnoise; };
 
  void SetGainRatio(unsigned int volID, float gainRatio) { _gainRatios.at(volID) = gainRatio; };
 
  void SetMaximumHighGainSignal(unsigned int volID, float maxHGADCvalues) {
    _maxHGADCvalues.at(volID) = maxHGADCvalues;
  };
 
  void SetMaximumLowGainSignal(unsigned int volID, float maxLGADCvalues) {
    _maxLGADCvalues.at(volID) = maxLGADCvalues;
  };
 
  void SetPedestal(unsigned int volID, float pedestal) { _pedestals.at(volID) = pedestal; };
 
private:
  std::vector<float> _MIPvalues;      
  std::vector<float> _HGnoises;       
  std::vector<float> _LGnoises;       
  std::vector<float> _gainRatios;     
  std::vector<float> _maxHGADCvalues; 
  std::vector<float> _maxLGADCvalues; 
  std::vector<float> _pedestals;      
  std::vector<float> _SiLpdMIPvalues; 
  std::vector<float> _SiSpdMIPvalues; 
  std::vector<float> _SiLpdMIPvar;    
  std::vector<float> _SiSpdMIPvar;    
 
#ifdef HS_USE_ROOT
  ClassDef(CaloPDChannelInfo, 2)
#endif
};
 
} // namespace Herd
 
#endif /* HERD_CALOPDCHANNELINFO_H_ */