FabPlnInstallLookup.cxx

Go to the documentation of this file.

// $Id: FabPlnInstallLookup.cxx,v 1.14 2008/03/04 21:46:45 rhatcher Exp $
//
// FabPlnInstallLookup
//
// FabPlnInstallLookup - for conveniently looking up plane installation info
//
// Author:  R. Hatcher 2002.11.05
//

#include "Fabrication/FabPlnInstallLookup.h"

#include "MessageService/MsgService.h"
CVSID("$Id: FabPlnInstallLookup.cxx,v 1.14 2008/03/04 21:46:45 rhatcher Exp $");

#include "TSystem.h"
#include <set>
#include <map>
using std::set;
using std::map;

#include <ctype.h>
#include <stdio.h>

ClassImp(FabPlnInstallLookup)

static FabPlnInstall* dummyPlnInstall = new FabPlnInstall();
static VldTimeStamp   farFuture(2037,12,31,23,59,59);

//_____________________________________________________________________________

FabPlnInstallLookup::FabPlnInstallLookup(const VldContext& vldc)
  : fPlnInstallTbl(vldc), fSteelPlateTbl(vldc), fVldContext(vldc)
{
  // Normal constructor

  // determine first/last non-veto shield planes
  const PlexPlaneId unsetPlnId;
  UInt_t n = fPlnInstallTbl.GetNumRows();
  for (UInt_t irow=0; irow < n; ++irow) {
    const FabPlnInstall* fab = fPlnInstallTbl.GetRow(irow);
    PlexPlaneId plnid = fab->GetPlaneId(); 
    if ( ! plnid.IsVetoShield() ) {
      plnid.SetIsSteel(kTRUE);
      if ( plnid == unsetPlnId ) {
        MSG("Fabrication",Msg::kWarning)
          << " row " << irow << " has bad PlexPlaneId" 
          << endl
          << *fab 
          << endl;
        continue;
      }
      if ( fFirstNormal == unsetPlnId ) { // first legal row
        fFirstNormal = plnid;
        fLastNormal  = plnid;
      }
      if ( plnid < fFirstNormal ) fFirstNormal = plnid;
      if ( plnid > fLastNormal  ) fLastNormal  = plnid;
    }
  }

  // leave fPlnInstallTblAlt unset

}

//_____________________________________________________________________________
FabPlnInstallLookup::~FabPlnInstallLookup()
{
   // Normal dtor
}

//_____________________________________________________________________________
const FabPlnInstall* FabPlnInstallLookup::NextInstall(const VldTimeStamp& start,
                                                      bool ignoreVeto) const
{
  // Find the entry for the next plane that was installed after some time
  
  // Old code assumed that the database returns all the rows in ascending
  // time order!  NOT TRUE!

  // One can not use the DbiValidityRec times for determining anything
  // either because of the artificial (10day) trimming that goes on


  VldTimeStamp alttime = start;
  const FabPlnInstall* fab;
  const DbiValidityRec* dbivld;

  // initialize the Alt DbiResultPtr
  VldContext vldcStart(fVldContext.GetDetector(),
                       fVldContext.GetSimFlag(),alttime);
  fPlnInstallTblAlt.NewQuery(vldcStart);

  UInt_t n = fPlnInstallTblAlt.GetNumRows();

  if ( n <= 0) {
    // no planes installed at the time given
    // determine when first plane went up
    
    VldContext vldcAlt(fVldContext.GetDetector(),
                       fVldContext.GetSimFlag(),farFuture);
    MSG("Fabrication",Msg::kDebug)
      << "No planes yet installed, determine first using " << vldcAlt << endl;
    fPlnInstallTblAlt.NewQuery(vldcAlt);
    if (fPlnInstallTblAlt.GetNumRows() <= 0) {
      // no info about any appropriate planes 
      MSG("Fabrication",Msg::kInfo)
        << "NextInstall() has no info for " << vldcAlt << endl;
      return 0;
    }
    // can't determine start from the future DbiValidityRec
    // because of 10day Dbi window artificially limits validity range
    dbivld = fPlnInstallTblAlt.GetValidityRec();
    alttime = dbivld->GetVldRange().GetTimeStart();

    // find when first plane actually went up
    n = fPlnInstallTblAlt.GetNumRows();
    for (UInt_t irow=0; irow < n; ++irow) {
      fab = fPlnInstallTblAlt.GetRow(irow);
      const VldTimeStamp& ts = fab->GetInstallDate();
      if (ts < alttime) alttime = ts;
    }

  }
  else {
    // determine when the last plane in Alt set went up
    // can't use DbiValidityRec because of 10day Dbi window
    dbivld = fPlnInstallTblAlt.GetValidityRec();
    alttime = dbivld->GetVldRange().GetTimeEnd();
    
    if ( alttime > farFuture) {
      // way in the future means nothing new is going up
      MSG("Fabrication",Msg::kInfo)
        << "NextInstall() " << vldcStart << " detector complete?" << endl;
      return 0;
    }
  }

  // force new query with newly determined starting time
  VldContext vldcAlt(fVldContext.GetDetector(),
                     fVldContext.GetSimFlag(),alttime);
  fPlnInstallTblAlt.NewQuery(vldcAlt);

  n = fPlnInstallTblAlt.GetNumRows();
  for (UInt_t irow=0; irow < n; ++irow) {
    fab = fPlnInstallTblAlt.GetRow(irow);
    if ( ignoreVeto && fab->GetPlaneId().IsVetoShield() ) continue;
    const VldTimeStamp& ts = fab->GetInstallDate();
    //const PlexPlaneId& plnid = fab->GetPlaneId();
    //cout << "looking at " << plnid << " on " << ts << endl;
    if (ts >= alttime) return fab;
  }

  // if nothing after ... return empty to signal no extra info about next
  return 0;

}

