CoilTools.cxx

Go to the documentation of this file.

#include "CoilTools.h"

#include "BfldDbiCoilLimits.h"
#include "BfldDbiCoilState.h"
#include "Dcs_Mag_Near.h"

#include <MessageService/MsgService.h>
CVSID("$Id: CoilTools.cxx,v 1.18 2007/12/07 00:37:46 rhatcher Exp $");
using namespace std;

#include <DatabaseInterface/DbiTableProxyRegistry.h>
#include <DatabaseInterface/DbiSqlContext.h>
#include <DatabaseInterface/DbiResultPtr.h>
#include <DatabaseInterface/DbiValidityRec.h>
#include <DatabaseInterface/DbiWriter.h>
#include <DatabaseInterface/DbiWriter.tpl>

#include <cmath>
#include <cassert>

ClassImp(CoilTools)

CoilTools* CoilTools::fgInstance = 0;  // initialize pointer to instance

//_____________________________________________________________________________

// function templates for extended/local query 

template <class T> 
void CoilTools::ExtendedQuery(const VldContext& vldc, 
                            DbiResultPtr<T>& resultPtr,
                            VldRange& resultRange)
{
  MSG("Dcs",Msg::kDebug)
    << " CoilTools::ExtendedQuery<" << typeid(T).name() 
    << "> looking for " << vldc.AsString("sql") << endl;

  // make an extended query on the DB for the Dcs_Mag_Near table
  Detector::Detector_t det = vldc.GetDetector();
  SimFlag::SimFlag_t  sflg = vldc.GetSimFlag();
  VldTimeStamp minTime = vldc.GetTimeStamp();
  VldTimeStamp maxTime = vldc.GetTimeStamp();
  minTime.Add(-60*60); // only 60 min in reverse direction
  maxTime.Add(+fWindow);
  // create an extended context
  DbiSqlContext econtext(DbiSqlContext::kOverlaps,
                         minTime,maxTime,det,sflg);
  // update the table with new context
  resultPtr.NewQuery(econtext,fTask);
  // record what range we requested
  resultRange = VldRange(det,sflg,minTime,maxTime,"econtext");
  // the DBI range might be bigger as it slops over the ends
  const DbiValidityRec* dbiVldRec = resultPtr.GetValidityRec();

  //resultRange = dbiVldRec->GetVldRange();

  if ( dbiVldRec->IsGap() ) {
    MAXMSG("Dcs",Msg::kInfo,10)  
      << " CoilTools::ExtendedQuery<" << typeid(T).name()
      << "> saw a gap for " << vldc.AsString("c")
      // << dbiVldRec->GetVldRange().AsString("acs-") // ==> (0,0,now,now,"unknown")
      << endl;
  }

  MSG("Dcs",Msg::kDebug) 
    << "CoilTools::ExtendedQuery<" << typeid(T).name() << "> narrow "
    << resultRange.AsString("acs-") 
    //<< " dbi " << dbiVldRec->GetVldRange().AsString("acs-")
    << " found " << resultPtr.GetNumRows() << " rows " << endl;

}

//_____________________________________________________________________________

