BeamlineChannelMap_service.cc

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// \file    BeamlineChannelMap_service.cc
/// \brief   Channel mapping service which may be used to interpret the
///          channels which are read out by the various beamline detector
///          elements.
///          NB/ Consider moving to fragments package, which is a
///              dependence for both the online and offline software bases,
///              so online processes (e.g. online monitoring) may use it.
/// \author  Mike Wallbank (University of Cincinnati) <wallbank@fnal.gov>
/// \date    August 2019
////////////////////////////////////////////////////////////////////////////

#include "BeamlineChannelMap.h"

using beamlinegeo::BeamlineSystem;
using beamlinegeo::SystemID;
using beamlinegeo::DetectorID;
using beamlinegeo::ChannelID;
using beamlinegeo::ToFChannel;
using beamlinegeo::ToFCounter;

// -----------------------------------------------------------------------
beamlineutil::BeamlineChannelMap::BeamlineChannelMap(fhicl::ParameterSet const& pset) {
  fhicl::ParameterSet channel_map = pset.get<fhicl::ParameterSet>("ChannelMap");
  this->FillBeamlineChannels(channel_map);
}

// -----------------------------------------------------------------------
beamlineutil::BeamlineChannelMap::BeamlineChannelMap(fhicl::ParameterSet const& pset, art::ActivityRegistry&)
  : BeamlineChannelMap(pset) {
}

// -----------------------------------------------------------------------
void beamlineutil::BeamlineChannelMap::FillBeamlineChannels(const fhicl::ParameterSet& map) {

  // cherenkov
  unsigned int cherenkov_channel
    = map.get<unsigned int>("CherenkovChannel");
  ChannelID cherenkovchan(BeamlineSystem::Cherenkov, 0, 0);
  fDigitOnlineToOffline[cherenkov_channel] = cherenkovchan;
  fDigitOfflineToOnline[cherenkovchan] = cherenkov_channel;

  // tof
  fhicl::ParameterSet tof_channels = map.get<fhicl::ParameterSet>("ToFChannels");
  for (std::map<ToFCounter, std::string>::const_iterator tofCounterIt = beamlinegeo::ToFCounterNames.begin();
       tofCounterIt != beamlinegeo::ToFCounterNames.end(); ++tofCounterIt) {
    DetectorID tofdet(BeamlineSystem::ToF, tofCounterIt->first);
    fhicl::ParameterSet tofdet_channels = tof_channels.get<fhicl::ParameterSet>(tofCounterIt->second);
    for (std::map<ToFChannel, std::string>::const_iterator tofChannelIt = beamlinegeo::ToFChannelNames.begin();
         tofChannelIt != beamlinegeo::ToFChannelNames.end(); ++tofChannelIt) {
      ChannelID tofchan(tofdet, tofChannelIt->first);
      unsigned int online_chan = tofdet_channels.get<unsigned int>(tofChannelIt->second);
      fDigitOnlineToOffline[online_chan] = tofchan;
      fDigitOfflineToOnline[tofchan] = online_chan;
    }
  }

  // muon stack
  std::vector<unsigned int> muonstack_channels
    = map.get<std::vector<unsigned int> >("MuonStackChannels");
  for (unsigned int muonstack_chan = 0; muonstack_chan < muonstack_channels.size(); ++muonstack_chan) {
    ChannelID muonstackchan(BeamlineSystem::MuonStack, 0, muonstack_chan);
    unsigned int online_chan = muonstack_channels[muonstack_chan];
    fDigitOnlineToOffline[online_chan] = muonstackchan;
    fDigitOfflineToOnline[muonstackchan] = online_chan;
  }

  // paddle
  std::vector<unsigned int> paddle_channels
    = map.get<std::vector<unsigned int> >("PaddlesChannels");
  for (unsigned int paddle_chan = 0; paddle_chan < paddle_channels.size(); ++paddle_chan) {
    ChannelID paddlechan(BeamlineSystem::Paddle, 0, paddle_chan);
    unsigned int online_chan = paddle_channels[paddle_chan];
    fDigitOnlineToOffline[online_chan] = paddlechan;
    fDigitOfflineToOnline[paddlechan] = online_chan;
  }

  // wc
  std::vector<unsigned int> wc_channels
    = map.get<std::vector<unsigned int> >("WCChannels");
  for (unsigned int wc_chan = 0; wc_chan < wc_channels.size(); ++wc_chan) {
    ChannelID wcdigitchan(BeamlineSystem::WCDigit, 0, wc_chan);
    unsigned int online_chan = wc_channels[wc_chan];
    fDigitOnlineToOffline[online_chan] = wcdigitchan;
    fDigitOfflineToOnline[wcdigitchan] = online_chan;
  }

  // other
  std::vector<unsigned int> other_channels
    = map.get<std::vector<unsigned int> >("OtherChannels");
  for (unsigned int other_chan = 0; other_chan < other_channels.size(); ++other_chan) {
    ChannelID otherchan(BeamlineSystem::Other, 0, other_chan);
    unsigned int online_chan = other_channels[other_chan];
    fDigitOnlineToOffline[online_chan] = otherchan;
    fDigitOfflineToOnline[otherchan] = online_chan;
  }

  return;

}