//_____________________________________________________________________________
VldTimeStamp FabPlnInstallLookup::TimeNextInstall(const VldTimeStamp& start,
                                                  bool ignoreVeto) const
{
  // Find when the next plane was installed after some time

  const FabPlnInstall* fab = NextInstall(start,ignoreVeto);
  if (fab) return fab->GetInstallDate();
  else     return farFuture;

}

//_____________________________________________________________________________
const FabPlnInstall* 
FabPlnInstallLookup::GetFabPlnInstall(const PlexPlaneId& plnid) const
{
  // Find the entry for the given plane

  if (plnid.GetDetector() != fVldContext.GetDetector()) return 0;
  return fPlnInstallTbl.GetRowByIndex(plnid.GetPlane());
}

//_____________________________________________________________________________
std::vector<const FabSteelPlate*>
FabPlnInstallLookup::GetFabSteelPlates(const PlexPlaneId& plnid) const
{
  // Find the entry for the given plane
  std::vector<const FabSteelPlate*> vplates(8);

  if (plnid.GetDetector() != fVldContext.GetDetector()) return vplates;
  const FabPlnInstall* plnrow = fPlnInstallTbl.GetRowByIndex(plnid.GetPlane());
  if ( ! plnrow ) return vplates;

  UInt_t ntotplates = fSteelPlateTbl.GetNumRows();
  for (UInt_t indx=0; indx<8; ++indx) {
    std::string mfgid1 = plnrow->GetSteelSlabMfgId(indx);
    // not very efficient!
    for (UInt_t iplate = 0; iplate < ntotplates; ++iplate) {
      const FabSteelPlate* platerow = fSteelPlateTbl.GetRow(iplate);
      std::string mfgid2 = platerow->GetSteelSlabMfgId();
      if ( mfgid1 == mfgid2 ) vplates[indx] = platerow;
    }
  }

  return vplates;
}

//_____________________________________________________________________________
std::string FabPlnInstallLookup::GetScintMdlMfgId(const PlexScintMdlId& mdlid) const
{
  // Find the Mfg-Id for a logical ScintMdlId

  const FabPlnInstall* fab = GetFabPlnInstall(mdlid);
  if (!fab) {
    MSG("Fabrication",Msg::kInfo)
      << "ScintMdl " << mdlid << " not known to be installed" << endl;
    fab = dummyPlnInstall;
  }
  if (mdlid.GetModule() > 7) {
    MSG("Fabrication",Msg::kWarning)
      << "FabPlnInstall doesn't support modules > 7; "
      << mdlid << " out-of-range" << endl;
  }
  return fab->GetScintMdlMfgId(mdlid.GetModule());
}