template <class T> 
void CoilTools::LocalQuery(const VldContext& vldc, 
                           DbiResultPtr<T>& extResPtr,
                           std::map<int, const T*>& resultAggMap,
                           VldRange& resultRange)
{
// Rummage through the DbiResultPtr set (holding an extended query results)
// to find an appropriate entries (for each aggregate #), put them into the 
// map and return the overall trimmed range.
// Assume that the one with the latest CREATIONDATE is "best" for the
// passed VldContext but we must also trim down the VldRange based on
// other later CREATIONDATE entries for the aggregate.
  
  MSG("Dcs",Msg::kDebug)
    << " Local looking for " << vldc.AsString("sql") << endl;

  // invalidate what we are going to fill
  resultAggMap.clear();
  resultRange = VldRange();

  // some temporaries
  std::map<int, VldTimeStamp> lastCreationDateMap; // = VldTimeStamp::GetBOT();
  std::map<int, VldRange>     aggRangeMap;
  std::map<int, UInt_t>       iSeqNoUsed; 
  typedef std::map<int, const T*>  resMap_t;
  typedef typename resMap_t::iterator resItr_t;
  resItr_t resItr;

  VldTimeStamp tsVldc = vldc.GetTimeStamp();

  // find the compatible row with latest CREATIONDATE
  for ( UInt_t irow = 0; irow < extResPtr.GetNumRows(); ++irow ) {
    const T* ptrRow = extResPtr.GetRow(irow);
    int aggNo = ptrRow->GetAggregateNo();
    const DbiValidityRec* dbiVldRec = extResPtr.GetValidityRec(ptrRow);
    const VldRange& rowRange = dbiVldRec->GetVldRange();
    if ( rowRange.IsCompatible(vldc) ) {
      VldTimeStamp foundCreationDate = dbiVldRec->GetCreationDate();
      MSG("Dcs",Msg::kVerbose)
        << " row " << irow 
        << " SEQNO " << dbiVldRec->GetSeqNo()
        << " created " << foundCreationDate.AsString("sql")
        << " vld " << rowRange.AsString("acs-")
        << endl;

      const T* oldRow = resultAggMap[aggNo];
      if ( ! oldRow ) lastCreationDateMap[aggNo] = VldTimeStamp::GetBOT();

      // take the last creation date that satisfies
      if ( foundCreationDate > lastCreationDateMap[aggNo] ) {
        lastCreationDateMap[aggNo] = foundCreationDate;
        resultAggMap[aggNo]        = ptrRow;
        aggRangeMap[aggNo]         = rowRange;
        iSeqNoUsed[aggNo]          = dbiVldRec->GetSeqNo();
      }
    }
  }

  // prepare to trim the range 
  std::map<int, VldTimeStamp> maxStart;
  std::map<int, VldTimeStamp> minEnd;
  for ( resItr=resultAggMap.begin() ; resItr!=resultAggMap.end() ; ++resItr) {
    int aggNo = resItr->first;
    maxStart[aggNo] = aggRangeMap[aggNo].GetTimeStart();
    minEnd[aggNo]   = aggRangeMap[aggNo].GetTimeEnd();
    MSG("Dcs",Msg::kVerbose)
      << " aggNo " << aggNo
      << " iSeqNoUsed " << iSeqNoUsed[aggNo] << " " 
      << aggRangeMap[aggNo].AsString("acs-") << endl;
  }

  // trim the ranges
  for ( UInt_t irow = 0; irow < extResPtr.GetNumRows(); ++irow ) {
    const T* ptrRow = extResPtr.GetRow(irow);
    int aggNo = ptrRow->GetAggregateNo();
    if ( ptrRow == resultAggMap[aggNo] ) continue;  // don't trim against self
    const DbiValidityRec* dbiVldRec = extResPtr.GetValidityRec(ptrRow);
    const VldRange& rowRange = dbiVldRec->GetVldRange();
    VldTimeStamp foundCreationDate = dbiVldRec->GetCreationDate();

    // skip entries created before the chosen one are not relevant
    if ( foundCreationDate < lastCreationDateMap[aggNo] ) continue;

    // Rows that overlap the chosen row but were created after it was
    // can trim its range.
    VldTimeStamp thisStart = rowRange.GetTimeStart();
    VldTimeStamp thisEnd   = rowRange.GetTimeEnd();
    //
    // start time is inclusive, end time is exclusive
    //
    // find overlaps
    if ( thisEnd   < maxStart[aggNo] ) continue;  // too low  for aggregate
    if ( thisStart > minEnd[aggNo]   ) continue;  // too high for aggregate

    //MSG("Dcs",Msg::kVerbose)
    //  << " row " << irow << " trim aggno=" << aggNo 
    //  << " SEQNO " << dbiVldRec->GetSeqNo()
    //  << " thisRnage " << rowRange.AsString("acs-")
    //  << endl;

    // trim low end of aggregate's range
    if ( thisEnd  < tsVldc && thisEnd > maxStart[aggNo] ) {  
      MSG("Dcs",Msg::kVerbose)
        << " row " << irow << " trim aggno=" << aggNo 
        << " low  " << maxStart[aggNo].AsString("sql")
        << " SEQNO " << dbiVldRec->GetSeqNo()
        << " created " << foundCreationDate.AsString("sql")
        << " vld " << aggRangeMap[aggNo].AsString("acs-")
        << endl;
      maxStart[aggNo] = thisEnd;
    }
    // trim high end of aggregate's range
    if ( thisStart > tsVldc && thisStart < minEnd[aggNo] ) { 
      MSG("Dcs",Msg::kVerbose)
        << " row " << irow << " trim aggno=" << aggNo
        << " high " << minEnd[aggNo].AsString("sql")
        << " SEQNO " << dbiVldRec->GetSeqNo()
        << " created " << foundCreationDate.AsString("sql")
        << " vld " << aggRangeMap[aggNo].AsString("acs-")
        << endl;
      minEnd[aggNo] = thisStart;
    }
  }

  resultRange = VldRange(0xFFFF,0xFFFF,
                         VldTimeStamp::GetBOT(),VldTimeStamp::GetEOT(),
                         "CoilTools::LocalQuery");
  for ( resItr=resultAggMap.begin() ; resItr!=resultAggMap.end() ; ++resItr) {
    int aggNo = resItr->first;
    // trim aggregate's range
    aggRangeMap[aggNo].SetTimeStart(maxStart[aggNo]);
    aggRangeMap[aggNo].SetTimeEnd(minEnd[aggNo]);
    // trim overall range base on this aggregate
    resultRange.TrimTo(aggRangeMap[aggNo]);
    MSG("Dcs",Msg::kDebug)
      << " trimmed aggNo " << aggNo << " SEQNO "
      << extResPtr.GetValidityRec(resultAggMap[aggNo])->GetSeqNo()
      << " VldRange " << aggRangeMap[aggNo].AsString("acs-") << endl;
  }
  MSG("Dcs",Msg::kDebug)
    << " overall final VldRange " << resultRange.AsString("acs-") << endl;

  int nfound = resultAggMap.size();
  if ( nfound == 0 ) {
    MSG("Dcs",Msg::kDebug) 
      << "LocalQuery<" << typeid(T).name() 
      << " saw no appropriate rows" << endl;
  } else if ( nfound != GetNCoils(vldc) ) {
    MSG("Dcs",Msg::kDebug) 
      << "LocalQuery<" << typeid(T).name() << " saw " << nfound 
      << " matching rows (expected " << GetNCoils(vldc) << " for " 
      << vldc << " in " 
      << extResPtr.GetValidityRec()->GetVldRange().AsString("acs-")
      << endl;
  }

}

