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_TotemRawToDigi_CounterChecker
#define EventFilter_TotemRawToDigi_CounterChecker

#include <map>
#include <string>
#include <vector>
#include <iostream>

#include "CondFormats/TotemReadoutObjects/interface/TotemFramePosition.h"

#include "DataFormats/TotemDigi/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