#include <LASProfileJudge.h>

Public Member Functions
void	EnableZeroFilter (bool)

bool	IsSignalIn (const LASModuleProfile &, double)

bool	JudgeProfile (const LASModuleProfile &, double)

	LASProfileJudge ()

void	SetOverdriveThreshold (unsigned int)

Private Member Functions
double	GetNegativity (int)

bool	IsNegativePeaksInProfile (int)

bool	IsOverdrive (int)

bool	IsPeaksInProfile (int)

Private Attributes
bool	isZeroFilter

unsigned int	overdriveThreshold

LASModuleProfile	profile

std::pair< unsigned int, double >	thePeak

Detailed Description

check if a LASModuleProfile is usable for being stored and fitted

Definition at line 14 of file LASProfileJudge.h.

Constructor & Destructor Documentation

◆ LASProfileJudge()

LASProfileJudge::LASProfileJudge ( )

Definition at line 14 of file LASProfileJudge.cc.

References isZeroFilter.

                                  : overdriveThreshold(0) {
   // switch on the zero filter by default
   isZeroFilter = true;
 }

Member Function Documentation

◆ EnableZeroFilter()

void LASProfileJudge::EnableZeroFilter ( bool zeroFilter )

toggle the zero filter (passed from cfg file)

Definition at line 79 of file LASProfileJudge.cc.

References EcnaPython_AdcPeg12_S1_10_R170298_1_0_150_Dee0::cerr, and isZeroFilter.

Referenced by LaserAlignment::LaserAlignment().

                                                       {
   if (!zeroFilter) {
     std::cerr << " [LASProfileJudge::EnableZeroFilter] ** WARNING: Zero filter has been disabled." << std::endl;
   }
 
   isZeroFilter = zeroFilter;
 }

◆ GetNegativity()

double LASProfileJudge::GetNegativity ( int offset )

private

In case of too high laser intensities, the APV baselines tend to drop down. here, the strip amplitudes in the area around the signal region are summed to return a variable which can indicate this.

Definition at line 97 of file LASProfileJudge.cc.

References LASModuleProfile::GetValue(), mps_fire::i, hltrates_dqm_sourceclient-live_cfg::offset, and profile.

Referenced by IsSignalIn(), and JudgeProfile().

                                                 {
   // here we could later run the sum only on the affected (pair of) APV
 
   // expected beam position (in strips)
   const unsigned int meanPosition = 256 + offset;
   // backplane "alignment hole" (="signal region") approx. half size
   const unsigned int halfWindowSize = 33;
   // half size of range over which is summed (must be > halfWindowSize)
   const unsigned int sumHalfRange = 128;
 
   double neg = 0;
 
   // need only x values, so cast here
   for (unsigned int i = meanPosition - sumHalfRange; i < meanPosition - halfWindowSize; ++i) {
     neg += profile.GetValue(i);
   }
 
   for (unsigned int i = meanPosition + halfWindowSize; i < meanPosition + sumHalfRange; ++i) {
     neg += profile.GetValue(i);
   }
 
   return (neg);
 }

◆ IsNegativePeaksInProfile()

bool LASProfileJudge::IsNegativePeaksInProfile ( int offset )

private

sometimes when the laser intensity is too high the APVs get confused and a negative peak (dip) shows up. this is filtered here.

Definition at line 161 of file LASProfileJudge.cc.

References LASModuleProfile::GetValue(), fftjetproducer_cfi::noiseLevel, hltrates_dqm_sourceclient-live_cfg::offset, profile, digitizers_cfi::strip, and thePeak.

Referenced by IsSignalIn(), and JudgeProfile().

                                                          {
   // expected beam position in middle of module (in strips)
   const unsigned int meanPosition = 256 + offset;
   // backplane "alignment hole" approx. half size (in strips)
   const unsigned int halfWindowSize = 33;
 
   bool returnValue = false;
 
   // calculate average out-of-signal
   double average = 0., counterD = 0.;
   for (unsigned int strip = 0; strip < 512; ++strip) {
     if (strip < meanPosition - halfWindowSize || strip > meanPosition + halfWindowSize) {
       average += profile.GetValue(strip);
       counterD += 1.;
     }
   }
   average /= counterD;
 
   // find strips with negative amplitude way above noise level
   const double noiseLevel = 2.;
   for (unsigned int strip = 0; strip < 512; ++strip) {
     if (profile.GetValue(strip) < (average - 10. * noiseLevel)) {
       returnValue = true;
       thePeak.first = strip;
       thePeak.second = profile.GetValue(strip);
       break;
     }
   }
 
   return (returnValue);
 }

◆ IsOverdrive()

bool LASProfileJudge::IsOverdrive ( int offset )

private

check if peak in signal region is too high; this can cause baseline distortions and therefore position bias

Definition at line 197 of file LASProfileJudge.cc.

References LASModuleProfile::GetValue(), hltrates_dqm_sourceclient-live_cfg::offset, overdriveThreshold, profile, and digitizers_cfi::strip.