//_____________________________________________________________________________
// mini function
int CoilTools::GetNCoils(const VldContext& vldc)
{
  // number of coils
  switch (vldc.GetDetector()) {
  case Detector::kNear:  return 1;
  case Detector::kFar:   return 2;
  default:               return 0;
  }
}

//_____________________________________________________________________________

CoilTools::CoilTools()
  : fWindow(2*24*60*60)   // by default 48hr window in local cache
  , fTask(0)
{
  // default ctor
  fCoilStateSet.clear();
  fMagNearSet.clear();
}

//_____________________________________________________________________________

CoilTools& CoilTools::Instance()
{
  //MSG("Dcs",Msg::kDebug) << " CoilTools::Instance() " << endl;

  // Cleaner destructor calls CoilTools dtor
  static Cleaner cleaner;
  
  // create singleton instance of CoilTools
  if ( ! fgInstance ) {
    MSG("Dcs",Msg::kDebug) << "create CoilTools::fgInstance " << endl;
    cleaner.UseMe();
    fgInstance = new CoilTools();
  }
  
  // die if we couldn't actually create an instance
  if ( ! fgInstance ) {
    MSG("Dcs",Msg::kFatal) 
      << "Could not create CoilTools::fgInstance !!" << endl;
    assert(fgInstance);
  }

  // return reference to the one-and-only
  return *fgInstance;

}

//_____________________________________________________________________________

