#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)

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_

uint32_t	noise_cache_id

edm::ESHandle< SiStripNoises >	noiseHandle

uint32_t	nSaturatedStrip_

uint32_t	nSigmaNoiseDerTh_

uint32_t	nSmooth_

uint32_t	pedestal_cache_id

edm::ESHandle< SiStripPedestals >	pedestalHandle

uint32_t	quality_cache_id

edm::ESHandle< SiStripQuality >	qualityHandle

std::string	restoreAlgo_

double	restoreThreshold_

int	size_window_

int32_t	slopeX_

int32_t	slopeY_

std::map< uint16_t, digimap_t >	smoothedMaps_

bool	useRealMeanCM_

int	width_cluster_

Static Private Attributes
constexpr static 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 )

protected

Definition at line 9 of file SiStripAPVRestorer.cc.

     : quality_cache_id(-1),
       noise_cache_id(-1),
       pedestal_cache_id(-1),
       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";
 }

References Exception, inspectAlgo_, and restoreAlgo_.

◆ ~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 268 of file SiStripAPVRestorer.cc.

                                                                                                         {
   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;
 }

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

Referenced by inspect().

◆ baselineAndSaturationInspect()

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

inlineprivate

Definition at line 233 of file SiStripAPVRestorer.cc.

                                                                                                              {
   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;
 }

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

Referenced by inspect().

◆ baselineCleaner()

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

inlineprivate

Definition at line 495 of file SiStripAPVRestorer.cc.

                                                                                                                   {
   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);
   }
 }

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

Referenced by flatRegionsFinder().

◆ baselineFollower()

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

inlineprivate

Definition at line 636 of file SiStripAPVRestorer.cc.

                                                                {
   //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;
       }
     }
   }
 }

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

Referenced by baselineFollowerRestore().

◆ baselineFollowerInspect()

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

inlineprivate

Definition at line 188 of file SiStripAPVRestorer.cc.

                                                                                                         {
   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;
 }

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

Referenced by inspect().

◆ baselineFollowerRestore()

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

inlineprivate

Definition at line 352 of file SiStripAPVRestorer.cc.

                                                                              {
   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));
 }

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

Referenced by restore().

◆ checkBaseline()

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

private

Definition at line 682 of file SiStripAPVRestorer.cc.

                                                                          {
   // 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_);
 }

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

Referenced by baselineFollowerRestore().

◆ cleaner_HighSlopeChecker()

void SiStripAPVRestorer::cleaner_HighSlopeChecker ( digimap_t & smoothedpoints )

inlineprivate

Definition at line 603 of file SiStripAPVRestorer.cc.

                                                                                   {
   //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;
     }
   }
 }

References visualization-live-secondInstance_cfg::m.

Referenced by baselineCleaner().

◆ cleaner_LocalMinimumAdder()

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

inlineprivate

Definition at line 536 of file SiStripAPVRestorer.cc.

                                                                          {
   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;
     }
   }
 }

References funct::abs(), ecalMGPA::adc(), detId_, dqmdumpme::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().

◆ cleaner_MonotonyChecker()

void SiStripAPVRestorer::cleaner_MonotonyChecker ( digimap_t & smoothedpoints )

inlineprivate

Definition at line 514 of file SiStripAPVRestorer.cc.

                                                                                  {
   //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;
     }
   }
 }

References hitStripThreshold_, and edm::second().

Referenced by baselineCleaner().

◆ createCMMapCMstored()

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

private

Definition at line 1012 of file SiStripAPVRestorer.cc.

                                                                                                   {
   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));
   }
 }

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

Referenced by loadMeanCMMap().

◆ createCMMapRealPed()

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

private

Definition at line 993 of file SiStripAPVRestorer.cc.

                                                                                         {
   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));
   }
 }

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

Referenced by loadMeanCMMap().

◆ derivativeFollowerRestore()

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

private

Definition at line 1027 of file SiStripAPVRestorer.cc.

                                                                                                         {
   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;
       }
     }
   }
 }

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

Referenced by restore().

◆ flatRegionsFinder()

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

inlineprivate

Definition at line 399 of file SiStripAPVRestorer.cc.

                                                                                                                     {
   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;
 }

References ecalMGPA::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().

◆ flatRestore()

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

inlineprivate

Definition at line 387 of file SiStripAPVRestorer.cc.

                                                                                                  {
   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));
 }

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

Referenced by restore().

◆ forceRestoreInspect()

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

inlineprivate

Definition at line 222 of file SiStripAPVRestorer.cc.

                                                                                                     {
   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;
 }

References apvFlags_, badAPVs_, nTotStripsPerAPV, and restoreAlgo_.

Referenced by inspect().

◆ getAPVFlags()

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

inline

Definition at line 55 of file SiStripAPVRestorer.h.

55 { return apvFlagsBool_; }

References apvFlagsBool_.

◆ getBaselineMap()

const baselinemap_t& SiStripAPVRestorer::getBaselineMap ( ) const

inline

Definition at line 53 of file SiStripAPVRestorer.h.

53 { return baselineMap_; }

References baselineMap_.

◆ getSmoothedPoints()

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

inline

Definition at line 54 of file SiStripAPVRestorer.h.

54 { return smoothedMaps_; }

References smoothedMaps_.

◆ hybridEmulationInspect()

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

inlineprivate

Definition at line 327 of file SiStripAPVRestorer.cc.

                                                                                                        {
   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;
 }

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

Referenced by inspect().

◆ hybridFormatInspect()

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

inlineprivate

Definition at line 160 of file SiStripAPVRestorer.cc.

                                                                                                     {
   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;
 }

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

Referenced by inspect().

◆ init()

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

Definition at line 54 of file SiStripAPVRestorer.cc.

                                                      {
   uint32_t n_cache_id = es.get<SiStripNoisesRcd>().cacheIdentifier();
   uint32_t q_cache_id = es.get<SiStripQualityRcd>().cacheIdentifier();
   uint32_t p_cache_id = es.get<SiStripPedestalsRcd>().cacheIdentifier();
  
   if (n_cache_id != noise_cache_id) {
     es.get<SiStripNoisesRcd>().get(noiseHandle);
     noise_cache_id = n_cache_id;
   } else {
     noise_cache_id = n_cache_id;
   }
   if (q_cache_id != quality_cache_id) {
     es.get<SiStripQualityRcd>().get(qualityHandle);
     quality_cache_id = q_cache_id;
   } else {
     quality_cache_id = q_cache_id;
   }
  
   if (p_cache_id != pedestal_cache_id) {
     es.get<SiStripPedestalsRcd>().get(pedestalHandle);
     pedestal_cache_id = p_cache_id;
   } else {
     pedestal_cache_id = p_cache_id;
   }
 }

References edm::EventSetup::get(), get, noise_cache_id, noiseHandle, pedestal_cache_id, pedestalHandle, quality_cache_id, and qualityHandle.

◆ inspect()

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

Definition at line 90 of file SiStripAPVRestorer.cc.

                                                                 {
   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;
 }

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().

◆ 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 80 of file SiStripAPVRestorer.cc.

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

References inspect(), and restore().

◆ loadMeanCMMap()

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

Definition at line 982 of file SiStripAPVRestorer.cc.

                                                              {
   if (useRealMeanCM_) {
     edm::Handle<edm::DetSetVector<SiStripRawDigi>> input;
     iEvent.getByLabel("siStripDigis", "VirginRaw", input);
     createCMMapRealPed(*input);
   } else {
     edm::Handle<edm::DetSetVector<SiStripProcessedRawDigi>> inputCM;
     iEvent.getByLabel("MEANAPVCM", inputCM);
     createCMMapCMstored(*inputCM);
   }
 }

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

◆ nullInspect()

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

inlineprivate

Definition at line 303 of file SiStripAPVRestorer.cc.

                                                                                             {
   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;
 }

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

Referenced by inspect().

◆ restore()

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

Definition at line 137 of file SiStripAPVRestorer.cc.

                                                                        {
   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)";
       }
     }
   }
 }

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

Referenced by inspectAndRestore().

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 120 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ applyBaselineRejection_

bool SiStripAPVRestorer::applyBaselineRejection_

private

Definition at line 126 of file SiStripAPVRestorer.h.

Referenced by baselineFollowerRestore().

◆ apvFlags_

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

private

Definition at line 95 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 96 of file SiStripAPVRestorer.h.

Referenced by getAPVFlags(), and inspect().

◆ apvFlagsBoolOverride_

std::vector<bool> SiStripAPVRestorer::apvFlagsBoolOverride_

private

Definition at line 97 of file SiStripAPVRestorer.h.

Referenced by baselineFollowerRestore(), and inspect().

◆ badAPVs_

std::vector<bool> SiStripAPVRestorer::badAPVs_

private

Definition at line 99 of file SiStripAPVRestorer.h.

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

◆ baselineMap_

baselinemap_t SiStripAPVRestorer::baselineMap_

private

Definition at line 101 of file SiStripAPVRestorer.h.

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

◆ cleaningSequence_

uint32_t SiStripAPVRestorer::cleaningSequence_

private

Definition at line 121 of file SiStripAPVRestorer.h.

Referenced by baselineCleaner().

◆ consecThreshold_

uint32_t SiStripAPVRestorer::consecThreshold_

private

Definition at line 117 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ deltaCMThreshold_

uint32_t SiStripAPVRestorer::deltaCMThreshold_

private

Definition at line 111 of file SiStripAPVRestorer.h.

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

◆ detId_

uint32_t SiStripAPVRestorer::detId_

private

Definition at line 94 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 113 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect().

◆ distortionThreshold_

uint32_t SiStripAPVRestorer::distortionThreshold_

private

Definition at line 119 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ filteredBaselineDerivativeSumSquare_

double SiStripAPVRestorer::filteredBaselineDerivativeSumSquare_

private

Definition at line 128 of file SiStripAPVRestorer.h.

Referenced by checkBaseline().

◆ filteredBaselineMax_

double SiStripAPVRestorer::filteredBaselineMax_

private

Definition at line 127 of file SiStripAPVRestorer.h.

Referenced by checkBaseline().

◆ forceNoRestore_

bool SiStripAPVRestorer::forceNoRestore_

private

Definition at line 106 of file SiStripAPVRestorer.h.

Referenced by restore().

◆ fraction_

double SiStripAPVRestorer::fraction_

private

Definition at line 112 of file SiStripAPVRestorer.h.

Referenced by abnormalBaselineInspect().

◆ gradient_threshold_

int SiStripAPVRestorer::gradient_threshold_

private

Definition at line 129 of file SiStripAPVRestorer.h.

Referenced by derivativeFollowerRestore().

◆ hitStripThreshold_

uint32_t SiStripAPVRestorer::hitStripThreshold_

private

Definition at line 124 of file SiStripAPVRestorer.h.

Referenced by cleaner_MonotonyChecker().

◆ inspectAlgo_

std::string SiStripAPVRestorer::inspectAlgo_

private

Definition at line 107 of file SiStripAPVRestorer.h.

Referenced by inspect(), and SiStripAPVRestorer().

◆ last_gradient_

int SiStripAPVRestorer::last_gradient_

private

Definition at line 130 of file SiStripAPVRestorer.h.

Referenced by derivativeFollowerRestore().

◆ meanCM_

int32_t SiStripAPVRestorer::meanCM_

private

Definition at line 110 of file SiStripAPVRestorer.h.

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

◆ meanCMmap_

CMMap SiStripAPVRestorer::meanCMmap_

private

Definition at line 92 of file SiStripAPVRestorer.h.

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

◆ median_

std::vector<float> SiStripAPVRestorer::median_

private

Definition at line 98 of file SiStripAPVRestorer.h.

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

◆ minStripsToFit_

uint32_t SiStripAPVRestorer::minStripsToFit_

private

Definition at line 125 of file SiStripAPVRestorer.h.

Referenced by baselineFollower().

◆ noise_cache_id

uint32_t SiStripAPVRestorer::noise_cache_id

private

Definition at line 89 of file SiStripAPVRestorer.h.

Referenced by init().

◆ noiseHandle

edm::ESHandle<SiStripNoises> SiStripAPVRestorer::noiseHandle

private

Definition at line 87 of file SiStripAPVRestorer.h.

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

◆ nSaturatedStrip_

uint32_t SiStripAPVRestorer::nSaturatedStrip_

private

Definition at line 115 of file SiStripAPVRestorer.h.

Referenced by baselineAndSaturationInspect().

◆ nSigmaNoiseDerTh_

uint32_t SiStripAPVRestorer::nSigmaNoiseDerTh_

private

Definition at line 116 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ nSmooth_

uint32_t SiStripAPVRestorer::nSmooth_

private

Definition at line 118 of file SiStripAPVRestorer.h.

Referenced by flatRegionsFinder().

◆ nTotStripsPerAPV

constexpr static uint16_t SiStripAPVRestorer::nTotStripsPerAPV = 128

staticconstexprprivate

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().

◆ pedestal_cache_id

uint32_t SiStripAPVRestorer::pedestal_cache_id

private

Definition at line 89 of file SiStripAPVRestorer.h.

Referenced by init().

◆ pedestalHandle

edm::ESHandle<SiStripPedestals> SiStripAPVRestorer::pedestalHandle

private

Definition at line 88 of file SiStripAPVRestorer.h.

Referenced by createCMMapRealPed(), and init().

◆ quality_cache_id

uint32_t SiStripAPVRestorer::quality_cache_id

private

Definition at line 89 of file SiStripAPVRestorer.h.

Referenced by init().

◆ qualityHandle

edm::ESHandle<SiStripQuality> SiStripAPVRestorer::qualityHandle

private

Definition at line 86 of file SiStripAPVRestorer.h.

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

◆ restoreAlgo_

std::string SiStripAPVRestorer::restoreAlgo_

private

Definition at line 108 of file SiStripAPVRestorer.h.

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

◆ restoreThreshold_

double SiStripAPVRestorer::restoreThreshold_

private

Definition at line 114 of file SiStripAPVRestorer.h.

Referenced by nullInspect().

◆ size_window_

int SiStripAPVRestorer::size_window_

private

Definition at line 131 of file SiStripAPVRestorer.h.

Referenced by derivativeFollowerRestore().

◆ slopeX_

int32_t SiStripAPVRestorer::slopeX_

private

Definition at line 122 of file SiStripAPVRestorer.h.

Referenced by cleaner_LocalMinimumAdder().

◆ slopeY_

int32_t SiStripAPVRestorer::slopeY_

private

Definition at line 123 of file SiStripAPVRestorer.h.

Referenced by cleaner_LocalMinimumAdder().

◆ smoothedMaps_

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

private

Definition at line 100 of file SiStripAPVRestorer.h.

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

◆ useRealMeanCM_

bool SiStripAPVRestorer::useRealMeanCM_

private

Definition at line 109 of file SiStripAPVRestorer.h.

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

◆ width_cluster_

int SiStripAPVRestorer::width_cluster_

private

Definition at line 132 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_

◆ noise_cache_id

◆ noiseHandle

◆ nSaturatedStrip_

◆ nSigmaNoiseDerTh_

◆ nSmooth_