#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 54 of file DataProviderAlg.h.

Member Enumeration Documentation

enum img::DataProviderAlg::EDownscaleMode

Enumerator
kMax
kMaxMean
kMean

Definition at line 56 of file DataProviderAlg.h.

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

img::DataProviderAlg::kMean

Definition: DataProviderAlg.h:56

img::DataProviderAlg::kMaxMean

Definition: DataProviderAlg.h:56

img::DataProviderAlg::kMax

Definition: DataProviderAlg.h:56

Constructor & Destructor Documentation

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

inline

Definition at line 93 of file DataProviderAlg.h.

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

95 {}

fhicl::Table< Config >

img::DataProviderAlg::DataProviderAlg

DataProviderAlg(const fhicl::ParameterSet &pset)

Definition: DataProviderAlg.h:93

img::DataProviderAlg::DataProviderAlg ( const Config & config )

Definition at line 26 of file DataProviderAlg.cxx.

   : 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

Member Function Documentation

void img::DataProviderAlg::addCoherentNoise ( )

private

Definition at line 549 of file DataProviderAlg.cxx.

 {
   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 530 of file DataProviderAlg.cxx.

 {
   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 424 of file DataProviderAlg.cxx.

 {
   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 167 of file DataProviderAlg.h.

   {
     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 237 of file DataProviderAlg.h.

   {
     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 192 of file DataProviderAlg.cxx.

 {
   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 214 of file DataProviderAlg.cxx.

 {
   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 250 of file DataProviderAlg.cxx.

 {
   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 198 of file DataProviderAlg.h.

   {
     return fDriftWindow;
   }

size_t img::DataProviderAlg::getAdcArea ( ) const

inline

Definition at line 155 of file DataProviderAlg.h.

   {
     return fAdcAreaOverThr;
   }

double img::DataProviderAlg::getAdcSum ( ) const

inline

Definition at line 150 of file DataProviderAlg.h.

   {
     return fAdcSumOverThr;
   }

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

inlineprotected

Definition at line 248 of file DataProviderAlg.h.

   {
     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 120 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 139 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 211 of file DataProviderAlg.h.

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

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

inline

Definition at line 193 of file DataProviderAlg.h.

   {
     return fAlgView.fNCachedDrifts;
   }

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

inline

Definition at line 188 of file DataProviderAlg.h.

   {
     return fAlgView.fNScaledDrifts;
   }

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

inline

Definition at line 183 of file DataProviderAlg.h.

   {
     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 450 of file DataProviderAlg.cxx.

 {
   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 488 of file DataProviderAlg.cxx.

 {
   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 177 of file DataProviderAlg.h.

   {
     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 140 of file DataProviderAlg.cxx.

 {
   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 109 of file DataProviderAlg.cxx.

 {
   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 369 of file DataProviderAlg.cxx.

 {
   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 384 of file DataProviderAlg.cxx.

 {
   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 272 of file DataProviderAlg.cxx.

 {
   if (wireIdx >= fAlgView.fWireDriftData.size()) return std::nullopt;
   auto& wData = fAlgView.fWireDriftData[wireIdx];
 
   if (fDownscaleFullView) {
     if (!adc.empty()) { return downscale(wData.size(), adc, 0); }
     else {
       return std::nullopt;
     }
   }
   else {
     if (adc.empty()) { return std::nullopt; }
     else if (adc.size() <= wData.size())
       return adc;
     else {
       return std::vector<float>(adc.begin(), adc.begin() + wData.size());
     }
   }
   return std::make_optional(wData);
 }

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 296 of file DataProviderAlg.cxx.

 {
   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(plane, tpc, cryo);
   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 172 of file DataProviderAlg.h.

   {
     return fTPC;
   }

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

inline

Definition at line 111 of file DataProviderAlg.h.

   {
     return fAlgView.fWireDriftData[widx];
   }

float img::DataProviderAlg::ZeroLevel ( ) const

inline

Level of zero ADC after scaling.

Definition at line 205 of file DataProviderAlg.h.

   {
     return fAdcZero;
   }

Member Data Documentation

size_t img::DataProviderAlg::fAdcAreaOverThr

private

Definition at line 289 of file DataProviderAlg.h.

float img::DataProviderAlg::fAdcMax

private

Definition at line 287 of file DataProviderAlg.h.

float img::DataProviderAlg::fAdcMin

private

Definition at line 287 of file DataProviderAlg.h.

float img::DataProviderAlg::fAdcOffset

private

Definition at line 287 of file DataProviderAlg.h.

float img::DataProviderAlg::fAdcScale

private

Definition at line 287 of file DataProviderAlg.h.

double img::DataProviderAlg::fAdcSumOverThr

private

Definition at line 288 of file DataProviderAlg.h.

double img::DataProviderAlg::fAdcSumThr

private

Definition at line 288 of file DataProviderAlg.h.

float img::DataProviderAlg::fAdcZero

private

Definition at line 287 of file DataProviderAlg.h.

DataProviderAlgView img::DataProviderAlg::fAlgView

protected

Definition at line 219 of file DataProviderAlg.h.

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

private

Definition at line 284 of file DataProviderAlg.h.

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

private

Definition at line 294 of file DataProviderAlg.h.

bool img::DataProviderAlg::fCalibrateAmpl

private

Definition at line 285 of file DataProviderAlg.h.

bool img::DataProviderAlg::fCalibrateLifetime

private

Definition at line 285 of file DataProviderAlg.h.

calo::CalorimetryAlg img::DataProviderAlg::fCalorimetryAlg

protected

Definition at line 276 of file DataProviderAlg.h.

float img::DataProviderAlg::fCoherentSigma

private

Definition at line 300 of file DataProviderAlg.h.

unsigned int img::DataProviderAlg::fCryo = 9999

private

Definition at line 286 of file DataProviderAlg.h.

bool img::DataProviderAlg::fDownscaleFullView

protected

Definition at line 224 of file DataProviderAlg.h.

EDownscaleMode img::DataProviderAlg::fDownscaleMode

protected

Definition at line 220 of file DataProviderAlg.h.

size_t img::DataProviderAlg::fDriftWindow

protected

Definition at line 223 of file DataProviderAlg.h.

float img::DataProviderAlg::fDriftWindowInv

protected

Definition at line 225 of file DataProviderAlg.h.

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

protected

Definition at line 279 of file DataProviderAlg.h.

float img::DataProviderAlg::fNoiseSigma

private

Definition at line 297 of file DataProviderAlg.h.

unsigned int img::DataProviderAlg::fPlane = 9999

private

Definition at line 286 of file DataProviderAlg.h.

CLHEP::HepJamesRandom img::DataProviderAlg::fRndEngine

private

Definition at line 291 of file DataProviderAlg.h.

unsigned int img::DataProviderAlg::fTPC = 9999

private

Definition at line 286 of file DataProviderAlg.h.

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

larreco/larreco/RecoAlg/ImagePatternAlgs/DataProvider/DataProviderAlg.h
larreco/larreco/RecoAlg/ImagePatternAlgs/DataProvider/DataProviderAlg.cxx

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation