UgliDbiTables Class Reference

#include <UgliDbiTables.h>

List of all members.

Public Member Functions

 UgliDbiTables (const VldContext &vldc)
 UgliDbiTables (const VldContext &vldc, bool b)
virtual ~UgliDbiTables ()
const UgliDbiGeometryGetDbiGeometry () const
unsigned int GetNumSteelRows () const
const UgliDbiSteelPlnGetDbiSteelPln (UInt_t irow) const
const UgliDbiSteelPlnGetDbiSteelPlnByIndex (UInt_t ipln) const
const UgliDbiScintPlnGetDbiScintPlnByIndex (UInt_t ipln) const
const UgliDbiScintMdlGetDbiScintMdlById (const PlexScintMdlId &mdlid) const
const UgliDbiStripGetDbiStripById (const PlexStripEndId &seid) const
void WriteCSVFiles (int vetoOnly=0) const

Static Public Member Functions

static void SetAlgorithmic (Detector::Detector_t det, Bool_t flag=kFALSE)
static Bool_t IsAlgorithmic (Detector::Detector_t det)
static void SetCutOnPlnInstall (Detector::Detector_t det, Bool_t flag=kFALSE)
static Bool_t IsCutOnPlnInstall (Detector::Detector_t det)

Public Attributes

Bool_t fAlgorithmic
VldContext fVldContext
Detector::Detector_t fDetector
DbiResultPtr< UgliDbiGeometryfGeomTbl
DbiResultPtr< UgliDbiSteelPlnfSteelTbl
DbiResultPtr
< UgliDbiScintPlnStruct
fScintPlnStructTbl
DbiResultPtr< UgliDbiScintPlnfScintPlnTbl
DbiResultPtr
< UgliDbiScintMdlStruct
fScintMdlStructTbl
DbiResultPtr< UgliDbiScintMdlfScintMdlTbl
DbiResultPtr< UgliDbiStripStructfStripStructTbl
DbiResultPtr< UgliDbiStripfStripTbl

Static Public Attributes

static std::map
< Detector::Detector_t, Bool_t > 
fgAlgorithmic
static std::map
< Detector::Detector_t, Bool_t > 
fgCutOnPlnInstall

Detailed Description

Definition at line 27 of file UgliDbiTables.h.


Constructor & Destructor Documentation

UgliDbiTables::UgliDbiTables ( const VldContext vldc  ) 

Definition at line 120 of file UgliDbiTables.cxx.

References Msg::kDebug, and MSG.

00120                                                    :
00121    fAlgorithmic(false),      fVldContext(vldc),
00122    fDetector(vldc.GetDetector()),
00123    fGeomTbl(vldc),           fSteelTbl(vldc), 
00124    fScintPlnStructTbl(vldc), fScintPlnTbl(vldc),
00125    fScintMdlStructTbl(vldc), fScintMdlTbl(vldc), 
00126    fStripStructTbl(vldc),    fStripTbl(vldc)
00127 {
00128    // Normal constructor
00129    MSG("Ugli",Msg::kDebug) << "UgliDbiTables normal vldc ctor" << endl;
00130 }

UgliDbiTables::UgliDbiTables ( const VldContext vldc,
bool  b 
)

Definition at line 134 of file UgliDbiTables.cxx.

References Msg::kDebug, and MSG.

00134                                                                  :
00135    fAlgorithmic(true), fVldContext(vldc), fDetector(vldc.GetDetector()),
00136    fScintPlnStructTbl(vldc), 
00137    fScintMdlStructTbl(vldc), 
00138    fStripStructTbl(vldc)
00139 {
00140    // Empty constructor
00141    // "b" is used only to make the signature different
00142    MSG("Ugli",Msg::kDebug) << "UgliDbiTables empty ctor" << endl;
00143 }

UgliDbiTables::~UgliDbiTables (  )  [virtual]

Definition at line 147 of file UgliDbiTables.cxx.

