CSCDQM_HistoDef.h

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  HistoDef.h
 *
 *    Description:  Histo Type Classes that are being used by EventProcessor
 *    to request histograms. 
 *
 *        Version:  1.0
 *        Created:  10/03/2008 11:54:31 AM
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Valdas Rapsevicius (VR), Valdas.Rapsevicius@cern.ch
 *        Company:  CERN, CH
 *
 * =====================================================================================
 */

#ifndef CSCDQM_HistoDef_H
#define CSCDQM_HistoDef_H 

#include <string>
#include <iostream>  

#include "CSCDQM_Utility.h"
#include "CSCDQM_Logger.h"

namespace cscdqm {

  typedef std::string HistoName; 

  typedef unsigned int HistoId; 

  typedef unsigned int HwId; 

  namespace h {
    const HistoName HISTO_SKIP = "0";
  }
  
  static const char PATH_FED[]     = "FED_%03d";

  static const char PATH_DDU[]     = "DDU_%02d";

  static const char PATH_CSC[]     = "CSC_%03d_%02d";

  static const TPRegexp REGEXP_ONDEMAND("^.*%d.*$");

  #include "CSCDQM_HistoNames.h"

  class HistoDef {

    private:

      HistoId id;

    public:

      HistoDef(const HistoId p_id) : id(p_id) { }
      
      virtual ~HistoDef() { }

      const HistoId getId() const { return id; }

      const HistoName&  getHistoName() const { return h::names[id]; }

      virtual const std::string getName() const { return getHistoName(); }

      const std::string getFullPath() const {
        std::string path(getPath());
        if (path.size() > 0) path.append("/");
        path.append(getName());
        return path;
      }

      const bool operator== (const HistoDef& t) const {
        if (getId()      != t.getId())      return false;
        if (getFEDId()   != t.getFEDId())   return false;
        if (getDDUId()   != t.getDDUId())   return false;
        if (getCrateId() != t.getCrateId()) return false;
        if (getDMBId()   != t.getDMBId())   return false;
        if (getAddId()   != t.getAddId())   return false;
        return true;
      }

      const HistoDef& operator= (const HistoDef& t) {
        id  = t.getId();
        return *this;
      }

      const bool operator< (const HistoDef& t) const {
        if (getId()      < t.getId())       return true; 
        if (getFEDId()   < t.getFEDId())    return true;
        if (getDDUId()   < t.getDDUId())    return true;
        if (getCrateId() < t.getCrateId())  return true;
        if (getDMBId()   < t.getDMBId())    return true;
        if (getAddId()   < t.getAddId())    return true;
        return false;
      }

      friend std::ostream& operator<<(std::ostream& out, const HistoDef& t) {
        return out << t.getFullPath();
      }

      virtual const std::string getPath() const { return ""; }

      virtual const HwId getCrateId() const { return  0; }

      virtual const HwId getDMBId() const { return  0; }

      virtual const HwId getAddId() const { return  0; }

      virtual const HwId getFEDId() const { return  0; }

      virtual const HwId getDDUId() const { return  0; }

      virtual const std::string processTitle(const std::string& p_title) const {
        return p_title;
      }

      static const bool getHistoIdByName(const std::string& p_name, HistoId& p_id) {
        for (HistoId i = 0; i < h::namesSize; i++) {
          if (p_name.compare(h::names[i]) == 0) {
            p_id = i;
            return true;
          }
        }
        return false;
      }

      static const std::string getHistoKeyById(const HistoId& p_id) {
        return h::keys[p_id];
      }

      static const std::string processName(const HistoName& p_name, const HwId p_id) {
        if (Utility::regexMatch(REGEXP_ONDEMAND, p_name)) {
          return Form(p_name.c_str(), p_id);
        }
        return p_name;
      }

  };

  class EMUHistoDef : public HistoDef {

    public:

      EMUHistoDef(const HistoId p_id) : HistoDef(p_id) { }

  };

