img::DataProviderAlg Class Reference

#include "DataProviderAlg.h"

Inheritance diagram for img::DataProviderAlg:

Classes
struct	Config

Public Types
enum	EDownscaleMode { kMax = 1, kMaxMean = 2, kMean = 3 }

Public Member Functions
	DataProviderAlg (const fhicl::ParameterSet &pset)
	DataProviderAlg (const Config &config)
virtual	~DataProviderAlg ()
bool	setWireDriftData (const detinfo::DetectorClocksData &clock_data, const detinfo::DetectorPropertiesData &det_prop, const std::vector< recob::Wire > &wires, unsigned int plane, unsigned int tpc, unsigned int cryo)
std::vector< float > const &	wireData (size_t widx) const
std::vector< std::vector< float > >	getPatch (size_t wire, float drift, size_t patchSizeW, size_t patchSizeD) const
float	getPixelOrZero (int wire, int drift) const
double	getAdcSum () const
size_t	getAdcArea () const
float	poolMax (int wire, int drift, size_t r=0) const
	Pool max value in a patch around the wire/drift pixel. More...
unsigned int	Cryo () const
	Pool sum of pixels in a patch around the wire/drift pixel. More...
unsigned int	TPC () const
unsigned int	Plane () const
unsigned int	NWires () const
unsigned int	NScaledDrifts () const
unsigned int	NCachedDrifts () const
unsigned int	DriftWindow () const
float	ZeroLevel () const
	Level of zero ADC after scaling. More...
double	LifetimeCorrection (detinfo::DetectorClocksData const &clock_data, detinfo::DetectorPropertiesData const &det_prop, double tick) const