References Msg::kDebug, and MSG.

00148 {
00149    // Normal dtor
00150    MSG("Ugli",Msg::kDebug) << "UgliDbiTables default dtor" << endl;
00151 }


Member Function Documentation

const UgliDbiGeometry * UgliDbiTables::GetDbiGeometry (  )  const

Definition at line 155 of file UgliDbiTables.cxx.

References fAlgorithmic, fDetector, fGeomTbl, fVldContext, DbiResultPtr< T >::GetNumRows(), DbiResultPtr< T >::GetRow(), Detector::kCalDet, Msg::kError, Detector::kFar, Msg::kFatal, Detector::kNear, and MSG.

Referenced by GeoGeometry::BuildGeometry(), and UgliGeometry::BuildNodes().

00156 {
00157 
00158   // if use real tables if we have them
00159 
00160   if (!fAlgorithmic) {
00161     int nrows = fGeomTbl.GetNumRows();
00162     if (nrows != 1) {
00163        MSG("Ugli",Msg::kError)
00164           << "UgliDbiGeometry unexpectedly had " 
00165           << nrows << " rows " << endl
00166           << " for VldContext: " << fVldContext << endl;
00167        if (nrows < 1) return 0;
00168     }
00169     return fGeomTbl.GetRow(0);
00170   }
00171 
00172   // algorithmic approach
00173 
00174   static UgliDbiGeometry* geo = 0;
00175   if (geo) { delete geo; geo = 0; }
00176 
00177   const Float_t near_min[] = {-4.358,-2.591,-49.07};
00178   const Float_t near_max[] = { 4.786, 2.591, 19.63};
00179   const Float_t far_min[] = {-6.9, -5.8, -0.75};
00180   const Float_t far_max[] = { 6.9,  5.8, 81.55};
00181   const Float_t caldet_min[] = {-1.5, -1.5,  0.0};
00182   const Float_t caldet_max[] = { 1.5,  1.5, 14.0};
00183 
00184   switch (fDetector) {
00185   case Detector::kNear:
00186     geo = new UgliDbiGeometry(Detector::kNear,false,near_min,near_max);
00187     break;
00188   case Detector::kFar:
00189     geo = new UgliDbiGeometry(Detector::kFar,false,far_min,far_max);
00190     break;
00191   case Detector::kCalDet:
00192     geo = new UgliDbiGeometry(Detector::kCalDet,true,caldet_min,caldet_max);
00193     break;
00194   default:
00195     MSG("Ugli",Msg::kFatal) 
00196       << "no algorithmic UgliDbiGeometry for " << fVldContext << endl;
00197     break;
00198   }
00199   return geo;
00200 }

const UgliDbiScintMdl * UgliDbiTables::GetDbiScintMdlById ( const PlexScintMdlId mdlid  )  const

Definition at line 395 of file UgliDbiTables.cxx.

References fAlgorithmic, fDetector, fScintMdlTbl, fVldContext, PlexScintMdlId::GetModule(), PlexPlaneId::GetPlane(), DbiResultPtr< T >::GetRowByIndex(), UgliDbiScintMdl::HashToIndex(), Detector::kCalDet, Detector::kFar, Msg::kFatal, Munits::m, and MSG.

Referenced by GeoGeometry::BuildModules(), UgliScintMdlNode::UgliScintMdlNode(), and UgliStripNode::UgliStripNode().