// Take a row from the DCS_MAG_FAR (or _NEAR) table and decide if we need 
// to write about it in BFLDDBICOILSTATE
void CoilTools::Distill(VldTimeStamp start, 
                        VldTimeStamp end, 
                        Int_t sm,  
                        Float_t curr,
                        Detector::Detector_t NearOrFar) {

  // Bail on bad SM or detector flag
  if ((sm > 2) || (sm < 1)) {
    MSG("Dcs", Msg::kError) << "HOWL!  Bad SM " << sm << endl;
    exit(-1);
  }
  CoilTools::CheckNearOrFar(NearOrFar);

  // Set up distillation parameters
  // On first pass, select Near or Far.  We will never mix the two in one job
  static Bool_t first = true;
  static Double_t MaxTime;
  static Double_t MaxDelay;
  static Double_t MaxSmallGap;
  static Float_t  MaxDeltaCurrent;
  if (first) {
    first = false;
    if (NearOrFar == Detector::kFar) { // Set parameters for Far Det
      MSG("Dcs", Msg::kInfo) << "Distilling the Far Detector Coil" << endl;
      MaxTime     = 3600.0; // 1 Hour, longest time to 
                                                  // wait between distilled
                                                  // rows

      MaxDelay    = 900.0;  // 15 Minutes, longest time
                                                  // of a gap in which the 
                                                  // magnet must have been up 
                                                  // the whole time if it's 
                                                  // at 80A afterwards, since 
                                                  // it takes 15 minutes to 
                                                  // ramp up the magnet 
                                                  // completely

      MaxSmallGap = 150.0;  // 2.5 Minutes, there are 
                                                  // often individual data 
                                                  // points dropped.  Given a 
                                                  // readout cycle of a bit 
                                                  // more than a minute, this 
                                                  // delta-t catches these 
                                                  // small gaps

      MaxDeltaCurrent = 0.015; // How big a current jump 
                                                     // can we tolerate before
                                                     // writing out a data 
                                                     // point? This is more 
                                                     // than 2 ADC ticks, I 
                                                     // think
    } else { // Set parameters for Near Det
      MSG("Dcs", Msg::kInfo) << "Distilling the Near Detector Coil" << endl;
      MaxTime     = 3600.0; // 1 Hour, longest time to 
                                                  // wait between distilled
                                                  // rows

      MaxDelay    = 2700.0; // 45 Minutes, longest time
                                                  // of a gap in which the 
                                                  // magnet must have been up 
                                                  // the whole time.  The ND 
                                                  // magnet ramps up much 
                                                  // faster than the ACNET 
                                                  // readout, so this 
                                                  // parameter is useless for 
                                                  // ND

      MaxSmallGap = 2700.0; // 45 Minutes, to allow us 
                                                  // to miss one readout cycle
                                                  // (20min) without freaking 
                                                  // out

      MaxDeltaCurrent = 5.1; // How big a current jump 
                                                   // can we tolerate before
                                                   // writing out a data 
                                                   // point?  2.5A seems to be one ADC tick at ND
    }
  } // end of if (first)

  // Static stuff to remember between calls
  static const VldTimeStamp BOT = VldTimeStamp::GetBOT();
  static const VldTimeStamp EOT = VldTimeStamp::GetEOT();

  // The last row written out:
  static VldTimeStamp LastDistillTime[2]    = {BOT, BOT};
  static Float_t      LastDistillCurrent[2] = {0.0, 0.0};

  // The last row read:
  static VldTimeStamp LastReadTime[2]       = {BOT, BOT};
  static Float_t      LastReadCurrent[2]    = {0.0, 0.0};

  // The row which will next be written out:
  static VldTimeStamp SaveReadTime[2]       = {BOT, BOT};
  static Float_t      SaveReadCurrent[2]    = {0.0, 0.0};

  // Index for the above arrays
  Int_t smindex = sm - 1;

  // If start==EOT, that's the signal to dump the last row saved through
  // last row seen unless it happened to have already been dumped, or the last 
  // saved value is bogus
  if ((start == EOT) && 
      (SaveReadTime[smindex] != BOT) &&
      (SaveReadTime[smindex] != EOT)) {
    MSG("Dcs", Msg::kInfo) << "SM" << sm << " Forced dump of this row "<< endl;
    // If row was just dumped, don't do it again
    if (SaveReadTime[smindex] == LastReadTime[smindex]) {
      MSG("Dcs", Msg::kInfo) << " Row already just dumped "<< endl;
    } else {
      CoilTools::WriteRow(SaveReadTime[smindex],LastReadTime[smindex],sm,
                          SaveReadCurrent[smindex],NearOrFar);
    }
    // reset saved values to defaults just in case
    SaveReadTime[smindex] = BOT;
    SaveReadCurrent[smindex] = 0.0;
    return;
  }

  // Comment out if you want to backfill early stuff
  // If LastReadTime is BOT then this is the first call - go to the DB 
  // and get the last previous entry as a starting point
  if (LastReadTime[smindex] == BOT)
    if (!CoilTools::GetLast(start,sm,&LastReadTime[smindex],
                            &LastReadCurrent[smindex],NearOrFar)) {
      SaveReadTime[smindex] = LastReadTime[smindex];
      SaveReadCurrent[smindex] = LastReadCurrent[smindex];
    } else {
      MSG("Dcs", Msg::kError) << "HOWL!  Can't get initial conditions from DB" << endl;
      //      exit(-1);
      // For initial run, of course we can't, so comment out this exit
    }

  // Spew this one
  MSG("Dcs", Msg::kDebug) << "SM" << sm << " Start: " << start.AsString("s") 
                          << " End: " << end.AsString("s") << "\tCurr: " 
                          << curr << endl;

  // Decide if we need to write a distilled entry.
  // 1) More than MaxTime time has elapsed since last one;
  // 2) Current has changed by more than MaxDeltaCurrent
  // 3) This reading is beyond the last entry + MaxDelay
  // 4) If start == EOT write out the last row (unless that row 
  //    happened to already have been written out, see above)
  // Need to be smarter about this - how long a gap do we really care
  // about?  Also need to be able to go back and overide earlier
  // validity if a long gap turns out to really be a problem.  Say, a gap
  // then a bad current should disqualify the whole gap.

  Float_t DeltaTime    = (Double_t)start - (Double_t)SaveReadTime[smindex];
  Float_t DeltaDelay   = (Double_t)start - (Double_t)LastReadTime[smindex];
  Float_t DeltaCurrent = curr - SaveReadCurrent[smindex];

  // Check to see if gap in time exists more than MaxSmallGap but less
  // than MaxDelay.  If so there may be a problem, but probably not if
  // the next data point is at full voltage (as was the last), since
  // ramping up that far takes MaxDelay to happen.  Otherwise, dump the row.
  // Gap will need to be set manually as with all gaps - but be sure
  // to flag this one as bad when you do!
  if ((DeltaDelay > MaxSmallGap) && (DeltaDelay < MaxDelay)) {
    if ((fabs(curr) < 79.0) || (fabs(LastReadCurrent[smindex]) < 79.0)) {
      // Uh-oh, magnet has crashed, dump saved stuff
      MSG("Dcs", Msg::kSynopsis) << "SM" << sm << " SAVED: DeltaTime = " 
                                 << DeltaTime << " DeltaDelay " 
                                 << DeltaDelay << " DeltaCurrent = " 
                                 << DeltaCurrent << endl;
      MSG("Dcs", Msg::kWarning) << "SM" << sm << " GAP from " 
                                << LastReadTime[smindex].AsString("s") 
                                << " to " 
                                << start.AsString("s") 
                                << " with low current " << curr << endl;
      CoilTools::WriteRow(SaveReadTime[smindex],LastReadTime[smindex],sm,
                          SaveReadCurrent[smindex],NearOrFar);
      // Save this info for next loop
      LastDistillTime[smindex] = SaveReadTime[smindex];
      LastDistillCurrent[smindex] = SaveReadCurrent[smindex];
      SaveReadTime[smindex] = start;
      SaveReadCurrent[smindex] = curr;
    } else {
      // Otherwise just keep on truckin'
      MSG("Dcs", Msg::kWarning) << "SM" << sm << " GAP of " << DeltaDelay 
                                << " skipped since current is " << curr 
                                << endl;
    }
  }

  if ((DeltaTime >= MaxTime) || 
      (fabs(DeltaCurrent) >= MaxDeltaCurrent) ||
      (DeltaDelay >= MaxDelay)) {
    MSG("Dcs", Msg::kSynopsis) << "SM" << sm << " SAVED: DeltaTime = " 
                               << DeltaTime << " DeltaDelay " 
                               << DeltaDelay << " DeltaCurrent = " 
                               << DeltaCurrent << endl;
    // If this is not the first row we want to save, we now know the 
    // validity of the last one, either:
    //   a) if not too big a gap, it stops now
    //   b) if too big a gap, take the last known readout as a stop point
    //      This leaves a validity gap which corresponds to the unknown
    //      time period, needs manually filled in the DB
    // don't write an empty row at the start though
    if (SaveReadTime[smindex] != BOT) { 
      if (DeltaDelay < MaxDelay) {
        CoilTools::WriteRow(SaveReadTime[smindex],start,sm,
                            SaveReadCurrent[smindex],NearOrFar);
      } else {
        MSG("Dcs", Msg::kWarning) << "SM" << sm << " GAP from " 
                                  << LastReadTime[smindex].AsString("s") 
                                  << " to " << start.AsString("s") << endl;
        CoilTools::WriteRow(SaveReadTime[smindex],
                            LastReadTime[smindex],sm,SaveReadCurrent[smindex],
                            NearOrFar);
      }
      LastDistillTime[smindex] = SaveReadTime[smindex];
      LastDistillCurrent[smindex] = SaveReadCurrent[smindex];
    }
    // Save current info to be start of next distillation
    SaveReadTime[smindex] = start;
    SaveReadCurrent[smindex] = curr;
  }

  // Record this row for future reference
  LastReadTime[smindex] = start;
  LastReadCurrent[smindex] = curr;
}