Protected Member Functions
std::vector< float >	downscaleMax (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
std::vector< float >	downscaleMaxMean (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
std::vector< float >	downscaleMean (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
std::vector< float >	downscale (std::size_t dst_size, std::vector< float > const &adc, size_t tick0) const
size_t	getDriftIndex (float drift) const
std::optional< std::vector< float > >	setWireData (std::vector< float > const &adc, size_t wireIdx) const
bool	patchFromDownsampledView (size_t wire, float drift, size_t size_w, size_t size_d, std::vector< std::vector< float >> &patch) const
bool	patchFromOriginalView (size_t wire, float drift, size_t size_w, size_t size_d, std::vector< std::vector< float >> &patch) const
virtual DataProviderAlgView	resizeView (detinfo::DetectorClocksData const &clock_data, detinfo::DetectorPropertiesData const &det_prop, size_t wires, size_t drifts)

Protected Attributes
DataProviderAlgView	fAlgView
EDownscaleMode	fDownscaleMode
size_t	fDriftWindow
bool	fDownscaleFullView
float	fDriftWindowInv
calo::CalorimetryAlg	fCalorimetryAlg
geo::GeometryCore const *	fGeometry

Private Member Functions
float	scaleAdcSample (float val) const
void	scaleAdcSamples (std::vector< float > &values) const
void	applyBlur ()
void	addWhiteNoise ()
void	addCoherentNoise ()

Private Attributes
std::vector< float >	fAmplCalibConst
bool	fCalibrateAmpl
bool	fCalibrateLifetime
unsigned int	fCryo = 9999
unsigned int	fTPC = 9999
unsigned int	fPlane = 9999
float	fAdcMax
float	fAdcMin
float	fAdcScale
float	fAdcOffset
float	fAdcZero
double	fAdcSumOverThr
double	fAdcSumThr
size_t	fAdcAreaOverThr
CLHEP::HepJamesRandom	fRndEngine
std::vector< float >	fBlurKernel
float	fNoiseSigma
float	fCoherentSigma

Detailed Description

Base class providing data for training / running image based classifiers. It can be used also for any other algorithms where 2D projection image is useful. Currently the image is 32-bit fp / pixel, as sson as have time will template it so e.g. byte pixels would be possible.

Definition at line 62 of file DataProviderAlg.h.

Member Enumeration Documentation

enum img::DataProviderAlg::EDownscaleMode

Enumerator
kMax
kMaxMean
kMean

Definition at line 64 of file DataProviderAlg.h.

{ kMax = 1, kMaxMean = 2, kMean = 3 };

Constructor & Destructor Documentation

img::DataProviderAlg::DataProviderAlg ( const fhicl::ParameterSet &  pset )

inline

Definition at line 101 of file DataProviderAlg.h.

    : DataProviderAlg(fhicl::Table<Config>(pset, {})())
  {}

img::DataProviderAlg::DataProviderAlg

(

const Config &

config

)

Definition at line 32 of file DataProviderAlg.cxx.

References calo::CalorimetryAlg::ElectronsFromADCPeak(), fAdcAreaOverThr, fAdcMax, fAdcMin, fAdcOffset, fAdcScale, fAdcSumOverThr, fAdcSumThr, fAdcZero, fAmplCalibConst, fBlurKernel, fCalibrateAmpl, fCalibrateLifetime, fCalorimetryAlg, fCoherentSigma, fDownscaleFullView, fDownscaleMode, fDriftWindow, fDriftWindowInv, fGeometry, fNoiseSigma, art::ServiceHandle< T, SCOPE >::get(), kMax, kMaxMean, kMean, geo::GeometryCore::MaxPlanes(), and ~DataProviderAlg().

  : fAlgView{}
  , fDownscaleMode(img::DataProviderAlg::kMax)
  , fDriftWindow(10)
  , fCalorimetryAlg(config.CalorimetryAlg())
  , fGeometry(art::ServiceHandle<geo::Geometry const>().get())
  , fAdcSumOverThr(0)
  , fAdcSumThr(10)
  , // set fixed threshold of 10 ADC counts for counting the sum
  fAdcAreaOverThr(0)
  , fNoiseSigma(0)
  , fCoherentSigma(0)
{
  fCalibrateLifetime = config.CalibrateLifetime();
  fCalibrateAmpl = config.CalibrateAmpl();

  fAmplCalibConst.resize(fGeometry->MaxPlanes());
  if (fCalibrateAmpl) {
    mf::LogInfo("DataProviderAlg") << "Using calibration constants:";
    for (size_t p = 0; p < fAmplCalibConst.size(); ++p) {
      try {
        fAmplCalibConst[p] = 1.2e-3 * fCalorimetryAlg.ElectronsFromADCPeak(1.0, p);
        mf::LogInfo("DataProviderAlg") << "   plane:" << p << " const:" << 1.0 / fAmplCalibConst[p];
      }
      catch (...) {
        fAmplCalibConst[p] = 1.0;
      }
    }
  }
  else {
    mf::LogInfo("DataProviderAlg") << "No plane-to-plane calibration.";
    for (size_t p = 0; p < fAmplCalibConst.size(); ++p) {
      fAmplCalibConst[p] = 1.0;
    }
  }

  fDriftWindow = config.DriftWindow();
  fDownscaleFullView = config.DownscaleFullView();
  fDriftWindowInv = 1.0 / fDriftWindow;

  std::string mode_str = config.DownscaleFn();
  mf::LogVerbatim("DataProviderAlg") << "Downscale mode is: " << mode_str;
  if (mode_str == "maxpool") {
    //fnDownscale = [this](std::vector<float> & dst, std::vector<float> const & adc, size_t tick0) { downscaleMax(dst, adc, tick0); };
    fDownscaleMode = img::DataProviderAlg::kMax;
  }
  else if (mode_str == "maxmean") {
    //fnDownscale = [this](std::vector<float> & dst, std::vector<float> const & adc, size_t tick0) { downscaleMaxMean(dst, adc, tick0); };
    fDownscaleMode = img::DataProviderAlg::kMaxMean;
  }
  else if (mode_str == "mean") {
    //fnDownscale = [this](std::vector<float> & dst, std::vector<float> const & adc, size_t tick0) { downscaleMean(dst, adc, tick0); };
    fDownscaleMode = img::DataProviderAlg::kMean;
  }
  else {
    mf::LogError("DataProviderAlg") << "Downscale mode string not recognized, set to max pooling.";
    //fnDownscale = [this](std::vector<float> & dst, std::vector<float> const & adc, size_t tick0) { downscaleMax(dst, adc, tick0); };
    fDownscaleMode = img::DataProviderAlg::kMax;
  }

  fAdcMax = config.AdcMax();
  fAdcMin = config.AdcMin();
  fAdcOffset = config.OutMin();
  fAdcScale = (config.OutMax() - fAdcOffset) / (fAdcMax - fAdcMin);
  fAdcZero = fAdcOffset + fAdcScale * (0 - fAdcMin); // level of zero ADC after scaling

  if (fAdcMax <= fAdcMin) {
    throw cet::exception("img::DataProviderAlg") << "Misconfigured: AdcMax <= AdcMin" << std::endl;
  }
  if (fAdcScale == 0) {
    throw cet::exception("img::DataProviderAlg") << "Misconfigured: OutMax == OutMin" << std::endl;
  }

  fBlurKernel = config.BlurKernel();
  fNoiseSigma = config.NoiseSigma();
  fCoherentSigma = config.CoherentSigma();
}

img::DataProviderAlg::~DataProviderAlg ( )

virtualdefault

Referenced by DataProviderAlg().

Member Function Documentation

void img::DataProviderAlg::addCoherentNoise ( )

private

Definition at line 535 of file DataProviderAlg.cxx.

References d, fAlgView, fCoherentSigma, fDownscaleFullView, fDriftWindow, img::DataProviderAlgView::fNCachedDrifts, fRndEngine, img::DataProviderAlgView::fWireDriftData, noise(), scaleAdcSample(), and w.

Referenced by setWireDriftData().

{
  if (fCoherentSigma == 0) return;

  double effectiveSigma = scaleAdcSample(fCoherentSigma);
  if (fDownscaleFullView) effectiveSigma /= fDriftWindow;

  CLHEP::RandGauss gauss(fRndEngine);
  std::vector<double> amps1(fAlgView.fWireDriftData.size());
  std::vector<double> amps2(1 + (fAlgView.fWireDriftData.size() / 32));
  gauss.fireArray(amps1.size(), amps1.data(), 1., 0.1); // 10% wire-wire ampl. variation
  gauss.fireArray(amps2.size(), amps2.data(), 1., 0.1); // 10% group-group ampl. variation

  double group_amp = 1.0;
  std::vector<double> noise(fAlgView.fNCachedDrifts);
  for (size_t w = 0; w < fAlgView.fWireDriftData.size(); ++w) {
    if ((w & 31) == 0) {
      group_amp = amps2[w >> 5]; // div by 32
      gauss.fireArray(fAlgView.fNCachedDrifts, noise.data(), 0., effectiveSigma);
    } // every 32 wires

    auto& wire = fAlgView.fWireDriftData[w];
    for (size_t d = 0; d < wire.size(); ++d) {
      wire[d] += group_amp * amps1[w] * noise[d];
    }
  }
}

void img::DataProviderAlg::addWhiteNoise ( )

private

Definition at line 517 of file DataProviderAlg.cxx.

References d, fAlgView, fDownscaleFullView, fDriftWindow, img::DataProviderAlgView::fNCachedDrifts, fNoiseSigma, fRndEngine, img::DataProviderAlgView::fWireDriftData, noise(), and scaleAdcSample().

Referenced by setWireDriftData().

{
  if (fNoiseSigma == 0) return;

  double effectiveSigma = scaleAdcSample(fNoiseSigma);
  if (fDownscaleFullView) effectiveSigma /= fDriftWindow;

  CLHEP::RandGauss gauss(fRndEngine);
  std::vector<double> noise(fAlgView.fNCachedDrifts);
  for (auto& wire : fAlgView.fWireDriftData) {
    gauss.fireArray(fAlgView.fNCachedDrifts, noise.data(), 0., effectiveSigma);
    for (size_t d = 0; d < wire.size(); ++d) {
      wire[d] += noise[d];
    }
  }
}

void img::DataProviderAlg::applyBlur ( )

private

Definition at line 414 of file DataProviderAlg.cxx.

References d, fAlgView, fBlurKernel, img::DataProviderAlgView::fWireDriftData, sum, and w.

Referenced by setWireDriftData().

{
  if (fBlurKernel.size() < 2) return;

  size_t margin_left = (fBlurKernel.size() - 1) >> 1,
         margin_right = fBlurKernel.size() - margin_left - 1;

  std::vector<std::vector<float>> src(fAlgView.fWireDriftData.size());
  for (size_t w = 0; w < fAlgView.fWireDriftData.size(); ++w) {
    src[w] = fAlgView.fWireDriftData[w];
  }

  for (size_t w = margin_left; w < fAlgView.fWireDriftData.size() - margin_right; ++w) {
    for (size_t d = 0; d < fAlgView.fWireDriftData[w].size(); ++d) {
      float sum = 0;
      for (size_t i = 0; i < fBlurKernel.size(); ++i) {
        sum += fBlurKernel[i] * src[w + i - margin_left][d];
      }
      fAlgView.fWireDriftData[w][d] = sum;
    }
  }
}

unsigned int img::DataProviderAlg::Cryo ( ) const

inline

Pool sum of pixels in a patch around the wire/drift pixel.

Definition at line 161 of file DataProviderAlg.h.

Referenced by nnet::TrainingDataAlg::collectVtxFlags().

{ return fCryo; }

std::vector<float> img::DataProviderAlg::downscale ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

inlineprotected

Definition at line 198 of file DataProviderAlg.h.

References kMax, kMaxMean, and kMean.

Referenced by patchFromOriginalView(), and setWireData().

  {
    switch (fDownscaleMode) {
    case img::DataProviderAlg::kMean: return downscaleMean(dst_size, adc, tick0);
    case img::DataProviderAlg::kMaxMean: return downscaleMaxMean(dst_size, adc, tick0);
    case img::DataProviderAlg::kMax: return downscaleMax(dst_size, adc, tick0);
    }
    throw cet::exception("img::DataProviderAlg") << "Downscale mode not supported." << std::endl;
  }

std::vector< float > img::DataProviderAlg::downscaleMax ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

protected

Definition at line 196 of file DataProviderAlg.cxx.

References fAlgView, fDriftWindow, img::DataProviderAlgView::fLifetimeCorrFactors, and scaleAdcSamples().

{
  size_t kStop = dst_size;
  std::vector<float> result(dst_size);
  if (adc.size() < kStop) { kStop = adc.size(); }
  for (size_t i = 0, k0 = 0; i < kStop; ++i, k0 += fDriftWindow) {
    size_t k1 = k0 + fDriftWindow;

    float max_adc = adc[k0] * fAlgView.fLifetimeCorrFactors[k0 + tick0];
    for (size_t k = k0 + 1; k < k1; ++k) {
      float ak = adc[k] * fAlgView.fLifetimeCorrFactors[k + tick0];
      if (ak > max_adc) max_adc = ak;
    }
    result[i] = max_adc;
  }
  scaleAdcSamples(result);
  return result;
}

std::vector< float > img::DataProviderAlg::downscaleMaxMean ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

protected

Definition at line 217 of file DataProviderAlg.cxx.

References fAlgView, fDriftWindow, img::DataProviderAlgView::fLifetimeCorrFactors, n, and scaleAdcSamples().

{
  size_t kStop = dst_size;
  std::vector<float> result(dst_size);
  if (adc.size() < kStop) { kStop = adc.size(); }
  for (size_t i = 0, k0 = 0; i < kStop; ++i, k0 += fDriftWindow) {
    size_t k1 = k0 + fDriftWindow;
    size_t max_idx = k0;
    float max_adc = adc[k0] * fAlgView.fLifetimeCorrFactors[k0 + tick0];
    for (size_t k = k0 + 1; k < k1; ++k) {
      float ak = adc[k] * fAlgView.fLifetimeCorrFactors[k + tick0];
      if (ak > max_adc) {
        max_adc = ak;
        max_idx = k;
      }
    }

    size_t n = 1;
    if (max_idx > 0) {
      max_adc += adc[max_idx - 1] * fAlgView.fLifetimeCorrFactors[max_idx - 1 + tick0];
      n++;
    }
    if (max_idx + 1 < adc.size()) {
      max_adc += adc[max_idx + 1] * fAlgView.fLifetimeCorrFactors[max_idx + 1 + tick0];
      n++;
    }

    result[i] = max_adc / n;
  }
  scaleAdcSamples(result);
  return result;
}

std::vector< float > img::DataProviderAlg::downscaleMean ( std::size_t  dst_size, std::vector< float > const &  adc, size_t  tick0  ) const

protected

Definition at line 252 of file DataProviderAlg.cxx.

References fAlgView, fDriftWindow, fDriftWindowInv, img::DataProviderAlgView::fLifetimeCorrFactors, and scaleAdcSamples().

{
  size_t kStop = dst_size;
  std::vector<float> result(dst_size);
  if (adc.size() < kStop) { kStop = adc.size(); }
  for (size_t i = 0, k0 = 0; i < kStop; ++i, k0 += fDriftWindow) {
    size_t k1 = k0 + fDriftWindow;

    float sum_adc = 0;
    for (size_t k = k0; k < k1; ++k) {
      if (k + tick0 < fAlgView.fLifetimeCorrFactors.size())
        sum_adc += adc[k] * fAlgView.fLifetimeCorrFactors[k + tick0];
    }
    result[i] = sum_adc * fDriftWindowInv;
  }
  scaleAdcSamples(result);
  return result;
}

unsigned int img::DataProviderAlg::DriftWindow ( ) const

inline

Definition at line 168 of file DataProviderAlg.h.

{ return fDriftWindow; }

size_t img::DataProviderAlg::getAdcArea ( ) const

inline

Definition at line 153 of file DataProviderAlg.h.

References r.

{ return fAdcAreaOverThr; }

double img::DataProviderAlg::getAdcSum ( ) const

inline

Definition at line 152 of file DataProviderAlg.h.

{ return fAdcSumOverThr; }

size_t img::DataProviderAlg::getDriftIndex ( float  drift ) const

inlineprotected

Definition at line 210 of file DataProviderAlg.h.

References lar::dump::vector().

Referenced by poolMax().

  {
    if (fDownscaleFullView)
      return (size_t)(drift * fDriftWindowInv);
    else
      return (size_t)drift;
  }

std::vector<std::vector<float> > img::DataProviderAlg::getPatch ( size_t  wire, float  drift, size_t  patchSizeW, size_t  patchSizeD  ) const

inline

Return patch of data centered on the wire and drift, witht the size in (downscaled) pixels givent with patchSizeW and patchSizeD. Pad with the zero-level calue if patch extends beyond the event projection.

Definition at line 122 of file DataProviderAlg.h.

  {
    bool ok = false;
    std::vector<std::vector<float>> patch;
    if (fDownscaleFullView) {
      ok = patchFromDownsampledView(wire, drift, patchSizeW, patchSizeD, patch);
    }
    else {
      ok = patchFromOriginalView(wire, drift, patchSizeW, patchSizeD, patch);
    }

    if (ok) return patch;
    throw cet::exception("img::DataProviderAlg") << "Patch filling failed." << std::endl;
  }

float img::DataProviderAlg::getPixelOrZero ( int  wire, int  drift  ) const

inline

Return value from the ADC buffer, or zero if coordinates are out of the view; will scale the drift according to the downscale settings.

Definition at line 142 of file DataProviderAlg.h.

  {
    size_t didx = getDriftIndex(drift), widx = (size_t)wire;

    if ((widx < fAlgView.fWireDriftData.size()) && (didx < fAlgView.fNCachedDrifts)) {
      return fAlgView.fWireDriftData[widx][didx];
    }
    return 0;
  }

double img::DataProviderAlg::LifetimeCorrection ( detinfo::DetectorClocksData const &  clock_data, detinfo::DetectorPropertiesData const &  det_prop, double  tick  ) const

inline

Definition at line 173 of file DataProviderAlg.h.

  {
    return fCalorimetryAlg.LifetimeCorrection(clock_data, det_prop, tick);
  }

unsigned int img::DataProviderAlg::NCachedDrifts ( ) const

inline

Definition at line 167 of file DataProviderAlg.h.

{ return fAlgView.fNCachedDrifts; }

unsigned int img::DataProviderAlg::NScaledDrifts ( ) const

inline

Definition at line 166 of file DataProviderAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fAlgView.fNScaledDrifts; }

unsigned int img::DataProviderAlg::NWires ( ) const

inline

Definition at line 165 of file DataProviderAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fAlgView.fNWires; }

bool img::DataProviderAlg::patchFromDownsampledView ( size_t  wire, float  drift, size_t  size_w, size_t  size_d, std::vector< std::vector< float >> &  patch  ) const

protected

Definition at line 439 of file DataProviderAlg.cxx.

References d, fAdcZero, fAlgView, fDriftWindow, trkf::fill(), img::DataProviderAlgView::fWireDriftData, and w.

{
  int halfSizeW = size_w / 2;
  int halfSizeD = size_d / 2;

  int w0 = wire - halfSizeW;
  int w1 = wire + halfSizeW;

  size_t sd = (size_t)(drift / fDriftWindow);
  int d0 = sd - halfSizeD;
  int d1 = sd + halfSizeD;

  int wsize = fAlgView.fWireDriftData.size();
  for (int w = w0, wpatch = 0; w < w1; ++w, ++wpatch) {
    auto& dst = patch[wpatch];
    if ((w >= 0) && (w < wsize)) {
      auto& src = fAlgView.fWireDriftData[w];
      int dsize = src.size();
      for (int d = d0, dpatch = 0; d < d1; ++d, ++dpatch) {
        if ((d >= 0) && (d < dsize)) { dst[dpatch] = src[d]; }
        else {
          dst[dpatch] = fAdcZero;
        }
      }
    }
    else {
      std::fill(dst.begin(), dst.end(), fAdcZero);
    }
  }

  return true;
}

bool img::DataProviderAlg::patchFromOriginalView ( size_t  wire, float  drift, size_t  size_w, size_t  size_d, std::vector< std::vector< float >> &  patch  ) const

protected

Definition at line 476 of file DataProviderAlg.cxx.

References d, downscale(), fAdcZero, fAlgView, fDriftWindow, trkf::fill(), img::DataProviderAlgView::fWireDriftData, util::size(), tmp, and w.

{
  int dsize = fDriftWindow * size_d;
  int halfSizeW = size_w / 2;
  int halfSizeD = dsize / 2;

  int w0 = wire - halfSizeW;
  int w1 = wire + halfSizeW;

  int d0 = int(drift) - halfSizeD;
  int d1 = int(drift) + halfSizeD;

  if (d0 < 0) d0 = 0;

  std::vector<float> tmp(dsize);
  int wsize = fAlgView.fWireDriftData.size();
  for (int w = w0, wpatch = 0; w < w1; ++w, ++wpatch) {
    if ((w >= 0) && (w < wsize)) {
      auto& src = fAlgView.fWireDriftData[w];
      int src_size = src.size();
      for (int d = d0, dpatch = 0; d < d1; ++d, ++dpatch) {
        if ((d >= 0) && (d < src_size)) { tmp[dpatch] = src[d]; }
        else {
          tmp[dpatch] = fAdcZero;
        }
      }
    }
    else {
      std::fill(tmp.begin(), tmp.end(), fAdcZero);
    }
    patch[wpatch] = downscale(patch[wpatch].size(), tmp, d0);
  }

  return true;
}

unsigned int img::DataProviderAlg::Plane ( ) const

inline

Definition at line 163 of file DataProviderAlg.h.

Referenced by setWireDriftData(), pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

{ return fPlane; }

float img::DataProviderAlg::poolMax	(	int	wire,
		int	drift,
		size_t	r = 0
	)		const

Pool max value in a patch around the wire/drift pixel.

Definition at line 145 of file DataProviderAlg.cxx.

References col, d, fAlgView, fDownscaleFullView, fDriftWindow, img::DataProviderAlgView::fNCachedDrifts, img::DataProviderAlgView::fNWires, img::DataProviderAlgView::fWireDriftData, getDriftIndex(), r, and w.

Referenced by pma::ProjectionMatchingAlg::validate_on_adc(), and pma::ProjectionMatchingAlg::validate_on_adc_test().

{
  size_t rw = r, rd = r;
  if (!fDownscaleFullView) { rd *= fDriftWindow; }

  size_t didx = getDriftIndex(drift);
  int d0 = didx - rd;
  if (d0 < 0) { d0 = 0; }
  int d1 = didx + rd;
  if (d1 >= (int)fAlgView.fNCachedDrifts) { d1 = fAlgView.fNCachedDrifts - 1; }

  int w0 = wire - rw;
  if (w0 < 0) { w0 = 0; }
  int w1 = wire + rw;
  if (w1 >= (int)fAlgView.fNWires) { w1 = fAlgView.fNWires - 1; }

  float adc, max_adc = 0;
  for (int w = w0; w <= w1; ++w) {
    auto const* col = fAlgView.fWireDriftData[w].data();
    for (int d = d0; d <= d1; ++d) {
      adc = col[d];
      if (adc > max_adc) { max_adc = adc; }
    }
  }

  return max_adc;
}

img::DataProviderAlgView img::DataProviderAlg::resizeView ( detinfo::DetectorClocksData const &  clock_data, detinfo::DetectorPropertiesData const &  det_prop, size_t  wires, size_t  drifts  )

protectedvirtual

Reimplemented in nnet::TrainingDataAlg.

Definition at line 114 of file DataProviderAlg.cxx.

References fAdcZero, fCalibrateLifetime, fCalorimetryAlg, fDownscaleFullView, fDriftWindow, img::DataProviderAlgView::fLifetimeCorrFactors, img::DataProviderAlgView::fNCachedDrifts, img::DataProviderAlgView::fNDrifts, img::DataProviderAlgView::fNScaledDrifts, img::DataProviderAlgView::fNWires, img::DataProviderAlgView::fWireChannels, img::DataProviderAlgView::fWireDriftData, raw::InvalidChannelID, and calo::CalorimetryAlg::LifetimeCorrection().

Referenced by nnet::TrainingDataAlg::resizeView(), and setWireDriftData().

{
  img::DataProviderAlgView result;
  result.fNWires = wires;
  result.fNDrifts = drifts;
  result.fNScaledDrifts = drifts / fDriftWindow;
  result.fNCachedDrifts = fDownscaleFullView ? result.fNScaledDrifts : drifts;

  result.fWireChannels.resize(wires, raw::InvalidChannelID);

  result.fWireDriftData.resize(wires, std::vector<float>(result.fNCachedDrifts, fAdcZero));

  result.fLifetimeCorrFactors.resize(drifts);
  if (fCalibrateLifetime) {
    for (size_t t = 0; t < drifts; ++t) {
      result.fLifetimeCorrFactors[t] = fCalorimetryAlg.LifetimeCorrection(clock_data, det_prop, t);
    }
  }
  else {
    for (size_t t = 0; t < drifts; ++t) {
      result.fLifetimeCorrFactors[t] = 1.0;
    }
  }
  return result;
}

float img::DataProviderAlg::scaleAdcSample ( float  val ) const

private

Definition at line 361 of file DataProviderAlg.cxx.

References fAdcMax, fAdcMin, fAdcOffset, fAdcScale, fAmplCalibConst, and fPlane.

Referenced by addCoherentNoise(), addWhiteNoise(), and scaleAdcSamples().

{
  val *= fAmplCalibConst[fPlane]; // prescale by plane-to-plane calibration factors

  if (val < fAdcMin) { val = fAdcMin; } // saturate
  else if (val > fAdcMax) {
    val = fAdcMax;
  }

  return fAdcOffset +
         fAdcScale *
           (val - fAdcMin); // shift and scale to the output range, shift to the output min
}

void img::DataProviderAlg::scaleAdcSamples ( std::vector< float > &  values ) const

private

Definition at line 375 of file DataProviderAlg.cxx.

References fAdcMax, fAdcMin, fAdcOffset, fAdcScale, fAmplCalibConst, fPlane, scaleAdcSample(), and util::size().

Referenced by downscaleMax(), downscaleMaxMean(), and downscaleMean().

{
  float calib = fAmplCalibConst[fPlane];
  auto* data = values.data();

  size_t k = 0, size4 = values.size() >> 2, size = values.size();
  for (size_t i = 0; i < size4; ++i) // vectorize if you can
  {
    data[k] *= calib; // prescale by plane-to-plane calibration factors
    data[k + 1] *= calib;
    data[k + 2] *= calib;
    data[k + 3] *= calib;

    if (data[k] < fAdcMin) { data[k] = fAdcMin; } // saturate min
    if (data[k + 1] < fAdcMin) { data[k + 1] = fAdcMin; }
    if (data[k + 2] < fAdcMin) { data[k + 2] = fAdcMin; }
    if (data[k + 3] < fAdcMin) { data[k + 3] = fAdcMin; }

    if (data[k] > fAdcMax) { data[k] = fAdcMax; } // saturate max
    if (data[k + 1] > fAdcMax) { data[k + 1] = fAdcMax; }
    if (data[k + 2] > fAdcMax) { data[k + 2] = fAdcMax; }
    if (data[k + 3] > fAdcMax) { data[k + 3] = fAdcMax; }

    data[k] = fAdcOffset +
              fAdcScale *
                (data[k] - fAdcMin); // shift and scale to the output range, shift to the output min
    data[k + 1] = fAdcOffset + fAdcScale * (data[k + 1] - fAdcMin);
    data[k + 2] = fAdcOffset + fAdcScale * (data[k + 2] - fAdcMin);
    data[k + 3] = fAdcOffset + fAdcScale * (data[k + 3] - fAdcMin);

    k += 4;
  }
  while (k < size) {
    data[k] = scaleAdcSample(data[k]);
    ++k;
  } // do the tail
}

std::optional< std::vector< float > > img::DataProviderAlg::setWireData ( std::vector< float > const &  adc, size_t  wireIdx  ) const

protected

Definition at line 273 of file DataProviderAlg.cxx.

References downscale(), fAlgView, fDownscaleFullView, and img::DataProviderAlgView::fWireDriftData.

Referenced by setWireDriftData().

{
  if (wireIdx >= fAlgView.fWireDriftData.size()) { return std::nullopt; }
  auto& wData = fAlgView.fWireDriftData[wireIdx];

  if (fDownscaleFullView) {
    if (!adc.empty()) { return downscale(wData.size(), adc, 0); }
    return std::nullopt;
  }
  if (adc.empty()) { return std::nullopt; }
  if (adc.size() <= wData.size()) { return adc; }
  return std::vector<float>(adc.begin(), adc.begin() + wData.size());
}

bool img::DataProviderAlg::setWireDriftData	(	const detinfo::DetectorClocksData &	clock_data,
		const detinfo::DetectorPropertiesData &	det_prop,
		const std::vector< recob::Wire > &	wires,
		unsigned int	plane,
		unsigned int	tpc,
		unsigned int	cryo
	)

Definition at line 289 of file DataProviderAlg.cxx.

References addCoherentNoise(), addWhiteNoise(), applyBlur(), geo::GeometryCore::ChannelToWire(), fAdcAreaOverThr, fAdcSumOverThr, fAdcSumThr, fAlgView, fCryo, fGeometry, fPlane, fTPC, img::DataProviderAlgView::fWireChannels, img::DataProviderAlgView::fWireDriftData, detinfo::DetectorPropertiesData::NumberTimeSamples(), geo::GeometryCore::Nwires(), Plane(), resizeView(), and setWireData().

Referenced by nnet::ParticleDecayId::DetectDecay(), nnet::EmTrackClusterId2out::produce(), nnet::EmTrackClusterId::produce(), nnet::EmTrackMichelId::produce(), nnet::TrainingDataAlg::setDataEventData(), and nnet::TrainingDataAlg::setEventData().

{
  mf::LogInfo("DataProviderAlg") << "Create image for cryo:" << cryo << " tpc:" << tpc
                                 << " plane:" << plane;

  fCryo = cryo;
  fTPC = tpc;
  fPlane = plane;

  fAdcSumOverThr = 0;
  fAdcAreaOverThr = 0;

  size_t nwires = fGeometry->Nwires({cryo, tpc, plane});
  size_t ndrifts = det_prop.NumberTimeSamples();

  fAlgView = resizeView(clock_data, det_prop, nwires, ndrifts);

  auto const& channelStatus =
    art::ServiceHandle<lariov::ChannelStatusService const>()->GetProvider();

  bool allWrong = true;
  for (auto const& wire : wires) {
    auto wireChannelNumber = wire.Channel();
    if (!channelStatus.IsGood(wireChannelNumber)) { continue; }

    size_t w_idx = 0;
    for (auto const& id : fGeometry->ChannelToWire(wireChannelNumber)) {
      if ((id.Plane == plane) && (id.TPC == tpc) && (id.Cryostat == cryo)) {
        w_idx = id.Wire;

        auto adc = wire.Signal();
        if (adc.size() < ndrifts) {
          mf::LogWarning("DataProviderAlg") << "Wire ADC vector size lower than NumberTimeSamples.";
          continue; // not critical, maybe other wires are OK, so continue
        }
        auto wire_data = setWireData(adc, w_idx);
        if (!wire_data) {
          mf::LogWarning("DataProviderAlg") << "Wire data not set.";
          continue; // also not critical, try to set other wires
        }
        fAlgView.fWireDriftData[w_idx] = *wire_data;
        for (auto v : adc) {
          if (v >= fAdcSumThr) {
            fAdcSumOverThr += v;
            fAdcAreaOverThr++;
          }
        }

        fAlgView.fWireChannels[w_idx] = wireChannelNumber;
        allWrong = false;
      }
    }
  }
  if (allWrong) {
    mf::LogError("DataProviderAlg")
      << "Wires data not set in the cryo:" << cryo << " tpc:" << tpc << " plane:" << plane;
    return false;
  }

  applyBlur();
  addWhiteNoise();
  addCoherentNoise();

  return true;
}

unsigned int img::DataProviderAlg::TPC ( ) const

inline

Definition at line 162 of file DataProviderAlg.h.

Referenced by nnet::TrainingDataAlg::collectVtxFlags().

{ return fTPC; }

std::vector<float> const& img::DataProviderAlg::wireData ( size_t  widx ) const

inline

Definition at line 117 of file DataProviderAlg.h.

Referenced by nnet::PointIdTrainingData::analyze().

{ return fAlgView.fWireDriftData[widx]; }

float img::DataProviderAlg::ZeroLevel ( ) const

inline

Level of zero ADC after scaling.

Definition at line 171 of file DataProviderAlg.h.

{ return fAdcZero; }

Member Data Documentation

size_t img::DataProviderAlg::fAdcAreaOverThr

private

Definition at line 251 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), and setWireDriftData().

