PedsFullNoiseSummaryFactory.cc

Go to the documentation of this file.

#include "DQM/SiStripCommissioningSummary/interface/PedsFullNoiseSummaryFactory.h"
#include "CondFormats/SiStripObjects/interface/PedsFullNoiseAnalysis.h"
#include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>
#include <sstream>

using namespace sistrip;

// -----------------------------------------------------------------------------
//
void PedsFullNoiseSummaryFactory::extract( Iterator iter ) {

  PedsFullNoiseAnalysis* anal = dynamic_cast<PedsFullNoiseAnalysis*>( iter->second );
  if ( !anal ) { return; }
  
  std::vector< float > temp(128, 1. * sistrip::invalid_ );
  std::vector< uint16_t > temp2(128, sistrip::invalid_);

  std::vector< std::vector<float> > value (2, temp);
  std::vector< std::vector<float> > peds (2, temp);
  std::vector< std::vector<float> > noise(2, temp);
  std::vector< std::vector<float> > adProbab(2, temp);
  std::vector< std::vector<float> > ksProbab(2, temp);
  std::vector< std::vector<float> > jbProbab(2, temp);
  std::vector< std::vector<float> > chi2Probab(2, temp);
  std::vector< std::vector<float> > residualRMS(2, temp);
  std::vector< std::vector<float> > residualGaus(2, temp);
  std::vector< std::vector<float> > noiseSignificance(2, temp);
  std::vector< std::vector<float> > residualMean(2, temp);
  std::vector< std::vector<float> > residualSkewness(2, temp);
  std::vector< std::vector<float> > residualKurtosis(2, temp);
  std::vector< std::vector<float> > residualIntegralNsigma(2, temp);
  std::vector< std::vector<float> > residualIntegral(2, temp);
  std::vector< std::vector<uint16_t> > badStripBit(2, temp2);
  std::vector< std::vector<uint16_t> > deadStripBit(2, temp2);

  // pedestal values
  peds[0]   = anal->peds()[0];
  peds[1]   = anal->peds()[1];
  // noise values
  noise[0]  = anal->noise()[0];
  noise[1]  = anal->noise()[1];
  // AD probab
  adProbab[0]   = anal->adProbab()[0]; 
  adProbab[1]   = anal->adProbab()[1]; 
  // KS probab
  ksProbab[0]   = anal->ksProbab()[0]; 
  ksProbab[1]   = anal->ksProbab()[1]; 
  // JB probab
  jbProbab[0]   = anal->jbProbab()[0]; 
  jbProbab[1]   = anal->jbProbab()[1]; 
  // CHI2 probab
  chi2Probab[0] = anal->chi2Probab()[0]; 
  chi2Probab[1] = anal->chi2Probab()[1]; 
  // noise RMS
  chi2Probab[0] = anal->chi2Probab()[0]; 
  chi2Probab[1] = anal->chi2Probab()[1]; 
  // residual RMS
  residualRMS[0] = anal->residualRMS()[0]; 
  residualRMS[1] = anal->residualRMS()[1]; 
  // residual Sigma
  residualGaus[0] = anal->residualSigmaGaus()[0]; 
  residualGaus[1] = anal->residualSigmaGaus()[1]; 
  // noise Significance
  noiseSignificance[0] = anal->noiseSignificance()[0]; 
  noiseSignificance[1] = anal->noiseSignificance()[1]; 
  // residual mean
  residualMean[0] = anal->residualMean()[0]; 
  residualMean[1] = anal->residualMean()[1]; 
  // noise Skweness
  residualSkewness[0] = anal->residualSkewness()[0]; 
  residualSkewness[1] = anal->residualSkewness()[1]; 
  // noise Kurtosis
  residualKurtosis[0] = anal->residualKurtosis()[0]; 
  residualKurtosis[1] = anal->residualKurtosis()[1]; 
  // noise integral N sigma
  residualIntegralNsigma[0] = anal->residualIntegralNsigma()[0]; 
  residualIntegralNsigma[1] = anal->residualIntegralNsigma()[1]; 
  // noise integral N sigma
  residualIntegral[0] = anal->residualIntegral()[0]; 
  residualIntegral[1] = anal->residualIntegral()[1]; 
  // bit to indicate if a strip is flagged as bad or not
  residualIntegral[0] = anal->residualIntegral()[0]; 
  residualIntegral[1] = anal->residualIntegral()[1]; 
  // bit to indicate if a strip is bad (1) or not (0)
  badStripBit[0] = anal->badStripBit()[0];
  badStripBit[1] = anal->badStripBit()[1];
  // bit to indicate if a strip is dead (1) or not (0)
  deadStripBit[0] = anal->deadStripBit()[0];
  deadStripBit[1] = anal->deadStripBit()[1];

  bool all_strips = false;
  // Monitor pedestals value for each strip
  if (mon_ == sistrip::PEDESTALS_ALL_STRIPS ) {
    all_strips = true;
    uint16_t bins = peds[0].size();
    if (peds[0].size() < peds[1].size() ) { bins = peds[1].size(); }
    for( uint16_t iped = 0; iped < bins; iped++ ) {
      value[0][iped] = peds[0][iped]; 
      value[1][iped] = peds[1][iped];  
    }
  } 
  // Monitor noise value for each strip
  else if ( mon_ == sistrip::NOISE_ALL_STRIPS ) {
    all_strips = true;
    uint16_t bins = noise[0].size();
    if ( noise[0].size() < noise[1].size() ) { bins = noise[1].size(); }
    for ( uint16_t inoise = 0; inoise < bins; inoise++ ) {
      value[0][inoise] = noise[0][inoise]; 
      value[1][inoise] = noise[1][inoise]; 
    }
  } 
  // Monitor pedestals aD probability for each strip
  else if ( mon_ == sistrip::AD_PROBAB_ALL_STRIPS ) {
    all_strips = true;
    uint16_t bins = adProbab[0].size();
    if ( adProbab[0].size() < adProbab[1].size() ) { bins = adProbab[1].size(); }
    for ( uint16_t iad = 0; iad < bins; iad++ ) {
      value[0][iad] = adProbab[0][iad];
      value[1][iad] = adProbab[1][iad];
    }
  } 
  // Monitor pedestals KS probability for each strip
  else if ( mon_ == sistrip::KS_PROBAB_ALL_STRIPS ) {
    all_strips = true;
    uint16_t bins = ksProbab[0].size();
    if ( ksProbab[0].size() < ksProbab[1].size() ) { bins = ksProbab[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = ksProbab[0][iks];
      value[1][iks] = ksProbab[1][iks];
    }
  } 
  // Monitor pedestals JB probability for each strip
  else if ( mon_ == sistrip::JB_PROBAB_ALL_STRIPS ) {
    all_strips = true;
    uint16_t bins = jbProbab[0].size();
    if ( jbProbab[0].size() < jbProbab[1].size() ) { bins = jbProbab[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = jbProbab[0][iks];
      value[1][iks] = jbProbab[1][iks];
    }
  } 
  // Monitor pedestals Chi2 probability for each strip
  else if ( mon_ == sistrip::CHI2_PROBAB_ALL_STRIPS ) {
    all_strips = true;
    uint16_t bins = chi2Probab[0].size();
    if ( chi2Probab[0].size() < chi2Probab[1].size() ) { bins = chi2Probab[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = chi2Probab[0][iks];
      value[1][iks] = chi2Probab[1][iks];
    }
  }
  // Monitor pedestals RMS residual for each strip 
  else if ( mon_ == sistrip::RESIDUAL_RMS_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualRMS[0].size();
    if ( residualRMS[0].size() < residualRMS[1].size() ) { bins = residualRMS[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualRMS[0][iks];
      value[1][iks] = residualRMS[1][iks];     
    }
  } 
  // Monitor pedestals sigma from gaussian firt for each strip 
  else if ( mon_ == sistrip::RESIDUAL_GAUS_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualGaus[0].size();
    if ( residualGaus[0].size() < residualGaus[1].size() ) { bins = residualGaus[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualGaus[0][iks];
      value[1][iks] = residualGaus[1][iks];     
    }
  }   
  // Monitor pedestals noise significance for each strip
  else if ( mon_ == sistrip::NOISE_SIGNIFICANCE_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = noiseSignificance[0].size();
    if (noiseSignificance[0].size() < noiseSignificance[1].size() ) { bins = noiseSignificance[1].size(); }
    for (uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = noiseSignificance[0][iks];
      value[1][iks] = noiseSignificance[1][iks];     
    }
  }  
  // Monitor mean residual for each strip
  else if ( mon_ == sistrip::RESIDUAL_MEAN_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualMean[0].size();
    if ( residualMean[0].size() < residualMean[1].size() ) { bins = residualMean[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualMean[0][iks];
      value[1][iks] = residualMean[1][iks];     
    }
  } 
  // Monitor skweness for each strip
  else if ( mon_ == sistrip::RESIDUAL_SKEWNESS_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualSkewness[0].size();
    if ( residualSkewness[0].size() < residualSkewness[1].size() ) { bins = residualSkewness[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualSkewness[0][iks];
      value[1][iks] = residualSkewness[1][iks];     
    }
  }   
  // Monitor Kurtosis for each strip
  else if ( mon_ == sistrip::RESIDUAL_KURTOSIS_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualKurtosis[0].size();
    if ( residualKurtosis[0].size() < residualKurtosis[1].size() ) { bins = residualKurtosis[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualKurtosis[0][iks];
      value[1][iks] = residualKurtosis[1][iks];     
    }
  } 
  // Monitor Integral above N sigma for each strip
  else if ( mon_ == sistrip::RESIDUAL_INTEGRALNSIGMA_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualIntegralNsigma[0].size();
    if ( residualIntegralNsigma[0].size() < residualIntegralNsigma[1].size() ) { bins = residualIntegralNsigma[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualIntegralNsigma[0][iks];
      value[1][iks] = residualIntegralNsigma[1][iks];     
    }
  } 
  // Monitor integral for each strip
  else if ( mon_ == sistrip::RESIDUAL_INTEGRAL_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = residualIntegral[0].size();
    if ( residualIntegral[0].size() < residualIntegral[1].size() ) { bins = residualIntegral[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = residualIntegral[0][iks];
      value[1][iks] = residualIntegral[1][iks];     
    }
  } 

  // Monitor BadStrip bit
  else if ( mon_ == sistrip::BAD_STRIP_BIT_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = badStripBit[0].size();
    if ( badStripBit[0].size() < badStripBit[1].size() ) { bins = badStripBit[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = 1.*badStripBit[0][iks];
      value[1][iks] = 1.*badStripBit[1][iks];     
    }
  } 
  // Dead strip bit
  else if ( mon_ == sistrip::DEAD_STRIP_BIT_ALL_STRIPS) {
    all_strips = true;
    uint16_t bins = deadStripBit[0].size();
    if ( deadStripBit[0].size() < deadStripBit[1].size() ) { bins = deadStripBit[1].size(); }
    for ( uint16_t iks = 0; iks < bins; iks++ ) {
      value[0][iks] = 1.*deadStripBit[0][iks];
      value[1][iks] = 1.*deadStripBit[1][iks];     
    }
  } 
  
  // Per APV information: pedsMean
  else if ( mon_ == sistrip::PEDESTALS_MEAN ) {
    value[0][0] = anal->pedsMean()[0];
    value[1][0] = anal->pedsMean()[1];
  } 

  // Per APV information: pedsSpread
  else if ( mon_ == sistrip::PEDESTALS_SPREAD ) { 
    value[0][0] = anal->pedsSpread()[0];
    value[1][0] = anal->pedsSpread()[1]; 
  } 

  // Per APV information: pedsMax
  else if ( mon_ == sistrip::PEDESTALS_MAX ) { 
    value[0][0] = anal->pedsMax()[0]; 
    value[1][0] = anal->pedsMax()[1];
  } 

  // Per APV information: pedsMin
  else if ( mon_ == sistrip::PEDESTALS_MIN ) { 
    value[0][0] = anal->pedsMin()[0]; 
    value[1][0] = anal->pedsMin()[1]; 
  } 

  // Per APV information: noiseMean
  else if ( mon_ == sistrip::NOISE_MEAN ) {
    value[0][0] = anal->noiseMean()[0];
    value[1][0] = anal->noiseMean()[1];
  } 
  // Per APV information: noiseSpread
  else if ( mon_ == sistrip::NOISE_SPREAD ) { 
    value[0][0] = anal->noiseSpread()[0]; 
    value[1][0] = anal->noiseSpread()[1];
  } 
  // Per APV information: noiseMax
  else if ( mon_ == sistrip::NOISE_MAX ) { 
    value[0][0] = anal->noiseMax()[0]; 
    value[1][0] = anal->noiseMax()[1]; 
  } 
  // Per APV information: noiseMin
  else if ( mon_ == sistrip::NOISE_MIN ) { 
    value[0][0] = anal->noiseMin()[0]; 
    value[1][0] = anal->noiseMin()[1]; 
  }
  
  // BAD channels per APV  
  else if ( mon_ == sistrip::NUM_OF_DEAD ) { 
    value[0][0] = 1. * anal->deadStrip()[0].size(); 
    value[1][0] = 1. * anal->deadStrip()[1].size();
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD ) { 
    value[0][0] = 1. * anal->badStrip()[0].size(); 
    value[1][0] = 1. * anal->badStrip()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_SHIFTED) { 
    value[0][0] = 1. * anal->shiftedStrip()[0].size(); 
    value[1][0] = 1. * anal->shiftedStrip()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_LOW_NOISE) { 
    value[0][0] = 1. * anal->lowNoiseStrip()[0].size(); 
    value[1][0] = 1. * anal->lowNoiseStrip()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_LARGE_NOISE) { 
    value[0][0] = 1. * anal->largeNoiseStrip()[0].size(); 
    value[1][0] = 1. * anal->largeNoiseStrip()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_LARGE_SIGNIF) { 
    value[0][0] = 1. * anal->largeNoiseSignificance()[0].size(); 
    value[1][0] = 1. * anal->largeNoiseSignificance()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_FIT_STATUS) { 
    value[0][0] = 1. * anal->badFitStatus()[0].size(); 
    value[1][0] = 1. * anal->badFitStatus()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_AD_PROBAB) { 
    value[0][0] = 1. * anal->badADProbab()[0].size(); 
    value[1][0] = 1. * anal->badADProbab()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_KS_PROBAB) { 
    value[0][0] = 1. * anal->badKSProbab()[0].size(); 
    value[1][0] = 1. * anal->badKSProbab()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_JB_PROBAB) { 
    value[0][0] = 1. * anal->badJBProbab()[0].size(); 
    value[1][0] = 1. * anal->badJBProbab()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_CHI2_PROBAB) { 
    value[0][0] = 1. * anal->badChi2Probab()[0].size(); 
    value[1][0] = 1. * anal->badChi2Probab()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_TAIL) { 
    value[0][0] = 1. * anal->badTailStrip()[0].size(); 
    value[1][0] = 1. * anal->badTailStrip()[1].size();    
  } 
  else if ( mon_ == sistrip::NUM_OF_BAD_DOUBLE_PEAK) { 
    value[0][0] = 1. * anal->badDoublePeakStrip()[0].size(); 
    value[1][0] = 1. * anal->badDoublePeakStrip()[1].size();    
  }   
  else { 
    edm::LogWarning(mlSummaryPlots_)
      << "[SummaryPlotFactory::" << __func__ << "]" 
      << " Unexpected monitorable: "
      << SiStripEnumsAndStrings::monitorable( SummaryPlotFactoryBase::mon_ );
    return; 
  }
   
  if ( !all_strips ) {
    
    SummaryPlotFactoryBase::generator_->fillMap( SummaryPlotFactoryBase::level_, 
                         SummaryPlotFactoryBase::gran_, 
                         iter->first, 
                         value[0][0] );
    
    SummaryPlotFactoryBase::generator_->fillMap( SummaryPlotFactoryBase::level_, 
                         SummaryPlotFactoryBase::gran_, 
                         iter->first, 
                         value[1][0] );

  } 
  else {

    for ( uint16_t istr = 0; istr < value[0].size(); istr++ ) {
      SummaryPlotFactoryBase::generator_->fillMap( SummaryPlotFactoryBase::level_, 
                           SummaryPlotFactoryBase::gran_, 
                           iter->first, 
                           value[0][istr] );
    } 

    for ( uint16_t istr = 0; istr < value[1].size(); istr++ ) {
      SummaryPlotFactoryBase::generator_->fillMap( SummaryPlotFactoryBase::level_, 
                           SummaryPlotFactoryBase::gran_, 
                           iter->first, 
                           value[1][istr] );
    }
  }
}

// -----------------------------------------------------------------------------
//
void PedsFullNoiseSummaryFactory::format() {
  
  if ( mon_ == sistrip::PEDESTALS_ALL_STRIPS ) {
    generator_->axisLabel( "Pedestal value [adc]" );
  }
  else if ( mon_ == sistrip::PEDESTALS_MEAN ) {
  } 
  else if ( mon_ == sistrip::PEDESTALS_SPREAD ) { 
  } 
  else if ( mon_ == sistrip::PEDESTALS_MAX ) { 
  } 
  else if ( mon_ == sistrip::PEDESTALS_MIN ) { 
  } 
  else if ( mon_ == sistrip::NOISE_ALL_STRIPS ) {
    generator_->axisLabel( "Noise [adc]" );
  } 
  else if ( mon_ == sistrip::NOISE_MEAN ) {
  } 
  else if ( mon_ == sistrip::NOISE_SPREAD ) { 
  } 
  else if ( mon_ == sistrip::NOISE_MAX ) { 
  } 
  else if ( mon_ == sistrip::NOISE_MIN ) { 
  }
  else if( mon_ == sistrip::AD_PROBAB_ALL_STRIPS) {
    generator_->axisLabel("Anderson-Darling p-value" );    
  }
  else if( mon_ == sistrip::KS_PROBAB_ALL_STRIPS) {
    generator_->axisLabel("Kolmogorov-Smirnov p-value" );    
  }
  else if( mon_ == sistrip::JB_PROBAB_ALL_STRIPS) {
    generator_->axisLabel("Jacque-Bera p-value" );    
  }
  else if( mon_ == sistrip::CHI2_PROBAB_ALL_STRIPS) {
    generator_->axisLabel("Chi2 p-value" );    
  }
  else if( mon_ == sistrip::RESIDUAL_RMS_ALL_STRIPS) {
    generator_->axisLabel("Residual RMS [adc]" );    
  }
  else if( mon_ == sistrip::RESIDUAL_GAUS_ALL_STRIPS) {
    generator_->axisLabel("Residual Gaus [adc]" );    
  }
  else if( mon_ == sistrip::NOISE_SIGNIFICANCE_ALL_STRIPS) {
    generator_->axisLabel("Noise Significance" );    
  }
  else if( mon_ == sistrip::RESIDUAL_MEAN_ALL_STRIPS) {
    generator_->axisLabel("Residual Mean [adc]" );    
  }
  else if( mon_ == sistrip::RESIDUAL_SKEWNESS_ALL_STRIPS) {
    generator_->axisLabel("Residual Skewness [adc]" );    
  }
  else if( mon_ == sistrip::RESIDUAL_KURTOSIS_ALL_STRIPS) {
    generator_->axisLabel("Residual Kurtosis [adc]" );    
  }
  else if( mon_ == sistrip::RESIDUAL_INTEGRALNSIGMA_ALL_STRIPS) {
    generator_->axisLabel("Residual Integral at N sigma" );    
  }
  else if( mon_ == sistrip::RESIDUAL_INTEGRAL_ALL_STRIPS) {
    generator_->axisLabel("Residual Integral" );    
  }
  else if( mon_ == sistrip::BAD_STRIP_BIT_ALL_STRIPS) {
    generator_->axisLabel("Bad Strip Bit" );    
  }
  else if( mon_ == sistrip::DEAD_STRIP_BIT_ALL_STRIPS) {
    generator_->axisLabel("Dead Strip Bit" );    
  }
  else if( mon_ == sistrip::NUM_OF_DEAD) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_SHIFTED) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_LOW_NOISE) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_LARGE_NOISE) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_LARGE_SIGNIF) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_FIT_STATUS) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_AD_PROBAB) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_KS_PROBAB) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_JB_PROBAB) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_CHI2_PROBAB) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_TAIL) {
  }
  else if( mon_ == sistrip::NUM_OF_BAD_DOUBLE_PEAK) {
  }

  else { 
    edm::LogWarning(mlSummaryPlots_)
      << "[SummaryPlotFactory::" << __func__ << "]" 
      << " Unexpected SummaryHisto value:"
      << SiStripEnumsAndStrings::monitorable( SummaryPlotFactoryBase::mon_ );
  } 

}