// -----------------------------------------------------------------------
bool beamlineutil::BeamlineChannelMap::ActiveDigitChannel(unsigned int channel) const {
  return fDigitOnlineToOffline.count(channel);
}

// -----------------------------------------------------------------------
SystemID beamlineutil::BeamlineChannelMap::DigitSystem(unsigned int channel) const {
  if (!fDigitOnlineToOffline.count(channel))
    throw cet::exception("BeamlineChannelMap")
      << "Requested online digitizer channel number " << channel << " unknown.";
  return fDigitOnlineToOffline.at(channel).GetSystemID();
}

// -----------------------------------------------------------------------
DetectorID beamlineutil::BeamlineChannelMap::DigitDetector(unsigned int channel) const {
  if (!fDigitOnlineToOffline.count(channel))
    throw cet::exception("BeamlineChannelMap")
      << "Requested online digitizer channel number " << channel << " unknown.";
  return fDigitOnlineToOffline.at(channel).GetDetectorID();
}

// -----------------------------------------------------------------------
ChannelID beamlineutil::BeamlineChannelMap::DigitChannel(unsigned int channel) const {
  if (!fDigitOnlineToOffline.count(channel))
    throw cet::exception("BeamlineChannelMap")
      << "Requested online digitizer channel number " << channel << " unknown.";
  return fDigitOnlineToOffline.at(channel);
}

// -----------------------------------------------------------------------
unsigned int beamlineutil::BeamlineChannelMap::OnlineDigitChannel(ChannelID channel) const {
  if (!fDigitOfflineToOnline.count(channel))
    throw cet::exception("BeamlineChannelMap")
      << "Requested offline digitizer channel " << channel << " unknown.";
  return fDigitOfflineToOnline.at(channel);
}

// -----------------------------------------------------------------------
DetectorID beamlineutil::BeamlineChannelMap::WCDetector(unsigned int detector) const {
  return DetectorID(BeamlineSystem::WC, detector);
}

// -----------------------------------------------------------------------
DetectorID beamlineutil::BeamlineChannelMap::TrigDetector() const {
  return DetectorID(BeamlineSystem::Trigger, 0);
}

// -----------------------------------------------------------------------
std::vector<SystemID> beamlineutil::BeamlineChannelMap::SystemIDs() const {
  std::vector<SystemID> systemIDs;
  for (const auto& online : fDigitOnlineToOffline)
    if (std::find(systemIDs.begin(), systemIDs.end(), online.second.GetSystemID()) == systemIDs.end())
      systemIDs.emplace_back(online.second.System);
  return systemIDs;
}

// -----------------------------------------------------------------------
std::vector<DetectorID> beamlineutil::BeamlineChannelMap::DetectorIDs() const {
  std::vector<DetectorID> detectorIDs;
  for (const auto& online : fDigitOnlineToOffline)
    if (std::find(detectorIDs.begin(), detectorIDs.end(), online.second.GetDetectorID()) == detectorIDs.end())
      detectorIDs.emplace_back(online.second.System, online.second.Detector);
  return detectorIDs;
}

// -----------------------------------------------------------------------
std::vector<ChannelID> beamlineutil::BeamlineChannelMap::ChannelIDs() const {
  std::vector<ChannelID> channelIDs;
  for (const auto& online : fDigitOnlineToOffline)
    if (std::find(channelIDs.begin(), channelIDs.end(), online.second) == channelIDs.end())
      channelIDs.push_back(online.second);
  return channelIDs;
}

DEFINE_ART_SERVICE(beamlineutil::BeamlineChannelMap)