ModuleRecData.cc

Go to the documentation of this file.

#include "ModuleRecData.h"

#include <list>


namespace mevt {

  utl::TraceUI&
  ModuleRecData::GetChannelsOn()
  {
    return *fChannelsOn;
  }

  utl::TraceUI&
  ModuleRecData::GetChannelsInhibited()
  {
    return *fChannelsInhibited;
  }

  utl::TraceD&
  ModuleRecData::GetMeanMuonsVsTime()
  {
    return *fMeanMuonsVsTime;
  }

  utl::TraceD&
  ModuleRecData::GetNumberOfMuonsVsTime()
  {
    return *fNumberOfMuonsVsTime;
  }

  const utl::TraceUI&
  ModuleRecData::GetChannelsOn()
    const
  {
    return *fChannelsOn;
  }

  const utl::TraceUI&
  ModuleRecData::GetChannelsInhibited()
    const
  {
    return *fChannelsInhibited;
  }

  const utl::TraceD&
  ModuleRecData::GetMeanMuonsVsTime()
    const
  {
    return *fMeanMuonsVsTime;
  }

  const utl::TraceD&
  ModuleRecData::GetNumberOfMuonsVsTime()
    const
  {
    return *fNumberOfMuonsVsTime;
  }

  void
  ModuleRecData::MakeChannelsOn()
  {
    if (fChannelsOn)
      ERROR("ChannelsOn already present.");
    else
      fChannelsOn = new utl::TraceUI();
  }


  bool
  ModuleRecData::HasChannelsOn()
    const
  {
    return bool(fChannelsOn);
  }

  void
  ModuleRecData::MakeChannelsInhibited()
  {
    if (fChannelsInhibited)
      ERROR("ChannelsInhibited already present.");
    else
      fChannelsInhibited = new utl::TraceUI();
  }


  bool
  ModuleRecData::HasChannelsInhibited()
    const
  {
    return bool(fChannelsInhibited);
  }

  void
  ModuleRecData::MakeMeanMuonsVsTime()
  {
    if (fMeanMuonsVsTime)
      ERROR("MeanMuonsVsTime already present.");
    else
      fMeanMuonsVsTime = new utl::TraceD();
  }

  bool
  ModuleRecData::HasMeanMuonsVsTime()
    const
  {
    return bool(fMeanMuonsVsTime);
  }

  void
  ModuleRecData::MakeNumberOfMuonsVsTime()
  {
    if (fNumberOfMuonsVsTime)
      ERROR("NumberOfMuonsVsTime already present.");
    else
      fNumberOfMuonsVsTime = new utl::TraceD();
  }

  bool
  ModuleRecData::HasNumberOfMuonsVsTime()
    const
  {
    return bool(fNumberOfMuonsVsTime);
  }

  unsigned int
  ModuleRecData::GetNumberOfChannelsOn()
    const
  {
    unsigned int nChannelsOn = 0;
    for (auto bin = fChannelsOn->Begin(), endBin = fChannelsOn->End();
         bin != endBin; ++bin)
      nChannelsOn += *bin;

    return nChannelsOn;
  }
  
  unsigned int
  ModuleRecData::GetNumberOfChannelsInhibited()
    const
  {
    unsigned int nChannelsInhibited = 0;
    for (auto bin = fChannelsInhibited->Begin(), endBin = fChannelsInhibited->End();
         bin != endBin; ++bin)
      nChannelsInhibited += *bin;

    return nChannelsInhibited;
  }


  unsigned int
  ModuleRecData::GetMaxChannelsOn()
    const
  {
    unsigned int nMaxChannelsOn = 0;
    for (auto bin = fChannelsOn->Begin(), endBin = fChannelsOn->End();
         bin != endBin; ++bin)
      nMaxChannelsOn = std::max(nMaxChannelsOn, *bin);

    return nMaxChannelsOn;
  }

}