UgliDbiTables.cxx

Go to the documentation of this file.

// $Id: UgliDbiTables.cxx,v 1.15 2008/01/09 18:06:17 rhatcher Exp $
//
// UgliDbiTables
//
// UgliDbiTables - for conveniently passing around collection of tables
//
// Author:  R. Hatcher 2002.01.24
//

#include "UgliGeometry/UgliDbiTables.h"

#include "Plex/PlexPlaneId.h"
#include "Conventions/Munits.h"
#include "TMath.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliDbiTables.cxx,v 1.15 2008/01/09 18:06:17 rhatcher Exp $");

#include "TSystem.h"
#include "TStopwatch.h"

#include <set>
#include <fstream>
using namespace std;

ClassImp(UgliDbiTables)

//_____________________________________________________________________________
// Initialize static members

map<Detector::Detector_t,Bool_t> UgliDbiTables::fgAlgorithmic;
map<Detector::Detector_t,Bool_t> UgliDbiTables::fgCutOnPlnInstall;

//_____________________________________________________________________________
void UgliDbiTablesInitDefaults() 
{
  static bool first = true;
  if (!first) return;
  first = false;

  bool algdflt = false;
  if (gSystem->Getenv("ALG_UGLI")) {
    MSG("Ugli",Msg::kInfo)
      << "UgliDbiTables::InitDefaults saw ALG_UGLI"
      << endl;
    algdflt = true;
  }
  // ensure the algorithmic approach is off for each detector
  UgliDbiTables::fgAlgorithmic[Detector::kUnknown  ] = algdflt;
  UgliDbiTables::fgAlgorithmic[Detector::kNear     ] = algdflt;
  UgliDbiTables::fgAlgorithmic[Detector::kFar      ] = algdflt;
  UgliDbiTables::fgAlgorithmic[Detector::kCalDet   ] = algdflt;
  UgliDbiTables::fgAlgorithmic[Detector::kTestStand] = algdflt;
  UgliDbiTables::fgAlgorithmic[Detector::kMapper   ] = algdflt;

  bool cutdflt = false;
  if (gSystem->Getenv("CUT_UGLI")) {
    MSG("Ugli",Msg::kInfo)
      << "UgliDbiTables::InitDefaults saw CUT_UGLI"
      << endl;
    cutdflt = true;
  }
  // ensure the algorithmic approach is off for each detector
  UgliDbiTables::fgCutOnPlnInstall[Detector::kUnknown  ] = cutdflt;
  UgliDbiTables::fgCutOnPlnInstall[Detector::kNear     ] = cutdflt;
  UgliDbiTables::fgCutOnPlnInstall[Detector::kFar      ] = cutdflt;
  UgliDbiTables::fgCutOnPlnInstall[Detector::kCalDet   ] = cutdflt;
  UgliDbiTables::fgCutOnPlnInstall[Detector::kTestStand] = cutdflt;
  UgliDbiTables::fgCutOnPlnInstall[Detector::kMapper   ] = cutdflt;

}

//_____________________________________________________________________________
void UgliDbiTables::SetAlgorithmic(Detector::Detector_t det, Bool_t flag)
{
  // set whether algorithmic approach is taken of any detector
  // disallow setting it for one's we haven't implemented
  // always allow setting it off
  
  UgliDbiTablesInitDefaults();
  if (!flag) fgAlgorithmic[det] = false;
  else {
    bool implemented = false;
    switch (det) {
    case Detector::kNear:   break;
    case Detector::kFar:    implemented = true; break;
    case Detector::kCalDet: implemented = true; break;
    default: break;
    }
    if (implemented) fgAlgorithmic[det] = true;
    else 
      MSG("Ugli",Msg::kWarning)
        << "UgliDbiTables::SetAlgorithmic - unable to generate "
        << Detector::AsString(det) << " geometry "
        << endl;
  }
}

Bool_t UgliDbiTables::IsAlgorithmic(Detector::Detector_t det)
{ UgliDbiTablesInitDefaults(); return fgAlgorithmic[det]; }