float img::DataProviderAlg::fAdcMax

private

Definition at line 249 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), scaleAdcSample(), and scaleAdcSamples().

float img::DataProviderAlg::fAdcMin

private

Definition at line 249 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), scaleAdcSample(), and scaleAdcSamples().

float img::DataProviderAlg::fAdcOffset

private

Definition at line 249 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), scaleAdcSample(), and scaleAdcSamples().

float img::DataProviderAlg::fAdcScale

private

Definition at line 249 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), scaleAdcSample(), and scaleAdcSamples().

double img::DataProviderAlg::fAdcSumOverThr

private

Definition at line 250 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), and setWireDriftData().

double img::DataProviderAlg::fAdcSumThr

private

Definition at line 250 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), and setWireDriftData().

float img::DataProviderAlg::fAdcZero

private

Definition at line 249 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), patchFromDownsampledView(), patchFromOriginalView(), and resizeView().

DataProviderAlgView img::DataProviderAlg::fAlgView

protected

Definition at line 181 of file DataProviderAlg.h.

Referenced by addCoherentNoise(), addWhiteNoise(), applyBlur(), downscaleMax(), downscaleMaxMean(), downscaleMean(), nnet::PointIdAlg::isInsideFiducialRegion(), patchFromDownsampledView(), patchFromOriginalView(), poolMax(), nnet::TrainingDataAlg::setDataEventData(), nnet::TrainingDataAlg::setEventData(), setWireData(), setWireDriftData(), and nnet::TrainingDataAlg::setWireEdepsAndLabels().

