#include <SiStripAPVRestorer.h>

Public Types
using	baselinemap_t = std::map< uint16_t, digivector_t >

using	digi_t = int16_t

using	digimap_t = std::map< uint16_t, digi_t >

using	digivector_t = std::vector< digi_t >

using	medians_t = std::vector< std::pair< short, float > >

Public Member Functions
const std::vector< bool > &	getAPVFlags () const

const baselinemap_t &	getBaselineMap () const

const std::map< uint16_t, digimap_t > &	getSmoothedPoints () const

void	init (const edm::EventSetup &es)

uint16_t	inspect (uint32_t detId, uint16_t firstAPV, const digivector_t &digis, const medians_t &vmedians)

uint16_t	inspectAndRestore (uint32_t detId, uint16_t firstAPV, const digivector_t &rawDigisPedSubtracted, digivector_t &processedRawDigi, const medians_t &vmedians)

void	loadMeanCMMap (const edm::Event &)

void	restore (uint16_t firstAPV, digivector_t &digis)

virtual	~SiStripAPVRestorer ()

Protected Member Functions
	SiStripAPVRestorer (const edm::ParameterSet &conf, edm::ConsumesCollector)

Private Types
using	CMMap = std::map< uint32_t, std::vector< float > >

Private Member Functions
uint16_t	abnormalBaselineInspect (uint16_t firstAPV, const digivector_t &digis)

uint16_t	baselineAndSaturationInspect (uint16_t firstAPV, const digivector_t &digis)

void	baselineCleaner (const digivector_t &adcs, digimap_t &smoothedpoints, uint16_t apvN)

void	baselineFollower (const digimap_t &, digivector_t &baseline, float median)

uint16_t	baselineFollowerInspect (uint16_t firstAPV, const digivector_t &digis)

void	baselineFollowerRestore (uint16_t apvN, uint16_t firstAPV, float median, digivector_t &digis)

bool	checkBaseline (const std::vector< int16_t > &baseline) const

void	cleaner_HighSlopeChecker (digimap_t &smoothedpoints)

void	cleaner_LocalMinimumAdder (const digivector_t &adcs, digimap_t &smoothedpoints, uint16_t apvN)

void	cleaner_MonotonyChecker (digimap_t &smoothedpoints)

void	createCMMapCMstored (const edm::DetSetVector< SiStripProcessedRawDigi > &input)

void	createCMMapRealPed (const edm::DetSetVector< SiStripRawDigi > &input)

void	derivativeFollowerRestore (uint16_t apvN, uint16_t firstAPV, digivector_t &digis)

bool	flatRegionsFinder (const digivector_t &adcs, digimap_t &smoothedpoints, uint16_t apvN)

void	flatRestore (uint16_t apvN, uint16_t firstAPV, digivector_t &digis)

uint16_t	forceRestoreInspect (uint16_t firstAPV, const digivector_t &digis)

uint16_t	hybridEmulationInspect (uint16_t firstAPV, const digivector_t &digis)

uint16_t	hybridFormatInspect (uint16_t firstAPV, const digivector_t &digis)

uint16_t	nullInspect (uint16_t firstAPV, const digivector_t &digis)

Private Attributes
bool	applyBaselineCleaner_

bool	applyBaselineRejection_

std::vector< std::string >	apvFlags_

std::vector< bool >	apvFlagsBool_

std::vector< bool >	apvFlagsBoolOverride_

std::vector< bool >	badAPVs_

baselinemap_t	baselineMap_

uint32_t	cleaningSequence_

uint32_t	consecThreshold_

uint32_t	deltaCMThreshold_

uint32_t	detId_

uint32_t	deviation_

uint32_t	distortionThreshold_

double	filteredBaselineDerivativeSumSquare_

double	filteredBaselineMax_

bool	forceNoRestore_

double	fraction_

int	gradient_threshold_

uint32_t	hitStripThreshold_

std::string	inspectAlgo_

int	last_gradient_

int32_t	meanCM_

CMMap	meanCMmap_

std::vector< float >	median_

uint32_t	minStripsToFit_

const SiStripNoises *	noiseHandle

edm::ESGetToken< SiStripNoises, SiStripNoisesRcd >	noiseToken_

edm::ESWatcher< SiStripNoisesRcd >	noiseWatcher_

uint32_t	nSaturatedStrip_

uint32_t	nSigmaNoiseDerTh_

uint32_t	nSmooth_

const SiStripPedestals *	pedestalHandle

edm::ESGetToken< SiStripPedestals, SiStripPedestalsRcd >	pedestalToken_

edm::ESWatcher< SiStripPedestalsRcd >	pedestalWatcher_

const SiStripQuality *	qualityHandle

edm::ESGetToken< SiStripQuality, SiStripQualityRcd >	qualityToken_

edm::ESWatcher< SiStripQualityRcd >	qualityWatcher_

std::string	restoreAlgo_

double	restoreThreshold_

edm::EDGetTokenT< edm::DetSetVector< SiStripProcessedRawDigi > >	siStripProcessedRawDigiToken_

edm::EDGetTokenT< edm::DetSetVector< SiStripRawDigi > >	siStripRawDigiToken_

int	size_window_

int32_t	slopeX_

int32_t	slopeY_

std::map< uint16_t, digimap_t >	smoothedMaps_

bool	useRealMeanCM_

int	width_cluster_

Static Private Attributes
static constexpr uint16_t	nTotStripsPerAPV = 128

Friends
class	SiStripRawProcessingFactory

Detailed Description

Definition at line 25 of file SiStripAPVRestorer.h.

Member Typedef Documentation

◆ baselinemap_t

using SiStripAPVRestorer::baselinemap_t = std::map<uint16_t, digivector_t>

Definition at line 38 of file SiStripAPVRestorer.h.

◆ CMMap

using SiStripAPVRestorer::CMMap = std::map<uint32_t, std::vector<float> >

private

Definition at line 58 of file SiStripAPVRestorer.h.

◆ digi_t

using SiStripAPVRestorer::digi_t = int16_t

Definition at line 34 of file SiStripAPVRestorer.h.

◆ digimap_t

using SiStripAPVRestorer::digimap_t = std::map<uint16_t, digi_t>

Definition at line 36 of file SiStripAPVRestorer.h.

◆ digivector_t

using SiStripAPVRestorer::digivector_t = std::vector<digi_t>

Definition at line 35 of file SiStripAPVRestorer.h.

◆ medians_t

using SiStripAPVRestorer::medians_t = std::vector<std::pair<short, float> >

Definition at line 37 of file SiStripAPVRestorer.h.

Constructor & Destructor Documentation

◆ SiStripAPVRestorer()

SiStripAPVRestorer::SiStripAPVRestorer	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector	iC
	)

protected

Definition at line 10 of file SiStripAPVRestorer.cc.

References Exception, inspectAlgo_, and restoreAlgo_.

     : siStripRawDigiToken_(iC.consumes<edm::DetSetVector<SiStripRawDigi>>(edm::InputTag("siStripDigis", "VirginRaw"))),
       siStripProcessedRawDigiToken_(
           iC.consumes<edm::DetSetVector<SiStripProcessedRawDigi>>(edm::InputTag("MEANAPVCM"))),
       qualityToken_(iC.esConsumes<SiStripQuality, SiStripQualityRcd>()),
       noiseToken_(iC.esConsumes<SiStripNoises, SiStripNoisesRcd>()),
       pedestalToken_(iC.esConsumes<SiStripPedestals, SiStripPedestalsRcd>()),
       forceNoRestore_(conf.getParameter<bool>("ForceNoRestore")),
       inspectAlgo_(conf.getParameter<std::string>("APVInspectMode")),
       restoreAlgo_(conf.getParameter<std::string>("APVRestoreMode")),
       // CM map settings
       useRealMeanCM_(conf.getParameter<bool>("useRealMeanCM")),
       meanCM_(conf.getParameter<int32_t>("MeanCM")),
       deltaCMThreshold_(conf.getParameter<uint32_t>("DeltaCMThreshold")),
       // abnormal baseline inspect
       fraction_(conf.getParameter<double>("Fraction")),
       deviation_(conf.getParameter<uint32_t>("Deviation")),
       // nullInspect
       restoreThreshold_(conf.getParameter<double>("restoreThreshold")),
       // baseline and saturation inspect
       nSaturatedStrip_(conf.getParameter<uint32_t>("nSaturatedStrip")),
       // FlatRegionsFinder
       nSigmaNoiseDerTh_(conf.getParameter<uint32_t>("nSigmaNoiseDerTh")),
       consecThreshold_(conf.getParameter<uint32_t>("consecThreshold")),
       nSmooth_(conf.getParameter<uint32_t>("nSmooth")),
       distortionThreshold_(conf.getParameter<uint32_t>("distortionThreshold")),
       applyBaselineCleaner_(conf.getParameter<bool>("ApplyBaselineCleaner")),
       cleaningSequence_(conf.getParameter<uint32_t>("CleaningSequence")),
       // cleaner_localmin
       slopeX_(conf.getParameter<int32_t>("slopeX")),
       slopeY_(conf.getParameter<int32_t>("slopeY")),
       // cleaner_monotony
       hitStripThreshold_(conf.getParameter<uint32_t>("hitStripThreshold")),
       // baseline follower (restore)
       minStripsToFit_(conf.getParameter<uint32_t>("minStripsToFit")),
       applyBaselineRejection_(conf.getParameter<bool>("ApplyBaselineRejection")),
       filteredBaselineMax_(conf.getParameter<double>("filteredBaselineMax")),
       filteredBaselineDerivativeSumSquare_(conf.getParameter<double>("filteredBaselineDerivativeSumSquare")),
       // derivative follower restorer
       gradient_threshold_(conf.getParameter<int>("discontinuityThreshold")),
       last_gradient_(conf.getParameter<int>("lastGradient")),
       size_window_(conf.getParameter<int>("sizeWindow")),
       width_cluster_(conf.getParameter<int>("widthCluster")) {
   if (restoreAlgo_ == "BaselineFollower" && inspectAlgo_ != "BaselineFollower" && inspectAlgo_ != "Hybrid")
     throw cms::Exception("Incompatible Algorithm")
         << "The BaselineFollower restore method requires the BaselineFollower (or Hybrid) inspect method";
 }

◆ ~SiStripAPVRestorer()

virtual SiStripAPVRestorer::~SiStripAPVRestorer ( )

inlinevirtual

Definition at line 32 of file SiStripAPVRestorer.h.

32 {};

Member Function Documentation

◆ abnormalBaselineInspect()

uint16_t SiStripAPVRestorer::abnormalBaselineInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 258 of file SiStripAPVRestorer.cc.

References funct::abs(), apvFlags_, badAPVs_, detId_, deviation_, cms::cuda::for(), fraction_, compareTotals::fs, SiStripBadStrip::getRange(), SiStripQuality::IsStripBad(), meanCM_, meanCMmap_, SiStripPI::min, nTotStripsPerAPV, qualityHandle, restoreAlgo_, and useRealMeanCM_.