//_____________________________________________________________________________
std::string FabPlnInstallLookup::GetSteelSlabMfgId(const PlexPlaneId& plnid,
                                                   UShort_t indx) const
{
  // Find the Mfg-Id for a logical slab in a logical plane

  const FabPlnInstall* fab = GetFabPlnInstall(plnid);
  if (!fab) {
    MSG("Fabrication",Msg::kInfo)
      << "Plane " << plnid << " not known to be installed" << endl;
    fab = dummyPlnInstall;
  }
  if (indx > 7) {
    MSG("Fabrication",Msg::kWarning)
      << "FabPlnInstall doesn't support steel slab > 7; "
      << indx << " out-of-range" << endl;
  }
  return fab->GetSteelSlabMfgId(indx);
}

//_____________________________________________________________________________
PlexScintMdlId FabPlnInstallLookup::WhereIsScintMdl(const std::string& mfgid) const
{
  // Find the logical ScintMdlId given the Mfg-Id
  // Uses a dumb linear search -- not very efficient
  UInt_t n = fPlnInstallTbl.GetNumRows();
  for (UInt_t irow=0; irow < n; ++irow) {
    const FabPlnInstall* fab = fPlnInstallTbl.GetRow(irow);
    for (UInt_t imdl=0; imdl < 8; ++imdl) {
      if (fab->GetScintMdlMfgId(imdl) == mfgid)
        return PlexScintMdlId(fab->GetPlaneId(),imdl);
    }
  }
  MSG("Fabrication",Msg::kInfo)
    << "no placement info for ScintMdl " << mfgid << endl;
  return PlexScintMdlId();
}

//_____________________________________________________________________________
std::pair<PlexPlaneId,UShort_t> 
FabPlnInstallLookup::WhereIsSteelSlab(const std::string& mfgid) const
{
  // Find the logical PlexPlaneId,slab# given the Mfg-Id
  // Uses a dumb linear search -- not very efficient
  UInt_t n = fPlnInstallTbl.GetNumRows();
  for (UInt_t irow=0; irow < n; ++irow) {
    const FabPlnInstall* fab = fPlnInstallTbl.GetRow(irow);
    for (UInt_t islab=0; islab < 8; ++islab) {
      if (fab->GetSteelSlabMfgId(islab) == mfgid)
        return pair<PlexPlaneId,UShort_t>(fab->GetPlaneId(),islab);
    }
  }
  MSG("Fabrication",Msg::kInfo)
    << "no placement info for steel slab " << mfgid << endl;
  return pair<PlexPlaneId,UShort_t>(PlexPlaneId(),0xffff);
}

//_____________________________________________________________________________
void FabPlnInstallLookup::Print(Option_t* /* option */) const
{
  // Print out what we've got in hand
  UInt_t n = fPlnInstallTbl.GetNumRows();
  for (UInt_t irow=0; irow < n; ++irow) {
    const FabPlnInstall* fab = fPlnInstallTbl.GetRow(irow);
    if (fab) cout << *fab;
  }
}

