CoilTools.h

Go to the documentation of this file.

#ifndef COILTOOLS_H
#define COILTOOLS_H

#include <Validity/VldTimeStamp.h>
#include <Validity/VldContext.h>
#include <Conventions/Detector.h>

// explicit includes (private data for caching)
#include <DatabaseInterface/DbiResultPtr.h>
#include <DcsUser/BfldDbiCoilState.h>
#include <DcsUser/Dcs_Mag_Near.h>

#include <map>
#include <utility>

class CoilTools {
 public:
  // Singleton access
  static CoilTools& Instance();

  // Distill the raw DCS magnet tables
  static void Distill(VldTimeStamp start,
                      VldTimeStamp end,
                      Int_t sm, 
                      Float_t curr,
                      Detector::Detector_t NearOrFar);
  // For incremental additions to the DB, get the starting point
  static Int_t GetLast(VldTimeStamp start,  
                       Int_t sm,  
                       VldTimeStamp *LastTime,
                       Float_t *LastCurr,
                       Detector::Detector_t NearOrFar);
  // Set up MsgService parameters
  static void FixFormat();

  // Query DB, return true if coil state is deemed "okay"
  static Bool_t IsOK(const VldContext& vldc);
  static Bool_t IsOK(VldTimeStamp now, Detector::Detector_t det);

  // Query DB, return true if coil was run in reverse current direction
  static Bool_t IsReverse(const VldContext& vldc);
  static Bool_t IsReverse(VldTimeStamp now, Detector::Detector_t det);

  // Query DB, return coil current(s)
  static std::pair<Float_t,Float_t> CoilCurrent(const VldContext& vldc);

  // Query DB, return coil limits for IsOK
  static std::pair<Float_t,Float_t> CoilCurrentLimits(const VldContext& vldc);

  // make general case accessible
  // in case users need access to other fields
  const BfldDbiCoilState* GetCoilState(const VldContext& vldc, int ism=1);
  const Dcs_Mag_Near*     GetMagNear(const VldContext& vldc);

  // Put a row into the distilled table
  static void Write(VldTimeStamp start,  
                    VldTimeStamp end,  
                    Int_t sm,  
                    Float_t curr,
                    UInt_t status,
                    Detector::Detector_t det);

  // Configurables for local caching
  // not static functions - use CoilTools::Instance().f()
  void SetWindow(Int_t wsec) 
  { fWindow = max(wsec,60); ClearCaches(); } // min 60 seconds
  void SetTask(Int_t task)
  { fTask   = task; ClearCaches(); }
  void ClearCaches()
  { fExtendedRangeCoilState = VldRange(); 
    fLocalRangeCoilState    = VldRange(); 
    fExtendedRangeMagNear   = VldRange(); 
    fLocalRangeMagNear      = VldRange();
  }

  // helper function
  static int GetNCoils(const VldContext& vldc);

 private:

  // Figure out a status to write, prepare to do so
  static void WriteRow(VldTimeStamp start,  
                       VldTimeStamp end,  
                       Int_t sm,  
                       Float_t curr,
                       Detector::Detector_t NearOrFar);
  // Make sure we are at one of the two places with a real coil
  static void CheckNearOrFar(Detector::Detector_t NearOrFar);

  // special handlers
  Bool_t IsCoilStateOK(const VldContext& vldc);
  Bool_t IsCoilStateReverse(const VldContext& vldc);
  Bool_t IsMagNearOK(const VldContext& vldc);
  Bool_t IsMagNearReverse(const VldContext& vldc);

  // Constructors and destructors (private because it's a singleton)
  CoilTools(); 
  virtual ~CoilTools() { }; 

  // Setup the singleton machinery
  struct Cleaner {
    void UseMe() { }  // Dummy method to quiet compiler
    ~Cleaner() {
      if ( CoilTools::fgInstance != 0 ) {
        delete CoilTools::fgInstance;
        CoilTools::fgInstance = 0;
      }
    }
  };
  friend struct Cleaner;
  static CoilTools* fgInstance;  // the one-and-only instance

  // helper templated functions
  template <class T> 
    void ExtendedQuery(const VldContext& vldc,
                       DbiResultPtr<T>& resultPtr, VldRange& resultRange);
  template <class T>
    void LocalQuery(const VldContext& vldc, DbiResultPtr<T>& extResPtr,
                    std::map<int, const T*>& resultAggMap,
                    VldRange& resultRange);

  Int_t                          fWindow;
  Int_t                          fTask;

  // private data for caching purposes

  DbiResultPtr<BfldDbiCoilState>         fDRPCoilState;
  VldRange                               fExtendedRangeCoilState;
  VldRange                               fLocalRangeCoilState;
  std::map<int, const BfldDbiCoilState*> fCoilStateSet; // ref ptrs only

  DbiResultPtr<Dcs_Mag_Near>             fDRPMagNear;
  VldRange                               fExtendedRangeMagNear;
  VldRange                               fLocalRangeMagNear;
  std::map<int, const Dcs_Mag_Near*>     fMagNearSet;  // ref ptrs only

  ClassDef(CoilTools,0)

};

#endif  // COILTOOLS_H

---