Referenced by inspect().

                                                                                                         {
   SiStripQuality::Range detQualityRange = qualityHandle->getRange(detId_);
 
   uint16_t nAPVflagged = 0;
 
   auto itCMMap = std::end(meanCMmap_);
   if (useRealMeanCM_)
     itCMMap = meanCMmap_.find(detId_);
 
   int devCount = 0, qualityCount = 0, minstrip = 0;
   for (uint16_t iAPV = firstAPV; iAPV < firstAPV + digis.size() / nTotStripsPerAPV; ++iAPV) {
     if (!badAPVs_[iAPV]) {
       float MeanAPVCM = meanCM_;
       if (useRealMeanCM_ && (std::end(meanCMmap_) != itCMMap))
         MeanAPVCM = itCMMap->second[iAPV];
 
       for (uint16_t istrip = iAPV * nTotStripsPerAPV; istrip < (iAPV + 1) * nTotStripsPerAPV; ++istrip) {
         const auto fs = static_cast<int>(digis[istrip - firstAPV * nTotStripsPerAPV]);
         if (!qualityHandle->IsStripBad(detQualityRange, istrip)) {
           qualityCount++;
           if (std::abs(fs - MeanAPVCM) > static_cast<int>(deviation_)) {
             devCount++;
             minstrip = std::min(fs, minstrip);
           }
         }
       }
       if (devCount > fraction_ * qualityCount) {
         apvFlags_[iAPV] = restoreAlgo_;  //specify any algo to make the restore
         nAPVflagged++;
       }
     }
   }
   return nAPVflagged;
 }

◆ baselineAndSaturationInspect()

uint16_t SiStripAPVRestorer::baselineAndSaturationInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 223 of file SiStripAPVRestorer.cc.

References funct::abs(), apvFlags_, badAPVs_, deltaCMThreshold_, detId_, meanCM_, meanCMmap_, median_, nSaturatedStrip_, nTotStripsPerAPV, restoreAlgo_, digitizers_cfi::strip, and useRealMeanCM_.

Referenced by inspect().

                                                                                                              {
   digivector_t singleAPVdigi;
   singleAPVdigi.reserve(nTotStripsPerAPV);
   uint16_t nAPVflagged = 0;
 
   auto itCMMap = std::end(meanCMmap_);
   if (useRealMeanCM_)
     itCMMap = meanCMmap_.find(detId_);
 
   for (uint16_t iAPV = firstAPV; iAPV < firstAPV + digis.size() / nTotStripsPerAPV; ++iAPV) {
     if (!badAPVs_[iAPV]) {
       float MeanAPVCM = meanCM_;
       if (useRealMeanCM_ && (std::end(meanCMmap_) != itCMMap))
         MeanAPVCM = itCMMap->second[iAPV];
 
       singleAPVdigi.clear();
       uint16_t nSatStrip = 0;
       for (int16_t strip = (iAPV - firstAPV) * nTotStripsPerAPV; strip < (iAPV - firstAPV + 1) * nTotStripsPerAPV;
            ++strip) {
         const uint16_t digi = digis[strip];
         singleAPVdigi.push_back(digi);
         if (digi >= 1023)
           ++nSatStrip;
       }
 
       const float DeltaCM = median_[iAPV] - MeanAPVCM;
       if ((DeltaCM < 0) && (std::abs(DeltaCM) > deltaCMThreshold_) && (nSatStrip >= nSaturatedStrip_)) {
         apvFlags_[iAPV] = restoreAlgo_;  //specify any algo to make the restore
         ++nAPVflagged;
       }
     }
   }
   return nAPVflagged;
 }

◆ baselineCleaner()

void SiStripAPVRestorer::baselineCleaner	(	const digivector_t &	adcs,
		digimap_t &	smoothedpoints,
		uint16_t	apvN
	)

inlineprivate

Definition at line 485 of file SiStripAPVRestorer.cc.

References cleaner_HighSlopeChecker(), cleaner_LocalMinimumAdder(), cleaner_MonotonyChecker(), and cleaningSequence_.

Referenced by flatRegionsFinder().

                                                                                                                   {
   if (cleaningSequence_ == 0) {  //default sequence used up to now
     cleaner_HighSlopeChecker(smoothedpoints);
     cleaner_LocalMinimumAdder(adcs, smoothedpoints, apvN);
   } else if (cleaningSequence_ == 1) {
     cleaner_LocalMinimumAdder(adcs, smoothedpoints, apvN);
     cleaner_HighSlopeChecker(smoothedpoints);
     cleaner_MonotonyChecker(smoothedpoints);
   } else if (cleaningSequence_ == 2) {
     cleaner_HighSlopeChecker(smoothedpoints);
   } else if (cleaningSequence_ == 3) {
     cleaner_LocalMinimumAdder(adcs, smoothedpoints, apvN);
     cleaner_HighSlopeChecker(smoothedpoints);
   } else {
     cleaner_HighSlopeChecker(smoothedpoints);
     cleaner_LocalMinimumAdder(adcs, smoothedpoints, apvN);
   }
 }

◆ baselineFollower()

void SiStripAPVRestorer::baselineFollower	(	const digimap_t &	smoothedpoints,
		digivector_t &	baseline,
		float	median
	)

inlineprivate

Definition at line 626 of file SiStripAPVRestorer.cc.

References visualization-live-secondInstance_cfg::m, median(), minStripsToFit_, and nTotStripsPerAPV.

Referenced by baselineFollowerRestore().

                                                                {
   //if not enough points
   if (smoothedpoints.size() < minStripsToFit_) {
     baseline.insert(baseline.begin(), nTotStripsPerAPV, median);
   } else {
     baseline.assign(size_t(nTotStripsPerAPV), 0);
 
     const auto lastIt = --smoothedpoints.end();
     const uint16_t firstStripFlat = smoothedpoints.begin()->first;
     const uint16_t lastStripFlat = lastIt->first;
     const int16_t firstStripFlatADC = smoothedpoints.begin()->second;
     const int16_t lastStripFlatADC = lastIt->second;
 
     //adding here the costant line at the extremities
     baseline.erase(baseline.begin(), baseline.begin() + firstStripFlat);
     baseline.insert(baseline.begin(), firstStripFlat, firstStripFlatADC);
 
     baseline.erase(baseline.begin() + lastStripFlat, baseline.end());
     baseline.insert(baseline.end(), nTotStripsPerAPV - lastStripFlat, lastStripFlatADC);
 
     //IMPORTANT: the itSmoothedpointsEnd should be at least smaller than smoothedpoints.end() -1
     for (auto itSmoothedpoints = smoothedpoints.begin(); itSmoothedpoints != (--smoothedpoints.end());
          ++itSmoothedpoints) {
       auto itNextSmoothedpoints = itSmoothedpoints;
       ++itNextSmoothedpoints;
       const float strip1 = itSmoothedpoints->first;
       const float strip2 = itNextSmoothedpoints->first;
       const float adc1 = itSmoothedpoints->second;
       const float adc2 = itNextSmoothedpoints->second;
 
       baseline[strip1] = adc1;
       baseline[strip2] = adc2;
       const float m = (adc2 - adc1) / (strip2 - strip1);
       uint16_t itStrip = strip1 + 1;
       float stripadc = adc1 + m;
       while (itStrip < strip2) {
         baseline[itStrip] = stripadc;
         ++itStrip;
         stripadc += m;
       }
     }
   }
 }

◆ baselineFollowerInspect()

uint16_t SiStripAPVRestorer::baselineFollowerInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 178 of file SiStripAPVRestorer.cc.

References funct::abs(), apvFlags_, badAPVs_, deltaCMThreshold_, detId_, flatRegionsFinder(), meanCM_, meanCMmap_, median_, eostools::move(), nTotStripsPerAPV, restoreAlgo_, smoothedMaps_, and useRealMeanCM_.

Referenced by inspect().

                                                                                                         {
   digivector_t singleAPVdigi;
   singleAPVdigi.reserve(nTotStripsPerAPV);
   uint16_t nAPVflagged = 0;
 
   auto itCMMap = std::end(meanCMmap_);
   if (useRealMeanCM_)
     itCMMap = meanCMmap_.find(detId_);
 
   for (uint16_t iAPV = firstAPV; iAPV < firstAPV + digis.size() / nTotStripsPerAPV; ++iAPV) {
     digimap_t smoothedmap;
     if (!badAPVs_[iAPV]) {
       float MeanAPVCM = meanCM_;
       if (useRealMeanCM_ && (std::end(meanCMmap_) != itCMMap))
         MeanAPVCM = itCMMap->second[iAPV];
 
       singleAPVdigi.clear();
       std::copy_n(std::begin(digis) + nTotStripsPerAPV * (iAPV - firstAPV),
                   nTotStripsPerAPV,
                   std::back_inserter(singleAPVdigi));
 
       const float DeltaCM = median_[iAPV] - MeanAPVCM;
       if ((DeltaCM < 0) && (std::abs(DeltaCM) > deltaCMThreshold_)) {
         if (!flatRegionsFinder(singleAPVdigi, smoothedmap, iAPV)) {
           apvFlags_[iAPV] = restoreAlgo_;  //specify any algo to make the restore
           ++nAPVflagged;
         }
       }
     }
     smoothedMaps_.emplace_hint(smoothedMaps_.end(), iAPV, std::move(smoothedmap));
   }
   return nAPVflagged;
 }

◆ baselineFollowerRestore()

void SiStripAPVRestorer::baselineFollowerRestore	(	uint16_t	apvN,
		uint16_t	firstAPV,
		float	median,
		digivector_t &	digis
	)

inlineprivate

Definition at line 342 of file SiStripAPVRestorer.cc.

References applyBaselineRejection_, apvFlagsBoolOverride_, baselineFollower(), baselineMap_, checkBaseline(), flatRegionsFinder(), median(), eostools::move(), nTotStripsPerAPV, and smoothedMaps_.

Referenced by restore().

                                                                              {
   digivector_t baseline(size_t(nTotStripsPerAPV), 0);
 
   //============================= Find Flat Regions & Interpolating the baseline & subtracting the baseline  =================
   if (!smoothedMaps_.empty()) {
     auto itSmootedMap = smoothedMaps_.find(apvN);
     baselineFollower(itSmootedMap->second, baseline, median);
   } else {
     //median=0;
     digivector_t singleAPVdigi;
     singleAPVdigi.reserve(nTotStripsPerAPV);
     std::copy_n(
         std::begin(digis) + nTotStripsPerAPV * (apvN - firstAPV), nTotStripsPerAPV, std::back_inserter(singleAPVdigi));
     digimap_t smoothedpoints;
     flatRegionsFinder(singleAPVdigi, smoothedpoints, apvN);
     baselineFollower(smoothedpoints, baseline, median);
   }
 
   if (applyBaselineRejection_) {
     if (checkBaseline(baseline))
       apvFlagsBoolOverride_[apvN] = true;
   }
 
   //============================= subtracting the baseline =============================================
   for (int16_t itStrip = 0; itStrip < nTotStripsPerAPV; ++itStrip) {
     digis[nTotStripsPerAPV * (apvN - firstAPV) + itStrip] -= baseline[itStrip] - median;
   }
 
   //============================= storing baseline to the map =============================================
   baselineMap_.emplace_hint(baselineMap_.end(), apvN, std::move(baseline));
 }

◆ checkBaseline()

bool SiStripAPVRestorer::checkBaseline ( const std::vector< int16_t > & baseline ) const

private

Definition at line 672 of file SiStripAPVRestorer.cc.

References DMR_cfg::cerr, ztail::d, filteredBaselineDerivativeSumSquare_, filteredBaselineMax_, mps_fire::i, dqmiolumiharvest::j, SiStripPI::max, and nTotStripsPerAPV.

