DbuFarRunQuality.h

Go to the documentation of this file.

#ifndef DBUFARRUNQUALITY_H
#define DBUFARRUNQUALITY_H

#include "Rtypes.h"
#include "DatabaseInterface/DbiTableRow.h"
#include "DatabaseInterface/DbiOutRowStream.h"
#include "DatabaseInterface/DbiResultSet.h"

class DbiValidityRec;

class DbuFarRunQuality : public DbiTableRow
{

using TObject::Compare;  // So won't be hidden

public:

// Constructors and destructors.
  DbuFarRunQuality() :
    fRun(-1), 
    fSubRun(-1) ,
    fRunType(-1),
    fRopMask(-1),
    fCrateMask(-1),
    fTriggerMask(-1),
    fStartTime(0,0),
    fEndTime(0,0),
    fTimeFrames(0),
    fSnarls(0),
    fGoodSnarls(0),
    fSnarlRateMin(-1),
    fSnarlRateMax(-1),
    fSnarlRateMean(-1.0),
    fSnarlRateMedian(-1.0),
    fTriggersPlane(0),
    fTriggersEnergy(0),
    fTriggersSpill(0),
    fTriggersRealSpill(0),
    fTriggersFakeSpill(0),
    fPhysicsRun(-1),
    fModifiedRun(-1),
    fTestRun(-1)
  { }

  DbuFarRunQuality(const DbuFarRunQuality& from) : 
    DbiTableRow(from) 
  { *this = from; }

  DbuFarRunQuality(Int_t run, Int_t subrun, Int_t runtype, Int_t ropmask, Int_t cratemask, Int_t triggermask, VldTimeStamp start, VldTimeStamp end, Int_t timeframes, Int_t snarls, Int_t goodsnarls, Int_t minrate, Int_t maxrate, Float_t meanrate, Float_t medianrate, Int_t planetriggers, Int_t energytriggers, Int_t spilltriggers, Int_t realspilltriggers, Int_t fakespilltriggers, Int_t physicsrun, Int_t modifiedrun, Int_t testrun) :
    fRun(run), 
    fSubRun(subrun),
    fRunType(runtype),
    fRopMask(ropmask),
    fCrateMask(cratemask),
    fTriggerMask(triggermask),
    fStartTime(start),
    fEndTime(end),
    fTimeFrames(timeframes),
    fSnarls(snarls),
    fGoodSnarls(goodsnarls),
    fSnarlRateMin(minrate),
    fSnarlRateMax(maxrate),
    fSnarlRateMean(meanrate),
    fSnarlRateMedian(medianrate),
    fTriggersPlane(planetriggers),
    fTriggersEnergy(energytriggers),
    fTriggersSpill(spilltriggers),
    fTriggersRealSpill(realspilltriggers),
    fTriggersFakeSpill(fakespilltriggers),
    fPhysicsRun(physicsrun),
    fModifiedRun(modifiedrun),
    fTestRun(testrun)
  { }

  virtual ~DbuFarRunQuality(){ };

// State testing member functions
  Bool_t CanL2Cache() const { return kTRUE; }
  Bool_t Compare(const DbuFarRunQuality& that ) const {
    return ( fRun == that.fRun
          && fSubRun == that.fSubRun
          && fRunType == that.fRunType
          && fRopMask == that.fRopMask
          && fCrateMask == that.fCrateMask
          && fTriggerMask == that.fTriggerMask 
          && fStartTime == that.fStartTime
          && fEndTime == that.fEndTime
          && fTimeFrames == that.fTimeFrames
          && fSnarls == that.fSnarls
          && fGoodSnarls == that.fGoodSnarls
          && fSnarlRateMin == that.fSnarlRateMin
          && fSnarlRateMax == that.fSnarlRateMax 
          && fSnarlRateMean == that.fSnarlRateMean
          && fSnarlRateMedian == that.fSnarlRateMedian 
          && fTriggersPlane == that.fTriggersPlane
          && fTriggersEnergy == that.fTriggersEnergy
          && fTriggersSpill == that.fTriggersSpill
          && fTriggersRealSpill == that.fTriggersRealSpill
          && fTriggersFakeSpill == that.fTriggersFakeSpill 
          && fPhysicsRun == that.fPhysicsRun
          && fModifiedRun == that.fModifiedRun
          && fTestRun == that.fTestRun ); }

// Access functions
  Int_t GetRun() const                { return fRun; }
  Int_t GetSubRun() const             { return fSubRun; }
  Int_t GetRunType() const            { return fRunType; }
  Int_t GetRopMask() const            { return fRopMask; }
  Int_t GetCrateMask() const          { return fCrateMask; }
  Int_t GetTriggerMask() const        { return fTriggerMask; }