//_____________________________________________________________________________
void UgliDbiTables::SetCutOnPlnInstall(Detector::Detector_t det,
                                       Bool_t flag)
{
  // set whether plane entry into geomtry should depend of
  // FabPlnInstall table entries.
  
  UgliDbiTablesInitDefaults();
  fgCutOnPlnInstall[det] = flag;
}

Bool_t UgliDbiTables::IsCutOnPlnInstall(Detector::Detector_t det)
{ UgliDbiTablesInitDefaults(); return fgCutOnPlnInstall[det]; }

//_____________________________________________________________________________

UgliDbiTables::UgliDbiTables(const VldContext& vldc) :
   fAlgorithmic(false),      fVldContext(vldc),
   fDetector(vldc.GetDetector()),
   fGeomTbl(vldc),           fSteelTbl(vldc), 
   fScintPlnStructTbl(vldc), fScintPlnTbl(vldc),
   fScintMdlStructTbl(vldc), fScintMdlTbl(vldc), 
   fStripStructTbl(vldc),    fStripTbl(vldc)
{
   // Normal constructor
   MSG("Ugli",Msg::kDebug) << "UgliDbiTables normal vldc ctor" << endl;
}

//_____________________________________________________________________________

UgliDbiTables::UgliDbiTables(const VldContext& vldc, bool /* b */) :
   fAlgorithmic(true), fVldContext(vldc), fDetector(vldc.GetDetector()),
   fScintPlnStructTbl(vldc), 
   fScintMdlStructTbl(vldc), 
   fStripStructTbl(vldc)
{
   // Empty constructor
   // "b" is used only to make the signature different
   MSG("Ugli",Msg::kDebug) << "UgliDbiTables empty ctor" << endl;
}

//_____________________________________________________________________________

UgliDbiTables::~UgliDbiTables()
{
   // Normal dtor
   MSG("Ugli",Msg::kDebug) << "UgliDbiTables default dtor" << endl;
}

//_____________________________________________________________________________

const UgliDbiGeometry* UgliDbiTables::GetDbiGeometry() const
{

  // if use real tables if we have them

  if (!fAlgorithmic) {
    int nrows = fGeomTbl.GetNumRows();
    if (nrows != 1) {
       MSG("Ugli",Msg::kError)
          << "UgliDbiGeometry unexpectedly had " 
          << nrows << " rows " << endl
          << " for VldContext: " << fVldContext << endl;
       if (nrows < 1) return 0;
    }
    return fGeomTbl.GetRow(0);
  }

  // algorithmic approach

  static UgliDbiGeometry* geo = 0;
  if (geo) { delete geo; geo = 0; }

  const Float_t near_min[] = {-4.358,-2.591,-49.07};
  const Float_t near_max[] = { 4.786, 2.591, 19.63};
  const Float_t far_min[] = {-6.9, -5.8, -0.75};
  const Float_t far_max[] = { 6.9,  5.8, 81.55};
  const Float_t caldet_min[] = {-1.5, -1.5,  0.0};
  const Float_t caldet_max[] = { 1.5,  1.5, 14.0};

  switch (fDetector) {
  case Detector::kNear:
    geo = new UgliDbiGeometry(Detector::kNear,false,near_min,near_max);
    break;
  case Detector::kFar:
    geo = new UgliDbiGeometry(Detector::kFar,false,far_min,far_max);
    break;
  case Detector::kCalDet:
    geo = new UgliDbiGeometry(Detector::kCalDet,true,caldet_min,caldet_max);
    break;
  default:
    MSG("Ugli",Msg::kFatal) 
      << "no algorithmic UgliDbiGeometry for " << fVldContext << endl;
    break;
  }
  return geo;
}

