QDbCorc.hh

Go to the documentation of this file.

#ifndef _QDBCORC_HH_
#define _QDBCORC_HH_

#include <vector>
#include <map>
#include <string>
#include "QVector.hh"
#include "QMatrix.hh"

namespace Cuore {class QIntervalSet;}

namespace QDbCorc{

  class Reference {

  public:
    
    double GetMin() const {return fMin;}

    double GetMax() const {return fMax;}

    double GetAvg() const {return fAvg;}

    void SetMin(double min) {fMin = min;}
    void SetMax(double max) {fMax = max;}
   void SetAvg(double avg) {fAvg = avg;}

  private:
    
    double fMin;
    double fMax;
    double fAvg;

  };
  
  Reference GetBoloReference(int run, int ch, std::string variable);

  Reference GetBoloBaselineReference(int run, int ch);

  Reference GetBoloBaselineRMSReference(int run, int ch);

  Reference GetBoloBaselineFluctuationReference(int run, int ch);

  Reference GetBoloStabHeaterReference(int run, int ch);

  Reference GetBoloStabHeaterRMSReference(int run, int ch);

  Reference GetBoloNonStabHeaterReference(int run, int ch);

  Reference GetBoloPowerSpectrumReference(int run, int ch);

  Reference GetBoloRateReference(int run, int ch);

  std::map<int,Reference>  GetReference(int run, std::string variable);

  std::map<int,Reference>  GetBaselineReference(int run);

  std::map<int,Reference>  GetBaselineRMSReference(int run);

  std::map<int,Reference>  GetBaselineFluctuationReference(int run);

  std::map<int,Reference>  GetStabHeaterReference(int run);

  std::map<int,Reference>  GetStabHeaterRMSReference(int run);



  std::map<int,Reference>  GetNonStabHeaterReference(int run);

  std::map<int,Reference>  GetPowerSpectrumReference(int run);

  std::map<int,Reference>  GetRateReference(int run);

  Cuore::QMatrix GetQMatrixReference(int run, std::string variable);

  Cuore::QMatrix GetQMatrixMasked(int run);

  int GetIsMasked(int run, int ch);
  std::vector<int>  GetMaskedChannels(int run);
  std::map<int,int>  GetMaskedMap(int run);

  std::map<std::string,std::string>  GetNameMap();

    struct TimeInterval {
        float fStart;
        float fEnd;
    };
    std::vector<TimeInterval> GetRejectedIntervalsSeconds(int run, int channel);

    const Cuore::QIntervalSet& GetRejectedIntervalSet(
        const int run, const int ch);

    double GetLiveTime(const int run, const int ch);

    void ClearSaturatedHigh(const int run, const int ch);
    
    void ClearSaturatedHigh(const int run, const int ch,
                            const std::string& dbOutputFile);
    
    void ClearSaturatedLow(const int run, const int ch);
    
    void ClearSaturatedLow(const int run, const int ch,
                           const std::string& dbOutputFile);
    
    void SetBadInterval(const int run, const int ch,
                        const double startTime, const double stopTime,
                        const std::string status);
    
    void SetSaturatedHigh(const int run, const int ch,
                          const Cuore::QIntervalSet& intervalSet);
    
    void SetSaturatedHigh(const int run, const int ch,
                          const Cuore::QIntervalSet& intervalSet,
                          const std::string& dbOutputFile);
    void SetSaturatedLow(const int run, const int ch,
                          const Cuore::QIntervalSet& intervalSet);
    void SetSaturatedLow(const int run, const int ch,
                         const Cuore::QIntervalSet& intervalSet,
                         const std::string& dbOutputFile);
    
    void SetBoloSummary(const int run, const int ch,
                        const std::string variable, double value);
    
    void SetBoloSummary(const int run, const int ch,
                        const std::string variable, double value,
                        const std::string& dbOutputFile);

         double GetBoloSummary(const int run, const int ch,
                                                                const std::string variable);
         
         double GetRmsStabHeaterAmplitude(const int run, const int ch);
};

#endif

---