Referenced by baselineFollowerRestore().

                                                                          {
   // The Savitzky-Golay (S-G) filter of any left length nL, right
   // length nR, and order m, and with an optional opt equals the
   // derivative order (0 for the magnitude, 1 for the first
   // derivative, etc.) can be calculated using the following
   // Mathematica code:
   //
   // SavitzkyGolay[m_?IntegerQ, {nL_?IntegerQ, nR_?IntegerQ},
   //   opt___] := Module[
   //   {a, d},
   //   d = If[opt === Null, 0, If[IntegerQ[opt], opt, 0]];
   //   a = Table[
   //     If[i == 0 && j == 0, 1, i^j], {i, -nL, nR}, {j, 0,
   //      m}]; (Inverse[Transpose[a].a].Transpose[a])[[d + 1]]];
   //
   // The following coefficients can be then calculated by:
   //
   // N[Join[Table[SavitzkyGolay[2, {k, 16}], {k, 0, 16}],
   //   Table[SavitzkyGolay[2, {16, k}], {k, 15, 0, -1}]]]
 
   // nLR = max(nL, nR)
   static const size_t savitzky_golay_n_l_r = 16;
   static const float savitzky_golay_coefficient[2 * savitzky_golay_n_l_r + 1][2 * savitzky_golay_n_l_r + 1] = {
       {0.422085,
        0.325077,
        0.23839,
        0.162023,
        0.0959752,
        0.0402477,
        -0.00515996,
        -0.0402477,
        -0.0650155,
        -0.0794634,
        -0.0835913,
        -0.0773994,
        -0.0608875,
        -0.0340557,
        0.00309598,
        0.0505676,
        0.108359},
       {0.315789,
        0.254902,
        0.19969,
        0.150155,
        0.106295,
        0.0681115,
        0.0356037,
        0.00877193,
        -0.0123839,
        -0.0278638,
        -0.0376677,
        -0.0417957,
        -0.0402477,
        -0.0330237,
        -0.0201238,
        -0.00154799,
        0.0227038,
        0.0526316},
       {0.234586,
        0.198496,
        0.165207,
        0.134719,
        0.107032,
        0.0821465,
        0.0600619,
        0.0407784,
        0.024296,
        0.0106148,
        -0.000265369,
        -0.00834439,
        -0.0136223,
        -0.0160991,
        -0.0157747,
        -0.0126493,
        -0.00672269,
        0.00200501,
        0.0135338},
       {0.172078,     0.153076,    0.135099,    0.118148,   0.102221,   0.0873206, 0.073445,
        0.0605947,    0.0487697,   0.0379699,   0.0281955,  0.0194463,  0.0117225, 0.00502392,
        -0.000649351, -0.00529733, -0.00892003, -0.0115174, -0.0130895, -0.0136364},
       {0.123659,  0.116431,   0.109144,    0.101798,    0.0943921,  0.0869268,  0.0794021,
        0.0718179, 0.0641743,  0.0564712,   0.0487087,   0.0408868,  0.0330054,  0.0250646,
        0.0170644, 0.00900473, 0.000885613, -0.00729294, -0.0155309, -0.0238283, -0.0321852},
       {0.0859684, 0.0868154,  0.0869565,   0.0863919,  0.0851214,  0.0831451, 0.080463,  0.0770751,
        0.0729814, 0.0681818,  0.0626765,   0.0564653,  0.0495483,  0.0419255, 0.0335968, 0.0245624,
        0.0148221, 0.00437606, -0.00677583, -0.0186335, -0.0311971, -0.0444664},
       {0.0565217, 0.0628458, 0.0680971,  0.0722756,   0.0753811,  0.0774139,  0.0783738, 0.0782609,
        0.0770751, 0.0748165, 0.071485,   0.0670807,   0.0616036,  0.0550536,  0.0474308, 0.0387352,
        0.0289667, 0.0181254, 0.00621118, -0.00677583, -0.0208357, -0.0359684, -0.0521739},
       {0.0334615, 0.0434281, 0.0521329, 0.0595759,  0.0657571,   0.0706765, 0.0743341,  0.07673,
        0.0778641, 0.0777364, 0.0763469, 0.0736957,  0.0697826,   0.0646078, 0.0581712,  0.0504728,
        0.0415126, 0.0312907, 0.0198069, 0.00706142, -0.00694588, -0.022215, -0.0387458, -0.0565385},
       {0.0153846, 0.0276923, 0.0386622,  0.0482943,  0.0565886,  0.0635452, 0.0691639, 0.0734448, 0.076388,
        0.0779933, 0.0782609, 0.0771906,  0.0747826,  0.0710368,  0.0659532, 0.0595318, 0.0517726, 0.0426756,
        0.0322408, 0.0204682, 0.00735786, -0.0070903, -0.0228763, -0.04,     -0.0584615},
       {0.001221,  0.0149451, 0.027326,  0.0383639,  0.0480586,   0.0564103,  0.0634188,  0.0690842, 0.0734066,
        0.0763858, 0.078022,  0.078315,  0.077265,   0.0748718,   0.0711355,  0.0660562,  0.0596337, 0.0518681,
        0.0427595, 0.0323077, 0.0205128, 0.00737485, -0.00710623, -0.0229304, -0.0400977, -0.0586081},
       {-0.00985222, 0.00463138, 0.0178098, 0.029683,  0.0402509, 0.0495137,   0.0574713,  0.0641236,  0.0694708,
        0.0735127,   0.0762494,  0.0776809, 0.0778073, 0.0766284, 0.0741442,   0.0703549,  0.0652604,  0.0588607,
        0.0511557,   0.0421456,  0.0318302, 0.0202097, 0.0072839, -0.00694708, -0.0224833, -0.0393247, -0.0574713},
       {-0.0184729, -0.00369458, 0.00984169, 0.0221359,   0.0331881,  0.0429982,  0.0515662,
        0.0588923,  0.0649762,   0.0698181,  0.073418,    0.0757758,  0.0768915,  0.0767652,
        0.0753968,  0.0727864,   0.0689339,  0.0638394,   0.0575028,  0.0499242,  0.0411035,
        0.0310408,  0.019736,    0.00718917, -0.00659972, -0.0216307, -0.0379037, -0.0554187},
       {-0.025139, -0.0103925,  0.00318873, 0.0156046,  0.0268552, 0.0369405, 0.0458605, 0.0536151,
        0.0602045, 0.0656285,   0.0698872,  0.0729806,  0.0749086, 0.0756714, 0.0752688, 0.0737009,
        0.0709677, 0.0670692,   0.0620054,  0.0557763,  0.0483818, 0.039822,  0.0300969, 0.0192065,
        0.0071508, -0.00607024, -0.0204566, -0.0360083, -0.0527253},
       {-0.0302419, -0.0157536, -0.00234785, 0.00997537, 0.021216,   0.0313741, 0.0404497, 0.0484427,
        0.0553532,  0.0611811,  0.0659264,   0.0695892,  0.0721695,  0.0736672, 0.0740823, 0.0734149,
        0.0716649,  0.0688324,  0.0649174,   0.0599198,  0.0538396,  0.0466769, 0.0384316, 0.0291038,
        0.0186934,  0.00720046, -0.00537502, -0.0190331, -0.0337736, -0.0495968},
       {-0.0340909, -0.0200147, -0.006937, 0.00514208,  0.0162226,  0.0263045, 0.0353878, 0.0434725,
        0.0505587,  0.0566463,  0.0617353, 0.0658257,   0.0689175,  0.0710107, 0.0721054, 0.0722014,
        0.0712989,  0.0693978,  0.0664981, 0.0625999,   0.057703,   0.0518076, 0.0449135, 0.0370209,
        0.0281297,  0.01824,    0.0073516, -0.00453534, -0.0174209, -0.031305, -0.0461877},
       {-0.0369318, -0.0233688, -0.0107221, 0.00100806, 0.0118218,   0.0217192,  0.0307001, 0.0387647,
        0.0459128,  0.0521444,  0.0574597,  0.0618585,  0.0653409,   0.0679069,  0.0695565, 0.0702896,
        0.0701063,  0.0690066,  0.0669905,  0.0640579,  0.0602089,   0.0554435,  0.0497617, 0.0431635,
        0.0356488,  0.0272177,  0.0178702,  0.0076063,  -0.00357405, -0.0156708, -0.028684, -0.0426136},
       {-0.038961, -0.025974,  -0.0138249,  -0.00251362, 0.00795978, 0.0175953, 0.026393,  0.0343527, 0.0414747,
        0.0477587, 0.0532049,  0.0578132,   0.0615836,   0.0645161,  0.0666108, 0.0678676, 0.0682866, 0.0678676,
        0.0666108, 0.0645161,  0.0615836,   0.0578132,   0.0532049,  0.0477587, 0.0414747, 0.0343527, 0.026393,
        0.0175953, 0.00795978, -0.00251362, -0.0138249,  -0.025974,  -0.038961},
       {-0.0426136, -0.028684, -0.0156708, -0.00357405, 0.0076063,  0.0178702,  0.0272177,  0.0356488,
        0.0431635,  0.0497617, 0.0554435,  0.0602089,   0.0640579,  0.0669905,  0.0690066,  0.0701063,
        0.0702896,  0.0695565, 0.0679069,  0.0653409,   0.0618585,  0.0574597,  0.0521444,  0.0459128,
        0.0387647,  0.0307001, 0.0217192,  0.0118218,   0.00100806, -0.0107221, -0.0233688, -0.0369318},
       {-0.0461877, -0.031305, -0.0174209, -0.00453534, 0.0073516, 0.01824,    0.0281297, 0.0370209,
        0.0449135,  0.0518076, 0.057703,   0.0625999,   0.0664981, 0.0693978,  0.0712989, 0.0722014,
        0.0721054,  0.0710107, 0.0689175,  0.0658257,   0.0617353, 0.0566463,  0.0505587, 0.0434725,
        0.0353878,  0.0263045, 0.0162226,  0.00514208,  -0.006937, -0.0200147, -0.0340909},
       {-0.0495968, -0.0337736, -0.0190331, -0.00537502, 0.00720046, 0.0186934, 0.0291038, 0.0384316,
        0.0466769,  0.0538396,  0.0599198,  0.0649174,   0.0688324,  0.0716649, 0.0734149, 0.0740823,
        0.0736672,  0.0721695,  0.0695892,  0.0659264,   0.0611811,  0.0553532, 0.0484427, 0.0404497,
        0.0313741,  0.021216,   0.00997537, -0.00234785, -0.0157536, -0.0302419},
       {-0.0527253, -0.0360083, -0.0204566, -0.00607024, 0.0071508, 0.0192065, 0.0300969, 0.039822,
        0.0483818,  0.0557763,  0.0620054,  0.0670692,   0.0709677, 0.0737009, 0.0752688, 0.0756714,
        0.0749086,  0.0729806,  0.0698872,  0.0656285,   0.0602045, 0.0536151, 0.0458605, 0.0369405,
        0.0268552,  0.0156046,  0.00318873, -0.0103925,  -0.025139},
       {-0.0554187, -0.0379037, -0.0216307, -0.00659972, 0.00718917, 0.019736,    0.0310408,
        0.0411035,  0.0499242,  0.0575028,  0.0638394,   0.0689339,  0.0727864,   0.0753968,
        0.0767652,  0.0768915,  0.0757758,  0.073418,    0.0698181,  0.0649762,   0.0588923,
        0.0515662,  0.0429982,  0.0331881,  0.0221359,   0.00984169, -0.00369458, -0.0184729},
       {-0.0574713, -0.0393247, -0.0224833, -0.00694708, 0.0072839, 0.0202097, 0.0318302, 0.0421456,  0.0511557,
        0.0588607,  0.0652604,  0.0703549,  0.0741442,   0.0766284, 0.0778073, 0.0776809, 0.0762494,  0.0735127,
        0.0694708,  0.0641236,  0.0574713,  0.0495137,   0.0402509, 0.029683,  0.0178098, 0.00463138, -0.00985222},
       {-0.0586081, -0.0400977, -0.0229304, -0.00710623, 0.00737485, 0.0205128, 0.0323077, 0.0427595, 0.0518681,
        0.0596337,  0.0660562,  0.0711355,  0.0748718,   0.077265,   0.078315,  0.078022,  0.0763858, 0.0734066,
        0.0690842,  0.0634188,  0.0564103,  0.0480586,   0.0383639,  0.027326,  0.0149451, 0.001221},
       {-0.0584615, -0.04,     -0.0228763, -0.0070903, 0.00735786, 0.0204682, 0.0322408, 0.0426756, 0.0517726,
        0.0595318,  0.0659532, 0.0710368,  0.0747826,  0.0771906,  0.0782609, 0.0779933, 0.076388,  0.0734448,
        0.0691639,  0.0635452, 0.0565886,  0.0482943,  0.0386622,  0.0276923, 0.0153846},
       {-0.0565385, -0.0387458, -0.022215, -0.00694588, 0.00706142, 0.0198069, 0.0312907, 0.0415126,
        0.0504728,  0.0581712,  0.0646078, 0.0697826,   0.0736957,  0.0763469, 0.0777364, 0.0778641,
        0.07673,    0.0743341,  0.0706765, 0.0657571,   0.0595759,  0.0521329, 0.0434281, 0.0334615},
       {-0.0521739, -0.0359684, -0.0208357, -0.00677583, 0.00621118, 0.0181254, 0.0289667, 0.0387352,
        0.0474308,  0.0550536,  0.0616036,  0.0670807,   0.071485,   0.0748165, 0.0770751, 0.0782609,
        0.0783738,  0.0774139,  0.0753811,  0.0722756,   0.0680971,  0.0628458, 0.0565217},
       {-0.0444664, -0.0311971, -0.0186335, -0.00677583, 0.00437606, 0.0148221, 0.0245624, 0.0335968,
        0.0419255,  0.0495483,  0.0564653,  0.0626765,   0.0681818,  0.0729814, 0.0770751, 0.080463,
        0.0831451,  0.0851214,  0.0863919,  0.0869565,   0.0868154,  0.0859684},
       {-0.0321852, -0.0238283, -0.0155309, -0.00729294, 0.000885613, 0.00900473, 0.0170644,
        0.0250646,  0.0330054,  0.0408868,  0.0487087,   0.0564712,   0.0641743,  0.0718179,
        0.0794021,  0.0869268,  0.0943921,  0.101798,    0.109144,    0.116431,   0.123659},
       {-0.0136364, -0.0130895, -0.0115174, -0.00892003, -0.00529733, -0.000649351, 0.00502392,
        0.0117225,  0.0194463,  0.0281955,  0.0379699,   0.0487697,   0.0605947,    0.073445,
        0.0873206,  0.102221,   0.118148,   0.135099,    0.153076,    0.172078},
       {0.0135338,
        0.00200501,
        -0.00672269,
        -0.0126493,
        -0.0157747,
        -0.0160991,
        -0.0136223,
        -0.00834439,
        -0.000265369,
        0.0106148,
        0.024296,
        0.0407784,
        0.0600619,
        0.0821465,
        0.107032,
        0.134719,
        0.165207,
        0.198496,
        0.234586},
       {0.0526316,
        0.0227038,
        -0.00154799,
        -0.0201238,
        -0.0330237,
        -0.0402477,
        -0.0417957,
        -0.0376677,
        -0.0278638,
        -0.0123839,
        0.00877193,
        0.0356037,
        0.0681115,
        0.106295,
        0.150155,
        0.19969,
        0.254902,
        0.315789},
       {0.108359,
        0.0505676,
        0.00309598,
        -0.0340557,
        -0.0608875,
        -0.0773994,
        -0.0835913,
        -0.0794634,
        -0.0650155,
        -0.0402477,
        -0.00515996,
        0.0402477,
        0.0959752,
        0.162023,
        0.23839,
        0.325077,
        0.422085}};
 
   float filtered_baseline[nTotStripsPerAPV];
   float filtered_baseline_derivative[nTotStripsPerAPV - 1];
 
   // Zero filtered_baseline
   memset(filtered_baseline, 0, nTotStripsPerAPV * sizeof(float));
   // Filter the left edge using (nL, nR) = (0, 16) .. (15, 16) S-G
   // filters
   for (size_t i = 0; i < savitzky_golay_n_l_r; i++) {
     for (size_t j = 0; j < savitzky_golay_n_l_r + 1 + i; j++) {
       filtered_baseline[i] += savitzky_golay_coefficient[i][j] * baseline[j];
     }
   }
   // Filter the middle section using the (nL, nR) = (16, 16) S-G
   // filter, while taking advantage of the symmetry to save 16
   // multiplications.
   for (size_t i = savitzky_golay_n_l_r; i < nTotStripsPerAPV - savitzky_golay_n_l_r; i++) {
     filtered_baseline[i] = savitzky_golay_coefficient[savitzky_golay_n_l_r][savitzky_golay_n_l_r] * baseline[i];
     for (size_t j = 0; j < savitzky_golay_n_l_r; j++) {
       filtered_baseline[i] += savitzky_golay_coefficient[savitzky_golay_n_l_r][j] *
                               (baseline[i + j - savitzky_golay_n_l_r] + baseline[i - j + savitzky_golay_n_l_r]);
     }
 #if 0
   // Test that the indexing above is correct
   float test = 0;
   for (size_t j = 0; j < 2 * savitzky_golay_n_l_r + 1; j++) {
     test +=
         savitzky_golay_coefficient[savitzky_golay_n_l_r][j] *
         baseline[i + j - savitzky_golay_n_l_r];
   }
   // test == filtered_baseline[i] should hold now
 #endif
   }
   // Filter the right edge using (nL, nR) = (16, 15) .. (16, 0) S-G
   // filters
   for (size_t i = nTotStripsPerAPV - savitzky_golay_n_l_r; i < nTotStripsPerAPV; i++) {
     for (size_t j = 0; j < nTotStripsPerAPV - i + savitzky_golay_n_l_r; j++) {
       filtered_baseline[i] += savitzky_golay_coefficient[2 * savitzky_golay_n_l_r + i + 1 - nTotStripsPerAPV][j] *
                               baseline[i + j - savitzky_golay_n_l_r];
     }
   }
   // In lieu of a spearate S-G derivative filter, the finite
   // difference is used here (since the output is sufficiently
   // smooth).
   for (size_t i = 0; i < (nTotStripsPerAPV - 1); i++) {
     filtered_baseline_derivative[i] = filtered_baseline[i + 1] - filtered_baseline[i];
   }
 
   // Calculate the maximum deviation between filtered and unfiltered
   // baseline, plus the sum square of the derivative.
 
   double filtered_baseline_max = 0;
   double filtered_baseline_derivative_sum_square = 0;
 
   for (size_t i = 0; i < nTotStripsPerAPV; i++) {
     const double d = filtered_baseline[i] - baseline[i];
 
     filtered_baseline_max = std::max(filtered_baseline_max, static_cast<double>(fabs(d)));
   }
   for (size_t i = 0; i < (nTotStripsPerAPV - 1); i++) {
     filtered_baseline_derivative_sum_square += filtered_baseline_derivative[i] * filtered_baseline_derivative[i];
   }
 
 #if 0
   std::cerr << __FILE__ << ':' << __LINE__ << ": "
           << filtered_baseline_max << ' '
           << filtered_baseline_derivative_sum_square << std::endl;
 #endif
 
   // Apply the cut
   return !(filtered_baseline_max >= filteredBaselineMax_ ||
            filtered_baseline_derivative_sum_square >= filteredBaselineDerivativeSumSquare_);
 }