//_____________________________________________________________________________
unsigned int UgliDbiTables::GetNumSteelRows() const
{

  //#define LIMITPLNS
#ifdef  LIMITPLNS
  unsigned int nmax = 4;
  MSG("Ugli",Msg::kError)
    << " **************** force " << nmax << " planes " << endl;
  return nmax;
#endif


  // if use real tables if we have them

  if (!fAlgorithmic) {
    int nrows = fSteelTbl.GetNumRows();
    if (nrows < 1) {
       MSG("Ugli",Msg::kError)
          << "UgliDbiSteelPln unexpectedly had " 
          << nrows << " rows " << endl;
       if (nrows < 1) return 0;
    }
    return nrows;
  }

  // algorithmic approach

  switch (fDetector) {
  case Detector::kNear:   return PlexPlaneId::LastPlaneNearSpect()+1;
  case Detector::kFar:    return PlexPlaneId::LastPlaneFarSM1()+1;
  case Detector::kCalDet: return 5*12 + 4 + 1;
  default:
    MSG("Ugli",Msg::kFatal) 
      << "no algorithmic GetNumSteelRows for " << fVldContext << endl;
  }
  return 0;
}

//_____________________________________________________________________________
const UgliDbiSteelPln* UgliDbiTables::GetDbiSteelPln(UInt_t irow) const
{

  // if use real tables if we have them

  if (!fAlgorithmic) return fSteelTbl.GetRow(irow);

  // algorithmic approach

  return GetDbiSteelPlnByIndex(irow);
}

//_____________________________________________________________________________
const UgliDbiSteelPln* UgliDbiTables::GetDbiSteelPlnByIndex(UInt_t ipln) const
{

  // if use real tables if we have them

  if (!fAlgorithmic) return fSteelTbl.GetRowByIndex(ipln);

  // algorithmic approach

  static UgliDbiSteelPln* steelRow = 0;
  if (steelRow) { delete steelRow; steelRow = 0; }

  PlexPlaneId plnid(fDetector,ipln,true);
  const float steelthick = 2.54 * Munits::cm;
  const float steelpitch = 5.94 * Munits::cm;
  const float pi    = TMath::Pi();
  const float piby2  = 0.5*TMath::Pi();
  const float pi3by2 = 1.5*TMath::Pi();

  switch (fDetector) {
    //  case Detector::kNear:
    //    steelRow = 0;
    //    break;
  case Detector::kFar:
    {
      int melt = 1000120;
      float totalz = steelthick + 
        ((PlaneCoverage::kNoActive==plnid.GetPlaneCoverage()) ? 
         0.0020 : 0.0130);
      const float zback0 = -0.0320 + steelpitch;
      // nominal steel spacing
      float zback = zback0 + (float)(ipln)*steelpitch; 
      if ( ipln > PlexPlaneId::LastPlaneFarSM0() )
        zback += 1.5 * Munits::m;  // supermodule gap
      const float piby2 = 0.5*TMath::Pi();
      const float x0=0.0, y0=0.0;
      const float thetaX=piby2, phiX=0, thetaY=piby2, phiY=piby2, 
                  thetaZ=0, phiZ=0;

      steelRow = new UgliDbiSteelPln(plnid,melt,steelthick,
                                     totalz,x0,y0,zback,
                                     thetaX,phiX,thetaY,phiY,thetaZ,phiZ);
    }
    break;
  case Detector::kCalDet:
    {
      int melt = 0;
      float thick  = steelthick;
      float totalz = 3.84 * Munits::cm;
      float x0=0, y0=0;
      float zback = (8.68 * Munits::cm) + (float)ipln*steelpitch;
      float thetaX=piby2, phiX=0, thetaY=piby2, phiY=piby2, thetaZ=0, phiZ=0;

      if (ipln >= 61) {
        thick = 0;
        totalz = 1.101 * Munits::cm;
        if (ipln&1) y0 = -1.600 * Munits::m;
        else        y0 = -1.611 * Munits::m;

        const float zbcosmic[] = { 0.5055, 1.5055, 2.0695, 3.0695};
        zback = zbcosmic[ipln-61];
        thetaX=pi; phiX=0; thetaY=piby2; phiY=0; thetaZ=piby2; phiZ=pi3by2;
      }
      steelRow = new UgliDbiSteelPln(plnid,melt,steelthick,
                                     totalz,x0,y0,zback,
                                     thetaX,phiX,thetaY,phiY,thetaZ,phiZ);
    }
    break;
  default:
    break;
  }
  if (!steelRow) 
    MSG("Ugli",Msg::kFatal) 
      << "no algorithmic UgliDbiSteelPln for " << fVldContext << endl;

  return steelRow;
}

