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