Referenced by JudgeProfile().

                                             {
   // expected beam position in middle of module (in strips)
   const unsigned int meanPosition = 256 + offset;
   // backplane "alignment hole" approx. half size (in strips)
   const unsigned int halfWindowSize = 33;
 
   // find maximum strip amplitude in range
   for (unsigned int strip = meanPosition - halfWindowSize; strip < meanPosition + halfWindowSize; ++strip) {
     if (profile.GetValue(strip) > overdriveThreshold)
       return true;
   }
 
   return false;
 }

◆ IsPeaksInProfile()

bool LASProfileJudge::IsPeaksInProfile ( int offset )

private

If the laser intensity is too small, there's no peak at all. Here we look if any strip is well above noise level.

Definition at line 125 of file LASProfileJudge.cc.

References LASModuleProfile::GetValue(), fftjetproducer_cfi::noiseLevel, hltrates_dqm_sourceclient-live_cfg::offset, profile, digitizers_cfi::strip, and thePeak.

Referenced by IsSignalIn(), and JudgeProfile().

                                                  {
   // expected beam position (in strips)
   const unsigned int meanPosition = 256 + offset;
   // backplane "alignment hole" approx. half size (in strips)
   const unsigned int halfWindowSize = 33;
 
   bool returnValue = false;
 
   // calculate average out-of-signal
   double average = 0., counterD = 0.;
   for (unsigned int strip = 0; strip < 512; ++strip) {
     if (strip < meanPosition - halfWindowSize || strip > meanPosition + halfWindowSize) {
       average += profile.GetValue(strip);
       counterD += 1.;
     }
   }
   average /= counterD;
 
   // find peaks well above noise level
   const double noiseLevel = 2.;  // to be softcoded..
   for (unsigned int strip = meanPosition - halfWindowSize; strip < meanPosition + halfWindowSize; ++strip) {
     if (profile.GetValue(strip) > (average + 10. * noiseLevel)) {
       returnValue = true;
       thePeak.first = strip;
       thePeak.second = profile.GetValue(strip);
       break;
     }
   }
 
   return (returnValue);
 }

◆ IsSignalIn()

bool LASProfileJudge::IsSignalIn	(	const LASModuleProfile &	aProfile,
		double	offset
	)

Check if a LASModuleProfile indicates that the module has been hit, i.e. contains a visible signal or is even distorted by too high laser amplitude. This method doesn't care if the profile is usable for analysis.

Definition at line 24 of file LASProfileJudge.cc.

References GetNegativity(), IsNegativePeaksInProfile(), IsPeaksInProfile(), hltrates_dqm_sourceclient-live_cfg::offset, profile, and mps_fire::result.

Referenced by LaserAlignment::produce().

                                                                                 {
   profile = aProfile;
 
   // need only approx values, so cast here to use integers throughout
   const int approxOffset = static_cast<int>(offset);
 
   const double negativity = GetNegativity(approxOffset);
   const bool isPeaks = IsPeaksInProfile(approxOffset);
   const bool isNegativePeaks = IsNegativePeaksInProfile(approxOffset);
 
   bool result = (negativity < -1000.) ||  // if we see negativity, there was laser..
                 (isPeaks) ||              // if we see a peak, " " "
                 (isNegativePeaks);        // same here
 
   return (result);
 }

◆ JudgeProfile()

bool LASProfileJudge::JudgeProfile	(	const LASModuleProfile &	aProfile,
		double	offset = `0.`
	)

Check if a LASModuleProfile is usable for being stored, i.e. contains a visible signal & no baseline distortions

Definition at line 45 of file LASProfileJudge.cc.

References GetNegativity(), IsNegativePeaksInProfile(), IsOverdrive(), IsPeaksInProfile(), isZeroFilter, hltrates_dqm_sourceclient-live_cfg::offset, profile, and mps_fire::result.

Referenced by LaserAlignment::produce().

                                                                                        {
   profile = aProfile;
 
   // need only approx values, so cast here to use integers throughout
   const int approxOffset = static_cast<int>(offset);
 
   // run the tests
   const double negativity = GetNegativity(approxOffset);
 
   bool isPeaks;
   if (!isZeroFilter)
     isPeaks = true;  // disable this test if set in cfg
   else
     isPeaks = IsPeaksInProfile(approxOffset);
 
   const bool isNegativePeaks = IsNegativePeaksInProfile(approxOffset);
 
   bool isOverdrive;  // disable this test if set in cfg
   if (!isZeroFilter)
     isOverdrive = false;
   else
     isOverdrive = IsOverdrive(approxOffset);
 
   bool result = (negativity > -1000.) &&  // < 1000. = distorted profile
                 (isPeaks) &&              // want to see a peak (zero filter)
                 !(isNegativePeaks) &&     // no negative peaks
                 !(isOverdrive);           // no overdrive
 
   return (result);
 }