std::vector<float> img::DataProviderAlg::fAmplCalibConst

private

Definition at line 246 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), scaleAdcSample(), and scaleAdcSamples().

std::vector<float> img::DataProviderAlg::fBlurKernel

private

Definition at line 256 of file DataProviderAlg.h.

Referenced by applyBlur(), and DataProviderAlg().

bool img::DataProviderAlg::fCalibrateAmpl

private

Definition at line 247 of file DataProviderAlg.h.

Referenced by DataProviderAlg().

bool img::DataProviderAlg::fCalibrateLifetime

private

Definition at line 247 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), and resizeView().

calo::CalorimetryAlg img::DataProviderAlg::fCalorimetryAlg

protected

Definition at line 238 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), and resizeView().

float img::DataProviderAlg::fCoherentSigma

private

Definition at line 262 of file DataProviderAlg.h.

Referenced by addCoherentNoise(), and DataProviderAlg().

unsigned int img::DataProviderAlg::fCryo = 9999

private

Definition at line 248 of file DataProviderAlg.h.

Referenced by setWireDriftData().

bool img::DataProviderAlg::fDownscaleFullView

protected

Definition at line 186 of file DataProviderAlg.h.

Referenced by addCoherentNoise(), addWhiteNoise(), DataProviderAlg(), nnet::PointIdAlg::isCurrentPatch(), nnet::PointIdAlg::isSamePatch(), poolMax(), resizeView(), setWireData(), and nnet::TrainingDataAlg::setWireEdepsAndLabels().