//_____________________________________________________________________________
const UgliDbiScintPln* UgliDbiTables::GetDbiScintPlnByIndex(UInt_t ipln) const
{

  // if use real tables if we have them

  if (!fAlgorithmic) return fScintPlnTbl.GetRowByIndex(ipln);

  // algorithmic approach

  static UgliDbiScintPln* scintPlnRow = 0;
  if (scintPlnRow) { delete scintPlnRow; scintPlnRow = 0; }

  PlexPlaneId plnid(fDetector,ipln,false);
  const float scintthick = 1.1 * Munits::cm;
  const float nominalgap = 2.0 * Munits::mm;

  const float piby4  = 0.25*TMath::Pi();
  const float pi3by2 = 1.5*TMath::Pi();

  const float vrot = piby4;
  const float urot = -vrot;

  switch (fDetector) {
    //  case Detector::kNear:
    //    steelRow = 0;
    //    break;
  case Detector::kFar:
    {
      float gap = nominalgap;
      const float x0=0.0, y0=0.0;
      float zrot = (PlaneView::kV==plnid.GetPlaneView()) ? vrot : urot ;

      scintPlnRow = new UgliDbiScintPln(plnid,scintthick,gap,x0,y0,zrot);
    }
    break;
  case Detector::kCalDet:
    {
      float gap = nominalgap;
      const float x0=0.0, y0=0.0;
      float zrot = (ipln&1) ? pi3by2 : 0.0;
      if (ipln >= 61 ) {
        gap = 0.0;
        zrot = 0;
      }
      scintPlnRow = new UgliDbiScintPln(plnid,scintthick,gap,x0,y0,zrot);
    }
    break;
  default:
    break;
  }
  if (!scintPlnRow)
    MSG("Ugli",Msg::kFatal) 
      << "no algorithmic UgliDbiScintPln for " << fVldContext << endl;

  return scintPlnRow;
}

//_____________________________________________________________________________
const UgliDbiScintMdl* 
UgliDbiTables::GetDbiScintMdlById(const PlexScintMdlId& mdlid) const
{
   int mdl_indx = UgliDbiScintMdl::HashToIndex(mdlid);

  // if use real tables if we have them

  if (!fAlgorithmic) return fScintMdlTbl.GetRowByIndex(mdl_indx);

  // algorithmic approach

  static UgliDbiScintMdl* scintMdlRow = 0;
  if (scintMdlRow) { delete scintMdlRow; scintMdlRow = 0; }

  unsigned int ipln = mdlid.GetPlane();
  unsigned int imdl = mdlid.GetModule();

  switch (fDetector) {
    //  case Detector::kNear:
    //    steelRow = 0;
    //    break;
  case Detector::kFar:
    {
      //const int nstrips_mdl[] = { 28, 28, 20, 20, 20, 20, 28, 28};
      //const int nmdl = sizeof(nstrips_mdl)/sizeof(int);
      const float farMdlWidth[8] =
        { 1.153, 1.153, 0.825, 0.825, 0.825, 0.825, 1.153, 1.153 };
      const float farMdlTPos[8] =
        { -3.378, -2.225, -1.237, -0.412, 0.412, 1.237, 2.225, 3.378 };

      float width = farMdlWidth[imdl];
      float tpos  = farMdlTPos[imdl];
      const float lpos = 0.0;
      const float zrot = 0.0;

      // completely bogus clear & WLS lengths
      float clearE=3, clearW=3, wlsE=0, wlsW=0;

      scintMdlRow = new UgliDbiScintMdl(mdlid,width,tpos,lpos,zrot,
                                        clearE,clearW,wlsE,wlsW);
    }
    break;
  case Detector::kCalDet:
    {
      const float width = 0.9835 * Munits::m;
      const float tpos=0.0, lpos=0.0, zrot=0.0;
      float              clearE=0, clearW=6, wlsE=4, wlsW=0;
      if (ipln & 1)    { clearE=6; clearW=0; wlsE=0; wlsW=4; }
      if (ipln >= 61 ) { clearE=6; clearW=6; wlsE=0; wlsW=0; }
      scintMdlRow = new UgliDbiScintMdl(mdlid,width,tpos,lpos,zrot,
                                        clearE,clearW,wlsE,wlsW);
    }
    break;
  default:
    break;
  }
  if (!scintMdlRow)
    MSG("Ugli",Msg::kFatal) 
      << "no algorithmic UgliDbiScintMdl for " << fVldContext << endl;

  return scintMdlRow;
}

