CounterChecker.h

Go to the documentation of this file.

/****************************************************************************
 *
 * This is a part of the TOTEM offline software.
 * Authors: 
 *   Maciej Wróbel (wroblisko@gmail.com)
 *   Jan Kašpar (jan.kaspar@gmail.com)
 *
 ****************************************************************************/
 
#ifndef EventFilter_CTPPSRawToDigi_CounterChecker
#define EventFilter_CTPPSRawToDigi_CounterChecker
 
#include <map>
#include <string>
#include <vector>
#include <iostream>
 
#include "CondFormats/PPSObjects/interface/TotemFramePosition.h"
 
#include "DataFormats/CTPPSDigi/interface/TotemVFATStatus.h"
 
class CounterChecker {
public:
  typedef unsigned short word;
 
  typedef std::map<word, std::vector<TotemFramePosition> > CounterMap;
 
  enum CheckerType { BCChecker, ECChecker };
 
  CounterChecker(CheckerType _type = CounterChecker::BCChecker,
                 const std::string &_name = "",
                 unsigned int _min = 0,
                 double _fraction = 0.,
                 unsigned int _verbosity = 0)
      : type(_type), name(_name), min(_min), fraction(_fraction), verbosity(_verbosity) {}
 
  void Fill(word counter, TotemFramePosition fr);
 
  template <typename T>
  void Analyze(T &status, bool error, std::ostream &es);
 
private:
  class Comparer {
  public:
    typedef unsigned short word;
    bool operator()(const std::pair<word, std::vector<TotemFramePosition> > &a,
                    const std::pair<word, std::vector<TotemFramePosition> > &b) {
      return a.second.size() < b.second.size();
    }
  };
 
  CounterMap relationMap;
 
  CheckerType type;
 
  std::string name;
 
  unsigned int min;
 
  double fraction;
 
  unsigned int verbosity;
};
 
template <typename T>
void CounterChecker::Analyze(T &status, bool error, std::ostream &es) {
  word mostFrequentCounter = 0;
  word mostFrequentSize = 0;
  unsigned int totalFrames = 0;
 
  // finding the most frequent counter
  for (CounterMap::iterator iter = relationMap.begin(); iter != relationMap.end(); iter++) {
    unsigned int iterSize = iter->second.size();
    totalFrames += iterSize;
 
    if (iterSize > mostFrequentSize) {
      mostFrequentCounter = iter->first;
      mostFrequentSize = iter->second.size();
    }
  }
 
  if (totalFrames < min) {
    if (verbosity > 0)
      es << "Too few frames to determine the most frequent " << name << " value.";
 
    return;
  }
 
  // if there are too few frames with the most frequent value
  if ((float)mostFrequentSize / (float)totalFrames < fraction) {
    if (verbosity > 0)
      es << "The most frequent " << name << " value is doubtful - variance is too high.";
 
    return;
  }
 
  for (CounterMap::iterator iter = relationMap.begin(); iter != relationMap.end(); iter++) {
    if (iter->first != mostFrequentCounter) {
      for (std::vector<TotemFramePosition>::iterator fr = iter->second.begin(); fr != iter->second.end(); fr++) {
        if (error) {
          if (type == ECChecker)
            status[*fr].status.setECProgressError();
          if (type == BCChecker)
            status[*fr].status.setBCProgressError();
        }
 
        if (verbosity > 0)
          es << "Frame at " << *fr << ": " << name << " number " << iter->first
             << " is different from the most frequent one " << mostFrequentCounter << std::endl;
      }
    }
  }
}
 
#endif