//_____________________________________________________________________________

// Figure out a status to write
void CoilTools::WriteRow(VldTimeStamp start, 
                         VldTimeStamp end, 
                         Int_t sm, 
                         Float_t curr,
                         Detector::Detector_t NearOrFar) {

  CoilTools::CheckNearOrFar(NearOrFar);

  // Figure out a status
  UInt_t status = 0;

  VldContext vldc(NearOrFar,SimFlag::kData,start);
  std::pair<Float_t,Float_t> limits = CoilCurrentLimits(vldc);
  // Switch on which detector
  if (NearOrFar == Detector::kFar) {
    // Check for reversed field
    if (curr < 0.0) status |= CoilStatus::kReverse;
    //if ((fabs(curr) < 79.0) || (fabs(curr) > 81.0)) {
    // RWH 2007.12 change to using CoilCurrentLimits()
    if (fabs(curr) < fabs(limits.first) || 
        fabs(curr) > fabs(limits.second)  ) { 
      status |= CoilStatus::kBad;
      status |= CoilStatus::kBadCurrent;
    }
  } else {
    // Check for reversed field.  Opposite sign convention for ND
    if (curr > 0.0) status |= CoilStatus::kReverse;
    // Changed from 4955 and 5005, April 2007, ATH
    //if ((fabs(curr) < 4940.0) || (fabs(curr) > 4990.0)) { 
    // RWH 2007.12 change to using CoilCurrentLimits()
    if (fabs(curr) < fabs(limits.first) || 
        fabs(curr) > fabs(limits.second)  ) { 
      status |= CoilStatus::kBad; 
      status |= CoilStatus::kBadCurrent; 
    } 
  }
  CoilTools::Write(start,end,sm,curr,status,NearOrFar);

  // Flagging gaps is done manually.  A tool to write the records after
  // a human reads the distiller logs and checks CRL is found in ManualGaps.C

  MSG("Dcs", Msg::kInfo) << "SM" << sm << " DISTILLED: Start: " 
                         << start.AsString("s") 
                         << " End: "  << end.AsString("s")<< "\tCurr: " 
                         << curr << " " << CoilStatus::MaskToString(status) 
                         << endl;
}

//_____________________________________________________________________________

// Get the last coil row before start for sm, return the time and current
// Need to figure out what to do if that time is in the middle of something 
// instead of on the end.  Hopefully it's always on the end during normal ops.
Int_t CoilTools::GetLast(VldTimeStamp start,   
                         Int_t sm,   
                         VldTimeStamp *LastTime, 
                         Float_t *LastCurr,
                         Detector::Detector_t NearOrFar) {

  CoilTools::CheckNearOrFar(NearOrFar);

  // Ask for last time before the start of the current record.
  // Originally this code section did not exist, but just asked for the
  // last record period.  However, it we are re-running data and trying
  // to overlay validities with new, better stuff we need the last entry
  // _before_ the current record.
  DbiSqlContext myContext = DbiSqlContext("TIMEEND <= \'");
  myContext << start.AsString("s")  << '\'';

  // Setup query for detector and SM
  if (NearOrFar == Detector::kNear) {
    myContext << " AND AGGREGATENO = 1 AND DETECTORMASK & 1 ORDER BY TIMEEND DESC LIMIT 1";
  } else {
    if (sm==1) 
      myContext << " AND AGGREGATENO = 1 AND DETECTORMASK & 2 ORDER BY TIMEEND DESC LIMIT 1";
    else
      myContext << " AND AGGREGATENO = 2 AND DETECTORMASK & 2 ORDER BY TIMEEND DESC LIMIT 1";
  }

  // Actually make the query
  DbiResultPtr<BfldDbiCoilState> rsPtr1("BFLDDBICOILSTATE",myContext);

  Int_t numRows = rsPtr1.GetNumRows();
  MSG("Dcs", Msg::kDebug) << "The context: " << myContext.GetString() 
                          << " selected " << numRows 
                          << " rows from the BFLDDBICOILSTATE table" << endl;

  Bool_t FoundIt = false;
  // Loop over the entries
  for (int i = 0; i < numRows; ++i) {
    // Grab the row
    const BfldDbiCoilState* mag = rsPtr1.GetRow(i);

    if (mag->GetSupermodule() == sm) {
      // Grab that row's validity
      const DbiValidityRec* v_rec = rsPtr1.GetValidityRec(mag);
      const VldRange&  v_range = v_rec->GetVldRange();
      *LastTime = v_range.GetTimeEnd();
      // Extract some magnet data
      *LastCurr=mag->GetCurrent();
      FoundIt = true;
      break;
    }
  }
  if (FoundIt) {
    MSG("Dcs", Msg::kInfo) << "SM" << sm << " Got last time in DB as " 
                            << LastTime->AsString("s")
                            << " with current " << *LastCurr << " given " 
                            << start.AsString("s") << endl;
    return(0);
  } else {
    MSG("Dcs", Msg::kError) << "SM" << sm << " No last time in DB given " 
                            << start.AsString("s") << endl;
    return(-1);
  }
}

