/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/SimRomanPot/SimFP420/src/ZeroSuppressFP420.cc

Go to the documentation of this file.

// File: ZeroSuppressFP420.cc
// Date: 12.2006
// Description: ZeroSuppressFP420 for FP420
// Modifications: 
#include "SimRomanPot/SimFP420/interface/ZeroSuppressFP420.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

ZeroSuppressFP420::ZeroSuppressFP420(const edm::ParameterSet& conf, float noise) : conf_(conf), theNumFEDalgos(4)
{
  noiseInAdc=noise;
  initParams(conf_);
  verbosity = conf_.getUntrackedParameter<int>("VerbosityLevel");
  //initParams();
  if(verbosity>0) {
    std::cout << "ZeroSuppressFP420: constructor: noiseInAdc=  " << noiseInAdc << std::endl;
  }
}

/*
 * The zero suppression algorithm, implemented in the trkFEDclusterizer method.
 * The class publically inherits from the ZSuppressFP420 class, which requires 
 * the use of a method named zeroSuppress.
 */

void ZeroSuppressFP420::initParams(edm::ParameterSet const& conf_)
{
  verbosity = conf_.getUntrackedParameter<int>("VerbosityLevel");
  algoConf      = conf_.getParameter<int>("FedFP420Algorithm"); //FedFP420Algorithm: =1  (,2,3,4)
  lowthreshConf      = conf_.getParameter<double>("FedFP420LowThreshold"); // FedFP420LowThreshold  =3.
  highthreshConf      = conf_.getParameter<double>("FedFP420HighThreshold"); // FedFP420HighThreshold  =4.
  
  /*
   * There are four possible algorithms, the default of which (4)
   * has different thresholds for isolated channels and ones in clusters.
   * It also merges clusters (single or multi channels) that are only separated
   * by one hole. This channel is selected as signal even though it is below
   * both thresholds.
   */
  
  theFEDalgorithm  = algoConf;
  theFEDlowThresh  = lowthreshConf * noiseInAdc;
  theFEDhighThresh = highthreshConf * noiseInAdc;
  
  if(verbosity>0) {
    std::cout << "ZeroSuppressFP420: initParams: !!!  theFEDalgorithm=  " << theFEDalgorithm << std::endl;
    std::cout << " lowthreshConf=  " << lowthreshConf << " highthreshConf=  " << highthreshConf << " theFEDlowThresh=  " << theFEDlowThresh << " theFEDhighThresh=  " << theFEDhighThresh << std::endl;
  }
  
  //Check zero suppress algorithm
  if (theFEDalgorithm < 1 || theFEDalgorithm > theNumFEDalgos) {
    edm::LogError("FP420DigiInfo")<<"ZeroSuppressFP420 FATAL ERROR: Unknown zero suppress algorithm "<<theFEDalgorithm;
    exit(1);
  }
  
  //Check thresholds
  if (theFEDlowThresh > theFEDhighThresh) {
    edm::LogError("FP420DigiInfo")<<"ZeroSuppressFP420 FATAL ERROR: Low threshold exceeds high threshold: "<<theFEDlowThresh<<" > "<<theFEDhighThresh;
    exit(2);
  }
}

ZSuppressFP420::DigitalMapType ZeroSuppressFP420::zeroSuppress(const DigitalMapType& notZeroSuppressedMap,int vrb)
{
  return trkFEDclusterizer(notZeroSuppressedMap, vrb); 
  if(vrb>0) {
    std::cout << "zeroSuppress: return trkFEDclusterizer(notZeroSuppressedMap)" << std::endl;
  }
}