◆ cleaner_HighSlopeChecker()

void SiStripAPVRestorer::cleaner_HighSlopeChecker ( digimap_t & smoothedpoints )

inlineprivate

Definition at line 593 of file SiStripAPVRestorer.cc.

References visualization-live-secondInstance_cfg::m.

Referenced by baselineCleaner().

                                                                                   {
   //Removing points in the slope is too high
   //----------------------------------------------------------------------------
   if (smoothedpoints.size() < 4)
     return;
 
   auto it = smoothedpoints.begin();
   while (smoothedpoints.size() > 2 && it != --smoothedpoints.end()) {  //while we are not at the last point
     //if(smoothedpoints.size() <2) break;
     // get info about current and next points
     auto itNext = it;
     ++itNext;
     const float strip1 = it->first;
     const float strip2 = itNext->first;
     const float adc1 = it->second;
     const float adc2 = itNext->second;
     const float m = (adc2 - adc1) / (strip2 - strip1);
 
     if (m > 2) {  // in case of large positive slope, remove next point and try again from same current point
       smoothedpoints.erase(itNext);
     } else if (m < -2) {  // in case of large negative slope, remove current point and either...
       // move to next point if we have reached the beginning (post-increment to avoid invalidating pointer during erase) or...
       if (it == smoothedpoints.begin())
         smoothedpoints.erase(it++);
       // try again from the previous point if we have not reached the beginning
       else
         smoothedpoints.erase(it--);
     } else {  // in case of a flat enough slope, continue on to the next point
       ++it;
     }
   }
 }

◆ cleaner_LocalMinimumAdder()

void SiStripAPVRestorer::cleaner_LocalMinimumAdder	(	const digivector_t &	adcs,
		digimap_t &	smoothedpoints,
		uint16_t	apvN
	)

inlineprivate

Definition at line 526 of file SiStripAPVRestorer.cc.

References funct::abs(), gpuClustering::adc, detId_, first, SiStripNoises::getNoiseFast(), SiStripNoises::getRange(), visualization-live-secondInstance_cfg::m, hgchebackDigitizer_cfi::noise, noiseHandle, nTotStripsPerAPV, edm::second(), slopeX_, slopeY_, and digitizers_cfi::strip.

Referenced by baselineCleaner().

                                                                          {
   SiStripNoises::Range detNoiseRange = noiseHandle->getRange(detId_);
   //inserting extra point is case of local minimum
   //--------------------------------------------------------------------------------------------------
   // these should be reset now for the point-insertion that follows
 
   if (smoothedpoints.size() >= 2) {
     for (auto it = smoothedpoints.begin(); it != --smoothedpoints.end(); ++it) {
       auto itNext = it;
       ++itNext;
       const float strip1 = it->first;
       const float strip2 = itNext->first;
       const float adc1 = it->second;
       const float adc2 = itNext->second;
       const float m = (adc2 - adc1) / (strip2 - strip1);
 
       //2,4
       if ((strip2 - strip1) > slopeX_ && std::abs(adc1 - adc2) > slopeY_) {
         float itStrip = 1;
         float strip = itStrip + strip1;
         while (strip < strip2) {
           const float adc = adcs[strip];
           const auto noise =
               static_cast<float>(noiseHandle->getNoiseFast(strip + apvN * nTotStripsPerAPV, detNoiseRange));
           if (adc < (adc1 + m * itStrip - 2 * noise)) {
             smoothedpoints.emplace_hint(itNext, strip, adc);
             ++it;
           }
           ++itStrip;
           ++strip;
         }
       }
     }
   }
 
   const uint16_t firstStripFlat = smoothedpoints.begin()->first;
   const uint16_t lastStripFlat = (--smoothedpoints.end())->first;
   const int16_t firstStripFlatADC = smoothedpoints.begin()->second;
   const int16_t lastStripFlatADC = (--smoothedpoints.end())->second;
   if (firstStripFlat > 3) {
     auto it = smoothedpoints.begin();
     float strip = 0;
     while (strip < firstStripFlat) {
       const float adc = adcs[strip];
       const auto noise = static_cast<float>(noiseHandle->getNoiseFast(strip + apvN * nTotStripsPerAPV, detNoiseRange));
       if (adc < (firstStripFlatADC - 2 * noise)) {
         smoothedpoints.emplace_hint(it, strip, adc);
         ++it;
       }
       ++strip;
     }
   }
   if (lastStripFlat < (nTotStripsPerAPV - 3)) {
     float strip = lastStripFlat + 1;
     while (strip < nTotStripsPerAPV) {
       const float adc = adcs[strip];
       const auto noise = static_cast<float>(noiseHandle->getNoiseFast(strip + apvN * nTotStripsPerAPV, detNoiseRange));
       if (adc < (lastStripFlatADC - 2 * noise)) {
         smoothedpoints.emplace_hint(smoothedpoints.end(), strip, adc);
       }
       ++strip;
     }
   }
 }