//_____________________________________________________________________________

// Format messages, which one can't do from CINT
// Use this to set up where logs will go in the cron jobbed database filler
void CoilTools::FixFormat() {
  // Get pointers to the message service and to the stream I want ("Dcs")
  MsgService* msvc = MsgService::Instance();
  MsgStream*  mstr = msvc->GetStream("Dcs");
  
  // Set the log level for the stream. If you just want the default
  // (kInfo) this line is not needed
  mstr->SetLogLevel(Msg::kDebug);
  
  // Send GAP-related messages off to a file instead of just stdout
  // so humans can be notified
  // kWarning should be the minimal level the cron job needs to work.  For 
  // more, it seems we have to list each level not just a threshold, that's 
  // a pain.
  mstr->AttachOStream(Msg::kWarning,"distill-gaps.log");
  mstr->AttachOStream(Msg::kError,"distill-gaps.log");
  mstr->AttachOStream(Msg::kInfo,"distill-gaps.log");
  mstr->AttachOStream(Msg::kDebug,"distill-gaps.log");
  mstr->AttachOStream(Msg::kSynopsis,"distill-gaps.log");
  
  // Clean up format flags for warning messages
  mstr->RemoveFormat(Msg::kWarning, 
                Msg::kPriority+Msg::kName+Msg::kTime+Msg::kFile+Msg::kCVSId+Msg::kLine);
  // Clean up format flags for debug messages
  mstr->RemoveFormat(Msg::kDebug, 
                Msg::kPriority+Msg::kName+Msg::kTime+Msg::kFile+Msg::kLine);
}

//_____________________________________________________________________________

// Check that NearOrFar is sane
void CoilTools::CheckNearOrFar(Detector::Detector_t NearOrFar) {
  if (!((NearOrFar == Detector::kNear) || (NearOrFar == Detector::kFar))) {
    MSG("Dcs", Msg::kError) << "HOWL!  Bad Detector Type " 
                            << Detector::AsString(NearOrFar) << endl;
    exit(-1);
  }
}

//_____________________________________________________________________________

// The ND stuff is a hack.  One could go distill DCS_MAG_NEAR into
// BfldDbiCoilState entries and just use mostly the same framework.
// However, DCS_MAG_NEAR is already distilled at the data collection end
// of things.  So, just go look there and don't waste time re-distilling
// data.

Bool_t CoilTools::IsOK(const VldContext& vldc)
{ 
  // Switch behavior by detector
  switch ( vldc.GetDetector() ) {
  case Detector::kFar:   
    return CoilTools::Instance().IsCoilStateOK(vldc);
    break;
  case Detector::kNear:  
    return CoilTools::Instance().IsMagNearOK(vldc);
    break;
  default:
    return false;
  }
}

Bool_t CoilTools::IsReverse(const VldContext& vldc)
{ 
  // Switch behavior by detector
  switch ( vldc.GetDetector() ) {
  case Detector::kFar:
    return CoilTools::Instance().IsCoilStateReverse(vldc);
    break;
  case Detector::kNear:
    return CoilTools::Instance().IsMagNearReverse(vldc);
    break;
  default:
    return false;
  }
}

std::pair<Float_t,Float_t> CoilTools::CoilCurrent(const VldContext& vldc)
{ 
  // Switch behavior by detector 
  std::pair<Float_t,Float_t> coil_currents(0,0);

  const BfldDbiCoilState* farsm1;
  const BfldDbiCoilState* farsm2;
  const Dcs_Mag_Near *nearstate;
  switch ( vldc.GetDetector() ) {
  case Detector::kFar:
    farsm1 = CoilTools::Instance().GetCoilState(vldc,1);
    farsm2 = CoilTools::Instance().GetCoilState(vldc,2);
    if (farsm1) coil_currents.first  = farsm1->GetCurrent();
    if (farsm1) coil_currents.second = farsm2->GetCurrent();
    break;
  case Detector::kNear:
    nearstate = CoilTools::Instance().GetMagNear(vldc);
    if (nearstate) {
      // just one coil, but set both to be same for convenience
      coil_currents.first = coil_currents.second = nearstate->GetCurrent();
    }
    break;
  default:
    break;
  }
  return coil_currents;
}

// Wrappers for broken out context (assuming kData)

