LArAccumulatedCalibDigit.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
//Dear emacs, this is -*-c++-*-
/* modifications : */
/*
03-12-06, G.Rosenbaum
Added constructor to take an int for isPulsed to store info re: which caliblines
have been pulsed (HEC can be pulsed by up to 4.
 
Changed getDelay to get the forst 12 bits of m_delayPulsed
Added functions to get the isPusled info
 
 
25-08-09 W. Lampl
Remove accumulation in converter, simplify LArAccumulatedDigit class
Contains now only the data of the currently processed substep.
 
*/
 
 
 
#ifndef LARACCUMULATEDCALIBDIGIT_H
#define LARACCUMULATEDCALIBDIGIT_H
#include <vector>
 
#include "Identifier/HWIdentifier.h"
#include "CaloIdentifier/CaloGain.h"     
 
#include "stdint.h"
 
class LArAccumulatedCalibDigit {
 
private:
 
  HWIdentifier m_hardwareID;
  
  CaloGain::CaloGain m_gain;
 
  std::vector < uint64_t > m_sampleSum;   
  
  std::vector < uint64_t > m_sample2Sum;
 
  //uint32_t m_nsamples;
 
  uint32_t m_nTriggers;
 
  uint32_t m_DAC;
 
  uint16_t m_delayPulsed;
 
  uint16_t m_nStep;
 
  uint16_t m_iStep;
 
public:
 
  LArAccumulatedCalibDigit(HWIdentifier & channel_value, CaloGain::CaloGain gain_value, 
               const std::vector < uint64_t >& sampleSum_value, 
               const std::vector < uint64_t >& sample2Sum_value,
               uint32_t nTrigger_value,  uint32_t DAC_value=0, uint16_t delay_value=0, 
               uint16_t isPulsed_value=false, uint16_t nStep_value=0, uint16_t iStep_value=0) : 
    m_hardwareID(channel_value), m_gain(gain_value), m_sampleSum(sampleSum_value), m_sample2Sum(sample2Sum_value),
    m_nTriggers(nTrigger_value), m_DAC(DAC_value), 
    m_delayPulsed((delay_value & 0xFFF) | (isPulsed_value<<12)),  
    m_nStep(nStep_value), m_iStep(iStep_value) 
    {};
  
  LArAccumulatedCalibDigit(HWIdentifier & channel_value, CaloGain::CaloGain gain_value, 
               uint32_t nsamples=7, uint32_t DAC_value=0, uint16_t delay_value=0, 
               uint16_t isPulsed_value=false, uint16_t nStep_value=0, uint16_t iStep_value=0) : 
    m_hardwareID(channel_value), m_gain(gain_value), 
    m_nTriggers(0), m_DAC(DAC_value),
    m_delayPulsed((delay_value & 0xFFF) | (isPulsed_value<<12)),
    m_nStep(nStep_value), m_iStep(iStep_value) 
  {
    m_sampleSum.resize(nsamples);
    m_sample2Sum.resize(nsamples);
  };
 
  virtual ~LArAccumulatedCalibDigit();
 
  LArAccumulatedCalibDigit() :
    m_hardwareID(0), m_gain(CaloGain::LARNGAIN), m_nTriggers(0), 
    m_DAC(0), m_delayPulsed(0), m_nStep(0), m_iStep(0) 
    {};
 
  const HWIdentifier & hardwareID() const {return m_hardwareID; }
 
  const HWIdentifier & channelID() const { return m_hardwareID; } 
 
  CaloGain::CaloGain gain() const { return m_gain; }
 
  size_t nsamples() const { return m_sampleSum.size(); }
 
  const std::vector < uint64_t > & sampleSum() const { return m_sampleSum; }
 
  const std::vector < uint64_t > & sample2Sum() const { return m_sample2Sum; }
 
  unsigned nTriggers() const {return m_nTriggers;}
 
  //unsigned nSamples() const {return m_nsamples;}
 
  int DAC() const {return static_cast<int>(m_DAC);}
 
  int delay() const {return static_cast<int>(m_delayPulsed & 0xFFF);}
  
  bool isPulsed() const {return static_cast<bool>(m_delayPulsed & 0xF000);}
 
  bool isPulsed(int n) const {
    if(n==1) return static_cast<bool>(m_delayPulsed & 0x1000);
    if(n==2) return static_cast<bool>(m_delayPulsed & 0x2000);
    if(n==3) return static_cast<bool>(m_delayPulsed & 0x4000);
    if(n==4) return static_cast<bool>(m_delayPulsed & 0x8000);
    return false;//WRITE ERROR MESSAGE
  }
 
  uint16_t getIsPulsedInt() const { return (m_delayPulsed >> 12);}
 
  std::vector<float> mean() const;
 
  std::vector<float> RMS() const;
 
 
  float mean(const size_t i) const;
 
  float RMS(const size_t i) const;
 
  uint16_t nSteps() const { return m_nStep;}
 
  uint16_t stepIndex() const {return m_iStep;}
 
  void setSampleSum(const std::vector< uint64_t >& sampleSum);
 
  void setSample2Sum(const std::vector< uint64_t >& sample2Sum);
 
  bool setAddDigit(const std::vector<short>& samples);
 
  bool setAddSubStep(const std::vector < uint64_t >& sampleSum, const std::vector < uint64_t >& sample2Sum, const uint32_t nTriggerPerStep);
 
};
 
#endif //LARDIGIT_H