00396 {
00397    int mdl_indx = UgliDbiScintMdl::HashToIndex(mdlid);
00398 
00399   // if use real tables if we have them
00400 
00401   if (!fAlgorithmic) return fScintMdlTbl.GetRowByIndex(mdl_indx);
00402 
00403   // algorithmic approach
00404 
00405   static UgliDbiScintMdl* scintMdlRow = 0;
00406   if (scintMdlRow) { delete scintMdlRow; scintMdlRow = 0; }
00407 
00408   unsigned int ipln = mdlid.GetPlane();
00409   unsigned int imdl = mdlid.GetModule();
00410 
00411   switch (fDetector) {
00412     //  case Detector::kNear:
00413     //    steelRow = 0;
00414     //    break;
00415   case Detector::kFar:
00416     {
00417       //const int nstrips_mdl[] = { 28, 28, 20, 20, 20, 20, 28, 28};
00418       //const int nmdl = sizeof(nstrips_mdl)/sizeof(int);
00419       const float farMdlWidth[8] =
00420         { 1.153, 1.153, 0.825, 0.825, 0.825, 0.825, 1.153, 1.153 };
00421       const float farMdlTPos[8] =
00422         { -3.378, -2.225, -1.237, -0.412, 0.412, 1.237, 2.225, 3.378 };
00423 
00424       float width = farMdlWidth[imdl];
00425       float tpos  = farMdlTPos[imdl];
00426       const float lpos = 0.0;
00427       const float zrot = 0.0;
00428 
00429       // completely bogus clear & WLS lengths
00430       float clearE=3, clearW=3, wlsE=0, wlsW=0;
00431 
00432       scintMdlRow = new UgliDbiScintMdl(mdlid,width,tpos,lpos,zrot,
00433                                         clearE,clearW,wlsE,wlsW);
00434     }
00435     break;
00436   case Detector::kCalDet:
00437     {
00438       const float width = 0.9835 * Munits::m;
00439       const float tpos=0.0, lpos=0.0, zrot=0.0;
00440       float              clearE=0, clearW=6, wlsE=4, wlsW=0;
00441       if (ipln & 1)    { clearE=6; clearW=0; wlsE=0; wlsW=4; }
00442       if (ipln >= 61 ) { clearE=6; clearW=6; wlsE=0; wlsW=0; }
00443       scintMdlRow = new UgliDbiScintMdl(mdlid,width,tpos,lpos,zrot,
00444                                         clearE,clearW,wlsE,wlsW);
00445     }
00446     break;
00447   default:
00448     break;
00449   }
00450   if (!scintMdlRow) {
00451     MSG("Ugli",Msg::kFatal) 
00452       << "no algorithmic UgliDbiScintMdl for " << fVldContext << endl;
00453   }
00454 
00455   return scintMdlRow;
00456 }

const UgliDbiScintPln * UgliDbiTables::GetDbiScintPlnByIndex ( UInt_t  ipln  )  const

Definition at line 335 of file UgliDbiTables.cxx.

References Munits::cm, fAlgorithmic, fDetector, fScintPlnTbl, fVldContext, PlexPlaneId::GetPlaneView(), DbiResultPtr< T >::GetRowByIndex(), Detector::kCalDet, Detector::kFar, Msg::kFatal, PlaneView::kV, Munits::mm, and MSG.

Referenced by GeoGeometry::BuildPlanePairVolumes(), and UgliScintPlnNode::UgliScintPlnNode().

00336 {
00337 
00338   // if use real tables if we have them
00339 
00340   if (!fAlgorithmic) return fScintPlnTbl.GetRowByIndex(ipln);
00341 
00342   // algorithmic approach
00343 
00344   static UgliDbiScintPln* scintPlnRow = 0;
00345   if (scintPlnRow) { delete scintPlnRow; scintPlnRow = 0; }
00346 
00347   PlexPlaneId plnid(fDetector,ipln,false);
00348   const float scintthick = 1.1 * Munits::cm;
00349   const float nominalgap = 2.0 * Munits::mm;
00350 
00351   const float piby4  = 0.25*TMath::Pi();
00352   const float pi3by2 = 1.5*TMath::Pi();
00353 
00354   const float vrot = piby4;
00355   const float urot = -vrot;
00356 
00357   switch (fDetector) {
00358     //  case Detector::kNear:
00359     //    steelRow = 0;
00360     //    break;
00361   case Detector::kFar:
00362     {
00363       float gap = nominalgap;
00364       const float x0=0.0, y0=0.0;
00365       float zrot = (PlaneView::kV==plnid.GetPlaneView()) ? vrot : urot ;
00366 
00367       scintPlnRow = new UgliDbiScintPln(plnid,scintthick,gap,x0,y0,zrot);
00368     }
00369     break;
00370   case Detector::kCalDet:
00371     {
00372       float gap = nominalgap;
00373       const float x0=0.0, y0=0.0;
00374       float zrot = (ipln&1) ? pi3by2 : 0.0;
00375       if (ipln >= 61 ) {
00376         gap = 0.0;
00377         zrot = 0;
00378       }
00379       scintPlnRow = new UgliDbiScintPln(plnid,scintthick,gap,x0,y0,zrot);
00380     }
00381     break;
00382   default:
00383     break;
00384   }
00385   if (!scintPlnRow) {
00386     MSG("Ugli",Msg::kFatal) 
00387       << "no algorithmic UgliDbiScintPln for " << fVldContext << endl;
00388   }
00389 
00390   return scintPlnRow;
00391 }