Bool_t CoilTools::IsOK(VldTimeStamp now, Detector::Detector_t det)
{
  // Go get the data at time "now" for detector det
  VldContext vldc(det,SimFlag::kData,now);
  return CoilTools::IsOK(vldc);
}

Bool_t CoilTools::IsReverse(VldTimeStamp now, Detector::Detector_t det)
{
  // Go get the data at time "now" for detector det
  VldContext vldc(det,SimFlag::kData,now);
  return CoilTools::IsReverse(vldc);
}

//_____________________________________________________________________________
std::pair<Float_t,Float_t> CoilTools::CoilCurrentLimits(const VldContext& vldc)
{ 
  std::pair<Float_t,Float_t> limits(0,0);

  // try the DB, don't abort if table is missing or no results
  Dbi::Task task = Dbi::kDefaultTask;
  DbiResultPtr<BfldDbiCoilLimits> rsptr_limits(vldc,task,Dbi::kDisabled);
  Int_t numrows = rsptr_limits.GetNumRows();
  if ( numrows > 0 ) {
    if ( numrows > 1 ) {
      MAXMSG("Dcs",Msg::kWarning,4)
        << "More than one BfldDbiCoilLimits entry for VLD " << vldc << endl;
    }
    const BfldDbiCoilLimits* limits_row = rsptr_limits.GetRow(0);
    limits = limits_row->GetLimits();

    // for test purposes
    static int lastSeqNo = 0;
    const DbiValidityRec* vldrec = rsptr_limits.GetValidityRec(limits_row);
    int currSeqNo = vldrec->GetSeqNo();
    if ( currSeqNo != lastSeqNo ) {
      MSG("Dcs",Msg::kSynopsis)
        << "BfldDbiCoilLimits: "
        << limits.first << " to " << limits.second
        << ", using SEQNO " << currSeqNo 
        << endl
        << " for " 
        << vldrec->GetVldRange().AsString("acs-") 
        << endl;
      lastSeqNo = currSeqNo;
    }
  } else {
    // set some defaults in case no DB entry
    switch ( vldc.GetDetector() ) {
    case Detector::kNear:
      // pre April 2007
      //limits.first  = 4955.0;
      //limits.second = 5005.0;
      // post April 2007 through mid Dec 2007
      //limits.first  = 4940.0;
      //limits.second = 4990.0;
      // post Dec 2007 - very wide, to account for noise in readback
      limits.first  = 4800.0;  // low limit
      limits.second = 5100.0;  // high limit
      break;
    case Detector::kFar:
      limits.first   = 79.0;   // low limit
      limits.second  = 81.0;   // high limit 
      break;
    default:
      MAXMSG("Dcs",Msg::kInfo,4) 
        << "Calling CoilCurrentLimits() on Detector::k"
        << Detector::AsString(vldc.GetDetector())
        << " is non-sensical" << endl;
      break;
    }
    MAXMSG("Dcs",Msg::kInfo,1) 
      << "No DBI entry for BfldDbiCoilLimits for " << endl
      << "   VldContext = " << vldc << endl
      << "   use: " << limits.first << " to " << limits.second << endl;
  }

  // return best limits
  return limits;
}

//_____________________________________________________________________________
const BfldDbiCoilState* CoilTools::GetCoilState(const VldContext& vldc, int ism)
{
  // make sure extended query fCoilState covers requested validity
  if ( ! fExtendedRangeCoilState.IsCompatible(vldc) ) {
    ExtendedQuery<BfldDbiCoilState>(vldc,fDRPCoilState,fExtendedRangeCoilState);
    fLocalRangeCoilState = VldRange();  // invalidate local range
  }
  // if necessary, find correct row in extended query
  if ( ! fLocalRangeCoilState.IsCompatible(vldc) )
    LocalQuery<BfldDbiCoilState>(vldc,fDRPCoilState,
                                 fCoilStateSet,fLocalRangeCoilState);

  // assume NearDet has sm=1 and FarDet has sm=1,2
  if ( ism < 0 || ism > GetNCoils(vldc) ) return 0;
  return fCoilStateSet[ism];  // index into array by SM
}

//_____________________________________________________________________________

Bool_t CoilTools::IsCoilStateOK(const VldContext& vldc)
{ 

  int nOK=0, nBad=0;

  int ncoils = GetNCoils(vldc);
  for (int icoil = 1; icoil <= ncoils ; ++icoil ) {
    const BfldDbiCoilState* coilState = GetCoilState(vldc,icoil);
    if ( ! coilState ) {
      // coilState should now be set.  If it isn't for Data it
      // is a problem, but for non-Data (i.e. MC)
      // assume it is simply "missing" (and OK).
      if (vldc.GetSimFlag() != SimFlag::kData) ++nOK; 
    } else {
      if ( coilState->IsOK() ) ++nOK;
      else                     ++nBad;
    }
  }

  if ( nOK  == ncoils ) return true;
  if ( nBad == ncoils ) return false;

  // inconsistent state
  static VldTimeStamp lastWarning = VldTimeStamp::GetBOT();
  VldTimeStamp thisTime = vldc.GetTimeStamp();
  // don't warn but every timeDelta seconds
  const int timeDelta = 60*20;  // 20 min
  if ( TMath::Abs(lastWarning.GetSec()-thisTime.GetSec()) > timeDelta ) {
      MSG("Dcs",Msg::kWarning)
        << "CoilTools saw inconsistent OK state " << endl
        << "  nOK=" << nOK << " nBad=" << nBad << " of " << ncoils << " coils "
        << " for " << vldc.AsString("c") << endl
        << "  suppress further warnings in the next " << timeDelta
        << " seconds." << endl;
      lastWarning = thisTime;
    }
  return false;  // what to choose, what to choose?  Anything bad ==> not OK

}

