/data/refman/pasoursint/CMSSW_5_2_7_hltpatch2/src/Alignment/LaserAlignment/src/LASProfileJudge.cc

Go to the documentation of this file.

#include "Alignment/LaserAlignment/interface/LASProfileJudge.h"


// terminal colors
#define _R "\033[1;31m"
#define _B "\033[1;34m"
#define _G "\033[1;32m"
#define _N "\033[22;30m"


LASProfileJudge::LASProfileJudge() :
  overdriveThreshold(0)
{

  // switch on the zero filter by default
  isZeroFilter = true;

}





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

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


}





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

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

}





void LASProfileJudge::EnableZeroFilter( bool zeroFilter ) {

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

  isZeroFilter = zeroFilter;

}





void LASProfileJudge::SetOverdriveThreshold( unsigned int aThreshold ) {

  overdriveThreshold = aThreshold;

}





double LASProfileJudge::GetNegativity( int offset ) {

  // 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 );

}




bool LASProfileJudge::IsPeaksInProfile( int offset ) {

  // 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 );

}




bool LASProfileJudge::IsNegativePeaksInProfile( int offset ) {

  // 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 );

}





bool LASProfileJudge::IsOverdrive( int offset ) {

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

}