//This performs the zero suppression
ZSuppressFP420::DigitalMapType ZeroSuppressFP420::trkFEDclusterizer(const DigitalMapType &in, int vrb) 
{
  const std::string s2("ZeroSuppressFP420::trkFEDclusterizer1");
  
  DigitalMapType selectedSignal;
  register DigitalMapType::const_iterator i, iPrev, iNext, iPrev2, iNext2;
  
  if(vrb>0) {
    std::cout << "Before For loop" << std::endl;
  }
  
  for (i = in.begin(); i != in.end(); i++) {
    
    //Find adc values for neighbouring strips
    int strip = i->first;
    int adc   = i->second;
    iPrev  = in.find(strip - 1);
    iNext  = in.find(strip + 1);
    if(vrb>0) {
      std::cout << "Inside For loop trkFEDclusterizer: strip= " << strip << " adc= " << adc << std::endl;
    }
    //Set values for channels just outside module to infinity.
    //This is to avoid losing channels at the edges, 
    //which otherwise would pass cuts if strips were next to each other.
    int adcPrev = -99999;
    int adcNext = -99999;
    if ( ((strip)%128) == 127) adcNext = 99999;
    if ( ((strip)%128) == 0)   adcPrev = 99999;
    //Otherwise if channel was found then find it's ADC count.
    if ( iPrev  != in.end() ) adcPrev  = iPrev->second;
    if ( iNext  != in.end() ) adcNext  = iNext->second;
    int adcMaxNeigh = std::max(adcPrev, adcNext);
    if(vrb>0) {
      std::cout << "adcPrev= " << adcPrev << " adcNext= " << adcNext << " adcMaxNeigh= " << adcMaxNeigh << std::endl;
    }
    
    //Find adc values for next neighbouring channes
    iPrev2 = in.find(strip - 2); 
    iNext2 = in.find(strip + 2);
    //See above 
    int adcPrev2 = -99999;
    int adcNext2 = -99999;
    if ( ((strip)%128) == 126) adcNext2 = 99999;
    if ( ((strip)%128) == 1)   adcPrev2 = 99999; 
    if ( iPrev2 != in.end() ) adcPrev2 = iPrev2->second; 
    if ( iNext2 != in.end() ) adcNext2 = iNext2->second; 
    
    if(vrb>0) {
      std::cout << "adcPrev2= " << adcPrev2 << " adcNext2= " << adcNext2 << std::endl;
      std::cout << "To be accepted or not?  adc= " << adc << " >= theFEDlowThresh=" << theFEDlowThresh << std::endl;
    }
    // Decide if this channel should be accepted.
    bool accept = false;
    switch (theFEDalgorithm) {
      
    case 1: 
      accept = (adc >= theFEDlowThresh);
      break;
      
    case 2:
      accept = (adc >= theFEDhighThresh || (adc >= theFEDlowThresh && 
                                            adcMaxNeigh >= theFEDlowThresh));
      break;
      
    case 3:
      accept = (adc >= theFEDhighThresh || (adc >= theFEDlowThresh && 
                                            adcMaxNeigh >= theFEDhighThresh));
      break;
      
    case 4:
      accept = ((adc >= theFEDhighThresh) ||           //Test for adc>highThresh (same as algorithm 2)
                ((adc >= theFEDlowThresh) &&           //Test for adc>lowThresh, with neighbour adc>lowThresh (same as algorithm 2)
                 (adcMaxNeigh >= theFEDlowThresh)) || 
                ((adc < theFEDlowThresh) &&            //Test for adc<lowThresh
                 (((adcPrev  >= theFEDhighThresh) &&   //with both neighbours>highThresh
                   (adcNext  >= theFEDhighThresh)) ||    
                  ((adcPrev  >= theFEDhighThresh) &&   //OR with previous neighbour>highThresh and
                   (adcNext  >= theFEDlowThresh)  &&   //both the next neighbours>lowThresh
                   (adcNext2 >= theFEDlowThresh))  ||    
                  ((adcNext  >= theFEDhighThresh) &&   //OR with next neighbour>highThresh and
                   (adcPrev  >= theFEDlowThresh)  &&   //both the previous neighbours>lowThresh
                   (adcPrev2 >= theFEDlowThresh))  ||
                  ((adcNext  >= theFEDlowThresh)  &&   //OR with both next neighbours>lowThresh and
                   (adcNext2 >= theFEDlowThresh)  &&   //both the previous neighbours>lowThresh
                   (adcPrev  >= theFEDlowThresh)  && 
                   (adcPrev2 >= theFEDlowThresh)))));
      break;
    }
    
    /*
     * When a channel satisfying only the lower threshold is at the edge of an APV or module, 
     * the trkFEDclusterizer method assumes that every channel just outside an APV or module has a hit on it.
     * This is to avoid channel inefficiencies at the edges of APVs and modules.   
     */
    if (accept) {   
      selectedSignal[strip] = adc;
      
      if(vrb>0) {
        std::cout << "selected strips = " << strip << " adc= " << adc << std::endl;
      }
    }  
  }
  
  if(vrb>0) {
    std::cout << "last line of trkFEDclusterizer: return selectedSignal" << std::endl;
  }
  return selectedSignal;
}