//_____________________________________________________________________________

Bool_t CoilTools::IsCoilStateReverse(const VldContext& vldc)
{

  int nfwd=0, nrev=0;

  int ncoils = GetNCoils(vldc);
  for (int icoil = 1; icoil <= ncoils ; ++icoil ) {
    const BfldDbiCoilState* coilState = GetCoilState(vldc,icoil);
    if ( ! coilState ) {
      // coilState should now be set.  If it isn't for Data it
      // is a problem, but for non-Data (i.e. MC)
      // assume it is simply "missing" (and 'forward').
      if (vldc.GetSimFlag() != SimFlag::kData) ++nfwd; 
    } else {
      if ( coilState->GetStatus() & CoilStatus::kReverse ) ++nrev;
      else                                                 ++nfwd;
    }
  }

  if ( nfwd == ncoils ) return false;
  if ( nrev == ncoils ) return true;

  static VldTimeStamp lastWarning = VldTimeStamp::GetBOT();
  VldTimeStamp thisTime = vldc.GetTimeStamp();
  // don't warn but every timeDelta seconds
  const int timeDelta = 60*20;  // 20 min
  if ( TMath::Abs(lastWarning.GetSec()-thisTime.GetSec()) > timeDelta ) {
      MSG("Dcs",Msg::kWarning)
        << "CoilTools saw inconsistent polarities " << endl
        << "  nforward=" << nfwd << " nreverse=" << nrev
        << " for " << vldc.AsString("c") << endl
        << "  suppress further warnings in the next " << timeDelta
        << " seconds." << endl;
      lastWarning = thisTime;
    }
  return true;  // what to choose, what to choose?  either reverse ==> report reversed

}

//_____________________________________________________________________________

const Dcs_Mag_Near* CoilTools::GetMagNear(const VldContext& vldc)
{
  // make sure extended query fMagNear covers requested validity
  if ( ! fExtendedRangeMagNear.IsCompatible(vldc) ) {
    ExtendedQuery<Dcs_Mag_Near>(vldc,fDRPMagNear,fExtendedRangeMagNear);
    fLocalRangeMagNear = VldRange();  // invalidate local range
  }
  // if necessary, find correct row in extended query
  if ( ! fLocalRangeMagNear.IsCompatible(vldc) )
    LocalQuery<Dcs_Mag_Near>(vldc,fDRPMagNear,fMagNearSet,fLocalRangeMagNear);

  return fMagNearSet[1];

}

//_____________________________________________________________________________

Bool_t CoilTools::IsMagNearOK(const VldContext& vldc)
{

  const Dcs_Mag_Near* magNear = GetMagNear(vldc);

  if ( ! magNear ) {
    // fMagNear should now be set.  If it isn't then assume it's bad
    // for data, but simply "missing" for MC.
    if (vldc.GetSimFlag() == SimFlag::kData) return false; 
    else                                     return true;
  }

  std::pair<Float_t,Float_t> limits = CoilCurrentLimits(vldc);
  Float_t curr = magNear->GetCurrent();
  // Changed from 4955 and 5005, April 2007, ATH
  // Changed from 4940 and 4990, December 2007, RWH
  if (((fabs(curr) < fabs(limits.first)) || 
        fabs(curr) > fabs(limits.second)) ||
      (magNear->GetInterLocksComplete() == 0) ||
      (magNear->GetPowerSupplyOn() == 0) ||
      (magNear->GetGroundFault() == 1) || 
      (magNear->GetOverCurrentDC() == 1) || 
      (magNear->GetOverTemperature() == 1) ) {
    return false;
  } else {
    return true;
  }

}

//_____________________________________________________________________________

Bool_t CoilTools::IsMagNearReverse(const VldContext& vldc)
{

  const Dcs_Mag_Near* magNear = GetMagNear(vldc);

  if ( ! magNear ) {
    // fMagNear should now be set.  If it isn't then assume it's bad
    // for data, but simply "missing" (and forward) for MC.
    if (vldc.GetSimFlag() == SimFlag::kData) return true; 
    else                                     return false;
  }

  return magNear->GetPolarity();
}

//_____________________________________________________________________________

void CoilTools::Write(VldTimeStamp start,   
                      VldTimeStamp end,   
                      Int_t sm,   
                      Float_t curr, 
                      UInt_t status,
                      Detector::Detector_t det) {
  // Ripped from DcsWriter to dump the stuff
  Int_t aggNo = sm;
  Dbi::Task task = 0;
  VldRange OutputRange(det,SimFlag::kData,start,end,"BfldDbiCoilState");
  // No creationdate argument below means use overlay times
  DbiWriter<BfldDbiCoilState> writer(OutputRange,aggNo,task);
  // writer.SetLogComment("Manual Gap Set");  // not needed for this table
  BfldDbiCoilState row0(curr,status,(UInt_t)sm);
  writer << row0;
  writer.Close();
}

//_____________________________________________________________________________

---