const UgliDbiSteelPln * UgliDbiTables::GetDbiSteelPln ( UInt_t  irow  )  const

Definition at line 242 of file UgliDbiTables.cxx.

References fAlgorithmic, fSteelTbl, GetDbiSteelPlnByIndex(), and DbiResultPtr< T >::GetRow().

Referenced by UgliGeometry::BuildNodes().

00243 {
00244 
00245   // if use real tables if we have them
00246 
00247   if (!fAlgorithmic) return fSteelTbl.GetRow(irow);
00248 
00249   // algorithmic approach
00250 
00251   return GetDbiSteelPlnByIndex(irow);
00252 }

const UgliDbiSteelPln * UgliDbiTables::GetDbiSteelPlnByIndex ( UInt_t  ipln  )  const

Definition at line 255 of file UgliDbiTables.cxx.

References Munits::cm, fAlgorithmic, fDetector, fSteelTbl, fVldContext, PlexPlaneId::GetPlaneCoverage(), DbiResultPtr< T >::GetRowByIndex(), Detector::kCalDet, Detector::kFar, Msg::kFatal, PlaneCoverage::kNoActive, PlexPlaneId::LastPlaneFarSM0(), Munits::m, MSG, and Mphysical::pi.

Referenced by GetDbiSteelPln(), and UgliSteelPlnNode::UgliSteelPlnNode().

