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";
  }  // namespace h

  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.icc"

  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.empty())
        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 == h::names[i]) {
          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 override { return fedId; }
    const std::string getPath() const override { 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 override {
      return processName(p_title, 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 override { return dduId; }
    const std::string getPath() const override { 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 override {
      return processName(p_title, 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 override { return crateId; }
    const HwId getDMBId() const override { return dmbId; }
    const HwId getAddId() const override { return addId; }
    const std::string getName() const override { return processName(getHistoName(), getAddId()); }
    const std::string getPath() const override { 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 override {
      return processName(p_title, 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);

}  // namespace cscdqm

#endif