PedsOnlyAlgorithm Class Reference

Histogram-based analysis for pedestal run. More...

#include <PedsOnlyAlgorithm.h>

Inheritance diagram for PedsOnlyAlgorithm:

Public Member Functions
const Histo &	hNoise () const
const Histo &	hPeds () const
	PedsOnlyAlgorithm (const edm::ParameterSet &pset, PedsOnlyAnalysis *const)
	~PedsOnlyAlgorithm () override
Public Member Functions inherited from CommissioningAlgorithm
void	analysis (const std::vector< TH1 * > &)
	CommissioningAlgorithm (CommissioningAnalysis *const)
	CommissioningAlgorithm ()
virtual	~CommissioningAlgorithm ()

Private Member Functions
void	analyse () override
void	extract (const std::vector< TH1 * > &) override
	PedsOnlyAlgorithm ()

Private Attributes
Histo	hNoise_
Histo	hPeds_

Additional Inherited Members
Public Types inherited from CommissioningAlgorithm
typedef std::pair< TH1 *, std::string >	Histo
Protected Member Functions inherited from CommissioningAlgorithm
CommissioningAnalysis *const	anal () const
uint32_t	extractFedKey (const TH1 *const)

Detailed Description

Histogram-based analysis for pedestal run.

Author

M. Wingham, R.Bainbridge

Definition at line 16 of file PedsOnlyAlgorithm.h.

Constructor & Destructor Documentation

PedsOnlyAlgorithm::PedsOnlyAlgorithm	(	const edm::ParameterSet &	pset,
		PedsOnlyAnalysis * const	anal
	)

Definition at line 16 of file PedsOnlyAlgorithm.cc.

    : CommissioningAlgorithm(anal), hPeds_(nullptr, ""), hNoise_(nullptr, "") {}

PedsOnlyAlgorithm::~PedsOnlyAlgorithm ( )

inlineoverride

Definition at line 20 of file PedsOnlyAlgorithm.h.

{ ; }

PedsOnlyAlgorithm::PedsOnlyAlgorithm ( )

inlineprivate

Definition at line 27 of file PedsOnlyAlgorithm.h.

{ ; }

Member Function Documentation

void PedsOnlyAlgorithm::analyse ( )

overrideprivatevirtual

Performs histogram anaysis.

Implements CommissioningAlgorithm.

Definition at line 77 of file PedsOnlyAlgorithm.cc.