//_____________________________________________________________________________
const UgliDbiStrip* 
UgliDbiTables::GetDbiStripById(const PlexStripEndId& seid) const
{
   int strip_indx = UgliDbiStrip::HashToIndex(seid);

  // if use real tables if we have them

  if (!fAlgorithmic) return fStripTbl.GetRowByIndex(strip_indx);

  // algorithmic approach

  static UgliDbiStrip* stripRow = 0;
  if (stripRow) { delete stripRow; stripRow = 0; }

  //unsigned int ipln   = seid.GetPlane();
  unsigned int istrip = seid.GetStrip();
  const float strip_width = 4.1 * Munits::cm;
  const float lpos = 0.0;
  const float zrot = 0.0;

  switch (fDetector) {
    //  case Detector::kNear:
    //    steelRow = 0;
    //    break;
  case Detector::kFar:
    {
      const int nstrips_mdl[] = { 28, 28, 20, 20, 20, 20, 28, 28};
      //const int nmdl = sizeof(nstrips_mdl)/sizeof(int);

      PlexScintMdlId mdlid = seid.GetScintMdlId();
      int stripinmdl       = seid.GetStripInMdl();

      int nstrips = nstrips_mdl[mdlid.GetModule()];
      float toff = ((float)(nstrips)/2 - 0.5);
      float tpos = ((float)stripinmdl - toff)*strip_width;

      stripRow = new UgliDbiStrip(seid,tpos,lpos,zrot);

    }
    break;
  case Detector::kCalDet:
    {
      const int nstrips=24;
      const float toff = ((float)(nstrips)/2 - 0.5);
      float tpos = ((float)istrip - toff)*strip_width;
      stripRow = new UgliDbiStrip(seid,tpos,lpos,zrot);
    }
    break;
  default:
    break;
  }
  if (!stripRow)
    MSG("Ugli",Msg::kFatal) 
      << "no algorithmic UgliDbiStrip for " << fVldContext << endl;

  return stripRow;
}

//_____________________________________________________________________________

static int gVetoOnly = 0;

template<class T>
bool alwaysTrue(const T* /* whoCares */ ) { return true; }

template<class T>
bool vetoPln(const T* dbirow )
{
    if ( gVetoOnly == 0 ) return true;
    bool isVeto = dbirow->GetPlaneId().IsVetoShield();
    bool keep = true;
    if ( gVetoOnly > 0 && ! isVeto ) keep = false;
    if ( gVetoOnly < 0 &&   isVeto ) keep = false;
    //cout  << dbirow->GetPlaneId() << " keep = " 
    //      << ((keep)?"YES":"no") << endl;
    return keep;
}

template<class T>
bool vetoMdl(const T* dbirow )
{
    if ( gVetoOnly == 0 ) return true;
    bool isVeto = dbirow->GetScintMdlId().IsVetoShield();
    bool keep = true;
    if ( gVetoOnly > 0 && ! isVeto ) keep = false;
    if ( gVetoOnly < 0 &&   isVeto ) keep = false;
    //cout  << dbirow->GetPlaneId() << " keep = " 
    //      << ((keep)?"YES":"no") << endl;
    return keep;
}

