AlgCaddy.h

Go to the documentation of this file.

#ifndef ANP_ALGDATA_H
#define ANP_ALGDATA_H

//
// A class that stores algorithm smart pointer
// along with count of passed/failed number of events and snarls.
// Template parameter T has to inherit from Base class to allow
// smart pointer symantics.
//

// C++
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>

// Local
#include "Handle.h"
#include "Record.h"

namespace Anp
{
   template<class T>
      class AlgCaddy
   {
   public:
      
      AlgCaddy();
      AlgCaddy(Handle<T> alg_, const std::string &name_);
      ~AlgCaddy();

      void AllEvent(double weight);
      void OutEvent(double weight);

      void AllSnarl(const Record &record);
      void OutSnarl(const Record &record);

      unsigned int Width(unsigned int number) const;

      void Print(unsigned int nw, unsigned int cw, const std::string &opt, std::ostream& o = std::cout) const;

   public:

      Handle<T> alg;

      std::string name;

      unsigned int NSnarlAll;
      unsigned int NSnarlOut;

      unsigned int NEventAll;
      unsigned int NEventOut;

      double WEventAll;
      double WEventOut;
   };
   
   template<class T>
      unsigned int NameWidth(const std::vector<AlgCaddy<T> > &vec)
   {
      unsigned int width = 0;      
      for(typename std::vector<AlgCaddy<T> >::const_iterator it = vec.begin(); it != vec.end(); ++it)
      {
         width = std::max<unsigned int>(width, (it -> name).size());
      }

      return width;
   }

   template<class T>
      unsigned int NumbWidth(const std::vector<AlgCaddy<T> > &vec)
   {
      unsigned int width = 0;      
      for(typename std::vector<AlgCaddy<T> >::const_iterator it = vec.begin(); it != vec.end(); ++it)
      {
         width = std::max<unsigned int>(width, it -> Width(it -> NSnarlAll));
         width = std::max<unsigned int>(width, it -> Width(it -> NSnarlOut));
         width = std::max<unsigned int>(width, it -> Width(it -> NEventAll));
         width = std::max<unsigned int>(width, it -> Width(it -> NEventAll));
         width = std::max<unsigned int>(width, it -> Width(static_cast<unsigned int>(it -> WEventAll)));
         width = std::max<unsigned int>(width, it -> Width(static_cast<unsigned int>(it -> WEventOut)));
      }

      return width;
   }

   //
   // Template function definitions
   //

   template<class T>
      AlgCaddy<T>::AlgCaddy() 
      : alg(0), name(),
      NSnarlAll(0), NSnarlOut(0), NEventAll(0), NEventOut(0), WEventAll(0.0), WEventOut(0.0)
   {
   }

   template<class T>
      AlgCaddy<T>::AlgCaddy(Handle<T> alg_, const std::string &name_) 
      : alg(alg_), name(name_),
      NSnarlAll(0), NSnarlOut(0), NEventAll(0), NEventOut(0), WEventAll(0.0), WEventOut(0.0)
   {
   }

   template<class T>
      AlgCaddy<T>::~AlgCaddy()
   {
   }

   template<class T>
      void AlgCaddy<T>::AllEvent(const double weight)
   {
      ++NEventAll;
      WEventAll += weight;
   }

   template<class T>
      void AlgCaddy<T>::OutEvent(const double weight)
   {
      ++NEventOut;
      WEventOut += weight;
   }

   template<class T>
      void AlgCaddy<T>::AllSnarl(const Record &record)
   {
      ++NSnarlAll;
      for(EventIter ievent = record.EventBeg(); ievent != record.EventEnd(); ++ievent)
      {
         ++NEventAll;
         WEventAll += ievent -> Weight();
      }
   }

   template<class T>
      void AlgCaddy<T>::OutSnarl(const Record &record)
   {
      ++NSnarlOut;
      for(EventIter ievent = record.EventBeg(); ievent != record.EventEnd(); ++ievent)
      {
         ++NEventOut;
         WEventOut += ievent -> Weight();
      }
   }

   template<class T>
      unsigned int AlgCaddy<T>::Width(const unsigned int number) const
   {
      if(number > 0)
      {
         return static_cast<unsigned int>(1 + std::log10(double(number)));
      }

      return 1;
   }

   template<class T>
      void AlgCaddy<T>::Print(unsigned int nw, unsigned int cw, const std::string &opt, std::ostream& o) const
   {
      if(nw < name.size())
      {
         nw = name.size();
      }      
      if(cw < 1)
      {
         cw = std::max<unsigned int>(cw, Width(NSnarlAll));
         cw = std::max<unsigned int>(cw, Width(NSnarlOut));
         cw = std::max<unsigned int>(cw, Width(NEventAll));
         cw = std::max<unsigned int>(cw, Width(NEventOut));
      }

      if(opt.find("snarl") != std::string::npos)
      {
         if(nw > 0)
         {
            o << std::setfill(' ') << std::setw(nw) << std::left << name << " ";
         }

         o << " snarl pass/total = ";
         o << std::setfill(' ') << std::setw(cw) << std::right << NSnarlOut << "/"; 
         o << std::setfill(' ') << std::setw(cw) << std::right << NSnarlAll;
         
         if(NSnarlAll > 0)
         {
            o << " = " << std::setfill(' ') 
                      << std::setprecision(5) << std::showpoint << double(NSnarlOut)/double(NSnarlAll);
         }
         o << std::noshowpoint << std::endl;
      }

      if(opt.find("event") != std::string::npos)
      {
         if(nw > 0)
         {
            o << std::setfill(' ') << std::setw(nw) << std::left << name << " ";
         }
         
         o << " event pass/total = ";
         o << std::setfill(' ') << std::setw(cw) << std::right << NEventOut << "/"; 
         o << std::setfill(' ') << std::setw(cw) << std::right << NEventAll;
         
         if(NEventAll > 0)
         {
            o << " = " << std::setfill(' ') 
                      << std::setprecision(5)  << std::showpoint << double(NEventOut)/double(NEventAll);
         }
         o << std::noshowpoint << std::endl;
      }

      if(opt.find("weight") != std::string::npos)
      {
         if(nw > 0)
         {
            o << std::setfill(' ') << std::setw(nw) << std::left << name << " ";
         }
         
         o << "weight pass/total = "
           << std::setfill(' ') << std::setw(cw) << std::right << static_cast<long int>(WEventOut) << "/"
           << std::setfill(' ') << std::setw(cw) << std::right << static_cast<long int>(WEventAll);
         
         if(WEventAll > 0.0)
         {
            o << " = " << std::setfill(' ') 
              << std::setprecision(5)  << std::showpoint << WEventOut/WEventAll;
         }
         o << std::noshowpoint << std::endl;
      }
   }
}

#endif

---