◆ cleaner_MonotonyChecker()

void SiStripAPVRestorer::cleaner_MonotonyChecker ( digimap_t & smoothedpoints )

inlineprivate

Definition at line 504 of file SiStripAPVRestorer.cc.

References hitStripThreshold_, and edm::second().

Referenced by baselineCleaner().

                                                                                  {
   //Removing points without monotony
   //--------------------------------------------------------------------------------------------------
   if (smoothedpoints.size() < 3)
     return;
 
   auto it = smoothedpoints.begin();
   while (smoothedpoints.size() > 3 && it != --(--smoothedpoints.end())) {  //while we are not at the last point
     // get info about current and next points
     auto it2 = it;
     const float adc1 = it2->second;
     const float adc2 = (++it2)->second;
     const float adc3 = (++it2)->second;
 
     if ((adc2 - adc1) > hitStripThreshold_ && (adc2 - adc3) > hitStripThreshold_) {
       smoothedpoints.erase(--it2);
     } else {
       ++it;
     }
   }
 }

◆ createCMMapCMstored()

void SiStripAPVRestorer::createCMMapCMstored ( const edm::DetSetVector< SiStripProcessedRawDigi > & input )

private

Definition at line 1002 of file SiStripAPVRestorer.cc.

References SiStripProcessedRawDigi::adc(), input, meanCMmap_, eostools::move(), and HcalDetIdTransform::transform().

Referenced by loadMeanCMMap().

                                                                                                   {
   meanCMmap_.clear();
   for (const auto& rawDigis : input) {
     std::vector<float> meanCMNValue;
     meanCMNValue.reserve(rawDigis.size());
     std::transform(
         std::begin(rawDigis), std::end(rawDigis), std::back_inserter(meanCMNValue), [](SiStripProcessedRawDigi cm) {
           return cm.adc();
         });
     meanCMmap_.emplace(rawDigis.id, std::move(meanCMNValue));
   }
 }

◆ createCMMapRealPed()

void SiStripAPVRestorer::createCMMapRealPed ( const edm::DetSetVector< SiStripRawDigi > & input )

private

Definition at line 983 of file SiStripAPVRestorer.cc.

References SiStripPedestals::getPed(), SiStripPedestals::getRange(), input, meanCMmap_, eostools::move(), nTotStripsPerAPV, pedestalHandle, and digitizers_cfi::strip.

Referenced by loadMeanCMMap().

                                                                                         {
   meanCMmap_.clear();
   for (const auto& rawDigis : input) {
     const auto detPedestalRange = pedestalHandle->getRange(rawDigis.id);
     const size_t nAPVs = rawDigis.size() / nTotStripsPerAPV;
     std::vector<float> meanCMDetSet;
     meanCMDetSet.reserve(nAPVs);
     for (uint16_t iAPV = 0; iAPV < nAPVs; ++iAPV) {
       uint16_t minPed = nTotStripsPerAPV;
       for (uint16_t strip = nTotStripsPerAPV * iAPV; strip < nTotStripsPerAPV * (iAPV + 1); ++strip) {
         uint16_t ped = static_cast<uint16_t>(pedestalHandle->getPed(strip, detPedestalRange));
         if (ped < minPed)
           minPed = ped;
       }
       meanCMDetSet.push_back(minPed);
     }
     meanCMmap_.emplace(rawDigis.id, std::move(meanCMDetSet));
   }
 }

◆ derivativeFollowerRestore()

void SiStripAPVRestorer::derivativeFollowerRestore	(	uint16_t	apvN,
		uint16_t	firstAPV,
		digivector_t &	digis
	)

private

Definition at line 1017 of file SiStripAPVRestorer.cc.

References funct::abs(), gradient_threshold_, last_gradient_, nTotStripsPerAPV, size_window_, and digitizers_cfi::strip.

Referenced by restore().

                                                                                                         {
   digivector_t singleAPVdigi;
   singleAPVdigi.clear();
   for (int16_t strip = (apvN - firstAPV) * nTotStripsPerAPV; strip < (apvN - firstAPV + 1) * nTotStripsPerAPV; ++strip)
     singleAPVdigi.push_back(digis[strip] + 1024);
 
   digimap_t discontinuities;  // it will contain the start and the end of each region in which a greadient is present
   discontinuities.clear();
 
   digimap_t::iterator itdiscontinuities;
 
   //----Variables of the first part---//
 
   bool isMinimumAndNoMax = false;
   bool isFirstStrip = false;
 
   //---Variables of the second part---//
 
   int actualStripADC = 0;
   int previousStripADC = 0;
 
   int greadient = 0;
   int maximum_value = 0;
   const uint32_t n_high_maximum_cluster = 1025 + 1024;
   int high_maximum_cluster = n_high_maximum_cluster;
   int number_good_minimum = 0;
   int first_gradient = 0;
   int strip_first_gradient = 0;
   int adc_start_point_cluster_pw = 0;
   int auxiliary_end_cluster = 0;
   int first_start_cluster_strip = 0;
   int first_start_cluster_ADC = 0;
   bool isAuxiliary_Minimum = false;
   bool isPossible_wrong_minimum = false;
   bool isMax = false;
 
   //----------SECOND PART: CLUSTER FINDING--------//
 
   for (uint16_t strip = 0; strip < singleAPVdigi.size(); ++strip) {
     if (strip == 0) {
       actualStripADC = singleAPVdigi[strip];
       if (std::abs(singleAPVdigi[strip] - singleAPVdigi[strip + 1]) > gradient_threshold_) {
         isFirstStrip = true;
         isMinimumAndNoMax = true;
         discontinuities.insert(discontinuities.end(), std::pair<int, int>(strip, actualStripADC));
       } else if (actualStripADC > (gradient_threshold_ + 1024)) {
         discontinuities.insert(discontinuities.end(), std::pair<uint16_t, int16_t>(strip, 0 + 1024));
         isMinimumAndNoMax = true;
         first_start_cluster_strip = strip;
         first_start_cluster_ADC = 1024;
       }
 
     } else {
       previousStripADC = actualStripADC;
       actualStripADC = singleAPVdigi[strip];
       greadient = actualStripADC - previousStripADC;
 
       if (((greadient > gradient_threshold_) && (!isMax) && (!isMinimumAndNoMax))) {
         isMax = false;
         if (((std::abs(maximum_value - previousStripADC) < (2 * gradient_threshold_)) &&
              discontinuities.size() > 1)) {  // add the || with the cluster size
           //to verify if the noise do not interfere and is detected fake hits
           isPossible_wrong_minimum = true;
           itdiscontinuities = --discontinuities.end();
           if (discontinuities.size() > 1) {
             --itdiscontinuities;
           }
           strip_first_gradient = itdiscontinuities->first;
           adc_start_point_cluster_pw = itdiscontinuities->second;
           first_gradient = std::abs(adc_start_point_cluster_pw - singleAPVdigi[strip_first_gradient + 1]);
           discontinuities.erase(++itdiscontinuities);
           discontinuities.erase(--discontinuities.end());
         }
 
         if ((discontinuities.size() % 2 == 1) && (!discontinuities.empty())) {  //&&(no_minimo == 0)
           discontinuities.erase(--discontinuities.end());
         }
 
         discontinuities.insert(discontinuities.end(), std::pair<uint16_t, int16_t>(strip - 1, previousStripADC));
         isMinimumAndNoMax = true;
         maximum_value = 0;
         first_start_cluster_strip = strip - 1;
         first_start_cluster_ADC = previousStripADC;
 
       } else if ((!isMax) && ((actualStripADC - previousStripADC < 0) && (isMinimumAndNoMax))) {
         isMax = true;
         isMinimumAndNoMax = false;
         high_maximum_cluster = n_high_maximum_cluster;
         if ((previousStripADC > maximum_value) && (discontinuities.size() % 2 == 1))
           maximum_value = previousStripADC;
       }
 
       if ((isMax) && (strip < (nTotStripsPerAPV - 2))) {
         if (high_maximum_cluster > (std::abs(singleAPVdigi[strip + 1] - actualStripADC))) {
           high_maximum_cluster = singleAPVdigi[strip + 1] - actualStripADC;
           auxiliary_end_cluster = strip + 2;
         } else {
           auxiliary_end_cluster = nTotStripsPerAPV - 1;
         }
       }
 
       if ((isMax) && ((actualStripADC - previousStripADC) >= 0) && (size_window_ > 0) &&
           (strip <= ((nTotStripsPerAPV - 1) - size_window_ - 1))) {
         number_good_minimum = 0;
         for (uint16_t wintry = 0; wintry <= size_window_; wintry++) {
           if (std::abs(singleAPVdigi[strip + wintry] - singleAPVdigi[strip + wintry + 1]) <= last_gradient_)
             ++number_good_minimum;
         }
         --number_good_minimum;
 
         if (size_window_ != number_good_minimum) {
           isMax = false;  // not Valid end Point
           isMinimumAndNoMax = true;
         }
 
       } else if ((isMax) && (strip > ((nTotStripsPerAPV - 1) - size_window_ - 1))) {
         isMax = true;
         isAuxiliary_Minimum = true;  //for minimums after strip 127-SW-1
       }
 
       if (!discontinuities.empty()) {
         itdiscontinuities = --discontinuities.end();
       }
 
       if ((isMax) && (actualStripADC <= first_start_cluster_ADC)) {
         if ((std::abs(first_start_cluster_ADC - singleAPVdigi[strip + 2]) > first_gradient) &&
             (isPossible_wrong_minimum)) {
           discontinuities.erase(itdiscontinuities);
           discontinuities.insert(discontinuities.end(),
                                  std::pair<int, int>(strip_first_gradient, adc_start_point_cluster_pw));
           discontinuities.insert(discontinuities.end(), std::pair<int, int>(strip, adc_start_point_cluster_pw));
         } else {
           if ((discontinuities.size() % 2 == 0) && (discontinuities.size() > 1)) {
             discontinuities.erase(--discontinuities.end());
           }
           discontinuities.insert(discontinuities.end(), std::pair<int, int>(strip, actualStripADC));
         }
         isMax = false;
         adc_start_point_cluster_pw = 0;
         isPossible_wrong_minimum = false;
         strip_first_gradient = 0;
         first_start_cluster_strip = 0;
         first_start_cluster_ADC = 0;
       }
 
       if ((isMax) && ((actualStripADC - previousStripADC) >= 0) &&
           (!isAuxiliary_Minimum)) {  //For the end Poit when strip >127-SW-1
         if ((std::abs(first_start_cluster_ADC - singleAPVdigi[strip + 1]) > first_gradient) &&
             (isPossible_wrong_minimum)) {
           discontinuities.erase(itdiscontinuities);
           discontinuities.insert(discontinuities.end(),
                                  std::pair<int, int>(strip_first_gradient, adc_start_point_cluster_pw));
         }
 
         if ((discontinuities.size() % 2 == 0) && (discontinuities.size() > 1)) {
           discontinuities.erase(--discontinuities.end());
         }
         discontinuities.insert(discontinuities.end(), std::pair<int, int>(strip - 1, previousStripADC));
         isMax = false;
         adc_start_point_cluster_pw = 0;
         isPossible_wrong_minimum = false;
         strip_first_gradient = 0;
         first_start_cluster_strip = 0;
         first_start_cluster_ADC = 0;
       }
     }
   }
 
   //----------THIRD PART reconstruction of the event without baseline-------//
 
   if (!discontinuities.empty()) {
     if ((first_start_cluster_strip) == (nTotStripsPerAPV - 1) - 1)
       discontinuities.insert(discontinuities.end(),
                              std::pair<int, int>((nTotStripsPerAPV - 1), first_start_cluster_ADC));
     if ((isMax) && (isAuxiliary_Minimum))
       discontinuities.insert(discontinuities.end(),
                              std::pair<int, int>(auxiliary_end_cluster, first_start_cluster_ADC));
   }
 
   if (isFirstStrip) {
     itdiscontinuities = discontinuities.begin();
     ++itdiscontinuities;
     ++itdiscontinuities;
     int firstADC = itdiscontinuities->second;
     --itdiscontinuities;
     itdiscontinuities->second = firstADC;
     --itdiscontinuities;
     itdiscontinuities->second = firstADC;
   }
 
   if (!discontinuities.empty()) {
     itdiscontinuities = discontinuities.begin();
     uint16_t firstStrip = itdiscontinuities->first;
     int16_t firstADC = itdiscontinuities->second;
     ++itdiscontinuities;
     uint16_t lastStrip = itdiscontinuities->first;
     int16_t secondADC = itdiscontinuities->second;
     ++itdiscontinuities;
 
     for (uint16_t strip = 0; strip < nTotStripsPerAPV; ++strip) {
       if (strip > lastStrip && itdiscontinuities != discontinuities.end()) {
         firstStrip = itdiscontinuities->first;
         firstADC = itdiscontinuities->second;
         ++itdiscontinuities;
         lastStrip = itdiscontinuities->first;
         secondADC = itdiscontinuities->second;
         ++itdiscontinuities;
       }
 
       if ((firstStrip <= strip) && (strip <= lastStrip) &&
           (0 < (singleAPVdigi[strip] - firstADC -
                 ((secondADC - firstADC) / (lastStrip - firstStrip)) * (strip - firstStrip) - gradient_threshold_))) {
         digis[(apvN - firstAPV) * nTotStripsPerAPV + strip] =
             singleAPVdigi[strip] - firstADC -
             (((secondADC - firstADC) / (lastStrip - firstStrip)) * (strip - firstStrip));
         edm::LogWarning("NoBaseline") << "No baseline " << digis[(apvN - firstAPV) * nTotStripsPerAPV + strip] << "\n";
       } else {
         digis[(apvN - firstAPV) * nTotStripsPerAPV + strip] = 0;
       }
     }
   }
 }

