DBReaderWorkers.h

Go to the documentation of this file.

#ifndef DBReaderWorkers_H
#define DBReaderWorkers_H
 
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
#include "OnlineDB/EcalCondDB/interface/EcalCondDBInterface.h"
#include "OnlineDB/EcalCondDB/interface/MonRunIOV.h"
 
#include "DataFormats/DetId/interface/DetId.h"
 
#include <map>
 
namespace ecaldqm {
  class DBReaderWorker {
  public:
    DBReaderWorker(std::string const &_name, edm::ParameterSet const &) : name_(_name), verbosity_(0) {}
    virtual ~DBReaderWorker() {}
 
    virtual std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) = 0;
 
    void setVerbosity(int _v) { verbosity_ = _v; }
 
    std::string const &getName() const { return name_; }
 
  protected:
    std::string const name_;
    int verbosity_;
  };
 
  class CrystalConsistencyReader : public DBReaderWorker {
  public:
    CrystalConsistencyReader(edm::ParameterSet const &_ps) : DBReaderWorker("CrystalConsistencyReader", _ps) {}
    ~CrystalConsistencyReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TTConsistencyReader : public DBReaderWorker {
  public:
    TTConsistencyReader(edm::ParameterSet const &_ps) : DBReaderWorker("TTConsistencyReader", _ps) {}
    ~TTConsistencyReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class MemChConsistencyReader : public DBReaderWorker {
  public:
    MemChConsistencyReader(edm::ParameterSet const &_ps) : DBReaderWorker("MemChConsistencyReader", _ps) {}
    ~MemChConsistencyReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class MemTTConsistencyReader : public DBReaderWorker {
  public:
    MemTTConsistencyReader(edm::ParameterSet const &_ps) : DBReaderWorker("MemTTConsistencyReader", _ps) {}
    ~MemTTConsistencyReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class LaserBlueReader : public DBReaderWorker {
  public:
    LaserBlueReader(edm::ParameterSet const &_ps) : DBReaderWorker("LaserBlueReader", _ps) {}
    ~LaserBlueReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingLaserBlueCrystalReader : public DBReaderWorker {
  public:
    TimingLaserBlueCrystalReader(edm::ParameterSet const &_ps) : DBReaderWorker("TimingLaserBlueCrystalReader", _ps) {}
    ~TimingLaserBlueCrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PNBlueReader : public DBReaderWorker {
  public:
    PNBlueReader(edm::ParameterSet const &_ps) : DBReaderWorker("PNBlueReader", _ps) {}
    ~PNBlueReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class LaserGreenReader : public DBReaderWorker {
  public:
    LaserGreenReader(edm::ParameterSet const &_ps) : DBReaderWorker("LaserGreenReader", _ps) {}
    ~LaserGreenReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingLaserGreenCrystalReader : public DBReaderWorker {
  public:
    TimingLaserGreenCrystalReader(edm::ParameterSet const &_ps)
        : DBReaderWorker("TimingLaserGreenCrystalReader", _ps) {}
    ~TimingLaserGreenCrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PNGreenReader : public DBReaderWorker {
  public:
    PNGreenReader(edm::ParameterSet const &_ps) : DBReaderWorker("PNGreenReader", _ps) {}
    ~PNGreenReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class LaserIRedReader : public DBReaderWorker {
  public:
    LaserIRedReader(edm::ParameterSet const &_ps) : DBReaderWorker("LaserIRedReader", _ps) {}
    ~LaserIRedReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingLaserIRedCrystalReader : public DBReaderWorker {
  public:
    TimingLaserIRedCrystalReader(edm::ParameterSet const &_ps) : DBReaderWorker("TimingLaserIRedCrystalReader", _ps) {}
    ~TimingLaserIRedCrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PNIRedReader : public DBReaderWorker {
  public:
    PNIRedReader(edm::ParameterSet const &_ps) : DBReaderWorker("PNIRedReader", _ps) {}
    ~PNIRedReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class LaserRedReader : public DBReaderWorker {
  public:
    LaserRedReader(edm::ParameterSet const &_ps) : DBReaderWorker("LaserRedReader", _ps) {}
    ~LaserRedReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingLaserRedCrystalReader : public DBReaderWorker {
  public:
    TimingLaserRedCrystalReader(edm::ParameterSet const &_ps) : DBReaderWorker("TimingLaserRedCrystalReader", _ps) {}
    ~TimingLaserRedCrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PNRedReader : public DBReaderWorker {
  public:
    PNRedReader(edm::ParameterSet const &_ps) : DBReaderWorker("PNRedReader", _ps) {}
    ~PNRedReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PedestalsReader : public DBReaderWorker {
  public:
    PedestalsReader(edm::ParameterSet const &_ps) : DBReaderWorker("PedestalsReader", _ps) {}
    ~PedestalsReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PNPedReader : public DBReaderWorker {
  public:
    PNPedReader(edm::ParameterSet const &_ps) : DBReaderWorker("PNPedReader", _ps) {}
    ~PNPedReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PedestalsOnlineReader : public DBReaderWorker {
  public:
    PedestalsOnlineReader(edm::ParameterSet const &_ps) : DBReaderWorker("PedestalsOnlineReader", _ps) {}
    ~PedestalsOnlineReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TestPulseReader : public DBReaderWorker {
  public:
    TestPulseReader(edm::ParameterSet const &_ps) : DBReaderWorker("TestPulseReader", _ps) {}
    ~TestPulseReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PulseShapeReader : public DBReaderWorker {
  public:
    PulseShapeReader(edm::ParameterSet const &_ps) : DBReaderWorker("PulseShapeReader", _ps) {}
    ~PulseShapeReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class PNMGPAReader : public DBReaderWorker {
  public:
    PNMGPAReader(edm::ParameterSet const &_ps) : DBReaderWorker("PNMGPAReader", _ps) {}
    ~PNMGPAReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingCrystalReader : public DBReaderWorker {
  public:
    TimingCrystalReader(edm::ParameterSet const &_ps) : DBReaderWorker("TimingCrystalReader", _ps) {}
    ~TimingCrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class Led1Reader : public DBReaderWorker {
  public:
    Led1Reader(edm::ParameterSet const &_ps) : DBReaderWorker("Led1Reader", _ps) {}
    ~Led1Reader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingLed1CrystalReader : public DBReaderWorker {
  public:
    TimingLed1CrystalReader(edm::ParameterSet const &_ps) : DBReaderWorker("TimingLed1CrystalReader", _ps) {}
    ~TimingLed1CrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class Led2Reader : public DBReaderWorker {
  public:
    Led2Reader(edm::ParameterSet const &_ps) : DBReaderWorker("Led2Reader", _ps) {}
    ~Led2Reader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class TimingLed2CrystalReader : public DBReaderWorker {
  public:
    TimingLed2CrystalReader(edm::ParameterSet const &_ps) : DBReaderWorker("TimingLed2CrystalReader", _ps) {}
    ~TimingLed2CrystalReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
 
  class OccupancyReader : public DBReaderWorker {
  public:
    OccupancyReader(edm::ParameterSet const &_ps) : DBReaderWorker("OccupancyReader", _ps) {}
    ~OccupancyReader() override {}
 
    std::map<DetId, double> run(EcalCondDBInterface *, MonRunIOV &, std::string const &) override;
  };
}  // namespace ecaldqm
 
#endif