EDownscaleMode img::DataProviderAlg::fDownscaleMode

protected

Definition at line 182 of file DataProviderAlg.h.

Referenced by DataProviderAlg().

size_t img::DataProviderAlg::fDriftWindow

protected

Definition at line 185 of file DataProviderAlg.h.

Referenced by addCoherentNoise(), addWhiteNoise(), DataProviderAlg(), downscaleMax(), downscaleMaxMean(), downscaleMean(), nnet::PointIdAlg::isCurrentPatch(), nnet::PointIdAlg::isInsideFiducialRegion(), nnet::PointIdAlg::isSamePatch(), patchFromDownsampledView(), patchFromOriginalView(), poolMax(), resizeView(), and nnet::TrainingDataAlg::setWireEdepsAndLabels().

float img::DataProviderAlg::fDriftWindowInv

protected

Definition at line 187 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), and downscaleMean().

geo::GeometryCore const* img::DataProviderAlg::fGeometry

protected

Definition at line 241 of file DataProviderAlg.h.

Referenced by DataProviderAlg(), nnet::TrainingDataAlg::getProjection(), and setWireDriftData().

float img::DataProviderAlg::fNoiseSigma

private

Definition at line 259 of file DataProviderAlg.h.

Referenced by addWhiteNoise(), and DataProviderAlg().

unsigned int img::DataProviderAlg::fPlane = 9999

private

Definition at line 248 of file DataProviderAlg.h.

Referenced by scaleAdcSample(), scaleAdcSamples(), and setWireDriftData().

CLHEP::HepJamesRandom img::DataProviderAlg::fRndEngine

private

Definition at line 253 of file DataProviderAlg.h.

Referenced by addCoherentNoise(), and addWhiteNoise().

unsigned int img::DataProviderAlg::fTPC = 9999

private

Definition at line 248 of file DataProviderAlg.h.

Referenced by setWireDriftData().

---

The documentation for this class was generated from the following files:

• larreco/v09_25_00/source/larreco/RecoAlg/ImagePatternAlgs/DataProvider/DataProviderAlg.h
• larreco/v09_25_00/source/larreco/RecoAlg/ImagePatternAlgs/DataProvider/DataProviderAlg.cxx