◆ flatRegionsFinder()

bool SiStripAPVRestorer::flatRegionsFinder	(	const digivector_t &	adcs,
		digimap_t &	smoothedpoints,
		uint16_t	apvN
	)

inlineprivate

Definition at line 389 of file SiStripAPVRestorer.cc.

References gpuClustering::adc, applyBaselineCleaner_, baselineCleaner(), consecThreshold_, detId_, distortionThreshold_, dqmMemoryStats::float, SiStripNoises::getNoiseFast(), SiStripNoises::getRange(), SiStripPI::max, dqmiodumpmetadata::n, noiseHandle, nSigmaNoiseDerTh_, nSmooth_, and nTotStripsPerAPV.

Referenced by baselineFollowerInspect(), baselineFollowerRestore(), and hybridFormatInspect().

                                                                                                                     {
   smoothedpoints.clear();
 
   SiStripNoises::Range detNoiseRange = noiseHandle->getRange(detId_);
 
   //============================= Height above local minimum ===============================
   std::vector<float> adcsLocalMinSubtracted(size_t(nTotStripsPerAPV), 0);
   for (uint32_t istrip = 0; istrip < nTotStripsPerAPV; ++istrip) {
     float localmin = 999.9;
     for (uint16_t jstrip = std::max(0, static_cast<int>(istrip - nSmooth_ / 2));
          jstrip < std::min((int)nTotStripsPerAPV, static_cast<int>(istrip + nSmooth_ / 2));
          ++jstrip) {
       const float nextvalue = adcs[jstrip];
       if (nextvalue < localmin)
         localmin = nextvalue;
     }
     adcsLocalMinSubtracted[istrip] = adcs[istrip] - localmin;
   }
 
   //============================= Find regions with stable slopes ========================
   digimap_t consecpoints;
   std::vector<uint16_t> nConsStrip;
   //Creating maps with all the neighborhood strip and putting in a nCosntStip vector how many we have
   uint16_t consecStrips = 0;
   for (uint32_t istrip = 0; istrip < nTotStripsPerAPV; ++istrip) {
     const int16_t adc = adcs[istrip];
     //if( adcsLocalMinSubtracted[istrip] < nSigmaNoiseDerTh_ * (float)noiseHandle->getNoise(istrip+apvN*128,detNoiseRange) && (adc - median) < hitStripThreshold_){
     if (adcsLocalMinSubtracted[istrip] <
         nSigmaNoiseDerTh_ * (float)noiseHandle->getNoiseFast(istrip + apvN * nTotStripsPerAPV, detNoiseRange)) {
       consecpoints.emplace_hint(consecpoints.end(), istrip, adc);
       ++consecStrips;
     } else if (consecStrips > 0) {
       nConsStrip.push_back(consecStrips);
       consecStrips = 0;
     }
   }
   //to cope with the last flat region of the APV
   if (consecStrips > 0)
     nConsStrip.push_back(consecStrips);
 
   //removing from the map the fist and last points in wide flat regions and erasing from the map too small regions
   auto itConsecpoints = consecpoints.begin();
   float MinSmoothValue = 20000., MaxSmoothValue = 0.;
   for (const auto consecStrips : nConsStrip) {
     if (consecStrips >= consecThreshold_) {
       ++itConsecpoints;  //skipping first point
       uint16_t nFirstStrip = itConsecpoints->first;
       uint16_t nLastStrip;
       float smoothValue = 0.0;
       float stripCount = 1;
       for (uint16_t n = 0; n < consecStrips - 2; ++n) {
         smoothValue += itConsecpoints->second;
         if (stripCount == consecThreshold_) {
           smoothValue /= (float)stripCount;
           nLastStrip = nFirstStrip + stripCount - 1;
           smoothedpoints.emplace_hint(smoothedpoints.end(), nFirstStrip, smoothValue);
           smoothedpoints.emplace_hint(smoothedpoints.end(), nLastStrip, smoothValue);
           if (smoothValue > MaxSmoothValue)
             MaxSmoothValue = smoothValue;
           if (smoothValue < MinSmoothValue)
             MinSmoothValue = smoothValue;
           nFirstStrip = nLastStrip + 1;
           smoothValue = 0;
           stripCount = 0;
         }
         ++stripCount;
         ++itConsecpoints;
       }
       ++itConsecpoints;  //and putting the pointer to the new seies of point
 
       if (stripCount > 1) {
         //if(smoothValue>0){
         --stripCount;
         smoothValue /= static_cast<float>(stripCount);
         nLastStrip = nFirstStrip + stripCount - 1;
         smoothedpoints.emplace_hint(smoothedpoints.end(), nFirstStrip, smoothValue);
         smoothedpoints.emplace_hint(smoothedpoints.end(), nLastStrip, smoothValue);
         if (smoothValue > MaxSmoothValue)
           MaxSmoothValue = smoothValue;
         if (smoothValue < MinSmoothValue)
           MinSmoothValue = smoothValue;
       }
     } else {
       for (int n = 0; n < consecStrips; ++n)
         ++itConsecpoints;
     }
   }
 
   if ((MaxSmoothValue - MinSmoothValue) > distortionThreshold_) {
     if (applyBaselineCleaner_)
       baselineCleaner(adcs, smoothedpoints, apvN);
     return false;
   }
   return true;
 }

◆ flatRestore()

void SiStripAPVRestorer::flatRestore	(	uint16_t	apvN,
		uint16_t	firstAPV,
		digivector_t &	digis
	)

inlineprivate

Definition at line 377 of file SiStripAPVRestorer.cc.

References baselineMap_, eostools::move(), and nTotStripsPerAPV.

Referenced by restore().

                                                                                                  {
   digivector_t baseline(size_t(nTotStripsPerAPV), 150);
   baseline[0] = 0;
   baseline[nTotStripsPerAPV - 1] = 0;
 
   for (int16_t itStrip = 0; itStrip < nTotStripsPerAPV; ++itStrip) {
     digis[nTotStripsPerAPV * (apvN - firstAPV) + itStrip] = baseline[itStrip];
   }
   baselineMap_.emplace_hint(baselineMap_.end(), apvN, std::move(baseline));
 }

◆ forceRestoreInspect()

uint16_t SiStripAPVRestorer::forceRestoreInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 212 of file SiStripAPVRestorer.cc.

References apvFlags_, badAPVs_, nTotStripsPerAPV, and restoreAlgo_.

Referenced by inspect().

                                                                                                     {
   uint16_t nAPVflagged = 0;
   for (uint16_t iAPV = firstAPV; iAPV < firstAPV + digis.size() / nTotStripsPerAPV; ++iAPV) {
     if (!badAPVs_[iAPV]) {
       apvFlags_[iAPV] = restoreAlgo_;  //specify any algo to make the restore
       nAPVflagged++;
     }
   }
   return nAPVflagged;
 }

◆ getAPVFlags()

const std::vector<bool>& SiStripAPVRestorer::getAPVFlags ( ) const

inline

Definition at line 55 of file SiStripAPVRestorer.h.

References apvFlagsBool_.

55 { return apvFlagsBool_; }

SiStripAPVRestorer::apvFlagsBool_

std::vector< bool > apvFlagsBool_

Definition: SiStripAPVRestorer.h:104

◆ getBaselineMap()

const baselinemap_t& SiStripAPVRestorer::getBaselineMap ( ) const

inline

Definition at line 53 of file SiStripAPVRestorer.h.

References baselineMap_.

53 { return baselineMap_; }

SiStripAPVRestorer::baselineMap_

baselinemap_t baselineMap_

Definition: SiStripAPVRestorer.h:109

◆ getSmoothedPoints()

const std::map<uint16_t, digimap_t>& SiStripAPVRestorer::getSmoothedPoints ( ) const

inline

Definition at line 54 of file SiStripAPVRestorer.h.

References smoothedMaps_.

54 { return smoothedMaps_; }

SiStripAPVRestorer::smoothedMaps_

std::map< uint16_t, digimap_t > smoothedMaps_

Definition: SiStripAPVRestorer.h:108

◆ hybridEmulationInspect()

uint16_t SiStripAPVRestorer::hybridEmulationInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 317 of file SiStripAPVRestorer.cc.

References funct::abs(), apvFlags_, badAPVs_, deltaCMThreshold_, detId_, meanCM_, meanCMmap_, median_, nTotStripsPerAPV, and useRealMeanCM_.