  class FEDHistoDef : public HistoDef {
      
    private:
      
      HwId fedId;

    public:

      FEDHistoDef(const HistoId p_id, const HwId p_fedId) : HistoDef(p_id), fedId(p_fedId) { }
      const HwId getFEDId() const { return fedId; }
      const std::string getPath() const { return getPath(fedId); }

      static const std::string getPath(const HwId p_fedId) {
        return Form(PATH_FED, p_fedId);
      } 
      
      const FEDHistoDef& operator= (const FEDHistoDef& t) {
        HistoDef *h1 = const_cast<FEDHistoDef*>(this);
        const HistoDef *h2 = &t;
        *h1 = *h2;
        fedId   = t.getFEDId();
        return *this;
      }

      const std::string processTitle(const std::string& p_title) const {
        return processName(p_title.c_str(), getFEDId());
      }
        
  };      

  class DDUHistoDef : public HistoDef {

    private:

      HwId dduId;

    public:

      DDUHistoDef(const HistoId p_id, const HwId p_dduId) : HistoDef(p_id), dduId(p_dduId) { }
      const HwId getDDUId() const { return dduId; }
      const std::string getPath() const { return getPath(dduId); }

      static const std::string getPath(const HwId p_dduId) { 
        return Form(PATH_DDU, p_dduId); 
      }

      const DDUHistoDef& operator= (const DDUHistoDef& t) {
        HistoDef *h1 = const_cast<DDUHistoDef*>(this);
        const HistoDef *h2 = &t;
        *h1 = *h2;
        dduId   = t.getDDUId();
        return *this;
      }

      const std::string processTitle(const std::string& p_title) const {
        return processName(p_title.c_str(), getDDUId());
      }

  };

  class CSCHistoDef : public HistoDef {

    private:

      HwId crateId;
      HwId dmbId;
      HwId addId;

    public:

      CSCHistoDef(const HistoId p_id, const HwId p_crateId, const HwId p_dmbId, const HwId p_addId = 0) : 
        HistoDef(p_id), crateId(p_crateId), dmbId(p_dmbId), addId(p_addId) { }

      const HwId getCrateId() const { return crateId; }
      const HwId getDMBId()   const { return dmbId; }
      const HwId getAddId()   const { return addId; }
      const std::string getName() const { return processName(getHistoName(), getAddId()); }
      const std::string getPath() const { return getPath(crateId, dmbId); }

      static const std::string getPath(const HwId p_crateId, const HwId p_dmbId) { 
        return Form(PATH_CSC, p_crateId, p_dmbId); 
      }

      const CSCHistoDef& operator= (const CSCHistoDef& t) {
        HistoDef *h1 = const_cast<CSCHistoDef*>(this);
        const HistoDef *h2 = &t;
        *h1 = *h2;
        crateId = t.getCrateId();
        dmbId   = t.getDMBId();
        addId   = t.getAddId();
        return *this;
      }

      const std::string processTitle(const std::string& p_title) const {
        return processName(p_title.c_str(), getAddId());
      }


  };

  class ParHistoDef : public HistoDef {

    private:

      HistoName name;


    public:

      ParHistoDef(const HistoName& p_name) : HistoDef(Utility::fastHash(p_name.c_str())), name(p_name) { }

      ParHistoDef(const HistoId p_id) : HistoDef(p_id) {
        name = HistoDef::getHistoName();
      }

      const HistoName&  getHistoName() const { return name; }

  };

  static const std::type_info& EMUHistoDefT = typeid(cscdqm::EMUHistoDef);
  static const std::type_info& FEDHistoDefT = typeid(cscdqm::FEDHistoDef);
  static const std::type_info& DDUHistoDefT = typeid(cscdqm::DDUHistoDef);
  static const std::type_info& CSCHistoDefT = typeid(cscdqm::CSCHistoDef);
  static const std::type_info& ParHistoDefT = typeid(cscdqm::ParHistoDef);

}

#endif