References CommissioningAnalysis::addErrorCode(), CommissioningAlgorithm::anal(), hNoise_, hPeds_, sistrip::invalid_, PedsOnlyAnalysis::legacy_, sistrip::maximum_, sistrip::mlCommissioning_, sistrip::nullPtr_, sistrip::numberOfBins_, PedsOnlyAnalysis::peds_, PedsOnlyAnalysis::pedsMax_, PedsOnlyAnalysis::pedsMean_, PedsOnlyAnalysis::pedsMin_, PedsOnlyAnalysis::pedsSpread_, PedsOnlyAnalysis::raw_, PedsOnlyAnalysis::rawMax_, PedsOnlyAnalysis::rawMean_, PedsOnlyAnalysis::rawMin_, PedsOnlyAnalysis::rawSpread_, mathSSE::sqrt(), digitizers_cfi::strip, and createJobs::tmp.

                                {
  if (!anal()) {
    edm::LogWarning(mlCommissioning_) << "[PedsOnlyAlgorithm::" << __func__ << "]"
                                      << " NULL pointer to base Analysis object!";
    return;
  }

  CommissioningAnalysis* tmp = const_cast<CommissioningAnalysis*>(anal());
  PedsOnlyAnalysis* anal = dynamic_cast<PedsOnlyAnalysis*>(tmp);
  if (!anal) {
    edm::LogWarning(mlCommissioning_) << "[PedsOnlyAlgorithm::" << __func__ << "]"
                                      << " NULL pointer to derived Analysis object!";
    return;
  }

  if (!hPeds_.first) {
    anal->addErrorCode(sistrip::nullPtr_);
    return;
  }

  if (!hNoise_.first) {
    anal->addErrorCode(sistrip::nullPtr_);
    return;
  }

  TProfile* peds_histo = dynamic_cast<TProfile*>(hPeds_.first);
  TProfile* raw_histo = dynamic_cast<TProfile*>(hNoise_.first);

  if (!peds_histo) {
    anal->addErrorCode(sistrip::nullPtr_);
    return;
  }

  if (!raw_histo) {
    anal->addErrorCode(sistrip::nullPtr_);
    return;
  }

  if (peds_histo->GetNbinsX() != 256) {
    anal->addErrorCode(sistrip::numberOfBins_);
    return;
  }

  if (raw_histo->GetNbinsX() != 256) {
    anal->addErrorCode(sistrip::numberOfBins_);
    return;
  }

  // Iterate through APVs
  for (uint16_t iapv = 0; iapv < 2; iapv++) {
    // Used to calc mean and rms for peds and noise
    float p_sum = 0., p_sum2 = 0., p_max = -1. * sistrip::invalid_, p_min = sistrip::invalid_;
    float r_sum = 0., r_sum2 = 0., r_max = -1. * sistrip::invalid_, r_min = sistrip::invalid_;

    // Iterate through strips of APV
    for (uint16_t istr = 0; istr < 128; istr++) {
      uint16_t strip = iapv * 128 + istr;

      // Pedestals
      if (peds_histo) {
        if (peds_histo->GetBinEntries(strip + 1)) {
          anal->peds_[iapv][istr] = peds_histo->GetBinContent(strip + 1);
          p_sum += anal->peds_[iapv][istr];
          p_sum2 += (anal->peds_[iapv][istr] * anal->peds_[iapv][istr]);
          if (anal->peds_[iapv][istr] > p_max) {
            p_max = anal->peds_[iapv][istr];
          }
          if (anal->peds_[iapv][istr] < p_min) {
            p_min = anal->peds_[iapv][istr];
          }
        }
      }

      // Raw noise
      if (!anal->legacy_) {
        if (raw_histo) {
          if (raw_histo->GetBinEntries(strip + 1)) {
            anal->raw_[iapv][istr] = raw_histo->GetBinContent(strip + 1);
            r_sum += anal->raw_[iapv][istr];
            r_sum2 += (anal->raw_[iapv][istr] * anal->raw_[iapv][istr]);
            if (anal->raw_[iapv][istr] > r_max) {
              r_max = anal->raw_[iapv][istr];
            }
            if (anal->raw_[iapv][istr] < r_min) {
              r_min = anal->raw_[iapv][istr];
            }
          }
        }
      } else {
        if (peds_histo) {
          if (peds_histo->GetBinEntries(strip + 1)) {
            anal->raw_[iapv][istr] = raw_histo->GetBinError(strip + 1);
            r_sum += anal->raw_[iapv][istr];
            r_sum2 += (anal->raw_[iapv][istr] * anal->raw_[iapv][istr]);
            if (anal->raw_[iapv][istr] > r_max) {
              r_max = anal->raw_[iapv][istr];
            }
            if (anal->raw_[iapv][istr] < r_min) {
              r_min = anal->raw_[iapv][istr];
            }
          }
        }
      }

    }  // strip loop

    // Calc mean and rms for peds
    if (!anal->peds_[iapv].empty()) {
      p_sum /= static_cast<float>(anal->peds_[iapv].size());
      p_sum2 /= static_cast<float>(anal->peds_[iapv].size());
      anal->pedsMean_[iapv] = p_sum;
      anal->pedsSpread_[iapv] = sqrt(fabs(p_sum2 - p_sum * p_sum));
    }

    // Calc mean and rms for raw noise
    if (!anal->raw_[iapv].empty()) {
      r_sum /= static_cast<float>(anal->raw_[iapv].size());
      r_sum2 /= static_cast<float>(anal->raw_[iapv].size());
      anal->rawMean_[iapv] = r_sum;
      anal->rawSpread_[iapv] = sqrt(fabs(r_sum2 - r_sum * r_sum));
    }

    // Set max and min values for peds and raw noise
    if (p_max > -1. * sistrip::maximum_) {
      anal->pedsMax_[iapv] = p_max;
    }
    if (p_min < 1. * sistrip::maximum_) {
      anal->pedsMin_[iapv] = p_min;
    }
    if (r_max > -1. * sistrip::maximum_) {
      anal->rawMax_[iapv] = r_max;
    }
    if (r_min < 1. * sistrip::maximum_) {
      anal->rawMin_[iapv] = r_min;
    }

  }  // apv loop
}