Referenced by inspect().

                                                                                                        {
   uint16_t nAPVflagged = 0;
 
   auto itCMMap = std::end(meanCMmap_);
   if (useRealMeanCM_)
     itCMMap = meanCMmap_.find(detId_);
 
   for (uint16_t iAPV = firstAPV; iAPV < firstAPV + digis.size() / nTotStripsPerAPV; ++iAPV) {
     if (!badAPVs_[iAPV]) {
       float MeanAPVCM = meanCM_;
       if (useRealMeanCM_ && (std::end(meanCMmap_) != itCMMap))
         MeanAPVCM = itCMMap->second[iAPV];
 
       const float DeltaCM = median_[iAPV] - (MeanAPVCM + 1024) / 2;
       if ((DeltaCM < 0) && (std::abs(DeltaCM) > deltaCMThreshold_ / 2)) {
         apvFlags_[iAPV] = "HybridEmulation";
         ++nAPVflagged;
       }
     }
   }
   return nAPVflagged;
 }

◆ hybridFormatInspect()

uint16_t SiStripAPVRestorer::hybridFormatInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 150 of file SiStripAPVRestorer.cc.

References gpuClustering::adc, apvFlags_, badAPVs_, flatRegionsFinder(), eostools::move(), nTotStripsPerAPV, restoreAlgo_, smoothedMaps_, and digitizers_cfi::strip.

Referenced by inspect().

                                                                                                     {
   digivector_t singleAPVdigi;
   singleAPVdigi.reserve(nTotStripsPerAPV);
   uint16_t nAPVflagged = 0;
   for (uint16_t iAPV = firstAPV; iAPV < digis.size() / nTotStripsPerAPV + firstAPV; ++iAPV) {
     digimap_t smoothedmap;
     if (!badAPVs_[iAPV]) {
       uint16_t stripsPerAPV = 0;
       singleAPVdigi.clear();
       for (int16_t strip = (iAPV - firstAPV) * nTotStripsPerAPV; strip < (iAPV - firstAPV + 1) * nTotStripsPerAPV;
            ++strip) {
         const uint16_t adc = digis[strip];
         singleAPVdigi.push_back(adc);
         if (adc > 0)
           ++stripsPerAPV;
       }
 
       if (stripsPerAPV > 64) {
         flatRegionsFinder(singleAPVdigi, smoothedmap, iAPV);
         apvFlags_[iAPV] = restoreAlgo_;  //specify any algo to make the restore
         nAPVflagged++;
       }
     }
     smoothedMaps_.emplace_hint(smoothedMaps_.end(), iAPV, std::move(smoothedmap));
   }
   return nAPVflagged;
 }

◆ init()

void SiStripAPVRestorer::init ( const edm::EventSetup & es )

Definition at line 58 of file SiStripAPVRestorer.cc.

References edm::ESWatcher< T >::check(), edm::EventSetup::getData(), noiseHandle, noiseToken_, noiseWatcher_, pedestalHandle, pedestalToken_, pedestalWatcher_, qualityHandle, qualityToken_, and qualityWatcher_.

                                                      {
   if (noiseWatcher_.check(es)) {
     noiseHandle = &es.getData(noiseToken_);
   }
   if (qualityWatcher_.check(es)) {
     qualityHandle = &es.getData(qualityToken_);
   }
   if (pedestalWatcher_.check(es)) {
     pedestalHandle = &es.getData(pedestalToken_);
   }
 }

◆ inspect()

uint16_t SiStripAPVRestorer::inspect	(	uint32_t	detId,
		uint16_t	firstAPV,
		const digivector_t &	digis,
		const medians_t &	vmedians
	)

Definition at line 80 of file SiStripAPVRestorer.cc.

References abnormalBaselineInspect(), apvFlags_, apvFlagsBool_, apvFlagsBoolOverride_, badAPVs_, baselineAndSaturationInspect(), baselineFollowerInspect(), baselineMap_, detId_, relativeConstraints::empty, Exception, forceRestoreInspect(), hybridEmulationInspect(), hybridFormatInspect(), mps_fire::i, inspectAlgo_, SiStripQuality::IsApvBad(), median_, nullInspect(), qualityHandle, and smoothedMaps_.

Referenced by inspectAndRestore().

                                                                 {
   detId_ = detId;
 
   apvFlags_.assign(6, "");
   apvFlagsBoolOverride_.assign(6, false);
   apvFlagsBool_.clear();
   median_.assign(6, -999);
   badAPVs_.assign(6, false);
   smoothedMaps_.clear();
   baselineMap_.clear();
   for (const auto& med : vmedians) {
     auto iAPV = med.first;
     median_[iAPV] = med.second;
     badAPVs_[iAPV] = qualityHandle->IsApvBad(detId_, iAPV);
   }
 
   uint16_t nAPVFlagged = 0;
   if (inspectAlgo_ == "Hybrid")
     nAPVFlagged = hybridFormatInspect(firstAPV, digis);
   else if (inspectAlgo_ == "HybridEmulation")
     nAPVFlagged = hybridEmulationInspect(firstAPV, digis);
   else if (inspectAlgo_ == "BaselineFollower")
     nAPVFlagged = baselineFollowerInspect(firstAPV, digis);
   else if (inspectAlgo_ == "AbnormalBaseline")
     nAPVFlagged = abnormalBaselineInspect(firstAPV, digis);
   else if (inspectAlgo_ == "Null")
     nAPVFlagged = nullInspect(firstAPV, digis);
   else if (inspectAlgo_ == "BaselineAndSaturation")
     nAPVFlagged = baselineAndSaturationInspect(firstAPV, digis);
   else if (inspectAlgo_ == "DerivativeFollower")
     nAPVFlagged = forceRestoreInspect(firstAPV, digis);
   else
     throw cms::Exception("Unregistered Inspect Algorithm")
         << "SiStripAPVRestorer possibilities: (Null), (AbnormalBaseline), (BaselineFollower), (BaselineAndSaturation), "
            "(DerivativeFollower), (Hybrid), (HybridEmulation)";
 
   // update boolean version of APV flags
   for (size_t i = 0; i < apvFlags_.size(); ++i) {
     apvFlagsBool_.push_back((!apvFlags_[i].empty()) && (!apvFlagsBoolOverride_[i]));
   }
 
   return nAPVFlagged;
 }

◆ inspectAndRestore()

uint16_t SiStripAPVRestorer::inspectAndRestore	(	uint32_t	detId,
		uint16_t	firstAPV,
		const digivector_t &	rawDigisPedSubtracted,
		digivector_t &	processedRawDigi,
		const medians_t &	vmedians
	)

Definition at line 70 of file SiStripAPVRestorer.cc.

References inspect(), and restore().

                                                                           {
   auto nAPVFlagged = inspect(detId, firstAPV, rawDigisPedSubtracted, vmedians);
   restore(firstAPV, processedRawDigi);
   return nAPVFlagged;
 }

◆ loadMeanCMMap()

void SiStripAPVRestorer::loadMeanCMMap ( const edm::Event & iEvent )

Definition at line 972 of file SiStripAPVRestorer.cc.

References createCMMapCMstored(), createCMMapRealPed(), iEvent, input, siStripProcessedRawDigiToken_, siStripRawDigiToken_, and useRealMeanCM_.

                                                              {
   if (useRealMeanCM_) {
     edm::Handle<edm::DetSetVector<SiStripRawDigi>> input;
     iEvent.getByToken(siStripRawDigiToken_, input);
     createCMMapRealPed(*input);
   } else {
     edm::Handle<edm::DetSetVector<SiStripProcessedRawDigi>> inputCM;
     iEvent.getByToken(siStripProcessedRawDigiToken_, inputCM);
     createCMMapCMstored(*inputCM);
   }
 }

◆ nullInspect()

uint16_t SiStripAPVRestorer::nullInspect	(	uint16_t	firstAPV,
		const digivector_t &	digis
	)

inlineprivate

Definition at line 293 of file SiStripAPVRestorer.cc.

References apvFlags_, badAPVs_, detId_, compareTotals::fs, SiStripBadStrip::getRange(), SiStripQuality::IsStripBad(), nTotStripsPerAPV, qualityHandle, restoreAlgo_, and restoreThreshold_.

Referenced by inspect().

                                                                                             {
   SiStripQuality::Range detQualityRange = qualityHandle->getRange(detId_);
 
   uint16_t nAPVflagged = 0;
   for (uint16_t iAPV = firstAPV; iAPV < firstAPV + digis.size() / nTotStripsPerAPV; ++iAPV) {
     if (!badAPVs_[iAPV]) {
       int zeroCount = 0, qualityCount = 0;
       for (uint16_t istrip = iAPV * nTotStripsPerAPV; istrip < (iAPV + 1) * nTotStripsPerAPV; ++istrip) {
         const auto fs = static_cast<int>(digis[istrip - firstAPV * nTotStripsPerAPV]);
         if (!qualityHandle->IsStripBad(detQualityRange, istrip)) {
           qualityCount++;
           if (fs < 1)
             zeroCount++;
         }
       }
       if (zeroCount > restoreThreshold_ * qualityCount) {
         apvFlags_[iAPV] = restoreAlgo_;  //specify any algo to make the restore
         nAPVflagged++;
       }
     }
   }
   return nAPVflagged;
 }

◆ restore()

void SiStripAPVRestorer::restore	(	uint16_t	firstAPV,
		digivector_t &	digis
	)

Definition at line 127 of file SiStripAPVRestorer.cc.

References apvFlags_, baselineFollowerRestore(), derivativeFollowerRestore(), Exception, flatRestore(), forceNoRestore_, median_, and nTotStripsPerAPV.

Referenced by inspectAndRestore().

                                                                        {
   if (forceNoRestore_)
     return;
 
   for (uint16_t iAPV = firstAPV; iAPV < digis.size() / nTotStripsPerAPV + firstAPV; ++iAPV) {
     auto algoToUse = apvFlags_[iAPV];
     if (!algoToUse.empty()) {
       if (algoToUse == "Flat") {
         flatRestore(iAPV, firstAPV, digis);
       } else if (algoToUse == "BaselineFollower") {
         baselineFollowerRestore(iAPV, firstAPV, median_[iAPV], digis);
       } else if (algoToUse == "DerivativeFollower") {
         derivativeFollowerRestore(iAPV, firstAPV, digis);
       } else {
         throw cms::Exception("Unregistered Restore Algorithm")
             << "SiStripAPVRestorer possibilities: (Flat), (BaselineFollower), (DerivativeFollower)";
       }
     }
   }
 }

Friends And Related Function Documentation

◆ SiStripRawProcessingFactory

friend class SiStripRawProcessingFactory

friend

Definition at line 26 of file SiStripAPVRestorer.h.

Member Data Documentation

◆ applyBaselineCleaner_

bool SiStripAPVRestorer::applyBaselineCleaner_

private

Definition at line 128 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ applyBaselineRejection_

bool SiStripAPVRestorer::applyBaselineRejection_

private

Definition at line 134 of file SiStripAPVRestorer.h.

Referenced by baselineFollowerRestore().

◆ apvFlags_

std::vector<std::string> SiStripAPVRestorer::apvFlags_

private

Definition at line 103 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), forceRestoreInspect(), hybridEmulationInspect(), hybridFormatInspect(), inspect(), nullInspect(), and restore().

◆ apvFlagsBool_

std::vector<bool> SiStripAPVRestorer::apvFlagsBool_

private

Definition at line 104 of file SiStripAPVRestorer.h.