template<class T>
bool vetoStrip(const T* dbirow )
{
    if ( gVetoOnly == 0 ) return true;
    bool isVeto = dbirow->GetStripEndId().IsVetoShield();
    bool keep = true;
    if ( gVetoOnly > 0 && ! isVeto ) keep = false;
    if ( gVetoOnly < 0 &&   isVeto ) keep = false;
    //cout  << dbirow->GetPlaneId() << " keep = " 
    //      << ((keep)?"YES":"no") << endl;
    return keep;
}

//_____________________________________________________________________________

template<class T>
void WriteTableToCSVFile(const DbiResultPtr<T>& tbl, 
                         string basename,
                         bool testFunc(const T*) )
{

   // write out CSV (comma separated value) text files
   string fnamedata = basename + ".csv";
   string fnamevld  = basename + "VLD.csv";

   cout << " ---------------- Write " << fnamedata << endl;
   TStopwatch timer;
   timer.Start();
    
   ofstream datafile(fnamedata.c_str());
   ofstream vldfile(fnamevld.c_str());

   string vldheaderline = "SEQNO INT PRIMARY KEY,TIMESTART DATETIME,TIMEEND DATETIME,DETECTORMASK TINYINT,SIMMASK TINYINT,TASK INT,AGGREGATENO INT,CREATIONDATE DATETIME,INSERTDATE DATETIME";
   vldfile << vldheaderline << endl;

   bool doheader = true;
   std::set<const DbiValidityRec*> usedvld;
   for (UInt_t irow=0; irow < tbl.GetNumRows(); ++irow) {
      const T* uglirow = tbl.GetRow(irow);
      if ( ! uglirow ) {
          cout << "Empty row???" << endl;
          continue;
      }
      // test if it passes a veto criteria (+1=only veto, 0=all, -1=no veto)
      if ( ! testFunc(uglirow) ) continue;

      const DbiValidityRec* vldrec = tbl.GetValidityRec(uglirow);
      const char* opt = (doheader)? "H,":",";   // CVS w/ or w/o header
      uglirow->FormatToOStream(datafile,opt,vldrec);
      doheader = false;
      if ( usedvld.find(vldrec) == usedvld.end() ) {
         VldRange vldr = vldrec->GetVldRange();
         vldfile 
             << vldrec->GetSeqNo() << ','
             << '"' << vldr.GetTimeStart().AsString("sql") << "\","
             << '"' << vldr.GetTimeEnd().AsString("sql") << "\","
             << vldr.GetDetectorMask() << ','
             << vldr.GetSimMask() << ','
             << vldrec->GetTask() << ','
             << vldrec->GetAggregateNo() << ','
             << '"' << vldrec->GetCreationDate().AsString("sql") << "\","
             << '"' << vldrec->GetInsertDate().AsString("sql") << '"'
             << endl;
         usedvld.insert(vldrec);
      }
   }

   timer.Stop();
   timer.Print();

}

//_____________________________________________________________________________

void UgliDbiTables::WriteCSVFiles(int vetoOnly ) const
{

    // write out CSV (comma separated value) text files

    gVetoOnly = vetoOnly;

    WriteTableToCSVFile(fGeomTbl,"UGLIDBIGEOMETRY",alwaysTrue);

    WriteTableToCSVFile(fSteelTbl,"UGLIDBISTEELPLN",vetoPln);

    WriteTableToCSVFile(fScintPlnStructTbl,"UGLIDBISCINTPLNSTRUCT",alwaysTrue);
    WriteTableToCSVFile(fScintPlnTbl,"UGLIDBISCINTPLN",vetoPln);

    WriteTableToCSVFile(fScintMdlStructTbl,"UGLIDBISCINTMDLSTRUCT",alwaysTrue);
    WriteTableToCSVFile(fScintMdlTbl,"UGLIDBISCINTMDL",vetoMdl);

    WriteTableToCSVFile(fStripStructTbl,"UGLIDBISTRIPSTRUCT",alwaysTrue);
    WriteTableToCSVFile(fStripTbl,"UGLIDBISTRIP",vetoStrip);

}

//_____________________________________________________________________________

---