00256 {
00257 
00258   // if use real tables if we have them
00259 
00260   if (!fAlgorithmic) return fSteelTbl.GetRowByIndex(ipln);
00261 
00262   // algorithmic approach
00263 
00264   static UgliDbiSteelPln* steelRow = 0;
00265   if (steelRow) { delete steelRow; steelRow = 0; }
00266 
00267   PlexPlaneId plnid(fDetector,ipln,true);
00268   const float steelthick = 2.54 * Munits::cm;
00269   const float steelpitch = 5.94 * Munits::cm;
00270   const float pi    = TMath::Pi();
00271   const float piby2  = 0.5*TMath::Pi();
00272   const float pi3by2 = 1.5*TMath::Pi();
00273 
00274   switch (fDetector) {
00275     //  case Detector::kNear:
00276     //    steelRow = 0;
00277     //    break;
00278   case Detector::kFar:
00279     {
00280       int melt = 1000120;
00281       float totalz = steelthick + 
00282         ((PlaneCoverage::kNoActive==plnid.GetPlaneCoverage()) ? 
00283          0.0020 : 0.0130);
00284       const float zback0 = -0.0320 + steelpitch;
00285       // nominal steel spacing
00286       float zback = zback0 + (float)(ipln)*steelpitch; 
00287       if ( ipln > PlexPlaneId::LastPlaneFarSM0() )
00288         zback += 1.5 * Munits::m;  // supermodule gap
00289       const float piby2 = 0.5*TMath::Pi();
00290       const float x0=0.0, y0=0.0;
00291       const float thetaX=piby2, phiX=0, thetaY=piby2, phiY=piby2, 
00292                   thetaZ=0, phiZ=0;
00293 
00294       steelRow = new UgliDbiSteelPln(plnid,melt,steelthick,
00295                                      totalz,x0,y0,zback,
00296                                      thetaX,phiX,thetaY,phiY,thetaZ,phiZ);
00297     }
00298     break;
00299   case Detector::kCalDet:
00300     {
00301       int melt = 0;
00302       float thick  = steelthick;
00303       float totalz = 3.84 * Munits::cm;
00304       float x0=0, y0=0;
00305       float zback = (8.68 * Munits::cm) + (float)ipln*steelpitch;
00306       float thetaX=piby2, phiX=0, thetaY=piby2, phiY=piby2, thetaZ=0, phiZ=0;
00307 
00308       if (ipln >= 61) {
00309         thick = 0;
00310         totalz = 1.101 * Munits::cm;
00311         if (ipln&1) y0 = -1.600 * Munits::m;
00312         else        y0 = -1.611 * Munits::m;
00313 
00314         const float zbcosmic[] = { 0.5055, 1.5055, 2.0695, 3.0695};
00315         zback = zbcosmic[ipln-61];
00316         thetaX=pi; phiX=0; thetaY=piby2; phiY=0; thetaZ=piby2; phiZ=pi3by2;
00317       }
00318       steelRow = new UgliDbiSteelPln(plnid,melt,steelthick,
00319                                      totalz,x0,y0,zback,
00320                                      thetaX,phiX,thetaY,phiY,thetaZ,phiZ);
00321     }
00322     break;
00323   default:
00324     break;
00325   }
00326   if (!steelRow) {
00327     MSG("Ugli",Msg::kFatal) 
00328       << "no algorithmic UgliDbiSteelPln for " << fVldContext << endl;
00329   }
00330 
00331   return steelRow;
00332 }

const UgliDbiStrip * UgliDbiTables::GetDbiStripById ( const PlexStripEndId seid  )  const

Definition at line 460 of file UgliDbiTables.cxx.

References Munits::cm, fAlgorithmic, fDetector, fStripTbl, fVldContext, PlexScintMdlId::GetModule(), DbiResultPtr< T >::GetRowByIndex(), PlexStripEndId::GetScintMdlId(), PlexStripEndId::GetStrip(), PlexStripEndId::GetStripInMdl(), UgliDbiStrip::HashToIndex(), Detector::kCalDet, Detector::kFar, Msg::kFatal, and MSG.

Referenced by GeoScintMdlVolume::Build4Corners(), GeoScintMdlVolume::BuildHalfY(), GeoScintMdlVolume::BuildNearIXtru(), GeoScintMdlVolume::BuildNeariXtru(), GeoGeometry::BuildStrips(), and UgliStripNode::UgliStripNode().