//_____________________________________________________________________________
unsigned int FabPlnInstallLookup::LookForOddEntries() const
{
  // Report all suspicious looking entries

  cout << endl << " === Looking for odd entries === " << endl;

  typedef set<UInt_t>                 uset_t;
  typedef set<UInt_t>::const_iterator usetitr_t;

  typedef set<std::string>            sset_t;
  typedef set<std::string>::iterator  ssetitr_t;
  typedef pair<ssetitr_t,bool>        ssetinsert_t;

  sset_t scintset, slabset; // list of all unique mfg-ids for dup search

  // slabs have "part numbers" easily confused with mfg-id's
  uset_t slabPartNums;
  slabPartNums.insert(350949);
  slabPartNums.insert(350950);
  slabPartNums.insert(350951);
  slabPartNums.insert(350952);
  slabPartNums.insert(350911);
  slabPartNums.insert(350912);
  slabPartNums.insert(350913);
  slabPartNums.insert(350914);

  unsigned int nerrors = 0;

  PlexPlaneId plnid;
  const FabPlnInstall* fab;
  int ipln_expect = 0;

  VldTimeStamp lastInstallDate((time_t)0,0);
  PlexPlaneId  lastPlaneId;
  // cross check for screwed up INSTALLDATE
  // will come out as "tomorrow" if entered as '0000-00-00 00:
  VldTimeStamp now;
  UInt_t year, month, day;
  now.GetDate(true,0,&year,&month,&day);
  VldTimeStamp today(year,month,day,0,0,0);
  VldTimeStamp tomorrow(year,month,day+1,0,0,0);
  //cout << " tomorrow is " << tomorrow.AsString("sql") << endl;
  
  UInt_t n = fPlnInstallTbl.GetNumRows();
  cout << "Total number of entries is: " << n << endl;
  cout << "Normal planes " << fFirstNormal << " to " << fLastNormal << endl;

  // create a map, so that results are in logical order
  // independent of how they come out of the DBI

  map<PlexPlaneId,const FabPlnInstall*> orderedmap;

  for (UInt_t irow=0; irow < n; ++irow) {
    fab = fPlnInstallTbl.GetRow(irow);
    plnid = fab->GetPlaneId(); plnid.SetIsSteel(kFALSE);
    orderedmap[plnid] = fab;
  }

  // loop over the map

  map<PlexPlaneId,const FabPlnInstall*>::const_iterator orderedItr;
  for (orderedItr  = orderedmap.begin();
       orderedItr != orderedmap.end();
       orderedItr++) {
    plnid = orderedItr->first;
    fab   = orderedItr->second;
    
    // check for monotonic, unitary increase in plane #
    // unless we're in the veto shield
    if ( ! plnid.IsVetoShield() ) {
      if (ipln_expect != plnid.GetPlane()) {
        cout << "Was expecting plane " << ipln_expect
             << ", instead got " << plnid << endl;
      }
    }
    ipln_expect = plnid.GetPlane()+1;

    // check for increasing installation date for FarDet (CalDet)
    //    (except for transition to veto shield)
    //    NearDet gets built from back to front...
    const VldTimeStamp& thisInstallDate = fab->GetInstallDate();
    // this check sometimes gets screwed up by UTC local confusion 
    if (thisInstallDate == tomorrow || thisInstallDate == today)
      cout << plnid << " tagged as installed on " 
           << thisInstallDate.AsString("sql") << "." << endl
           << "  probably entered as 0000-00-00 in DB table" << endl;
    bool out_of_order = false;
    switch (plnid.GetDetector()) {
    case Detector::kFar:
      if ( plnid.IsVetoShield() && ! lastPlaneId.IsVetoShield() )
        out_of_order = false; // this case is okay
      else
        out_of_order = ( thisInstallDate < lastInstallDate );
      break;
    case Detector::kNear:
      out_of_order = ( thisInstallDate > lastInstallDate );
      break;
    default:
      out_of_order = false; // don't bother checking CalDet
      break;
    }
    if (out_of_order) 
      cout << "Plane " << plnid << " installed on "
           << thisInstallDate.AsString("sql")
           << " installed before previous " << endl
           << "      " << lastPlaneId << " installed on " 
           << lastInstallDate.AsString("sql") << "." << endl;
    lastPlaneId     = plnid;
    lastInstallDate = thisInstallDate;

    uset_t badscint, badsteel;  // list of potential problem elements for pln

    UInt_t nmdls  = 8;
    UInt_t nslabs = 1;
    if (plnid.GetDetector() == Detector::kFar) {
      nslabs = ( plnid.IsVetoShield() ) ? 0 : 8;
    }

    switch (plnid.GetPlaneCoverage()) {
    case PlaneCoverage::kNoActive:     nmdls = 0; break;
    case PlaneCoverage::kNearPartial:  nmdls = 3; break;
    case PlaneCoverage::kNearFull:     nmdls = 5; break;
    case PlaneCoverage::kTotal:        nmdls = 8; 
      if (plnid.GetDetector()==Detector::kCalDet) nmdls = 1;
      break;
    case PlaneCoverage::kVScN: 
    case PlaneCoverage::kVSCN: 
    case PlaneCoverage::kVSeS: 
    case PlaneCoverage::kVSES: 
    case PlaneCoverage::kVScS: 
    case PlaneCoverage::kVSCS: 
    case PlaneCoverage::kVSeN: 
    case PlaneCoverage::kVSEN: 
      nmdls = 1; break;
    default:
      // complain
      break;
    }

    //
    // Check for oddities in the ScintMdl's
    //
    for (UInt_t imdl=0; imdl < 8; ++imdl) {
      string mfgid = fab->GetScintMdlMfgId(imdl);

      if ( imdl >= nmdls ) {
        // non-existent modules (ie. shouldn't be there)
        bool ismissing = (strlen(mfgid.c_str()) == 0 ||
                          strncmp(mfgid.c_str(),"n/a",3) == 0 );
        if (!ismissing) {
          nerrors++;
          cout << "On plane " << plnid << " mdl " << imdl
               << " should be 'n/a' but was '" << mfgid << "' " << endl;
        }
        continue; // move on to next module 
      }

      bool problem = false;
      // mfgid should be 8 char   FFFxxxxT  F=factory, xxxx=#, T=type
      if (strlen(mfgid.c_str()) < 8) problem = true;  
      PlexScintMdlId  mdlid(plnid,imdl);
      const char* asstring = mdlid.AsString();
      const char mdltype = toupper(asstring[10]);
      if      (strncmp(mfgid.c_str(),"CIT",3) == 0 ||
               strncmp(mfgid.c_str(),"UMN",3) == 0    ) {
        if (mfgid.c_str()[7] != mdltype) problem = true;
        }
      else problem = true; // neither CIT nor UMN

      if (problem) badscint.insert(imdl);

      if (!problem) {
        // doesn't look to be a problem id
        ssetinsert_t inpos = scintset.insert(mfgid);
        if (!inpos.second ) {
          nerrors++;
          // failed to insert because it already exists
          // WhereIsScintMdl won't work if things are misordered
          cout << "Duplicate scint mfg-id '" << mfgid << "' in "
               << mdlid << " (" << imdl << ") previously in " 
               << WhereIsScintMdl(mfgid) << endl;
        }
      }
    } // loop over all scint modules

    //
    // Check for oddities in the steel slabs
    //
    for (UInt_t islab=0; islab < 8; ++islab) {
      string mfgid = fab->GetSteelSlabMfgId(islab);

      if ( islab >= nslabs ) {
        // non-existent modules (ie. shouldn't be there)
        bool ismissing = (strlen(mfgid.c_str()) == 0 ||
                          strncmp(mfgid.c_str(),"n/a",3) == 0 );
        if (!ismissing) {
          nerrors++;
          cout << "On plane " << plnid << " slab " << islab
               << " should be 'n/a' but was '" << mfgid << "' " << endl;
        }
        continue; // move on to next module 
      }

      Int_t nid = -1;
      Int_t nscan = sscanf(mfgid.c_str(),"%d",&nid);
      bool problem = false;
      // does it look to be in range
      if (nscan != 1 || nid<100000 || nid>400000 ) problem = true;
      if ( problem && (nid>700000 && nid<=799999)) problem = false;  //special case for some duplicates

      if (problem) badsteel.insert(islab);

      if (!problem) {
        // check if it looks like a part #
        if (slabPartNums.find(nid) != slabPartNums.end()) {
          nerrors++;
          cout << "Slab " << plnid <<"," << islab << " has mfg-id '"
               << mfgid << "' which is a part #" << endl;
        }
        else {
          // doesn't look to be a problem id
          ssetinsert_t inpos = slabset.insert(mfgid);
          if (!inpos.second ) {
            nerrors++;
            // failed to insert because it already exists
            std::pair<PlexPlaneId,UShort_t> otherloc = WhereIsSteelSlab(mfgid);
            cout << "Duplicate slab mfg-id '" << mfgid << "' in "
                 << plnid << "," << islab << " previously in " 
                 << otherloc.first << "," << otherloc.second << endl;
          } // not a part number either
        }
      }
    } // loop over all slabs

    if (! (badscint.empty() && badsteel.empty()) ) {
      cout << "Potential problem on " << plnid.AsString("c") << ": " << endl;
      usetitr_t scintitr = badscint.begin();
      while (scintitr != badscint.end()) {
        nerrors++;
        PlexScintMdlId mdlid(plnid,*scintitr);
        cout << "  suspicious scint mdl [" << mdlid.AsString()
             << "] mfg-id: '" << fab->GetScintMdlMfgId(*scintitr) 
             << "'" << endl;
        scintitr++;
      }
      usetitr_t steelitr = badsteel.begin();
      while (steelitr != badsteel.end()) {
        nerrors++;
        cout << "  suspicious steel slab [" << *steelitr 
             << "] mfg-id: '" << fab->GetSteelSlabMfgId(*steelitr) 
             << "'" << endl;
        steelitr++;
      }
    } // dealt with problem

  } // loop over all entries (planes)

  cout << "last plane seen was: " << plnid << endl << endl;

  return nerrors;
}

//_____________________________________________________________________________

---