void PedsOnlyAlgorithm::extract ( const std::vector< TH1 * > &  histos )

overrideprivatevirtual

Extracts and organises histograms.

Implements CommissioningAlgorithm.

Definition at line 21 of file PedsOnlyAlgorithm.cc.

References a, CommissioningAnalysis::addErrorCode(), CommissioningAlgorithm::anal(), CommissioningAlgorithm::extractFedKey(), CommissioningAnalysis::fedKey(), hNoise_, hPeds_, PedsOnlyAnalysis::legacy_, sistrip::mlCommissioning_, sistrip::numberOfHistos_, sistrip::extrainfo::pedestals_, sistrip::PEDS_ONLY, sistrip::extrainfo::pedsAndRawNoise_, sistrip::extrainfo::rawNoise_, runGCPTkAlMap::title, sistrip::unexpectedExtraInfo_, and sistrip::unexpectedTask_.

Referenced by BeautifulSoup.PageElement::_invert(), and BeautifulSoup.Tag::decompose().

                                                             {
  if (!anal()) {
    edm::LogWarning(mlCommissioning_) << "[PedsOnlyAlgorithm::" << __func__ << "]"
                                      << " NULL pointer to Analysis object!";
    return;
  }

  // Check number of histograms
  if (histos.size() != 2) {
    anal()->addErrorCode(sistrip::numberOfHistos_);
  }

  // Extract FED key from histo title
  if (!histos.empty()) {
    anal()->fedKey(extractFedKey(histos.front()));
  }

  // Extract histograms
  std::vector<TH1*>::const_iterator ihis = histos.begin();
  for (; ihis != histos.end(); ihis++) {
    // Check for NULL pointer
    if (!(*ihis)) {
      continue;
    }

    // Check run type
    SiStripHistoTitle title((*ihis)->GetName());
    if (title.runType() != sistrip::PEDS_ONLY) {
      anal()->addErrorCode(sistrip::unexpectedTask_);
      continue;
    }

    // Extract peds and raw noise histos (check for legacy names first!)
    if (title.extraInfo().find(sistrip::extrainfo::pedsAndRawNoise_) != std::string::npos) {
      hPeds_.first = *ihis;
      hPeds_.second = (*ihis)->GetName();
      hNoise_.first = *ihis;
      hNoise_.second = (*ihis)->GetName();
      PedsOnlyAnalysis* a = dynamic_cast<PedsOnlyAnalysis*>(const_cast<CommissioningAnalysis*>(anal()));
      if (a) {
        a->legacy_ = true;
      }
    } else if (title.extraInfo().find(sistrip::extrainfo::pedestals_) != std::string::npos) {
      hPeds_.first = *ihis;
      hPeds_.second = (*ihis)->GetName();
    } else if (title.extraInfo().find(sistrip::extrainfo::rawNoise_) != std::string::npos) {
      hNoise_.first = *ihis;
      hNoise_.second = (*ihis)->GetName();
    } else {
      anal()->addErrorCode(sistrip::unexpectedExtraInfo_);
    }
  }
}

const PedsOnlyAlgorithm::Histo & PedsOnlyAlgorithm::hNoise ( ) const

inline

Definition at line 45 of file PedsOnlyAlgorithm.h.

References hNoise_.

{ return hNoise_; }

const PedsOnlyAlgorithm::Histo & PedsOnlyAlgorithm::hPeds ( ) const

inline

Definition at line 43 of file PedsOnlyAlgorithm.h.

References hPeds_.

{ return hPeds_; }

Member Data Documentation

Histo PedsOnlyAlgorithm::hNoise_

private

Residuals and noise

Definition at line 40 of file PedsOnlyAlgorithm.h.

Referenced by analyse(), extract(), and hNoise().

Histo PedsOnlyAlgorithm::hPeds_

private

Pedestals and raw noise

Definition at line 37 of file PedsOnlyAlgorithm.h.

Referenced by analyse(), extract(), and hPeds().