00461 {
00462    int strip_indx = UgliDbiStrip::HashToIndex(seid);
00463 
00464   // if use real tables if we have them
00465 
00466   if (!fAlgorithmic) return fStripTbl.GetRowByIndex(strip_indx);
00467 
00468   // algorithmic approach
00469 
00470   static UgliDbiStrip* stripRow = 0;
00471   if (stripRow) { delete stripRow; stripRow = 0; }
00472 
00473   //unsigned int ipln   = seid.GetPlane();
00474   unsigned int istrip = seid.GetStrip();
00475   const float strip_width = 4.1 * Munits::cm;
00476   const float lpos = 0.0;
00477   const float zrot = 0.0;
00478 
00479   switch (fDetector) {
00480     //  case Detector::kNear:
00481     //    steelRow = 0;
00482     //    break;
00483   case Detector::kFar:
00484     {
00485       const int nstrips_mdl[] = { 28, 28, 20, 20, 20, 20, 28, 28};
00486       //const int nmdl = sizeof(nstrips_mdl)/sizeof(int);
00487 
00488       PlexScintMdlId mdlid = seid.GetScintMdlId();
00489       int stripinmdl       = seid.GetStripInMdl();
00490 
00491       int nstrips = nstrips_mdl[mdlid.GetModule()];
00492       float toff = ((float)(nstrips)/2 - 0.5);
00493       float tpos = ((float)stripinmdl - toff)*strip_width;
00494 
00495       stripRow = new UgliDbiStrip(seid,tpos,lpos,zrot);
00496 
00497     }
00498     break;
00499   case Detector::kCalDet:
00500     {
00501       const int nstrips=24;
00502       const float toff = ((float)(nstrips)/2 - 0.5);
00503       float tpos = ((float)istrip - toff)*strip_width;
00504       stripRow = new UgliDbiStrip(seid,tpos,lpos,zrot);
00505     }
00506     break;
00507   default:
00508     break;
00509   }
00510   if (!stripRow) {
00511     MSG("Ugli",Msg::kFatal) 
00512       << "no algorithmic UgliDbiStrip for " << fVldContext << endl;
00513   }
00514 
00515   return stripRow;
00516 }

unsigned int UgliDbiTables::GetNumSteelRows (  )  const

Definition at line 203 of file UgliDbiTables.cxx.

References fAlgorithmic, fDetector, fSteelTbl, fVldContext, DbiResultPtr< T >::GetNumRows(), Detector::kCalDet, Msg::kError, Detector::kFar, Msg::kFatal, Detector::kNear, PlexPlaneId::LastPlaneFarSM1(), PlexPlaneId::LastPlaneNearSpect(), and MSG.

Referenced by UgliGeometry::BuildNodes().

00204 {
00205 
00206   //#define LIMITPLNS
00207 #ifdef  LIMITPLNS
00208   unsigned int nmax = 4;
00209   MSG("Ugli",Msg::kError)
00210     << " **************** force " << nmax << " planes " << endl;
00211   return nmax;
00212 #endif
00213 
00214 
00215   // if use real tables if we have them
00216 
00217   if (!fAlgorithmic) {
00218     int nrows = fSteelTbl.GetNumRows();
00219     if (nrows < 1) {
00220        MSG("Ugli",Msg::kError)
00221           << "UgliDbiSteelPln unexpectedly had " 
00222           << nrows << " rows " << endl;
00223        if (nrows < 1) return 0;
00224     }
00225     return nrows;
00226   }
00227 
00228   // algorithmic approach
00229 
00230   switch (fDetector) {
00231   case Detector::kNear:   return PlexPlaneId::LastPlaneNearSpect()+1;
00232   case Detector::kFar:    return PlexPlaneId::LastPlaneFarSM1()+1;
00233   case Detector::kCalDet: return 5*12 + 4 + 1;
00234   default:
00235     MSG("Ugli",Msg::kFatal) 
00236       << "no algorithmic GetNumSteelRows for " << fVldContext << endl;
00237   }
00238   return 0;
00239 }

Bool_t UgliDbiTables::IsAlgorithmic ( Detector::Detector_t  det  )  [static]

Definition at line 101 of file UgliDbiTables.cxx.

References fgAlgorithmic, and UgliDbiTablesInitDefaults().

Bool_t UgliDbiTables::IsCutOnPlnInstall ( Detector::Detector_t  det  )  [static]
void UgliDbiTables::SetAlgorithmic ( Detector::Detector_t  det,
Bool_t  flag = kFALSE 
) [static]

Definition at line 76 of file UgliDbiTables.cxx.

References bfld::AsString(), fgAlgorithmic, Detector::kCalDet, Detector::kFar, Detector::kNear, Msg::kWarning, MSG, and UgliDbiTablesInitDefaults().

Referenced by UgliLoanPool::Config().