Referenced by getAPVFlags(), and inspect().

◆ apvFlagsBoolOverride_

std::vector<bool> SiStripAPVRestorer::apvFlagsBoolOverride_

private

Definition at line 105 of file SiStripAPVRestorer.h.

Referenced by baselineFollowerRestore(), and inspect().

◆ badAPVs_

std::vector<bool> SiStripAPVRestorer::badAPVs_

private

Definition at line 107 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), forceRestoreInspect(), hybridEmulationInspect(), hybridFormatInspect(), inspect(), and nullInspect().

◆ baselineMap_

baselinemap_t SiStripAPVRestorer::baselineMap_

private

Definition at line 109 of file SiStripAPVRestorer.h.

Referenced by baselineFollowerRestore(), flatRestore(), getBaselineMap(), and inspect().

◆ cleaningSequence_

uint32_t SiStripAPVRestorer::cleaningSequence_

private

Definition at line 129 of file SiStripAPVRestorer.h.

Referenced by baselineCleaner().

◆ consecThreshold_

uint32_t SiStripAPVRestorer::consecThreshold_

private

Definition at line 125 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ deltaCMThreshold_

uint32_t SiStripAPVRestorer::deltaCMThreshold_

private

Definition at line 119 of file SiStripAPVRestorer.h.

Referenced by baselineAndSaturationInspect(), baselineFollowerInspect(), and hybridEmulationInspect().

◆ detId_

uint32_t SiStripAPVRestorer::detId_

private

Definition at line 102 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), cleaner_LocalMinimumAdder(), flatRegionsFinder(), hybridEmulationInspect(), inspect(), and nullInspect().

◆ deviation_

uint32_t SiStripAPVRestorer::deviation_

private

Definition at line 121 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect().

◆ distortionThreshold_

uint32_t SiStripAPVRestorer::distortionThreshold_

private

Definition at line 127 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ filteredBaselineDerivativeSumSquare_

double SiStripAPVRestorer::filteredBaselineDerivativeSumSquare_

private

Definition at line 136 of file SiStripAPVRestorer.h.

Referenced by checkBaseline().

◆ filteredBaselineMax_

double SiStripAPVRestorer::filteredBaselineMax_

private

Definition at line 135 of file SiStripAPVRestorer.h.

Referenced by checkBaseline().

◆ forceNoRestore_

bool SiStripAPVRestorer::forceNoRestore_

private

Definition at line 114 of file SiStripAPVRestorer.h.

Referenced by restore().

◆ fraction_

double SiStripAPVRestorer::fraction_

private

Definition at line 120 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect().

◆ gradient_threshold_

int SiStripAPVRestorer::gradient_threshold_

private

Definition at line 137 of file SiStripAPVRestorer.h.

Referenced by derivativeFollowerRestore().

◆ hitStripThreshold_

uint32_t SiStripAPVRestorer::hitStripThreshold_

private

Definition at line 132 of file SiStripAPVRestorer.h.

Referenced by cleaner_MonotonyChecker().

◆ inspectAlgo_

std::string SiStripAPVRestorer::inspectAlgo_

private

Definition at line 115 of file SiStripAPVRestorer.h.

Referenced by inspect(), and SiStripAPVRestorer().

◆ last_gradient_

int SiStripAPVRestorer::last_gradient_

private

Definition at line 138 of file SiStripAPVRestorer.h.

Referenced by derivativeFollowerRestore().

◆ meanCM_

int32_t SiStripAPVRestorer::meanCM_

private

Definition at line 118 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), and hybridEmulationInspect().

◆ meanCMmap_

CMMap SiStripAPVRestorer::meanCMmap_

private

Definition at line 100 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), createCMMapCMstored(), createCMMapRealPed(), and hybridEmulationInspect().

◆ median_

std::vector<float> SiStripAPVRestorer::median_

private

Definition at line 106 of file SiStripAPVRestorer.h.

Referenced by baselineAndSaturationInspect(), baselineFollowerInspect(), hybridEmulationInspect(), inspect(), and restore().

◆ minStripsToFit_

uint32_t SiStripAPVRestorer::minStripsToFit_

private

Definition at line 133 of file SiStripAPVRestorer.h.

Referenced by baselineFollower().

◆ noiseHandle

const SiStripNoises* SiStripAPVRestorer::noiseHandle

private

Definition at line 93 of file SiStripAPVRestorer.h.

Referenced by cleaner_LocalMinimumAdder(), flatRegionsFinder(), and init().

◆ noiseToken_

edm::ESGetToken<SiStripNoises, SiStripNoisesRcd> SiStripAPVRestorer::noiseToken_

private

Definition at line 90 of file SiStripAPVRestorer.h.

Referenced by init().

◆ noiseWatcher_

edm::ESWatcher<SiStripNoisesRcd> SiStripAPVRestorer::noiseWatcher_

private

Definition at line 96 of file SiStripAPVRestorer.h.

Referenced by init().

◆ nSaturatedStrip_

uint32_t SiStripAPVRestorer::nSaturatedStrip_

private

Definition at line 123 of file SiStripAPVRestorer.h.

Referenced by baselineAndSaturationInspect().

◆ nSigmaNoiseDerTh_

uint32_t SiStripAPVRestorer::nSigmaNoiseDerTh_

private

Definition at line 124 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ nSmooth_

uint32_t SiStripAPVRestorer::nSmooth_

private

Definition at line 126 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ nTotStripsPerAPV

constexpr uint16_t SiStripAPVRestorer::nTotStripsPerAPV = 128

staticprivate

Definition at line 59 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollower(), baselineFollowerInspect(), baselineFollowerRestore(), checkBaseline(), cleaner_LocalMinimumAdder(), createCMMapRealPed(), derivativeFollowerRestore(), flatRegionsFinder(), flatRestore(), forceRestoreInspect(), hybridEmulationInspect(), hybridFormatInspect(), nullInspect(), and restore().

◆ pedestalHandle

const SiStripPedestals* SiStripAPVRestorer::pedestalHandle

private

Definition at line 94 of file SiStripAPVRestorer.h.

Referenced by createCMMapRealPed(), and init().

◆ pedestalToken_

edm::ESGetToken<SiStripPedestals, SiStripPedestalsRcd> SiStripAPVRestorer::pedestalToken_

private

Definition at line 91 of file SiStripAPVRestorer.h.

Referenced by init().

◆ pedestalWatcher_

edm::ESWatcher<SiStripPedestalsRcd> SiStripAPVRestorer::pedestalWatcher_

private

Definition at line 97 of file SiStripAPVRestorer.h.

Referenced by init().

◆ qualityHandle

const SiStripQuality* SiStripAPVRestorer::qualityHandle

private

Definition at line 92 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), init(), inspect(), and nullInspect().

◆ qualityToken_

edm::ESGetToken<SiStripQuality, SiStripQualityRcd> SiStripAPVRestorer::qualityToken_

private

Definition at line 89 of file SiStripAPVRestorer.h.

Referenced by init().

◆ qualityWatcher_

edm::ESWatcher<SiStripQualityRcd> SiStripAPVRestorer::qualityWatcher_

private

Definition at line 95 of file SiStripAPVRestorer.h.

Referenced by init().

◆ restoreAlgo_

std::string SiStripAPVRestorer::restoreAlgo_

private

Definition at line 116 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), forceRestoreInspect(), hybridFormatInspect(), nullInspect(), and SiStripAPVRestorer().

◆ restoreThreshold_

double SiStripAPVRestorer::restoreThreshold_

private

Definition at line 122 of file SiStripAPVRestorer.h.

Referenced by nullInspect().

◆ siStripProcessedRawDigiToken_

edm::EDGetTokenT<edm::DetSetVector<SiStripProcessedRawDigi> > SiStripAPVRestorer::siStripProcessedRawDigiToken_

private

Definition at line 87 of file SiStripAPVRestorer.h.

Referenced by loadMeanCMMap().

◆ siStripRawDigiToken_

edm::EDGetTokenT<edm::DetSetVector<SiStripRawDigi> > SiStripAPVRestorer::siStripRawDigiToken_

private

Definition at line 86 of file SiStripAPVRestorer.h.

Referenced by loadMeanCMMap().

◆ size_window_

int SiStripAPVRestorer::size_window_

private

Definition at line 139 of file SiStripAPVRestorer.h.

Referenced by derivativeFollowerRestore().

◆ slopeX_

int32_t SiStripAPVRestorer::slopeX_

private

Definition at line 130 of file SiStripAPVRestorer.h.

Referenced by cleaner_LocalMinimumAdder().

◆ slopeY_

int32_t SiStripAPVRestorer::slopeY_

private

Definition at line 131 of file SiStripAPVRestorer.h.

Referenced by cleaner_LocalMinimumAdder().

◆ smoothedMaps_

std::map<uint16_t, digimap_t> SiStripAPVRestorer::smoothedMaps_

private

Definition at line 108 of file SiStripAPVRestorer.h.

Referenced by baselineFollowerInspect(), baselineFollowerRestore(), getSmoothedPoints(), hybridFormatInspect(), and inspect().

◆ useRealMeanCM_

bool SiStripAPVRestorer::useRealMeanCM_

private

Definition at line 117 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect(), baselineAndSaturationInspect(), baselineFollowerInspect(), hybridEmulationInspect(), and loadMeanCMMap().

◆ width_cluster_

int SiStripAPVRestorer::width_cluster_

private

Definition at line 140 of file SiStripAPVRestorer.h.

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ baselinemap_t

◆ CMMap

◆ digi_t

◆ digimap_t

◆ digivector_t

◆ medians_t

Constructor & Destructor Documentation

◆ SiStripAPVRestorer()

◆ ~SiStripAPVRestorer()

Member Function Documentation

◆ abnormalBaselineInspect()

◆ baselineAndSaturationInspect()

◆ baselineCleaner()

◆ baselineFollower()

◆ baselineFollowerInspect()

◆ baselineFollowerRestore()

◆ checkBaseline()

◆ cleaner_HighSlopeChecker()

◆ cleaner_LocalMinimumAdder()

◆ cleaner_MonotonyChecker()

◆ createCMMapCMstored()

◆ createCMMapRealPed()

◆ derivativeFollowerRestore()

◆ flatRegionsFinder()

◆ flatRestore()

◆ forceRestoreInspect()

◆ getAPVFlags()

◆ getBaselineMap()

◆ getSmoothedPoints()

◆ hybridEmulationInspect()

◆ hybridFormatInspect()

◆ init()

◆ inspect()

◆ inspectAndRestore()

◆ loadMeanCMMap()

◆ nullInspect()

◆ restore()

Friends And Related Function Documentation

◆ SiStripRawProcessingFactory

Member Data Documentation

◆ applyBaselineCleaner_

◆ applyBaselineRejection_

◆ apvFlags_

◆ apvFlagsBool_

◆ apvFlagsBoolOverride_

◆ badAPVs_

◆ baselineMap_

◆ cleaningSequence_

◆ consecThreshold_

◆ deltaCMThreshold_

◆ detId_

◆ deviation_

◆ distortionThreshold_

◆ filteredBaselineDerivativeSumSquare_

◆ filteredBaselineMax_

◆ forceNoRestore_

◆ fraction_

◆ gradient_threshold_

◆ hitStripThreshold_

◆ inspectAlgo_

◆ last_gradient_

◆ meanCM_

◆ meanCMmap_

◆ median_

◆ minStripsToFit_

◆ noiseHandle

◆ noiseToken_

◆ noiseWatcher_

◆ nSaturatedStrip_

◆ nSigmaNoiseDerTh_