SimPhotonCounterAlg.cxx

Go to the documentation of this file.

#include "SimPhotonCounterAlg.h"
#include "OpDetResponseInterface.h"
#include "OpDigiProperties.h"

#include "fhiclcpp/ParameterSet.h"

opdet::SimPhotonCounterAlg::SimPhotonCounterAlg(fhicl::ParameterSet const& p)
{
  FillAllRanges(p.get<std::vector<fhicl::ParameterSet>>("SimPhotonCounterParams"));
}

void opdet::SimPhotonCounterAlg::FillAllRanges(std::vector<fhicl::ParameterSet> const& pv)
{
  fTimeRanges.clear();
  fWavelengthRanges.clear();

  fTimeRanges.reserve(pv.size());
  fWavelengthRanges.reserve(pv.size());

  for (auto const& p : pv)
    FillRanges(p);
}

void opdet::SimPhotonCounterAlg::FillRanges(fhicl::ParameterSet const& p)
{
  std::vector<float> time_range(4);
  time_range[0] = p.get<float>("MinPromptTime");
  time_range[1] = p.get<float>("MaxPromptTime");
  time_range[2] = p.get<float>("MinLateTime");
  time_range[3] = p.get<float>("MaxLateTime");

  if (time_range[0] > time_range[1] || time_range[2] > time_range[3] ||
      time_range[1] > time_range[2])
    throw std::runtime_error("ERROR in SimPhotonCounterAlg: Bad time range.");

  fTimeRanges.push_back(time_range);

  std::vector<float> wavelength_range(2);
  wavelength_range[0] = p.get<float>("MinWavelength");
  wavelength_range[1] = p.get<float>("MaxWavelength");

  if (wavelength_range[0] >= wavelength_range[1])
    throw std::runtime_error("ERROR in SimPhotonCounterAlg: Bad wavelength range.");

  fWavelengthRanges.push_back(wavelength_range);
}

void opdet::SimPhotonCounterAlg::InitializeCounters(geo::GeometryCore const& geo,
                                                    opdet::OpDigiProperties const& opdigip)
{
  fCounters.resize(fTimeRanges.size());
  art::ServiceHandle<opdet::OpDetResponseInterface const> odresponse;
  for (size_t i = 0; i < fCounters.size(); i++)
    fCounters[i] = SimPhotonCounter(fTimeRanges[i][0],
                                    fTimeRanges[i][1],
                                    fTimeRanges[i][2],
                                    fTimeRanges[i][3],
                                    fWavelengthRanges[i][0],
                                    fWavelengthRanges[i][1],
                                    std::vector<float>(odresponse->NOpChannels(), opdigip.QE()));
}

void opdet::SimPhotonCounterAlg::AddSimPhotonCollection(sim::SimPhotonsCollection const& ph_col)
{
  if (ph_col.size() != fCounters.at(0).GetVectorSize())
    throw std::runtime_error(
      "ERROR in SimPhotonCounterAlg: Photon collection size and OpDet size not equal.");

  for (auto const& photons : ph_col)
    for (auto& counter : fCounters)
      counter.AddSimPhotons(photons.second);
}

void opdet::SimPhotonCounterAlg::AddSimPhotonsVector(std::vector<sim::SimPhotons> const& spv)
{
  for (auto const& photons : spv)
    for (auto& counter : fCounters)
      counter.AddSimPhotons(photons);
}

void opdet::SimPhotonCounterAlg::ClearCounters()
{
  for (auto& counter : fCounters)
    counter.ClearVectors();
}

std::vector<float> const& opdet::SimPhotonCounterAlg::PromptPhotonVector(size_t i)
{
  return fCounters.at(i).PromptPhotonVector();
}

std::vector<float> const& opdet::SimPhotonCounterAlg::LatePhotonVector(size_t i)
{
  return fCounters.at(i).LatePhotonVector();
}

opdet::SimPhotonCounter const& opdet::SimPhotonCounterAlg::GetSimPhotonCounter(size_t i)
{
  return fCounters.at(i);
}