00077 {
00078   // set whether algorithmic approach is taken of any detector
00079   // disallow setting it for one's we haven't implemented
00080   // always allow setting it off
00081   
00082   UgliDbiTablesInitDefaults();
00083   if (!flag) fgAlgorithmic[det] = false;
00084   else {
00085     bool implemented = false;
00086     switch (det) {
00087     case Detector::kNear:   break;
00088     case Detector::kFar:    implemented = true; break;
00089     case Detector::kCalDet: implemented = true; break;
00090     default: break;
00091     }
00092     if (implemented) fgAlgorithmic[det] = true;
00093     else 
00094       MSG("Ugli",Msg::kWarning)
00095         << "UgliDbiTables::SetAlgorithmic - unable to generate "
00096         << Detector::AsString(det) << " geometry "
00097         << endl;
00098   }
00099 }

void UgliDbiTables::SetCutOnPlnInstall ( Detector::Detector_t  det,
Bool_t  flag = kFALSE 
) [static]

Definition at line 105 of file UgliDbiTables.cxx.

References fgCutOnPlnInstall, and UgliDbiTablesInitDefaults().

Referenced by UgliLoanPool::Config().

00107 {
00108   // set whether plane entry into geomtry should depend of
00109   // FabPlnInstall table entries.
00110   
00111   UgliDbiTablesInitDefaults();
00112   fgCutOnPlnInstall[det] = flag;
00113 }

void UgliDbiTables::WriteCSVFiles ( int  vetoOnly = 0  )  const

Definition at line 625 of file UgliDbiTables.cxx.

References alwaysTrue(), fGeomTbl, fScintMdlStructTbl, fScintMdlTbl, fScintPlnStructTbl, fScintPlnTbl, fSteelTbl, fStripStructTbl, fStripTbl, gVetoOnly, vetoMdl(), vetoPln(), vetoStrip(), and WriteTableToCSVFile().

00626 {
00627 
00628     // write out CSV (comma separated value) text files
00629 
00630     gVetoOnly = vetoOnly;
00631 
00632     WriteTableToCSVFile(fGeomTbl,"UGLIDBIGEOMETRY",alwaysTrue);
00633 
00634     WriteTableToCSVFile(fSteelTbl,"UGLIDBISTEELPLN",vetoPln);
00635 
00636     WriteTableToCSVFile(fScintPlnStructTbl,"UGLIDBISCINTPLNSTRUCT",alwaysTrue);
00637     WriteTableToCSVFile(fScintPlnTbl,"UGLIDBISCINTPLN",vetoPln);
00638 
00639     WriteTableToCSVFile(fScintMdlStructTbl,"UGLIDBISCINTMDLSTRUCT",alwaysTrue);
00640     WriteTableToCSVFile(fScintMdlTbl,"UGLIDBISCINTMDL",vetoMdl);
00641 
00642     WriteTableToCSVFile(fStripStructTbl,"UGLIDBISTRIPSTRUCT",alwaysTrue);
00643     WriteTableToCSVFile(fStripTbl,"UGLIDBISTRIP",vetoStrip);
00644 
00645 }


Member Data Documentation

Definition at line 76 of file UgliDbiTables.h.

Referenced by IsAlgorithmic(), SetAlgorithmic(), and UgliDbiTablesInitDefaults().

Definition at line 56 of file UgliDbiTables.h.

Referenced by GetDbiGeometry(), and WriteCSVFiles().

Definition at line 61 of file UgliDbiTables.h.

Referenced by GetDbiScintMdlById(), and WriteCSVFiles().

Definition at line 59 of file UgliDbiTables.h.

Referenced by GetDbiScintPlnByIndex(), and WriteCSVFiles().

Definition at line 62 of file UgliDbiTables.h.

Referenced by UgliStripNode::UgliStripNode(), and WriteCSVFiles().

Definition at line 63 of file UgliDbiTables.h.

Referenced by GetDbiStripById(), and WriteCSVFiles().


The documentation for this class was generated from the following files:

Generated on 2 Nov 2017 for loon by  doxygen 1.6.1