  VldTimeStamp GetStartTime() const   { return fStartTime; }
  VldTimeStamp GetEndTime() const     { return fEndTime; }
  Int_t GetTimeFrames() const         { return fTimeFrames; }  
  Int_t GetSnarls() const             { return fSnarls; }
  Int_t GetGoodSnarls() const         { return fGoodSnarls; }
  Int_t GetMinSnarlRate() const       { return fSnarlRateMin; }
  Int_t GetMaxSnarlRate() const       { return fSnarlRateMax; }
  Float_t GetMeanSnarlRate() const    { return fSnarlRateMean; }
  Float_t GetMedianSnarlRate() const  { return fSnarlRateMedian; }
  Int_t GetPlaneTriggers() const      { return fTriggersPlane; }
  Int_t GetEnergyTriggers() const     { return fTriggersEnergy; }
  Int_t GetSpillTriggers() const      { return fTriggersSpill; }
  Int_t GetSpillTriggersReal() const  { return fTriggersRealSpill; }
  Int_t GetSpillTriggersFake() const  { return fTriggersFakeSpill; }

  Int_t GetPhysicsRun() const         { return fPhysicsRun; }
  Int_t GetModifiedRun() const        { return fModifiedRun; }
  Int_t GetTestRun() const            { return fTestRun; }

  Bool_t GetGoodRun() const           { return this->IsOK(); }
  Bool_t GoodRun() const              { return this->IsOK(); }
  Bool_t IsOK() const;

  Bool_t GoodRunType() const;
  Bool_t GoodReadout() const;
  Bool_t Short() const;
  Bool_t LowRate() const;
  Bool_t HighRate() const;

  Int_t GetAggregateNo() const        { return fRun; }

  UInt_t GetIndex() const             { return this->GetIndex(fRun,fSubRun); }
  UInt_t GetIndex(UInt_t) const       { return this->GetIndex(fRun,fSubRun); } 
  static UInt_t GetIndex(Int_t run, Int_t subrun);
  
// I/O  member functions
  virtual void Fill(DbiResultSet& rs, const DbiValidityRec* vrec);
  virtual void Store(DbiOutRowStream& ors, const DbiValidityRec* vrec) const;

  virtual DbiTableRow* CreateTableRow() const { return new DbuFarRunQuality; }

private:  

  Int_t fRun;
  Int_t fSubRun;
  Int_t fRunType;
  Int_t fRopMask;
  Int_t fCrateMask;
  Int_t fTriggerMask;
  VldTimeStamp fStartTime;
  VldTimeStamp fEndTime;
  Int_t fTimeFrames;
  Int_t fSnarls;
  Int_t fGoodSnarls;
  Int_t fSnarlRateMin;
  Int_t fSnarlRateMax;
  Float_t fSnarlRateMean;
  Float_t fSnarlRateMedian;
  Int_t fTriggersPlane;
  Int_t fTriggersEnergy;
  Int_t fTriggersSpill;
  Int_t fTriggersRealSpill;
  Int_t fTriggersFakeSpill;
  Int_t fPhysicsRun;
  Int_t fModifiedRun;
  Int_t fTestRun;

  ClassDef(DbuFarRunQuality,0)

};

#endif  // DBUFARRUNQUALITY_H

---