GeoGeometry Class Reference

#include <GeoGeometry.h>

Inheritance diagram for GeoGeometry:

List of all members.

Public Types
typedef std::map< PlexPlaneId, GeoPlnNode * >::iterator	PlaneMapItr
typedef std::map< PlexPlaneId, GeoPlnNode * >::const_iterator	PlaneMapConstItr
typedef std::map< PlexPlaneId, GeoPlnNode * > ::reverse_iterator	PlaneMapRevItr
typedef std::map< PlexPlaneId, GeoPlnNode * > ::const_reverse_iterator	PlaneMapConstRevItr
Public Member Functions
	GeoGeometry ()
	GeoGeometry (const VldContext &vldc, Geo::EAppType apptype=Geo::kRecons)
virtual	~GeoGeometry ()
virtual void	UpdateGlobalManager () const
bool	IsAlgorithmic () const
bool	IsFrozen () const
Geo::EAppType	GetAppType () const
virtual PlexPlaneId	GetPlaneIdFromZ (Double_t z) const
virtual GeoStripNode *	GetStripNode (const PlexStripEndId &seid) const
virtual TVector3	GetHallExtentMin () const
virtual TVector3	GetHallExtentMax () const
virtual GeoScintPlnNode *	GetScintPlnNode (PlexPlaneId planeId) const
virtual GeoSteelPlnNode *	GetNearestSteelPlnNode (Double_t z) const
virtual const GeoMediumMap &	GetMediumMap () const
const std::vector < GeoScintPlnNode * > &	GetScintPlnNodePtrVector () const
const std::vector < GeoSteelPlnNode * > &	GetSteelPlnNodePtrVector () const
const std::vector< GeoPlnNode * > &	GetPlnNodePtrVector () const
const std::map< Float_t, GeoSteelPlnNode * > &	GetSteelPlnNodeMap () const
virtual GeoSteelPlnNode *	GetSteelPlnNode (PlexPlaneId planeId) const
virtual void	GetTransverseExtent (PlaneView::PlaneView_t view, Float_t &tmin, Float_t &tmax) const
virtual void	GetTransverseExtent (PlaneView::PlaneView_t view, Double_t &tmin, Double_t &tmax) const
virtual void	GetZExtent (Float_t &zmin, Float_t &zmax, Int_t isup=-1) const
virtual void	GetZExtent (Double_t &zmin, Double_t &zmax, Int_t isup=-1) const
virtual const VldRange &	GetVldRange () const
bool	IsCompatible (const VldContext &vldc, Geo::EAppType apptype) const
TGeoMedium *	GetMedium (const char *name) const
virtual void	Draw (Option_t *volname="")
virtual void	ls (Option_t *option="") const
virtual void	Print (Option_t *option="") const
virtual void	PrintHeader (Option_t *option="") const
virtual void	DumpVolume (std::string volname, std::string preface="") const
virtual void	SwitchMedia (bool toswim)
TGeoRotation *	GetRot45 () const
TGeoRotation *	GetRot315 () const
Static Public Member Functions
static std::string	GetGeoCompatibleName (std::string name)
Private Member Functions
virtual void	BuildAll (const VldContext &vldc)
virtual void	BuildVldRange (const VldContext &vldc)
virtual void	TrimVldRange (const char *tblName="", const DbiValidityRec *dbivrec=0)
virtual void	BuildRotations ()
virtual void	BuildGeometry (const VldContext &vldc)
virtual void	BuildDetector (const VldContext &vldc, TGeoVolume *hallVol)
virtual void	BuildStrips (const UgliDbiTables &tbl, GeoScintMdlNode *node)
virtual void	BuildHallExtent ()
virtual TGeoVolume *	BuildFarMARS ()
virtual TGeoVolume *	BuildNearMARS ()
virtual void	BuildFarCoil (TGeoVolume *hallVol)
virtual void	BuildFarLeadStacks (TGeoVolume *hallVol)
virtual void	BuildMinerva (int mversion)
virtual int	Time2MinervaVersion (const VldTimeStamp &vts) const
virtual void	BuildNearCoil (TGeoVolume *hallVol)
virtual TGeoVolume *	BuildCoilAirGapVolume (const VldContext &vldc) const
virtual TGeoVolume *	BuildFarCoilAirGapVolume () const
virtual TGeoVolume *	BuildNearCoilAirGapVolume () const
virtual void	BuildPlanePairVolumes (const VldContext &vldc)
virtual void	BuildStripVolumes (const VldContext &vldc)
virtual void	BuildModules (const UgliDbiTables &tbl, GeoScintPlnNode *node)
virtual void	UpdateNodeMatrices (TGeoVolume *volume)
Int_t	GetSMPlaneLimits (const VldContext &vldc, Int_t *plnMin, Int_t *plnMax)
Private Attributes
VldRange	fVldRange
Geo::EAppType	fAppType
Float_t	fSMZMin [2]
Float_t	fSMZMax [2]
Float_t	fScale
std::string	fHallPath
TVector3	fHallMin
TVector3	fHallMax
TGeoManager *	fGeoManager
std::map< PlexPlaneId, GeoPlnNode * >	fPlaneMap
std::vector< GeoScintPlnNode * >	fScintPlnNodes
std::vector< GeoSteelPlnNode * >	fSteelPlnNodes
std::vector< GeoPlnNode * >	fPlnNodes
std::map< Float_t, GeoSteelPlnNode * >	fSteelPlnNodeMap
GeoShield	fGeoShield
Bool_t	fIsSwimMedia
GeoMediumMap *	fMediumMap
TGeoRotation *	fRot45
TGeoRotation *	fRot315

---

Detailed Description

Definition at line 47 of file GeoGeometry.h.

---

Member Typedef Documentation

typedef std::map<PlexPlaneId,GeoPlnNode*>::const_iterator GeoGeometry::PlaneMapConstItr

Definition at line 53 of file GeoGeometry.h.

typedef std::map<PlexPlaneId,GeoPlnNode*>::const_reverse_iterator GeoGeometry::PlaneMapConstRevItr

Definition at line 56 of file GeoGeometry.h.

typedef std::map<PlexPlaneId,GeoPlnNode*>::iterator GeoGeometry::PlaneMapItr

Definition at line 52 of file GeoGeometry.h.

typedef std::map<PlexPlaneId,GeoPlnNode*>::reverse_iterator GeoGeometry::PlaneMapRevItr

Definition at line 54 of file GeoGeometry.h.

---

Constructor & Destructor Documentation

GeoGeometry::GeoGeometry

(

)

Definition at line 54 of file GeoGeometry.cxx.

References Msg::kDebug, and MSG.

                         : fVldRange(),fAppType(Geo::kRecons),
                fScale(1),fHallPath(""),fGeoManager(0),fGeoShield(),
                fIsSwimMedia(false),fMediumMap(0),fRot45(0),fRot315(0) {
  // Default constructor, used for i/o

  MSG("Geo",Msg::kDebug) << "GeoGeometry def ctor @ " << this << endl;

  UpdateGlobalManager(); // this is okay, because fGeoManager ptr stored

  // fScale has been set before this step
  for ( int ism = 0; ism < 2; ism++ ) { 
     fSMZMin[ism] = +999.*fScale; 
     fSMZMax[ism] = -999.*fScale; 
  }

  for ( int ic = 0; ic < 3; ic++ ) {
    fHallMin[ic] = 0;
    fHallMax[ic] = 0;
  }

}

GeoGeometry::GeoGeometry	(	const VldContext &	vldc,
		Geo::EAppType	apptype = Geo::kRecons
	)

Definition at line 77 of file GeoGeometry.cxx.

References VldContext::AsString(), BuildAll(), BuildHallExtent(), fGeoManager, fMediumMap, fScale, fSMZMax, fSMZMin, Geo::GetScale(), Msg::kDebug, Msg::kInfo, Nav::kWarning, MSG, UpdateGlobalManager(), and UpdateNodeMatrices().

                                                                    : 
  fVldRange(),fAppType(apptype),fScale(1),fHallPath(""),
  fGeoManager(0),fGeoShield(this),fIsSwimMedia(false),fMediumMap(0),
  fRot45(0),fRot315(0) {
  // Normal constructor
  // Geometry is built for application type Geo::kRecons by default.
  // The application type determines the units the geometry will be built
  // in.  The default apptype = Geo::kRecons will build the geometry in
  // Minos standard units of meters.  Specifying apptype = Geo::kVMC will
  // build the geometry in TVirtualMC standard units of cm.
  
  MSG("Geo",Msg::kDebug) << "GeoGeometry normal ctor @ " << this << endl;

  UpdateGlobalManager(); // set gGeoManager to null before building new 

  MSG("Geo",Msg::kInfo) << "GeoGeometry build for validity " 
                        << vldc << "." << endl;
  
  // Silence TGeoManager info messages
  Int_t saveErrorIgnoreLevel = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kWarning;
  
  //MsgStream* msgeo = MsgService::Instance() -> GetStream("Geo");
  //msgeo -> SetLogLevel(Msg::kVerbose);
  
  fScale = Geo::GetScale(apptype);

  // fScale must be set before this step
  for ( int ism = 0; ism < 2; ism++ ) { 
     fSMZMin[ism] = +999.*fScale; 
     fSMZMax[ism] = -999.*fScale; 
  }

  fGeoManager = new TGeoManager(vldc.AsString("s1ac-"),"a MINOS geometry");
  UpdateGlobalManager(); // set gGeoManager to fGeoManager

  fMediumMap = new GeoMediumMap(this,vldc);
  
  // Build all materials and detector geometry
  this -> BuildAll(vldc);
  
  fGeoManager->CloseGeometry();

  BuildHallExtent(); // fill in hall coordinates
  
  TGeoVolume* volume = fGeoManager->GetTopVolume();
  UpdateNodeMatrices(volume);
  // Invoke CdTop to position back to top (MARS) volume.
  fGeoManager->CdTop();
  
  //this -> DumpVolume("MARS");
  
  fGeoManager->SetVisLevel(4);
  fGeoManager->SetVisOption(0);

  MSG("Geo",Msg::kInfo) << "GeoGeometry build complete." << endl;
  gErrorIgnoreLevel = saveErrorIgnoreLevel;

}

GeoGeometry::~GeoGeometry

(

)

[virtual]

Definition at line 138 of file GeoGeometry.cxx.

References fGeoManager, fMediumMap, fPlaneMap, Msg::kDebug, MSG, and UpdateGlobalManager().

                          {
  // delete all the owned sub-objects

  MSG("Geo",Msg::kDebug) << "GeoGeometry dtor @ " << this << endl;

  UpdateGlobalManager();

  fPlaneMap.clear();
  if ( fMediumMap ) delete fMediumMap; fMediumMap = 0;
  
  if ( fGeoManager ) {
    delete fGeoManager; fGeoManager = 0;
  }
 
  UpdateGlobalManager(); // set gGeoManager to null to avoid further use
  
}

---

Member Function Documentation

void GeoGeometry::BuildAll

(

const VldContext &

vldc

)

[private, virtual]

Definition at line 791 of file GeoGeometry.cxx.

References BuildGeometry(), BuildRotations(), BuildVldRange(), fGeoManager, Msg::kDebug, MSG, and UpdateGlobalManager().

Referenced by GeoGeometry().

                                                 {
  // Private.  Build materials & geometry

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug) << "GeoGeometry BuildAll " << endl;
  assert(fGeoManager);

  // Get the VldRange that fits this context
  BuildVldRange(vldc);

  // Build commonly used rotation matrices
  BuildRotations();
  
  // Build Detector Geometry
  BuildGeometry(vldc);

}

TGeoVolume * GeoGeometry::BuildCoilAirGapVolume

(

const VldContext &

vldc

)

const [private, virtual]

Definition at line 2301 of file GeoGeometry.cxx.

References BuildFarCoilAirGapVolume(), BuildNearCoilAirGapVolume(), VldContext::GetDetector(), Detector::kFar, Detector::kNear, and UpdateGlobalManager().

Referenced by BuildPlanePairVolumes().

                                                                           {
  // Build coil region volume to be used in airgaps between scint and
  // steel planes.

  UpdateGlobalManager();
  
  TGeoVolume* coilVol = 0;

  Detector::Detector_t dettype = (Detector::Detector_t)vldc.GetDetector();

  switch (dettype) {

  case Detector::kFar:
    coilVol = BuildFarCoilAirGapVolume();
    break;

  case Detector::kNear:
    coilVol = BuildNearCoilAirGapVolume();
    break;

  default:
    break;

  }

  return coilVol;
  
}

void GeoGeometry::BuildDetector	(	const VldContext &	vldc,
		TGeoVolume *	hallVol
	)			[private, virtual]

Definition at line 1137 of file GeoGeometry.cxx.

References PlexPlaneId::AsString(), BuildFarCoil(), GeoShield::BuildGroupNodes(), BuildNearCoil(), BuildPlanePairVolumes(), fGeoManager, fGeoShield, fScale, VldContext::GetDetector(), GetGeoCompatibleName(), DbiResultPtr< T >::GetNumRows(), UgliDbiSteelPln::GetPhiDeg(), PlexPlaneId::GetPlane(), DbiResultPtr< T >::GetRow(), DbiResultPtr< T >::GetRowByIndex(), UgliLoanPool::GetShieldOff(), GetSMPlaneLimits(), UgliDbiSteelPln::GetThetaDeg(), UgliDbiSteelPln::GetThickness(), UgliDbiSteelPln::GetTotalZ(), UgliDbiSteelPln::GetX0(), UgliDbiSteelPln::GetY0(), UgliDbiSteelPln::GetZBack(), UgliLoanPool::Instance(), PlexPlaneId::IsVetoShield(), Detector::kCalDet, Msg::kDebug, Detector::kFar, Msg::kFatal, Msg::kInfo, Detector::kNear, MSG, and UpdateGlobalManager().

Referenced by BuildGeometry().

                                                     {
   // Private. Build this geometry's steel+scint planes + coil

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildDetector " << endl;
  assert(fGeoManager);

  DbiResultPtr<UgliDbiSteelPln> steelTbl(vldc);

  BuildPlanePairVolumes(vldc); // pre-build plane pair volumes

  // Build shield group volumes and install them as nodes in hall
  // and install shield plane pair nodes in group volumes
  bool shieldOff = UgliLoanPool::Instance()->GetShieldOff();
  if ( vldc.GetDetector() == Detector::kFar ) {
    if ( shieldOff ) {
      MSG("Geo",Msg::kInfo) 
        << "GeoGeometry build of Veto Shield disabled." << endl;
    }
    else fGeoShield.BuildGroupNodes(hallVol);
  }
 
  // Plane db positions are stored relative to mars so need
  // hall global position to recalculate
  // Translation taken from liner, since hall placed with identity
  // matrix relative to liner
  TGeoNode* linrNode = fGeoManager->GetVolume("MARS")->GetNode("LINR_1");
  const Double_t* h0 = linrNode -> GetMatrix() -> GetTranslation();
  
  Int_t plnMin[2] = {-1};
  Int_t plnMax[2] = {-1};
  Int_t nSM = GetSMPlaneLimits(vldc,plnMin,plnMax);

  std::string minPlaneName[2];
  std::string maxPlaneName[2];
  Int_t minPlane[2] = {9999,9999};
  Int_t maxPlane[2] = {-9999,-9999};
  
  // order construction by plane #, STL set will sort them
  std::set<PlexPlaneId> steelset;
  for (unsigned int irow=0; irow < steelTbl.GetNumRows(); ++irow) {
    const UgliDbiSteelPln* stRow = steelTbl.GetRow(irow);
    PlexPlaneId steelId = stRow -> GetPlaneId();
    steelset.insert(steelId);
  }
  
  std::set<PlexPlaneId>::const_iterator steelitr = steelset.begin();
  for ( ; steelitr != steelset.end() ; steelitr++) {
    PlexPlaneId steelId = *steelitr;
    if ( shieldOff && steelId.IsVetoShield() ) continue;
    const UgliDbiSteelPln* stRow = steelTbl.GetRowByIndex(steelId.GetPlane());
    if ( (vldc.GetDetector() ==  Detector::kFar && !steelId.IsVetoShield()) ) {
      // Dispatch some anomalies in the database
       if ( steelId.GetPlane() > 485 ) continue; // because db has 0-497
       // Skip planes that have intentionally been placed at unphysical
       // locations
       if ( TMath::Abs(stRow->GetX0() ) > 50. ) continue;
    }

    // This is used just for reporting info at end of build
    Int_t vsId = 0;
    std::string stName = GetGeoCompatibleName(steelId.AsString());
    if ( steelId.IsVetoShield() ) vsId = 1;
    if ( steelId.GetPlane() < minPlane[vsId] ) {
        minPlane[vsId] = steelId.GetPlane();
        minPlaneName[vsId] = stName;
    }
    if ( steelId.GetPlane() > maxPlane[vsId] ) {
        maxPlane[vsId] = steelId.GetPlane();
        maxPlaneName[vsId] = stName;
    }
    
    // Veto shield built separately
    if ( vldc.GetDetector() == Detector::kFar && steelId.IsVetoShield() ) 
                                                              continue;
    
    Double_t offxyz[3] = {h0[0],h0[1],h0[2]};
       
    // The pair volumes have been pre-built
    std::string pairName = GetGeoCompatibleName(steelId.AsString("b"));
    TGeoVolume* pairVol = fGeoManager -> GetVolume(pairName.c_str());
    if ( !pairVol ) {
      MSG("Geo",Msg::kFatal) 
         << "Unable to find pre-built pairvol for volume "
         << pairName.c_str() << endl;
      abort();
    }
    
    // Position pair bounding box 
    TGeoRotation* stRotMatrix = new TGeoRotation(pairName.c_str(),
                                stRow->GetThetaDeg(0),stRow->GetPhiDeg(0),
                                stRow->GetThetaDeg(1),stRow->GetPhiDeg(1),
                                stRow->GetThetaDeg(2),stRow->GetPhiDeg(2));
    stRotMatrix -> RegisterYourself();
    
    // Plane DB translation is relative to MARS, move to SM or hall local 
    Float_t x0pair = (stRow->GetX0())*fScale - offxyz[0];
    Float_t y0pair = (stRow->GetY0())*fScale - offxyz[1];

    // If plane is first plane in supermodule than thickness of pair
    // box is just "Thickness".  If it's part of vetoshield, than 
    // thickness of pair box is just "TotalZ", else pair box thickness 
    // is set by distance from back face of
    // of current steel plane to back face of previous steel plane. z0pair
    // is defined as the position of the center of this pair box in z.
    Int_t planeno = steelId.GetPlane();
    Float_t z0pair = 0;
    if ( vldc.GetDetector() == Detector::kCalDet || steelId.IsVetoShield() ) 
      z0pair =(stRow->GetZBack()-0.5*(stRow->GetTotalZ()))*fScale - offxyz[2];
    else
      z0pair =(stRow->GetZBack()-0.5*(stRow->GetThickness()))*fScale-offxyz[2];
          
    if ( !steelId.IsVetoShield() ) {
      if ( planeno != plnMin[0] ) {
        if ( nSM == 1 || (nSM > 1 && planeno != plnMin[1]) ) {
          const UgliDbiSteelPln* stPrevRow = steelTbl.GetRowByIndex(planeno-1);
          z0pair = (stRow->GetZBack()-0.5*(stRow->GetZBack()
                                  -stPrevRow->GetZBack()))*fScale - offxyz[2];
        }
      }
    }
    
    TGeoCombiTrans* pairMatrix = new TGeoCombiTrans(pairName.c_str(),
                                    x0pair,y0pair,z0pair,stRotMatrix);
    MSG("Geo",Msg::kDebug) << "Placing plane pair " << pairName.c_str()
                           << " at " << x0pair << ","
                           << y0pair << "," << z0pair 
                           << "\n rotmatrix:(thetax/y/z,phix/y/z) (" 
                           << stRow->GetThetaDeg(0) << ","  
                           << stRow->GetPhiDeg(0) << "),("
                           << stRow->GetThetaDeg(1) << ","  
                           << stRow->GetPhiDeg(1) << "),("
                           << stRow->GetThetaDeg(2) << ","  
                           << stRow->GetPhiDeg(2) << ")"
                           << endl;

    // Place plane pairs directly in hall
    hallVol -> AddNode(pairVol,1,pairMatrix);
  } // end of loop over all plane db rows


  MSG("Geo",Msg::kInfo) << "GeoGeometry built detector planes "
                        << minPlaneName[0].c_str() << " to " 
                        << maxPlaneName[0].c_str() << "." << endl;
  if ( !minPlaneName[1].empty() ) {
    MSG("Geo",Msg::kInfo) << "GeoGeometry built shield planes "
                          << minPlaneName[1].c_str() << " to " 
                          << maxPlaneName[1].c_str() << "." << endl;
  }
  
  // Build outer coil after all planes are positioned so that detector
  // limits are known
  Detector::Detector_t dettype = (Detector::Detector_t)vldc.GetDetector();
  switch ( dettype ) {
  case Detector::kFar:
    BuildFarCoil(hallVol);
    break;
  case Detector::kNear:
    BuildNearCoil(hallVol);
    break;
  default:
    break;
  }

  return;
  
}

void GeoGeometry::BuildFarCoil

(

TGeoVolume *

hallVol

)

[private, virtual]

Definition at line 1907 of file GeoGeometry.cxx.

References fGeoManager, fScale, GeoMediumMap::GetMedium(), GetMediumMap(), GetZExtent(), Geo::kCoilRad, Msg::kDebug, Geo::kRCAir, Geo::kRCCoil, MSG, and UpdateGlobalManager().

Referenced by BuildDetector().

                                                  {
  // Private. Build the far detector coil outside of the detector.  
  // x0,y0 is coil hole center in HALL coordinates (assumed constant
  // over all planes).

  UpdateGlobalManager();
 
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildFarCoil " << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();

  // These dimensions/etc. of the coil should be in the db, but for now
  // use hardwired values

  // Nomenclature (BUS) is chosen to match that of gminos
  // BUSn is the center of the coil made up of medium FARCOIL
  // In the convention used here, n = supermodule number

  Float_t sRad = Geo::kCoilRad*fScale; // coil radius 

  Float_t halfhally = dynamic_cast<TGeoBBox*>(hallVol -> GetShape())->GetDY();
  
  // SM0 coil along z-direction of detector, ends at supermodule ends
  // return coil lies on floor
  Float_t zmin0,zmax0;
  GetZExtent(zmin0,zmax0,0);
  // Convert to HALL coordinates
  TGeoNode* linrNode = fGeoManager->GetVolume("MARS")->GetNode("LINR_1");
  const Double_t* h0 = linrNode -> GetMatrix() -> GetTranslation();
  zmin0 -= h0[2];
  zmax0 -= h0[2];
  Float_t x0 = -h0[0];
  Float_t y0 = -h0[1];

  // Per specification from J. Nelson received 8/1/2006, model return
  // coil lying along far detector floor as box of halfx 0.225 m and
  // halfy 0.05 m.
  Float_t retcoilhalfx = 0.225*fScale;
  Float_t retcoilhalfy = 0.05*fScale;

  Float_t zcoillen0 = zmax0-zmin0;
  TGeoVolume* BUS0=fGeoManager->MakeBox("BUS0",medMap.GetMedium(Geo::kRCCoil),
                                      retcoilhalfx,retcoilhalfy,0.5*zcoillen0);
  BUS0 -> SetLineColor(42); // tan  
  BUS0 -> SetVisibility(kTRUE);

  // Place SM0 return coil in hall
  Float_t z0 = 0.5*(zmin0 + zmax0);
  hallVol -> AddNode(BUS0,1,new TGeoTranslation("BUS0",x0,
                                           -halfhally+retcoilhalfy,z0));
  
  // SM1 coil along z-direction of detector, ends at supermodule ends
  Float_t zmin1,zmax1;
  GetZExtent(zmin1,zmax1,1);
  // Convert to HALL coordinates
  zmin1 -= h0[2];
  zmax1 -= h0[2];

  Float_t zcoillen1 = zmax1-zmin1;
  TGeoVolume* BUS1=fGeoManager->MakeBox("BUS1",medMap.GetMedium(Geo::kRCCoil),
                                      retcoilhalfx,retcoilhalfy,0.5*zcoillen1);
  BUS1 -> SetLineColor(42);  // tan  
  BUS1 -> SetVisibility(kTRUE);

  // Place SM1 return coil in hall
  Float_t z1 = 0.5*(zmin1 + zmax1);
  hallVol -> AddNode(BUS1,1,new TGeoTranslation("BUS1",x0,
                                                -halfhally+retcoilhalfy,z1));

  // Build coil volume on xy faces
  // Dimensions for horse's tail are roughly those received from J. Nelson 
  // correspondence of 8/1/2006, but y-length of bottom section is adjusted to 
  // actual distance to floor, and top & mid-sections are trapezoids 
  // instead of boxes, dimension in z has been squeezed to fit the supermodule
  // gap...
  Float_t ycoillen = y0+halfhally+sRad; // top of coil to floor

  // gap between bottom section of tail & plane. Adjust to fit avail region.
  Float_t zbotgap = 0.10*fScale; 
  // Define bounding box to contain tail 
  Float_t xhalftail = 0.40*fScale;
  Float_t yhalftail = 0.5*ycoillen;
  Float_t zhalftail = 0.5*(zbotgap+0.4*fScale);
  TGeoVolume* BUXY = fGeoManager->MakeBox("BUXY",medMap.GetMedium(Geo::kRCAir),
                                           xhalftail,yhalftail,zhalftail);
  BUXY -> SetLineColor(14); // gray bounding box, invisible by default 
  BUXY -> SetVisibility(kFALSE);

  // Horse's tail bounding box is placed at 4 end planes, rotating &
  // translating as necessary
  // rotFlip defines a 180 rotation
  TGeoRotation *rotFlip = new TGeoRotation("BUXY",90,180,90,90,180,0);
  rotFlip -> RegisterYourself();
  
  Float_t xcoil = x0;
  Float_t ycoil = y0 + sRad - ycoillen/2.;
  hallVol -> AddNode(BUXY,1,new TGeoTranslation("BUXY_1",xcoil,ycoil,
                     zmin0-zhalftail));
  hallVol -> AddNode(BUXY,2,new TGeoCombiTrans("BUXY_2",xcoil,ycoil,
                     zmax0+zhalftail,rotFlip));
  hallVol -> AddNode(BUXY,3,new TGeoTranslation("BUXY_3",xcoil,ycoil,
                     zmin1-zhalftail));
  hallVol -> AddNode(BUXY,4,new TGeoCombiTrans("BUXY_4",xcoil,ycoil,
                     zmax1+zhalftail,rotFlip));

  // Now build the inserts for the coil tail bounding box
  // Top section is a trapezoid
  Float_t yhalftop = 0.5*0.53*fScale;
  Float_t zhalftop = 0.10*fScale;
  Float_t xhalfloy = 0.2825*fScale;
  Float_t xhalfhiy = 0.12*fScale;
  TGeoTrap* bxyTopShp = new TGeoTrap("BXYTOP",zhalftop,0.,0.,
                                     yhalftop,xhalfloy,xhalfhiy,0.,
                                     yhalftop,xhalfloy,xhalfhiy,0.);
  TGeoVolume* BXYTOP = new TGeoVolume("BXYTOP",bxyTopShp,
                                       medMap.GetMedium(Geo::kRCCoil));
  BXYTOP -> SetLineColor(42);  // tan
  BXYTOP -> SetVisibility(kTRUE);
  BUXY -> AddNode(BXYTOP,1,new TGeoTranslation(0.,yhalftail-sRad-yhalftop,
                                              -zhalftail+zhalftop));
  

  // Middle section is a trapezoid that skews towards the face of the
  // steel plane with decreasing y
  Float_t yhalfmid = 0.5*0.85*fScale;
  TGeoArb8* bxyMidShp = new TGeoArb8(yhalfmid);
  bxyMidShp -> SetVertex(0,-0.4*fScale,0.05*fScale);
  bxyMidShp -> SetVertex(1,-0.4*fScale,0.15*fScale);
  bxyMidShp -> SetVertex(2,0.4*fScale,0.15*fScale);
  bxyMidShp -> SetVertex(3,0.4*fScale,0.05*fScale);
  bxyMidShp -> SetVertex(4,-0.2825*fScale,-0.25*fScale);
  bxyMidShp -> SetVertex(5,-0.2825*fScale,-0.05*fScale);
  bxyMidShp -> SetVertex(6,0.2825*fScale,-0.05*fScale);
  bxyMidShp -> SetVertex(7,0.2825*fScale,-0.25*fScale);
  
  TGeoVolume* BXYMID = new TGeoVolume("BXYMID",bxyMidShp,
                                       medMap.GetMedium(Geo::kRCCoil));
  BXYMID -> SetLineColor(42); // tan
  BXYMID -> SetVisibility(kTRUE);

  TGeoRotation *rotMid = new TGeoRotation("BXYMid",90,0,0,0,90,90);
  rotMid -> RegisterYourself();
  BUXY -> AddNode(BXYMID,1,new TGeoCombiTrans("BXYMID",0.,
                  yhalftail-sRad-2.*yhalftop-yhalfmid,0.,rotMid));

  // Bottom section is a box that extends to floor
  Float_t xhalfbot = 0.4*fScale;
  Float_t yhalfbot = 0.5*(ycoillen-sRad-2.*yhalftop-2.*yhalfmid);
  Float_t zhalfbot = 0.05*fScale;
  
  TGeoVolume* BXYBOT = fGeoManager -> MakeBox("BXYBOT",
                                               medMap.GetMedium(Geo::kRCCoil),
                                               xhalfbot,yhalfbot,zhalfbot);
  BXYBOT -> SetLineColor(42); // tan
  BXYBOT -> SetVisibility(kTRUE);
  BUXY -> AddNode(BXYBOT,1,new TGeoTranslation(0.,-yhalftail+yhalfbot,
                                               zhalftail-zbotgap-zhalfbot));
  
  // Return coil along floor that extends outside of detector
  TGeoVolume* BXYRET = fGeoManager -> MakeBox("BXYRET",
                               medMap.GetMedium(Geo::kRCCoil),
                               retcoilhalfx,retcoilhalfy,0.5*zbotgap);
  BXYRET -> SetLineColor(42);  // tan
  BXYRET -> SetVisibility(kTRUE);
  BUXY -> AddNode(BXYRET,1,new TGeoTranslation(0.,-yhalftail+retcoilhalfy,
                                               zhalftail-0.5*zbotgap));

  // Segment of coil tube that extends out beyond detector
  TGeoVolume* BXYSTB = fGeoManager -> MakeTube("BXYSTB",
                                                medMap.GetMedium(Geo::kRCCoil),
                                                0.,sRad,zhalftail);
  BXYSTB -> SetLineColor(42);  // tan
  BXYSTB -> SetVisibility(kTRUE);
  BUXY -> AddNodeOverlap(BXYSTB,1,new TGeoTranslation(0.,yhalftail-sRad,0.));
                                   
  return;

}

TGeoVolume * GeoGeometry::BuildFarCoilAirGapVolume

(

)

const [private, virtual]

Definition at line 2332 of file GeoGeometry.cxx.

References GetAppType(), GeoMediumMap::GetMedium(), GetMediumMap(), Geo::GetScale(), gGeoManager, Geo::kCoilRad, Geo::kCRGapBypass, Geo::kCRGapCoil, Geo::kCRGapFlange, Geo::kCRGapThroat, Geo::kFarBypassRad, Geo::kFlangeRad, Geo::kThroatRad, and UpdateGlobalManager().

Referenced by BuildCoilAirGapVolume().

                                                        {
  //
  // Build far coil region to be used in airgaps between scint and steel
  // planes.  The far detector coil in the air gap
  // regions is built according to the same parameters as are used in
  // the build of the coil in the far detector scint pln:
  //   1)Insert a "bypass" (r=Geo::kFarBypassRad) region (not to be confused
  //     with the bypass plastic insert).  This is constructed of magnetized
  //     air, and indicates the region near the coil where the detailed
  //     field map will be used.
  //   2)Insert into the "bypass" a "flange" (r=Geo::kFlangeRad) of magnetized
  //     iron.
  //   3)Insert into the "flange" a "throat" (r=Geo::kThroatRad) of magnetized
  //     air.
  //   4)Insert into the "throat" a "coil segment" (r=Geo::kCoilRad) of
  //     magnetized FARCOIL medium.  The coil segment is set to rest on the
  //     throat (off-center in y).
  //
  // The thickness in z of all pieces is set to be -1 when defining the shapes,
  // and built as a TGeoVolumeMulti.  When placed as a node in the air gap
  // volume, the volumemulti shape will take on the thickness of its parent.
  // This allows for variable thickness of the air gaps in a non-perfect
  // geometry.
  //

  UpdateGlobalManager();

  // The nomenclature used here is "F" (far), "G" (gap), followed by
  // the two letter code to indicate the coil part type.

  const GeoMediumMap& medMap = GetMediumMap();
  
  // First check to see if volumemulti has been built. Need only build once.
  TGeoVolume* volBypass = gGeoManager->GetVolume("FGBY");
  if ( volBypass ) return volBypass;

  Double_t scale = Geo::GetScale(GetAppType());

  TGeoVolume* volCoil
    = gGeoManager->MakeTube("FGCO",medMap.GetMedium(Geo::kCRGapCoil),
                            0,Geo::kCoilRad*scale,-1.); // coil
  volCoil -> SetLineColor(42); // tan

  TGeoVolume* volThroat
    = gGeoManager->MakeTube("FGTR",medMap.GetMedium(Geo::kCRGapThroat),
                            0,Geo::kThroatRad*scale,-1.); // throat
  volThroat -> SetLineColor(kBlue);

  TGeoVolume* volFlange
    = gGeoManager->MakeTube("FGFL",medMap.GetMedium(Geo::kCRGapFlange),
                             0,Geo::kFlangeRad*scale,-1.); // flange
  volFlange -> SetLineColor(46); // rust

  volBypass
    = gGeoManager->MakeTube("FGBY",medMap.GetMedium(Geo::kCRGapBypass),
                             0,Geo::kFarBypassRad*scale,-1.); // bypass
  volBypass -> SetLineColor(kBlue);
  volBypass -> SetLineStyle(2); // dashed
  volBypass -> SetVisibility(kFALSE); // invisible by default

  volBypass -> AddNode(volFlange,1,gGeoIdentity);
  volFlange -> AddNode(volThroat,1,gGeoIdentity);
  volThroat -> AddNode(volCoil,1,new TGeoTranslation(0,-0.01*scale,0));

  return volBypass;

}

void GeoGeometry::BuildFarLeadStacks

(

TGeoVolume *

hallVol

)

[private, virtual]

Definition at line 1308 of file GeoGeometry.cxx.

References fGeoManager, fScale, GeoMediumMap::GetMedium(), GetMediumMap(), gGeoManager, Msg::kDebug, Geo::kSoLo, MSG, and UpdateGlobalManager().

Referenced by BuildGeometry().

                                                        {
  // Private. Build the lead stacks (SOLO & Reeve's Castle) that sit south 
  // of the detector in the beam-line of the far detector cavern hall.  

  UpdateGlobalManager();
 
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildFarLeadStacks " << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();

  // HALL origin
  TGeoNode* linrNode = fGeoManager->GetVolume("MARS")->GetNode("LINR_1");
  const Double_t* h0 = linrNode -> GetMatrix() -> GetTranslation();
  Double_t hallX0 = h0[0];
  //Double_t hallY0 = h0[1];
  Double_t hallZ0 = h0[2];
  // HALL half-width
  TGeoBBox* hallBox = dynamic_cast<TGeoBBox*>(hallVol->GetShape());
  Double_t dyHall = hallBox->GetDY();
  
  // "SOLO" & "Reeve's castle" lead stacks sitting south of plane 0.
    
  // J. Beatty communication of July 15, 2008:  "SoLo is a 40"x40"x40" 
  // stack of lead bricks weighing a nominal 12 tons. It's center of mass 
  // sits 45" above floor level."  It has a sample chamber in the middle
  // which is not modeled here.  SoLo stands for SOudan LOw Background
  // counting facility.
  Double_t dxSoLo = 0.508*fScale; // half-width in x (0.5*40"*2.54/100.)
  Double_t dySoLo = 0.508*fScale; // half-width in y
  Double_t dzSoLo = 0.508*fScale; // half-width in z

  TGeoVolume* volSoLo = gGeoManager -> MakeBox("SoLo",
                        medMap.GetMedium(Geo::kSoLo),dxSoLo,dySoLo,dzSoLo);
  volSoLo -> SetLineColor(17); // Grey

  // z-offset of SoLo center from upstream face of plane 0 
  Double_t dzSoLoOffset = -12.3698*fScale; // 40' 7"
  Double_t dxSoLoOffset = -1.8288*fScale; // 6' east of center 
  // y-offset of Solo center from floor
  Double_t dySoLoOffset = +1.143*fScale; // 45" above the floor

  hallVol -> AddNode(volSoLo,1,
             new TGeoTranslation(-hallX0+dxSoLoOffset,
                                 -dyHall+dySoLoOffset,
                                 -hallZ0+dzSoLoOffset));

  // J. Beatty communication of July 15 & 20, 2008:  Reeve's castle is 
  // a 44"x36"x44" stack of lead bricks weighing a nominal 12 tons. It's 
  // center of mass is 22" above floor level.  Measurements were difficult
  // to take "don't hold me to an inch accuracy".  It has a sample chamber
  // in the middle which is not modeled here.
  Float_t dxReeves = 0.5588*fScale; // half-width in x (0.5*44"*2.54/100.)
  Float_t dyReeves = 0.4572*fScale; // half-width in y (0.5*36"*2.54/100.)
  Float_t dzReeves = 0.5588*fScale; // half-width in z (0.5*44"*2.54/100.)
  TGeoVolume* volReeves 
            = gGeoManager -> MakeBox("Reeves",
                    medMap.GetMedium(Geo::kSoLo),dxReeves,dyReeves,dzReeves);
  volReeves -> SetLineColor(17); // Grey

  // z-offset of Reeves center from upstream face of plane 0 
  Double_t dzReevesOffset = -11.5062*fScale; // 37' 9"
  // x-offset of Reeves center from detector center line
  Double_t dxReevesOffset = +3.556*fScale; // 11' 8" west of center
  // y-offset of Reeves center from floor
  Double_t dyReevesOffset = +0.5588*fScale; // 22" above the floor

  hallVol -> AddNode(volReeves,1,
          new TGeoTranslation(-hallX0+dxReevesOffset,
                              -dyHall+dyReevesOffset,
                              -hallZ0+dzReevesOffset));
    

                                   
  return;

}

TGeoVolume * GeoGeometry::BuildFarMARS

(

)

[private, virtual]

Definition at line 1700 of file GeoGeometry.cxx.

References fGeoManager, fScale, GeoMediumMap::GetMedium(), GetMediumMap(), gGeoManager, Msg::kDebug, Geo::kHall, Geo::kMars, MSG, and UpdateGlobalManager().

Referenced by BuildGeometry().

                                      {
  // Private. Build MARS appropriate for the far detector site.

  UpdateGlobalManager();
 
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildFarMARS " << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();

  // Dimensions of MARS should be db parameters?
  Float_t mars_halfx =  85.*fScale; //  85 m MARS half-x
  Float_t mars_halfy =  30.*fScale; //  30 m MARS half-y
  Float_t mars_halfz = 250.*fScale; // 250 m MARS half-z
  
  // Far detector rock medium is different than that of near
  TGeoVolume* volMARS = fGeoManager->MakeBox("MARS",
                                        medMap.GetMedium(Geo::kMars),
                                        mars_halfx,mars_halfy,mars_halfz);

  // Build shaft, tunnel, Soudan 2 cavern & ghost of S2 detector out of air 
  // and according to gminos dimensions, except as noted.

  Float_t shft_halfx =  1.*fScale; //  1 m shaft half-x
  Float_t shft_halfy = 30.*fScale; // 30 m shaft half-y == MARS half-y
  Float_t shft_halfz =  1.*fScale; //  1 m shaft half-z
  TGeoVolume* volSHFT = gGeoManager->MakeBox("SHFT",
                                             medMap.GetMedium(Geo::kHall),
                                             shft_halfx,shft_halfy,shft_halfz);
  volSHFT -> SetVisibility(kTRUE);
  volSHFT -> SetVisContainers(kTRUE);
  
  // Shorten tunnel by 1 m from gminos dimensions to avoid overlap with LINR
  Float_t tunl_halfx =  2.*fScale; //  2 m tunnel half-x
  Float_t tunl_halfy =  2.*fScale; //  2 m tunnel half-y 
  Float_t tunl_halfz = 13.5*fScale; // 13.5 m tunnel half-z
  TGeoVolume* volTUNL = gGeoManager->MakeBox("TUNL",
                                            medMap.GetMedium(Geo::kHall),
                                            tunl_halfx,tunl_halfy,tunl_halfz);
  volTUNL -> SetVisibility(kTRUE);
  volTUNL -> SetVisContainers(kTRUE);
  
  Float_t s2hl_halfx =  7.  *fScale; //  7    m S2 hall half-x
  Float_t s2hl_halfy =  5.65*fScale; //  5.65 m S2 hall half-y 
  Float_t s2hl_halfz = 35.  *fScale; // 35.   m S2 hall half-z
  TGeoVolume* volS2HL = gGeoManager->MakeBox("S2HL",
                                            medMap.GetMedium(Geo::kHall),
                                            s2hl_halfx,s2hl_halfy,s2hl_halfz);
  volS2HL -> SetVisibility(kTRUE);
  volS2HL -> SetVisContainers(kTRUE);
  
  // The ghost of the S2 detector size is adjusted from that in gminos to 
  // be more realistic, but it doesn't matter of course because it's not there!
  Float_t s2dt_halfx =  4. *fScale; // 4   m S2 detector half-x
  Float_t s2dt_halfy =  2.7*fScale; // 2.7 m S2 detector half-y (4.5, gminos) 
  Float_t s2dt_halfz =  7.5*fScale; // 7.5 m S2 detector half-z 
  TGeoVolume* volS2DT = gGeoManager->MakeBox("S2DT",
                                            medMap.GetMedium(Geo::kHall),
                                            s2dt_halfx,s2dt_halfy,s2dt_halfz);
  volS2DT -> SetVisibility(kTRUE);
  volS2DT -> SetVisContainers(kTRUE);
  
  volS2HL -> AddNode(volS2DT,1,
                     new TGeoTranslation(0*fScale,-1.15*fScale,-23.5*fScale));


  volMARS -> AddNode(volSHFT,1,
                     new TGeoTranslation(-5.*fScale,0.*fScale,98.18*fScale));
  volMARS -> AddNode(volTUNL,1,
                     new TGeoTranslation(-5.*fScale,-4.1*fScale,83.68*fScale));
  TGeoRotation* s2rot = new TGeoRotation("s2rot",64,0,90,90,26,180);
  s2rot -> RegisterYourself();
  volMARS -> AddNode(volS2HL,1,
                     new TGeoCombiTrans(36.*fScale,-0.45*fScale,61.68*fScale,
                                        s2rot));

  return volMARS;

}

void GeoGeometry::BuildGeometry

(

const VldContext &

vldc

)

[private, virtual]

Definition at line 898 of file GeoGeometry.cxx.

References BuildDetector(), BuildFarLeadStacks(), BuildFarMARS(), BuildMinerva(), BuildNearMARS(), fGeoManager, fHallPath, fScale, UgliDbiTables::GetDbiGeometry(), VldContext::GetDetector(), UgliDbiGeometry::GetHallXYZMax(), UgliDbiGeometry::GetHallXYZMin(), GeoMediumMap::GetMedium(), GetMediumMap(), VldContext::GetTimeStamp(), UgliLoanPool::GetUseNewCavern(), UgliLoanPool::Instance(), Msg::kDebug, Detector::kFar, Msg::kFatal, Geo::kHall, Geo::kLinr, Geo::kMars, Detector::kNear, Detector::kUnknown, MSG, Time2MinervaVersion(), and UpdateGlobalManager().

Referenced by BuildAll().

                                                      {
  // Private. Build this geometry's hierarchy of nodes

  UpdateGlobalManager();
  
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildGeometry" << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();
  
  if (vldc.GetDetector() == Detector::kUnknown) {
    // build a minimalistic geometry
    TGeoVolume* volMARS = fGeoManager -> MakeBox("MARS",
                                   medMap.GetMedium(Geo::kMars),1.2,1.2,1.2);
    TGeoVolume* volLINR = fGeoManager -> MakeBox("LINR",
                                   medMap.GetMedium(Geo::kLinr),1.1,1.1,1.1);
    volMARS -> AddNode(volLINR,1,gGeoIdentity);
    TGeoVolume* volHALL = fGeoManager -> MakeBox("HALL",
                                   medMap.GetMedium(Geo::kHall),1.0,1.0,1.0);
    volLINR -> AddNode(volHALL,1,gGeoIdentity);
    fGeoManager -> SetTopVolume(volMARS);
    return;
  }

  const UgliDbiTables& ugliDbiTables = UgliDbiTables(vldc);
  const UgliDbiGeometry* ugliDbiGeo = ugliDbiTables.GetDbiGeometry();
  if (!ugliDbiGeo) {
    MSG("Geo",Msg::kFatal) 
       << "No UgliDbiGeometry for " << vldc << endl;
    abort();
  }

  // Start with the hall, this is the widest view stored in db 
  const Float_t* hmin = ugliDbiGeo->GetHallXYZMin();
  const Float_t* hmax = ugliDbiGeo->GetHallXYZMax();

  TGeoVolume* volHALL = 0;
  Double_t hminsc[3] = {0};
  Double_t hmaxsc[3] = {0};
  
  bool useNewCavern = UgliLoanPool::Instance()->GetUseNewCavern();
  if ( useNewCavern && vldc.GetDetector() == Detector::kFar ) {
    // New far detector cavern has arched ceiling and other improvements
    // The cavern consists of three sections: South, Main, North
    // "Main" is the section around the main detector
    // Dimensions are from autocad diagrams provided by Jim Beatty, 6/2008
    
    Double_t dx[3] = {0};
    Double_t dz[3] = {0};
    std::string region[3] = {"S","M","N"};
    
    // South section of cavern:
    dx[0] = 6.9088*fScale; // 22'8", half-width in x 
    dz[0] = 5.461*fScale;  // 17'11", half-width in z
     
    // Main section of cavern:
    dx[1] = 7.2136*fScale; // 23'8", half-width in x
    dz[1] =15.0114*fScale; // 49'3", half-width in z

    // North section of cavern:
    dx[2] = 7.9248*fScale; // 26', half-width in x
    // north section z-width is defined to align new cavern north wall 
    // with old cavern north wall position.  If accuracy
    // north of the detector is important to any analysis, modeling
    // in the north cavern/tunnel/shaft region could be improved...
    dz[2] = 20.9176*fScale; 
 
    // offset of south wall from upstream face of plane 0 
    Double_t dzOffset = -13.6*fScale; 
    Double_t dzHall = dz[0] + dz[1] + dz[2]; // half-width in z of enclosure

    // Loop over 3 sections of detector cavern building cavern shape
    // with arched ceiling
    Double_t dyArch = 2.04*fScale;// 6.7',arch height,semiminor axis of ellipse
    Double_t dyBox = 5.79*fScale; // 19',half-width in y of box under arch
    Double_t dyHall 
         = (dyBox*2+dyArch)/2.; // 22.35',half-width in y of box enclosing hall
    Double_t dyOffset = -4.73*fScale; // offset of floor from coil center

    hminsc[0] = -dx[2]-(dx[2]-dx[1]);
    hmaxsc[0] = +dx[2]-(dx[2]-dx[1]);
    hminsc[1] = dyOffset;
    hmaxsc[1] = 2.*dyHall+hminsc[1];
    hminsc[2] = dzOffset;
    hmaxsc[2] = 2.*dzHall+hminsc[2];

    // Place the center of the elliptical tube used for the arch at the 
    // top of the box used for the base, and make y0 the center of
    // the entire height.
    TGeoTranslation* trArch=new TGeoTranslation("cavArch",0.,dyHall-dyArch,0.);
    trArch -> RegisterYourself();
    TGeoTranslation* trBox=new TGeoTranslation("cavBox",0.,-dyHall+dyBox,0.);
    trBox -> RegisterYourself();

    std::string secName[3];
    Double_t epsil = 1.e-4;
    for ( int iz = 0; iz < 3; iz++ ) {
      std::string archName = "cavArch"+region[iz];
      new TGeoEltu(archName.c_str(),dx[iz],dyArch,dz[iz]+epsil);
      std::string boxName = "cavBox"+region[iz];
      new TGeoBBox(boxName.c_str(),dx[iz],dyBox+epsil,dz[iz]+epsil);
      std::string composite = boxName + ":cavBox+" + archName + ":cavArch";
      secName[iz] = "hall" + region[iz];
      new TGeoCompositeShape(secName[iz].c_str(),composite.c_str());
      Double_t dzrel = 0;
      for ( int izz = 0; izz < iz; izz++ ) dzrel += 2.*dz[izz];
      TGeoTranslation* offset = new TGeoTranslation(secName[iz].c_str(),
                                dx[2]-dx[iz],0.,-dzHall + dzrel + dz[iz]);
      offset -> RegisterYourself();
    }

    // Now piece the three sections together to construct the Hall
    std::string composite = secName[0] + ":" + secName[0] + "+"
                          + secName[1] + ":" + secName[1] + "+"
                          + secName[2] + ":" + secName[2];

    TGeoCompositeShape* hallShp = new TGeoCompositeShape("HALL",
                                                         composite.c_str());
    volHALL 
       = new TGeoVolume("HALL",hallShp,medMap.GetMedium(Geo::kHall));
    
    volHALL -> SetLineColor(42);

  }
  else {
    // Near det, cal det & old style far det cavern
    
    // pad as necessary hall dimensions
    Double_t xpad = 0.*fScale;
    // For near detector, pad y-dim by 1 cm because otherwise scint plane
    // polygon extrudes floor in imperfect geometry. Fix me.
    Double_t ypad = 0.*fScale;
    if ( vldc.GetDetector() == Detector::kNear ) ypad = 0.01*fScale;
  
    hminsc[0] = hmin[0]*fScale-xpad;
    hminsc[1] = hmin[1]*fScale-ypad;
    hminsc[2] = hmin[2]*fScale;
    hmaxsc[0] = hmax[0]*fScale+xpad;
    hmaxsc[1] = hmax[1]*fScale+ypad;
    hmaxsc[2] = hmax[2]*fScale;
  
    // Hall
    volHALL   = fGeoManager->MakeBox("HALL",
                               medMap.GetMedium(Geo::kHall),
                               0.5*(hmaxsc[0]-hminsc[0]),
                               0.5*(hmaxsc[1]-hminsc[1]),
                               0.5*(hmaxsc[2]-hminsc[2]));

    volHALL-> SetVisibility(kTRUE);
    volHALL-> SetVisContainers(kTRUE);
    volHALL-> SetLineColor(42);
  }
  
  // x/y/zhsiz is half-width in each dimension of hall
  Double_t xhsiz = 0.5*(hmaxsc[0] - hminsc[0]);
  Double_t yhsiz = 0.5*(hmaxsc[1] - hminsc[1]);
  Double_t zhsiz = 0.5*(hmaxsc[2] - hminsc[2]);

  // x/y/z0hall is center of hall
  Double_t x0hall = 0.5*(hmaxsc[0] + hminsc[0]);
  Double_t y0hall = 0.5*(hmaxsc[1] + hminsc[1]);
  Double_t z0hall = 0.5*(hmaxsc[2] + hminsc[2]);

  MSG("Geo",Msg::kDebug) << "Hall halfwidths " << xhsiz << ","
                         << yhsiz << "," << zhsiz << " placed at "
                         << x0hall << "," << y0hall << "," << z0hall << endl;
  
  // Liner pad is box with halfwidth dimensions equal
  // to the hall halfwidths + the liner thickness (1 m)
  Detector::Detector_t dettype = (Detector::Detector_t)vldc.GetDetector();
  const Double_t linerpad = 1.0*fScale; // thickness concrete liner (1 m)
  
  TGeoVolume* volLINR     = fGeoManager->MakeBox("LINR",
                                         medMap.GetMedium(Geo::kLinr),
                                         xhsiz+linerpad,yhsiz+linerpad,
                                         zhsiz+linerpad);
  volLINR-> SetVisibility(kTRUE);
  volLINR-> SetVisContainers(kTRUE);
  volLINR-> SetLineColor(kYellow);

  // Build MARS appropriate to detector type.
  TGeoVolume* volMARS = 0;
  switch ( dettype ) {
  case Detector::kFar:
    volMARS = BuildFarMARS();
    break;
  case Detector::kNear:
    volMARS = BuildNearMARS();
    break;
  default:
    // Rock shell default is
    // rock padding, minimum 5 m thick onto half hall dimensions
    const Double_t rockpad = 5.0*fScale; // thickness of considered rock (5 m)
    Double_t absxmax = TMath::Max(TMath::Abs(hminsc[0]),
                                  TMath::Abs(hmaxsc[0]));
    Double_t absymax = TMath::Max(TMath::Abs(hminsc[1]),
                                TMath::Abs(hmaxsc[1]));
    Double_t abszmax = TMath::Max(TMath::Abs(hminsc[2]),
                                TMath::Abs(hmaxsc[2]));
    volMARS = fGeoManager->MakeBox("MARS",medMap.GetMedium(Geo::kMars),
                                    absxmax+rockpad,
                                    absymax+rockpad,abszmax+rockpad);
    break;
  }

  volMARS -> SetVisibility(kTRUE);
  volMARS -> SetVisContainers(kTRUE);
  volMARS -> SetLineColor(kBlack); 

  // The top level volume MARS will be assigned node path "/MARS_1" by root
  fGeoManager -> SetTopVolume(volMARS);
  // GeoNodes are owned by the TGeoManager
  std::string nodename = "LINR_1";
  std::string globalpath = "/MARS_1/" + nodename;
  volMARS -> AddNode(volLINR,1,
                     new TGeoTranslation("LINR",x0hall,y0hall,z0hall));
   
  nodename = "HALL_1";
  globalpath += "/" + nodename;
  fHallPath = globalpath;
  volLINR -> AddNode(volHALL,1,gGeoIdentity);

  if ( useNewCavern && vldc.GetDetector() == Detector::kFar ) {
    if ( UgliLoanPool::Instance() -> GetLeadStacks() ) {
      BuildFarLeadStacks(volHALL);
    }
  }

  if ( vldc.GetDetector() == Detector::kNear ) {
    int mversion = UgliLoanPool::Instance() -> GetMinervaVersion();
    if ( mversion == -1 ) mversion = Time2MinervaVersion(vldc.GetTimeStamp());
    if ( mversion !=  0 ) BuildMinerva(mversion);
  }
  
  BuildDetector(vldc,volHALL);
  
}

void GeoGeometry::BuildHallExtent

(

)

[private, virtual]

Definition at line 248 of file GeoGeometry.cxx.

References cd(), fHallMax, fHallMin, fHallPath, gGeoManager, and UpdateGlobalManager().

Referenced by GeoGeometry().

                                  {
  // Purpose: Fill the min and max (x,y,z) of the detector hall in global
  // (MARS) coordinates.

  UpdateGlobalManager();
  
  gGeoManager -> cd(fHallPath.c_str());
  TGeoNode* hallNode = gGeoManager->GetCurrentNode();
  TGeoVolume* hallVol = hallNode->GetVolume();

  TGeoBBox* hallBox = dynamic_cast<TGeoBBox*>(hallVol->GetShape());
  
  Double_t lxyz[3] = {-(hallBox->GetDX()),-(hallBox->GetDY()),
                      -(hallBox->GetDZ())};
  Double_t gxyz[3] = {0};
  
  gGeoManager->LocalToMaster(lxyz,gxyz);
  
  for ( int ic = 0; ic < 3; ic++ ) {
    lxyz[ic] *= -1.;
    fHallMin[ic] = gxyz[ic];
  }
  
  gGeoManager->LocalToMaster(lxyz,gxyz);
  for ( int ic = 0; ic < 3; ic++ ) fHallMax[ic] = gxyz[ic];
  
}

void GeoGeometry::BuildMinerva

(

int

mversion

)

[private, virtual]

Definition at line 1387 of file GeoGeometry.cxx.

References Msg::kInfo, and MSG.

Referenced by BuildGeometry().

                                           {
  // Private.  Build a reduced/stripped-down pseudo-Minerva geometry 
  MSG("Geo",Msg::kInfo) << "GeoGeometry build pseudo-Minerva version " 
                        << mversion << endl;
}

void GeoGeometry::BuildModules	(	const UgliDbiTables &	tbl,
		GeoScintPlnNode *	node
	)			[private, virtual]

Definition at line 2088 of file GeoGeometry.cxx.

References PlexScintMdlId::AsString(), BuildStrips(), fGeoManager, fScale, UgliDbiTables::fScintPlnStructTbl, UgliDbiScintMdl::GetClearLenEast(), UgliDbiScintMdl::GetClearLenWest(), UgliDbiTables::GetDbiScintMdlById(), GetGeoCompatibleName(), GeoNode::GetGlobalPath(), DbiResultPtr< T >::GetRowByIndex(), UgliDbiScintMdl::GetWlsLenEast(), UgliDbiScintMdl::GetWlsLenWest(), UgliDbiStructHash::HashAsPlane(), Msg::kDebug, Msg::kVerbose, MSG, and UpdateGlobalManager().

Referenced by BuildPlanePairVolumes().

                                                         {
  // Private. Purpose: Build the modules as part of the scintillator plane
  
  UpdateGlobalManager();
  
  assert(fGeoManager);

  const PlexPlaneId& plexPlaneId = plnNode -> GetPlexPlaneId();
  MSG("Geo",Msg::kDebug) <<"GeoGeometry::BuildModules for scint pln  " 
                         << plnNode->GetName() << endl;

  // Global path to plane node. Used to build module global path.
  std::string plnPath = plnNode->GetGlobalPath();

  // ScintPlnStruct used to retrieve number of modules in plane  
  UgliDbiStructHash planestructhash(plexPlaneId);
  const UgliDbiScintPlnStruct* plnStruct = ugliDbiTables.fScintPlnStructTbl
        .GetRowByIndex(planestructhash.HashAsPlane());
  Int_t nmodules = plnStruct -> GetNModules();
  
  // Loop over all modules in plane
  for ( int imod = 0; imod < nmodules; imod++ ) {
    // For each module
    PlexScintMdlId plexModuleId(plexPlaneId,imod);

    std::string mdlName = GetGeoCompatibleName(plexModuleId.AsString());
    
    // Build the module volume
    // Ideally could just build one module of each type but alignment varies
    // tpos and this may cause slight size variations
    // So for now generate one mdl volume per module
    GeoScintMdlVolume* mdlVol = new GeoScintMdlVolume(this,plexModuleId,
                                                      ugliDbiTables);
 
    // Build the node and place it in the plane
    // Establish the rotational & translational matrix for the module
    const UgliDbiScintMdl* scModule 
      = ugliDbiTables.GetDbiScintMdlById(plexModuleId);
    Float_t tposMod = (scModule -> GetTPosRelPln())*fScale;
    Float_t lposMod = (scModule -> GetLPosRelPln())*fScale;
    Float_t zrotMod = scModule -> GetZRotRelPlnDeg(); 
 
    TGeoRotation* modRotMatrix = new TGeoRotation(mdlName.c_str(), 90.,zrotMod,
                                                  90.,90.+zrotMod,0.,0.);
    modRotMatrix -> RegisterYourself();

    TGeoCombiTrans* combiMatrix = new TGeoCombiTrans(mdlName.c_str(),
                                     lposMod,tposMod,0.,modRotMatrix);
    std::string mdlNodeName = mdlName + "_1";

    MSG("Geo",Msg::kVerbose) << "Mdl node " << mdlNodeName.c_str() 
                             << "tpos, lpos, zrot(deg) rel pln " 
                             << tposMod << "," << lposMod << "," << zrotMod 
                             << endl;
    
    GeoScintMdlNode* mdlNode = new GeoScintMdlNode(this,mdlVol,combiMatrix,
                                                   plnNode,mdlNodeName,
                                                   plexModuleId,
                                          scModule->GetClearLenEast()*fScale,
                                          scModule->GetClearLenWest()*fScale,
                                          scModule->GetWlsLenEast()*fScale,
                                          scModule->GetWlsLenWest()*fScale);

    // Add strips to module node
    BuildStrips(ugliDbiTables,mdlNode);

  }
  
}

void GeoGeometry::BuildNearCoil

(

TGeoVolume *

hallVol

)

[private, virtual]

Definition at line 1806 of file GeoGeometry.cxx.

References fGeoManager, fScale, GeoMediumMap::GetMedium(), GetMediumMap(), GetRot315(), GetRot45(), GetZExtent(), Geo::kCoilRad, Msg::kDebug, Geo::kNeckRad, Geo::kRCAir, Geo::kRCCoil, Geo::kRCShaft, Geo::kThroatRad, MSG, and UpdateGlobalManager().

Referenced by BuildDetector().

                                                   {
  // Private. Build the near detector coil. Fix me.  
  // x0,y0 is coil hole center in hall coordinates (assumed constant
  // over all planes).

  UpdateGlobalManager();
 
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildNearCoil " << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();

  // The dimensions of the coil should be extracted from the db
  Float_t shalfx  = Geo::kNeckRad*fScale; // steel 
  Float_t shalfy  = shalfx; // steel
  Float_t ahalfx  = Geo::kThroatRad*fScale; // air
  Float_t ahalfy  = ahalfx; // air
  Float_t alhalfx = Geo::kCoilRad*fScale; // aluminum
  Float_t alhalfy = alhalfx; // aluminum
 
  // Build coil along z-direction, extends to ends of super module
  Float_t zmin,zmax;
  GetZExtent(zmin,zmax,-1); // returned in MARS coordinates
  // Convert to HALL coordinates
  TGeoNode* linrNode = fGeoManager->GetVolume("MARS")->GetNode("LINR_1");
  const Double_t* h0 = linrNode -> GetMatrix() -> GetTranslation();
  zmin -= h0[2];
  zmax -= h0[2];
  Float_t x0 = -h0[0];
  Float_t y0 = -h0[1];
  
  Float_t zcoillen = zmax - zmin;
  TGeoVolume* BUS0 = fGeoManager->MakeBox("BUS0",
                                           medMap.GetMedium(Geo::kRCShaft),
                                           shalfx,shalfy,0.5*zcoillen);
  BUS0 -> SetLineColor(14);  // gray  
  BUS0 -> SetVisibility(kTRUE);

  TGeoVolume* BUA0 = fGeoManager->MakeBox("BUA0",
                                           medMap.GetMedium(Geo::kRCAir),
                                           ahalfx,ahalfy,0.5*zcoillen);
  BUA0 -> SetLineColor(14);  
  BUA0 -> SetVisibility(kTRUE);
  BUS0 -> AddNode(BUA0,1,gGeoIdentity);

  TGeoVolume* BUC0 = fGeoManager->MakeBox("BUC0",
                                           medMap.GetMedium(Geo::kRCCoil),
                                           alhalfx,alhalfy,0.5*zcoillen);
  BUC0 -> SetLineColor(14);  
  BUC0 -> SetVisibility(kTRUE);
  BUA0 -> AddNode(BUC0,1,gGeoIdentity);

  // Rotate first, then translate
  TGeoRotation *rot45 = GetRot45();
  Float_t zcoil = (zmin+zmax)/2.;

  // Place return coil in hall
  Float_t steelhalfy = 1.9*fScale; // 1.9 m halfwidth in y direction
  Float_t xcoil = x0 - steelhalfy;
  Float_t ycoil = y0 - steelhalfy;
  // overlap because it overlaps pair plane volumes. Fix me.
  hallVol -> AddNodeOverlap(BUS0,2,
                            new TGeoCombiTrans(xcoil,ycoil,zcoil,rot45)); 

  // Along xy face
  Float_t cos45 = 0.707107;
  Float_t coillenxy = steelhalfy/cos45 + 2.*shalfx;
  TGeoVolume* BUSXY = fGeoManager->MakeBox("BUSXY",
                                            medMap.GetMedium(Geo::kRCShaft),
                                            shalfx,0.5*coillenxy,shalfy);
  BUSXY -> SetLineColor(14);  // gray  
  BUSXY -> SetVisibility(kTRUE);
  TGeoVolume* BUAXY = fGeoManager->MakeBox("BUAXY",
                                            medMap.GetMedium(Geo::kRCAir),
                                            ahalfx,0.5*coillenxy,ahalfy);
  BUAXY -> SetLineColor(14);  
  BUAXY -> SetVisibility(kTRUE);
  BUSXY -> AddNode(BUAXY,1,gGeoIdentity);

  TGeoVolume* BUCXY = fGeoManager->MakeBox("BUCXY",
                                            medMap.GetMedium(Geo::kRCCoil),
                                            alhalfx,0.5*coillenxy,alhalfy);
  BUCXY -> SetLineColor(14);  
  BUCXY -> SetVisibility(kTRUE);
  BUAXY -> AddNode(BUCXY,1,gGeoIdentity);

  // Will be rotated and then translated
  TGeoRotation* rotneg45 = GetRot315();
  xcoil = x0 - (0.5*coillenxy - shalfx)*cos45;
  ycoil = y0 - (0.5*coillenxy - shalfy)*cos45;
  zcoil = zmin - shalfy;
  hallVol -> AddNode(BUSXY,1,new TGeoCombiTrans(xcoil,ycoil,zcoil,rotneg45));  

  zcoil = zmax + shalfy;
  hallVol -> AddNode(BUSXY,2,new TGeoCombiTrans(xcoil,ycoil,zcoil,rotneg45));  

  return;

}

TGeoVolume * GeoGeometry::BuildNearCoilAirGapVolume

(

)

const [private, virtual]

to rest on the throat

Definition at line 2401 of file GeoGeometry.cxx.

References GetAppType(), GeoMediumMap::GetMedium(), GetMediumMap(), Geo::GetScale(), gGeoManager, Geo::kCoilRad, Geo::kCRGapBypass, Geo::kCRGapCoil, Geo::kCRGapFlange, Geo::kCRGapThroat, Geo::kCRGapWater, Geo::kFlangeRad, Geo::kNearCoolRad, Geo::kNearFullBypassRad, Geo::kThroatRad, and UpdateGlobalManager().

Referenced by BuildCoilAirGapVolume().

                                                         {
  //
  // Build near coil region to be used in airgaps between scint and steel
  // planes.  The near detector coil in the air gap
  // regions is built according to the same parameters as are used in
  // the build of the coil in the near detector full coverage scint pln:
  //   1)Insert a "bypass" tube (r=Geo::kNearFullBypassRad) region (not to 
  //     be confused with the bypass plastic insert).  This is constructed of 
  //     magnetized air.
  //   2)Insert into the "bypass" a "flange" (box of halfx/y = Geo::kFlangeRad)
  //     of  magnetized iron.
  //   3)Insert into the "flange" a "throat" (box of halfx/y = Geo::kThroatRad)
  //     of  magnetized air.
  //   4)Insert into the "throat" a "coil segment" (box of halfx/y
  //     = Geo::kCoilRad) of magnetized aluminum.  The coil segment is set
  //   5)Insert into the "coil segment" tubes (r=Geo::kNearCoolRad) of
  //     magnetized water in an array of 6 columns x 8 rows.
  //
  // The thickness in z of all pieces is set to be -1 when defining the shapes,
  // and built as a TGeoVolumeMulti.  When placed as a node in the scint
  // plane, the volumemulti shape will take on the thickness of its parent.
  // This allows for variable thickness of the scint plane in a non-perfect
  // geometry.
  //

  UpdateGlobalManager();

  const GeoMediumMap& medMap = GetMediumMap();
  
  // The nomenclature used here is "N" (near), "G" (gap), followed by
  // the two letter code to indicate the coil part type.
  std::string preface = "NG";

  // First check to see if volumemulti has been built. Need only build once.
  TGeoVolume* volBypass
              = gGeoManager->GetVolume(std::string(preface+"BY").c_str());
  if ( volBypass ) return volBypass;

  Double_t scale = Geo::GetScale(GetAppType());

  TGeoVolume* volWater
    = gGeoManager->MakeTube(std::string(preface+"WA").c_str(),
                            medMap.GetMedium(Geo::kCRGapWater),0,
                            Geo::kNearCoolRad*scale,-1.); // water
  volWater -> SetLineColor(kGreen);

  TGeoVolume* volCoil
    = gGeoManager->MakeBox(std::string(preface+"CO").c_str(),
                          medMap.GetMedium(Geo::kCRGapCoil),
                          Geo::kCoilRad*scale,Geo::kCoilRad*scale,-1.); // coil
  volCoil -> SetLineColor(kBlack);

  TGeoVolume* volThroat
    = gGeoManager->MakeBox(std::string(preface+"TR").c_str(),
                           medMap.GetMedium(Geo::kCRGapThroat),
                     Geo::kThroatRad*scale,Geo::kThroatRad*scale,-1.); //throat
  volThroat -> SetLineColor(kBlue);

  TGeoVolume* volFlange
    = gGeoManager->MakeBox(std::string(preface+"FL").c_str(),
                           medMap.GetMedium(Geo::kCRGapFlange),
                     Geo::kFlangeRad*scale,Geo::kFlangeRad*scale,-1.); //flange
  volFlange -> SetLineColor(kBlack);

  volBypass
      = gGeoManager->MakeTube(std::string(preface+"BY").c_str(),
                              medMap.GetMedium(Geo::kCRGapBypass),0,
                              Geo::kNearFullBypassRad*scale,-1.); // bypass
  volBypass -> SetLineColor(kBlue);
  volBypass -> SetLineStyle(2); // dashed

  volBypass -> AddNode(volFlange,1,gGeoIdentity);
  volFlange -> AddNode(volThroat,1,gGeoIdentity);

  volThroat -> AddNode(volCoil,1,
                       new TGeoTranslation(-0.01*scale,-0.01*scale,0));

  Int_t nx = 6;
  Int_t ny = 8;

  Float_t xedge = 0.02475*scale;// dist from x-edge to center of 1st(last) tube
  Float_t x0   = -Geo::kCoilRad*scale + xedge;  // first tube position in x
  // separation of tubes in x direction
  Float_t xsep = 2.*(Geo::kCoilRad*scale - xedge)/(Float_t)(nx-1);

  Float_t yedge = 0.02221*scale;// dist from y-edge to center of 1st(last) tube
  Float_t y0   = -Geo::kCoilRad*scale + yedge;  // first tube position in y
  // separation of tubes in y direction
  Float_t ysep = 2.*(Geo::kCoilRad*scale - yedge)/(Float_t)(ny-1);

  for ( int ix = 0; ix < nx; ix++ ) {
    Float_t xpos = x0 + (Float_t)ix*xsep;
    for ( int iy = 0; iy < ny; iy++ ) {
      Float_t ypos = y0 + (Float_t)iy*ysep;
      Int_t itube = ix*ny+iy+1;
      volCoil -> AddNode(volWater,itube,new TGeoTranslation(xpos,ypos,0));
    }
  }

  return volBypass;

}

TGeoVolume * GeoGeometry::BuildNearMARS

(

)

[private, virtual]

Definition at line 1781 of file GeoGeometry.cxx.

References fGeoManager, fScale, GeoMediumMap::GetMedium(), GetMediumMap(), Msg::kDebug, Geo::kMars, MSG, and UpdateGlobalManager().

Referenced by BuildGeometry().

                                       {
  // Private. Build MARS appropriate for the near detector site.

  UpdateGlobalManager();
 
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildNearMARS " << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();

  // Dimensions of MARS should be db parameters?
  Float_t mars_halfx =  85.*fScale; //  85 m MARS half-x
  Float_t mars_halfy =  30.*fScale; //  30 m MARS half-y
  Float_t mars_halfz = 250.*fScale; // 250 m MARS half-z
  
  // Near detector rock medium is different than that of far 
  TGeoVolume* volMARS = fGeoManager->MakeBox("MARS",
                                           medMap.GetMedium(Geo::kMars),
                                           mars_halfx,mars_halfy,mars_halfz);

  return volMARS;

}

void GeoGeometry::BuildPlanePairVolumes

(

const VldContext &

vldc

)

[private, virtual]

Definition at line 1406 of file GeoGeometry.cxx.

References GeoShield::AddVolume(), bfld::AsString(), PlexPlaneId::AsString(), BuildCoilAirGapVolume(), BuildModules(), BuildStripVolumes(), fGeoManager, fGeoShield, fHallPath, fPlaneMap, fScale, fSMZMax, fSMZMin, UgliDbiTables::GetDbiScintPlnByIndex(), VldContext::GetDetector(), GetGeoCompatibleName(), GeoMediumMap::GetMedium(), GetMediumMap(), DbiResultPtr< T >::GetNumRows(), PlexPlaneId::GetPlane(), PlexPlaneId::GetPlaneCoverage(), GetRot45(), DbiResultPtr< T >::GetRow(), DbiResultPtr< T >::GetRowByIndex(), UgliLoanPool::GetShieldOff(), GetSMPlaneLimits(), UgliDbiSteelPln::GetThickness(), UgliDbiScintPln::GetThickness(), UgliDbiSteelPln::GetTotalZ(), UgliDbiSteelPln::GetX0(), UgliDbiScintPln::GetX0RelSteel(), UgliDbiScintPln::GetY0RelSteel(), UgliDbiSteelPln::GetZBack(), UgliDbiScintPln::GetZRotRelSteelDeg(), UgliLoanPool::Instance(), PlexPlaneId::IsVetoShield(), Detector::kCalDet, Msg::kDebug, Detector::kFar, Geo::kHall, Detector::kNear, PlaneCoverage::kNoActive, Geo::kPlnAirGap, PlaneCoverage::kUnknown, MSG, PlexVetoShieldHack::RenumberMuxToMdl(), PlexPlaneId::SetIsSteel(), and UpdateGlobalManager().

Referenced by BuildDetector().

                                                              {
  // Private. Build this geometry's steel+scint plane pair volumes

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildPlanePairVolumes " << endl;
  assert(fGeoManager);

  const GeoMediumMap& medMap = GetMediumMap();

  DbiResultPtr<UgliDbiSteelPln> steelTbl(vldc);
  const UgliDbiTables& ugliDbiTables = UgliDbiTables(vldc);

  // Pre-build strip volumes
  BuildStripVolumes(vldc);

  Int_t plnMin[2] = {-1};
  Int_t plnMax[2] = {-1};
  Int_t nSM = GetSMPlaneLimits(vldc,plnMin,plnMax);
  
  // Build coil segment volume to be used for air gaps between scint & steel
  // planes.  This is built as TGeoVolumeMulti, and can be built once and
  // used to fill every air gap in detector.
  TGeoVolume* coilVol = BuildCoilAirGapVolume(vldc); 
  TGeoRotation* rot45 = GetRot45();
  Detector::Detector_t dettype = (Detector::Detector_t)vldc.GetDetector();
  
  bool shieldOff = UgliLoanPool::Instance()->GetShieldOff();

  for (unsigned int irow=0; irow < steelTbl.GetNumRows(); ++irow) {

    // Build steel and scint plane volumes first, then position so
    // that we know pair volume size.

    // Steel plane
    GeoSteelPlnVolume* stplnVolume = 0;
    const UgliDbiSteelPln* stRow = steelTbl.GetRow(irow);
    PlexPlaneId steelId = stRow -> GetPlaneId();
    if ( shieldOff && steelId.IsVetoShield() ) continue;

    std::string stName = GetGeoCompatibleName(steelId.AsString());
     
    if ( steelId.IsVetoShield() 
      && vldc.GetDetector() == Detector::kFar ) steelId =
      PlexVetoShieldHack::RenumberMuxToMdl(vldc,steelId);  // don't know why 
    else if ( steelId.GetPlane() > 485 ) continue; // because db has 0-497
    // Skip planes that have intentionally been placed at unphysical
    // locations
    if ( TMath::Abs(stRow->GetX0() ) > 50. ) continue;
    
    Double_t pairhalfx = 0;
    Double_t pairhalfy = 0;

    // If plane is first plane in supermodule, thickness of pair box is just
    // "Thickness", else pair box thickness is set by distance from back 
    // face of of current steel plane to back face of previous steel plane. 
    Int_t planeno = steelId.GetPlane();
    Double_t pairhalfz = 0;
    if ( vldc.GetDetector() == Detector::kCalDet || steelId.IsVetoShield() ) 
      pairhalfz = 0.5*(stRow->GetTotalZ())*fScale;
    else
      pairhalfz = 0.5*(stRow->GetThickness())*fScale;
    if ( !steelId.IsVetoShield() ) {
      if ( planeno != plnMin[0] ) {
        if ( nSM == 1 || (nSM > 1 && planeno != plnMin[1]) ) {
          const UgliDbiSteelPln* stPrevRow = steelTbl.GetRowByIndex(planeno-1);
          pairhalfz = 0.5*(stRow->GetZBack() - stPrevRow->GetZBack())*fScale;
        }
      }
    }
    
    if ( !steelId.IsVetoShield() ) {
      stplnVolume = new GeoSteelPlnVolume(this,steelId,
                                       stRow->GetThickness()*fScale);
      stplnVolume -> SetLineColor(kRed);
      stplnVolume -> SetVisibility(kTRUE);

      // Since we assume that pair is always placed at (x,y)=(0,0), need
      // to take into account bbox origin when determining pair dx,dy
      TGeoBBox* bbox = dynamic_cast<TGeoBBox*>(stplnVolume->GetShape());
      pairhalfx = bbox->GetDX() + TMath::Abs((bbox->GetOrigin())[0]);
      pairhalfy = bbox->GetDY() + TMath::Abs((bbox->GetOrigin())[1]);
    }
    
    // Scint plane
    GeoScintPlnVolume* scplnVolume = 0;
    const UgliDbiScintPln* scRow = 0;
    PlexPlaneId scintId = steelId;
    scintId.SetIsSteel(false);
    std::string scName = GetGeoCompatibleName(scintId.AsString());
    if ( PlaneCoverage::kNoActive != steelId.GetPlaneCoverage() && 
         PlaneCoverage::kUnknown  != steelId.GetPlaneCoverage() ) {
      scRow = ugliDbiTables.GetDbiScintPlnByIndex(scintId.GetPlane());
      MSG("Geo",Msg::kDebug) << "Build ScintPln " << scintId.AsString()
                             << " w/thickness " << scRow->GetThickness()*fScale
                             << endl;

      scplnVolume = new GeoScintPlnVolume(this,scintId,
                                          scRow->GetThickness()*fScale);
      scplnVolume -> SetVisibility(kFALSE); // deactivate when not debugging
      scplnVolume -> SetLineColor(kBlue);

      // This only works because scint planes are rotated in a way such that
      // width and height of bounding box don't change.
      TGeoBBox* bbox = dynamic_cast<TGeoBBox*>(scplnVolume->GetShape());
      pairhalfx = TMath::Max(pairhalfx,bbox->GetDX() 
                                     + TMath::Abs((bbox->GetOrigin())[0]));
      pairhalfy = TMath::Max(pairhalfy,bbox->GetDY() 
                                     + TMath::Abs((bbox->GetOrigin())[1]));
    }
    // avoid extension of near detector pair box into hall floor. Fix me.
    if ( vldc.GetDetector() == Detector::kNear ) pairhalfy = 2.91*fScale;
    
    // Build pair bounding box and position according to steel plane coords
    std::string pairName = GetGeoCompatibleName(steelId.AsString("b"));
    MSG("Geo",Msg::kDebug) << "Build PairBox " << pairName.c_str()
                           << " w/halfx,y,z " << pairhalfx << ","
                           << pairhalfy << "," << pairhalfz << "." << endl;

    Geo::EDetComponent detcomp = Geo::kPlnAirGap;
    if ( steelId.IsVetoShield() ) detcomp = Geo::kHall;
    TGeoVolume* pairVol = fGeoManager->MakeBox(pairName.c_str(),
                                             medMap.GetMedium(detcomp),
                                             pairhalfx,pairhalfy,pairhalfz);
    pairVol -> SetVisibility(kFALSE);
    pairVol -> VisibleDaughters(kTRUE);

    // Build 2 boxes representing air gaps.  "airgap0" is the gap between
    // the "front" (low-z face) of the scint plane in the current pair and the
    // "back" (high-z face) of the steel plane in the previous pair.
    // "airgap1" is the gap between the scint & steel plane in the current
    // pair.  The airgap coil segment will be added to each air gap.
    if ( !steelId.IsVetoShield() && coilVol ) {
      if ( planeno != plnMin[0] ) {
        if ( nSM == 1 || (nSM > 1 && planeno != plnMin[1]) ) {
          std::string airgap0 = pairName + "_air0";
          Double_t airgap0halfz = pairhalfz - 0.5*(stRow->GetTotalZ())*fScale;
          // totalz includes airgap even when scint pln not present? 
          // compensate for it here
          if ( !scplnVolume ) airgap0halfz 
                             = pairhalfz - 0.5*(stRow->GetThickness())*fScale;
          TGeoVolume* airgap0Vol = fGeoManager->MakeBox(airgap0.c_str(),
                                          medMap.GetMedium(Geo::kPlnAirGap),
                                          pairhalfx,pairhalfy,airgap0halfz);
          airgap0Vol -> SetVisibility(kFALSE);
          airgap0Vol -> VisibleDaughters(kTRUE);
          Double_t airgap0z0 = -pairhalfz + airgap0halfz;
          pairVol->AddNode(airgap0Vol,1,new TGeoTranslation(0.,0.,airgap0z0));
          if (dettype == Detector::kNear) airgap0Vol->AddNode(coilVol,1,rot45);
          else airgap0Vol -> AddNode(coilVol,1,gGeoIdentity);
        }
      }
      if ( scplnVolume ) {  // can't have airgap1 without active plane
        std::string airgap1 = pairName + "_air1";
        Double_t airgap1halfz = 0.5*(stRow->GetTotalZ()-stRow->GetThickness() 
                          - scRow->GetThickness())*fScale;
        TGeoVolume* airgap1Vol = fGeoManager->MakeBox(airgap1.c_str(),
                                     medMap.GetMedium(Geo::kPlnAirGap),
                                     pairhalfx,pairhalfy,airgap1halfz);
        airgap1Vol -> SetVisibility(kFALSE);
        airgap1Vol -> VisibleDaughters(kTRUE);
        Double_t airgap1z0 = pairhalfz-stRow->GetThickness()*fScale
                           - airgap1halfz;
        pairVol -> AddNode(airgap1Vol,1,new TGeoTranslation(0.,0.,airgap1z0));

        if ( dettype == Detector::kNear ) airgap1Vol->AddNode(coilVol,1,rot45);
        else airgap1Vol -> AddNode(coilVol,1,gGeoIdentity);
      }  
    }
    
    // Add to shield groups so as to be able to build bounding volume
    // default for caldet shield planes is still to place pair directly in hall


    std::string pairPath = fHallPath + "/" + pairName +"_1"; 
    if ( steelId.IsVetoShield() && vldc.GetDetector() == Detector::kFar ) { 
      GeoShield::EGroupType group=fGeoShield.AddVolume(pairVol,steelId,stRow);
      pairPath = fHallPath + "/" + GeoShield::AsString(group) + "_1/" + 
                 pairName+"_1";
    }
      
    int iSM = -1; // veto shield
    if ( !steelId.IsVetoShield() ) {
      iSM = 0;
      if ( nSM > 1 && steelId.GetPlane() > plnMax[0] ) iSM = 1;
    }
      
    if ( stplnVolume ) {
      // Place the steel plane within the pairVol
      std::string stplnNodeName = stName + "_1";
      std::string steelPlnPath = pairPath + "/" + stplnNodeName;
      double z0steel = pairhalfz - 0.5*(stRow->GetThickness())*fScale;
      MSG("Geo",Msg::kDebug) << "Placing steel pln at " << 0. << ","
                             << 0. << "," << z0steel << endl;
      GeoSteelPlnNode* stplnNode = new GeoSteelPlnNode(this,stplnVolume,
                          new TGeoTranslation(stName.c_str(),0.,0.,z0steel),
                          pairVol,steelPlnPath,stplnNodeName,steelId);
      
      // fSMZMin/Max in MARS coordinates
      if ( vldc.GetDetector() != Detector::kCalDet ) 
        fSMZMin[iSM] = TMath::Min(fSMZMin[iSM],(stRow->GetZBack()
                                  -stRow->GetThickness())*fScale);  
      else 
        fSMZMin[iSM] = TMath::Min(fSMZMin[iSM],(stRow->GetZBack()
                                  -stRow->GetTotalZ())*fScale);      
      fSMZMax[iSM] = TMath::Max(fSMZMax[iSM],(stRow->GetZBack())*fScale);

      // Insert steelplnNode in plane map
      fPlaneMap[steelId] = stplnNode;
    }
    
    if ( scplnVolume ) {
      // Place the scint plane within the pairVol
      Float_t x0pln = (scRow->GetX0RelSteel())*fScale;
      Float_t y0pln = (scRow->GetY0RelSteel())*fScale;
      Float_t z0pln = pairhalfz + 
                      (-stRow->GetTotalZ()+0.5*(scRow->GetThickness()))*fScale;

      // Rotation matrix relative to steel
      // (thetax,phix) = (90, 0+zrotrelsteel)
      // (thetay,phiy) = (90,90+zrotrelsteel)
      // (thetaz,phiz) = ( 0, 0)
      Double_t zrotrelsteel = scRow->GetZRotRelSteelDeg();

      MSG("Geo",Msg::kDebug) << "Placing scint pln at " << x0pln << ", "
                             << y0pln << "," << z0pln 
                             << " zrotrelsteel " << zrotrelsteel << endl;
        
      TGeoRotation* scRotMatrix = new TGeoRotation(scName.c_str(),90.,
                                  zrotrelsteel,90.,90.+zrotrelsteel,0.,0.);
      scRotMatrix -> RegisterYourself();
      
      TGeoCombiTrans* combiMatrix 
         = new TGeoCombiTrans(scName.c_str(),x0pln,y0pln,z0pln,scRotMatrix);

      std::string scplnNodeName = scName + "_1";
      std::string scintPlnPath = pairPath + "/" + scplnNodeName;
      GeoScintPlnNode* scplnNode 
          = new GeoScintPlnNode(this,scplnVolume,combiMatrix,pairVol,
                                scintPlnPath,scplnNodeName,scintId);
    
      this -> BuildModules(ugliDbiTables, scplnNode);

      // Insert scint pln node in plane map
      fPlaneMap[scintId] = scplnNode;

    }
    
  } // end of loop over all plane db rows

  
  return;
  
}

void GeoGeometry::BuildRotations

(

)

[private, virtual]

Definition at line 882 of file GeoGeometry.cxx.

References fRot315, and fRot45.

Referenced by BuildAll().

                                 {
  // Build commonly used rotation matrices

  // Rotation about the z-axis by +45 degrees
  fRot45 = new TGeoRotation("rot45",90,45,90,135,0,0);
  fRot45 -> RegisterYourself(); // do this so that it can be found later


  // Rotation about the z-axis by -45 degrees
  fRot315 = new TGeoRotation("rot315",90,315,90,45,0,0);
  fRot315 -> RegisterYourself(); // do this so that it can be found later

}

void GeoGeometry::BuildStrips	(	const UgliDbiTables &	tbl,
		GeoScintMdlNode *	node
	)			[private, virtual]

Definition at line 2160 of file GeoGeometry.cxx.

References PlexStripEndId::AsString(), fGeoManager, fScale, UgliDbiTables::fScintMdlStructTbl, UgliDbiTables::GetDbiStripById(), GetGeoCompatibleName(), GeoScintMdlNode::GetPlexScintMdlId(), DbiResultPtr< T >::GetRowByIndex(), UgliDbiStructHash::HashAsScintMdl(), Msg::kDebug, Msg::kFatal, Msg::kVerbose, MSG, and UpdateGlobalManager().

Referenced by BuildModules().

                                                        {
  // Purpose:: Build this planes's scint strips and add them as nodes to the
  // det plane volume
  // This method should be moved to GeoScintPlnVolume

  UpdateGlobalManager();
  assert(fGeoManager);
 
  PlexScintMdlId plexModuleId = mdlNode->GetPlexScintMdlId();
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildStrips for module " 
                         << mdlNode->GetName() << endl;
  
  // Determine lo,hi strip in plane
  UgliDbiStructHash modulestructhash(plexModuleId);
  const UgliDbiScintMdlStruct* scModuleStruct 
       = ugliDbiTables.fScintMdlStructTbl
        .GetRowByIndex(modulestructhash.HashAsScintMdl());
  Int_t lostrip = scModuleStruct -> GetFirstStrip();
  Int_t histrip = scModuleStruct -> GetLastStrip();

  for ( int istp = lostrip; istp <= histrip; istp++ ) {
    // For each strip in module
    PlexStripEndId seid(plexModuleId,istp);
    std::string stpName = GetGeoCompatibleName(seid.AsString());

    MSG("Geo",Msg::kVerbose)  << "Strip " << istp << " name " 
                              << stpName.c_str() << endl;
    const UgliDbiStrip* scStrip = ugliDbiTables.GetDbiStripById(seid);

    // The strip volumes have been pre-built
    std::string stpVolName = GetGeoCompatibleName(seid.AsString("s"));
    TGeoVolume* stpVol = fGeoManager -> GetVolume(stpVolName.c_str());
    if ( !stpVol ) {
      MSG("Geo",Msg::kFatal) 
         << "Unable to find pre-built stripvol for volume "
         << stpName.c_str() << " shape name " 
         << stpVolName.c_str() << endl;
      abort();
    } 

    // Build the node and place it in the plane
    Float_t tposStp = (scStrip -> GetTPosRelMdl())*fScale;
    Float_t lposStp = (scStrip -> GetLPosRelMdl())*fScale;
    Float_t zrotStp = scStrip -> GetZRotRelMdlDeg();
    MSG("Geo",Msg::kVerbose) << "tpos, lpos, zrot(deg) rel to module " 
                             << tposStp << ", " << lposStp << ", " 
                             << zrotStp << endl;

    std::string stpNodeName = stpVolName+"_1";

    TGeoRotation* stpRotMatrix = new TGeoRotation(stpNodeName.c_str(), 90.,
                                       zrotStp,90.,90.+zrotStp,0.,0.);
    stpRotMatrix -> RegisterYourself();
    TGeoCombiTrans* combiMatrix 
     = new TGeoCombiTrans(stpNodeName.c_str(),lposStp,tposStp,0.,stpRotMatrix);

    new GeoStripNode(this,stpVol,combiMatrix,mdlNode,stpNodeName,seid);

  }

  return;
  
}

void GeoGeometry::BuildStripVolumes

(

const VldContext &

vldc

)

[private, virtual]

Definition at line 2226 of file GeoGeometry.cxx.

References fGeoManager, fScale, VldContext::GetDetector(), GetGeoCompatibleName(), UgliDbiStripStruct::GetLenEastPart(), UgliDbiStripStruct::GetLenWestPart(), DbiResultPtr< T >::GetNumRows(), UgliDbiStripStruct::GetPlaneView(), DbiResultPtr< T >::GetRow(), UgliLoanPool::GetShieldOff(), UgliDbiStripStruct::GetTotalLen(), UgliDbiStripStruct::GetWlsLenBypass(), UgliDbiStripStruct::GetWlsLenEast(), UgliDbiStripStruct::GetWlsLenWest(), UgliLoanPool::Instance(), Detector::kCalDet, Msg::kDebug, Detector::kFar, PlaneView::kU, PlaneView::kV, PlaneView::kX, PlaneView::kY, MSG, and UpdateGlobalManager().

Referenced by BuildPlanePairVolumes().

                                                          {
  // pre-build set of strip volumes for this vldc.  strip volumes will be 
  // placed appropriately in module volumes as nodes when planes are 
  // constructed.

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildStripVolumes " << endl;
  assert(fGeoManager);

  DbiResultPtr<UgliDbiStripStruct> stripTbl(vldc);
  Detector::Detector_t dettype = vldc.GetDetector();
  
  bool shieldOff = UgliLoanPool::Instance()->GetShieldOff();

  for ( unsigned int irow = 0; irow < stripTbl.GetNumRows(); irow++ ) {
    const UgliDbiStripStruct* sRow = stripTbl.GetRow(irow);
    string stpName = GetGeoCompatibleName(sRow -> GetShapeName());
    PlaneView::PlaneView_t plnview = sRow->GetPlaneView();
    bool isVetoShield = false;
    if ( dettype == Detector::kFar ) {
      if ( plnview != PlaneView::kU && plnview != PlaneView::kV ) 
        isVetoShield = true;
    }
    else if ( dettype == Detector::kCalDet ) {
      if ( plnview != PlaneView::kX && plnview != PlaneView::kY )
        isVetoShield = true;
    }

    if ( shieldOff && isVetoShield ) continue;
    
    // Volumes will self-register with fGeoManager
    Float_t totallen = (sRow->GetTotalLen())*fScale;
    Float_t leneastpart = (sRow->GetLenEastPart())*fScale;
    Float_t lenwestpart = (sRow->GetLenWestPart())*fScale;
    // Clean up some caldet database crud
    if ( totallen < 1.E-4*fScale ) continue;
    if ( leneastpart < 1.E-4*fScale ) leneastpart = totallen;
    if ( lenwestpart < 1.E-4*fScale ) lenwestpart = totallen;
    
    new GeoStripVolume(this,stpName.c_str(),totallen,leneastpart,lenwestpart,
                                       (sRow->GetWlsLenEast())*fScale, 
                                       (sRow->GetWlsLenWest())*fScale, 
                                       (sRow->GetWlsLenBypass())*fScale,
                                       isVetoShield);
  } 

}

void GeoGeometry::BuildVldRange

(

const VldContext &

vldc

)

[private, virtual]

Definition at line 811 of file GeoGeometry.cxx.

References det, Detector::FullMask(), fVldRange, VldTimeStamp::GetBOT(), VldContext::GetDetector(), VldTimeStamp::GetEOT(), VldContext::GetSimFlag(), DbiResultPtr< T >::GetValidityRec(), Msg::kDebug, Detector::kUnknown, MSG, TrimVldRange(), and UpdateGlobalManager().

Referenced by BuildAll().

                                                      {
  // Private. Build VldRange from VldContext

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildVldRange for VldContext " 
                         << vldc << endl;
  
  Detector::Detector_t det = vldc.GetDetector();
  bool isunknown = (Detector::kUnknown == det);
  const char* src = "DBI";
  Int_t detmask = Detector::FullMask();
  Int_t simmask = SimFlag::FullMask();
  if ( isunknown ) { 
    src = "Fake (unknown detector)";
    detmask = det;
    simmask = vldc.GetSimFlag();
  }
  
  // Start the VldRange covering all of time and then trim it down
  VldTimeStamp starttime = VldTimeStamp::GetBOT();
  VldTimeStamp endtime = VldTimeStamp::GetEOT();
  fVldRange = VldRange(detmask,simmask,starttime,endtime,src);

  // special return for unknown detector
  if (isunknown) return;

  DbiResultPtr<UgliDbiSteelPln> steelTbl(vldc);
  TrimVldRange("UgliDbiSteelPln",steelTbl.GetValidityRec());

  DbiResultPtr<UgliDbiScintPlnStruct> scintStructTbl(vldc);
  TrimVldRange("UgliDbiScintPlnStruct",scintStructTbl.GetValidityRec());

  DbiResultPtr<UgliDbiScintPln> scintTbl(vldc);
  TrimVldRange("UgliDbiScintPln",scintTbl.GetValidityRec());

  DbiResultPtr<UgliDbiScintMdlStruct> mdlStructTbl(vldc);
  TrimVldRange("UgliDbiScintMdlStruct",mdlStructTbl.GetValidityRec());

  DbiResultPtr<UgliDbiScintMdl> mdlTbl(vldc);
  TrimVldRange("UgliDbiScintMdl",mdlTbl.GetValidityRec());

  DbiResultPtr<UgliDbiStripStruct> stripStructTbl(vldc);
  TrimVldRange("UgliDbiStripStruct",stripStructTbl.GetValidityRec());

  DbiResultPtr<UgliDbiStrip> stripTbl(vldc);
  TrimVldRange("UgliDbiStrip",stripTbl.GetValidityRec());
  
  MSG("Geo",Msg::kDebug) << "GeoGeometry::BuildVldRange built VldRange " 
                         << fVldRange << endl;
  
}

void GeoGeometry::Draw

(

Option_t *

volname = ""

)

[virtual]

Definition at line 157 of file GeoGeometry.cxx.

References fGeoManager, Msg::kInfo, Msg::kWarning, MSG, and UpdateGlobalManager().

Referenced by UgliGeomHandle::Draw().

                                        {
  // Public. Draw this geometry from volume volname (default "HALL")

  UpdateGlobalManager();

  std::string volnamestr(volname);
  if (volnamestr.empty()) volnamestr = "HALL"; 
   
  MSG("Geo",Msg::kInfo) << "GeoGeometry::Draw() from top volume " 
                        << volnamestr.empty() << "." << endl;

  if ( !fGeoManager ) {
    MSG("Geo",Msg::kWarning) << "Null fGeoManager" << endl;
    return;
  }
  
  TGeoVolume* topVol = fGeoManager -> GetVolume(volnamestr.c_str());
  if ( !topVol ) {
    MSG("Geo",Msg::kWarning) << "No volume of name " << volnamestr.c_str() 
                             << endl;
    return;
  }
  //fGeoManager->SetTopVisible();
  topVol -> SetVisContainers();
  topVol -> Draw();
   
}

void GeoGeometry::DumpVolume	(	std::string	volname,
		std::string	preface = ""
	)			const [virtual]

Definition at line 186 of file GeoGeometry.cxx.

References fGeoManager, and UpdateGlobalManager().

Referenced by Print().

                                                                       {
  // Print information about volume down through all daughter nodes

  UpdateGlobalManager();

  TGeoVolume* volume = fGeoManager->GetVolume(volname.c_str());
  if ( !volume ) {
    cout << "No volume of name \"" << volname.c_str() << "\"!" << endl;
    return;
  }
  
  cout << preface.c_str() << "Volume " << volume->GetName() << ", shape:" 
       << endl;
  cout << preface.c_str();
  volume->GetShape()->InspectShape();
  
  Int_t ndaughter = volume -> GetNdaughters();
  if ( ndaughter > 0 ) 
    cout << preface.c_str() << ndaughter << " daughter nodes:" << endl;
  else
    cout << preface.c_str() << "No daughter nodes." << endl;
  
  for ( int id = 0; id < ndaughter; id++ ) {
    TGeoNode* daughternode = volume->GetNode(id);
    cout << preface.c_str() << "  " << id << ")" << daughternode->GetName() 
         << endl;
    cout << preface.c_str() << "  ";
    daughternode->GetMatrix()->Print();
    TGeoVolume* daughtervol = daughternode->GetVolume();
    this -> DumpVolume(daughtervol->GetName(),preface+"  ");
  }
  
}

Geo::EAppType GeoGeometry::GetAppType

(

)

const [inline]

Definition at line 68 of file GeoGeometry.h.

References fAppType.

Referenced by GeoStripVolume::AddPstyreneNodes(), GeoShieldGroup::AddVolume(), BuildFarCoilAirGapVolume(), BuildNearCoilAirGapVolume(), GeoScintMdlVolume::BuildNearLmXtru(), GeoScintMdlVolume::BuildNearlMXtru(), GeoShieldGroup::BuildNode(), GeoVolume::GetScale(), and UgliGeomHandle::ResetVldContext().

{ return fAppType; }

std::string GeoGeometry::GetGeoCompatibleName

(

std::string

name

)

[static]

Definition at line 221 of file GeoGeometry.cxx.

Referenced by GeoScintMdlVolume::Build4Corners(), BuildDetector(), BuildModules(), GeoScintMdlVolume::BuildNearIXtru(), GeoScintMdlVolume::BuildNeariXtru(), BuildPlanePairVolumes(), BuildStrips(), BuildStripVolumes(), and GeoScintMdlVolume::GeoScintMdlVolume().

                                                          {
  // Public Static method to return acceptable node or volume name
  // Symbol "/" is replaced with "f" to avoid conflict with "/" used in paths
  // Symbol "-" is replaced with "h" to avoid conflict with "-" used in
  // composite shapes. 

  std::string okayname = name;
  // Name cannot include "/" because of ambiguity with "/" used in
  // path to nodes. Replace "/" with "f".
  size_t ipos = okayname.find("/");
  while ( ipos != std::string::npos ) {
    okayname.replace(ipos,1,"f");
    ipos = okayname.find("/");
  }

  // Name cannot include "-" because of ambiguity with "-" used in
  // composite shapes. Replace "-" with "h".
  ipos = okayname.find("-");
  while ( ipos != std::string::npos ) {
    okayname.replace(ipos,1,"h");
    ipos = okayname.find("-");
  }
  
  return okayname; 
}

virtual TVector3 GeoGeometry::GetHallExtentMax

(

)

const [inline, virtual]

Definition at line 72 of file GeoGeometry.h.

References fHallMax.

Referenced by UgliGeomHandle::GetHallExtentMax().

{ return fHallMax; }

virtual TVector3 GeoGeometry::GetHallExtentMin

(

)

const [inline, virtual]

Definition at line 71 of file GeoGeometry.h.

References fHallMin.

Referenced by UgliGeomHandle::GetHallExtentMin().

{ return fHallMin; }

TGeoMedium * GeoGeometry::GetMedium

(

const char *

name

)

const

Definition at line 643 of file GeoGeometry.cxx.

References fGeoManager, Msg::kFatal, medium, MSG, and UpdateGlobalManager().

Referenced by SwitchMedia().

                                                         {
  // Public. Purpose:: Return ptr to medium of given name.  If geometry
  // is not closed, such that this method is being called during the
  // geometry build stage, will abort with fatal message if no medium
  // of given name is found.  Otherwise, will return null ptr if
  // medium not found.
  //  

  UpdateGlobalManager();

  TGeoMedium* medium = fGeoManager->GetMedium(name);
  if ( !medium && !(fGeoManager->IsClosed()) ) {
    MSG("Geo",Msg::kFatal) << "GeoGeometry::GetMedium did not find medium\n"
                           << name << " during geometry build stage. Abort."
                           << endl;
    abort();
  }
  
  return medium;

}

virtual const GeoMediumMap& GeoGeometry::GetMediumMap

(

)

const [inline, virtual]

Definition at line 75 of file GeoGeometry.h.

References fMediumMap.

Referenced by GeoScintMdlVolume::AddAirNode(), GeoStripVolume::AddPstyreneNodes(), BuildFarCoil(), BuildFarCoilAirGapVolume(), GeoScintPlnVolume::BuildFarCoilVolume(), GeoSteelPlnVolume::BuildFarCoilVolume(), BuildFarLeadStacks(), BuildFarMARS(), BuildGeometry(), BuildNearCoil(), BuildNearCoilAirGapVolume(), GeoScintPlnVolume::BuildNearCoilVolume(), GeoSteelPlnVolume::BuildNearCoilVolume(), BuildNearMARS(), GeoShieldGroup::BuildNode(), BuildPlanePairVolumes(), GeoScintMdlVolume::GeoScintMdlVolume(), GeoScintPlnVolume::GeoScintPlnVolume(), GeoStripVolume::GeoStripVolume(), and ls().

{ return *fMediumMap; }

GeoSteelPlnNode * GeoGeometry::GetNearestSteelPlnNode

(

Double_t

z

)

const [virtual]

Definition at line 277 of file GeoGeometry.cxx.

References fGeoManager, GetSteelPlnNodeMap(), Msg::kDebug, MSG, and UpdateGlobalManager().

                                                                     {
  // Public. Purpose:: Retrieve the nearest steel node for a given z

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug) << "GeoGeometry::GetNearestSteelPlnNode to z " 
                         << z << "." << endl;
  assert(fGeoManager);

  const std::map<Float_t,GeoSteelPlnNode*>& stnodemap = GetSteelPlnNodeMap();

  // Steel planes in map are all in main detector block
  // Ordering of planes is lo to hi
  std::map<Float_t,GeoSteelPlnNode*>::const_iterator steelplnItr;
  
  // Lower bound returns steel plane with z value greater than or equal to key
  steelplnItr = stnodemap.lower_bound(z);
  GeoSteelPlnNode* loplnNode = 0;
  Double_t         loplnz0   = -9999.;
  GeoSteelPlnNode* hiplnNode = 0;
  Double_t         hiplnz0   = -9999.;
  if ( steelplnItr != stnodemap.end() ) {
    hiplnNode = steelplnItr->second;
    hiplnz0   = steelplnItr->first;
  }
  if ( steelplnItr != stnodemap.begin() ) {
    steelplnItr--;
    loplnNode = steelplnItr->second;
    loplnz0   = steelplnItr->first;
  }
  if ( hiplnNode == 0 ) return loplnNode;
  else if ( loplnNode == 0 ) return hiplnNode;
  
  // Bracketed by two planes, determine which is closer
  // avoid additional (slow) coordinate transformations by using
  // information stored in the map
  return ( TMath::Abs(z-loplnz0) < TMath::Abs(z-hiplnz0) ) ? loplnNode : hiplnNode;


}

PlexPlaneId GeoGeometry::GetPlaneIdFromZ

(

Double_t

z

)

const [virtual]

Definition at line 319 of file GeoGeometry.cxx.

References fGeoManager, fPlaneMap, GeoNode::GlobalToLocal(), Msg::kDebug, MSG, Munits::second, and UpdateGlobalManager().

Referenced by UgliGeomHandle::GetPlaneIdFromZ().

                                                         {
  // Purpose:: Retrieve detector plane corresponding to the first
  // plane in the main detector block with a back face (high-z side)
  // "downstream" of z (greater than z).  The exception is that if z 
  // is greater than back face of highest-z plane in detector, return 
  // plexplaneid of last plane, even though this plane's high-z face is 
  // not downstream of z.  This behavior is that used in UgliGeometry. 
  // Use PlexPlaneId::IsValid() to determine validity of returned PlexPlaneId.
  // Will only return invalid plexplaneid if no planes in main detector
  // block.  
 
  UpdateGlobalManager();
  
  MSG("Geo",Msg::kDebug) << "GeoGeometry::GetPlaneIdFromZ " << z << "."<< endl;
  assert(fGeoManager);

  PlexPlaneId defplex;  // default plex is invalid
  
  PlaneMapConstItr plnItr;
  // Move through the plane map from low to high z
  Double_t xyz_global[3] = {0,0,z};
  Double_t xyz_local[3] = {0};
      
  // fPlaneMap has scint & steel planes 
  for ( plnItr = fPlaneMap.begin();  plnItr != fPlaneMap.end(); ++plnItr) {
    if ( (plnItr->first).IsVetoShield() ) continue; // No shield
    GeoPlnNode* plnNode = dynamic_cast<GeoPlnNode*>(plnItr -> second);
    plnNode->GlobalToLocal(xyz_global,xyz_local);
    Float_t dz  = dynamic_cast<TGeoBBox*>(plnNode->GetVolume()->GetShape())
                  ->GetDZ();
    if ( xyz_local[2] < dz ) {
      return plnItr->first;
    }
    defplex = plnItr->first; // default plex is highest-z pln in main block
  }

  return defplex;

}

const vector< GeoPlnNode * > & GeoGeometry::GetPlnNodePtrVector

(

)

const

Definition at line 360 of file GeoGeometry.cxx.

References fPlaneMap, fPlnNodes, Msg::kDebug, MSG, and UpdateGlobalManager().

Referenced by UgliGeomHandle::GetPlnHandleVector().

                                                                  {
  // Public. Purpose:: Return collection of ptrs for all pln nodes in detector

  MSG("Geo",Msg::kDebug) << "GetPlnNodePtrVector" << endl;

  UpdateGlobalManager();

  if ( fPlnNodes.empty() ) {
    PlaneMapConstItr plnItr;
    for ( plnItr = fPlaneMap.begin(); plnItr != fPlaneMap.end(); ++plnItr) {
      GeoPlnNode* plnNode = plnItr->second;
      fPlnNodes.push_back(plnNode);
    }
  }
  
  return fPlnNodes;

}

TGeoRotation* GeoGeometry::GetRot315

(

)

const [inline]

Definition at line 106 of file GeoGeometry.h.

References fRot315.

Referenced by GeoScintPlnVolume::AddCoilNode(), and BuildNearCoil().

{ return fRot315; }

TGeoRotation* GeoGeometry::GetRot45

(

)

const [inline]

Definition at line 105 of file GeoGeometry.h.

References fRot45.

Referenced by GeoScintPlnVolume::AddCoilNode(), GeoSteelPlnVolume::AddCoilNode(), BuildNearCoil(), and BuildPlanePairVolumes().

{ return fRot45; } 

GeoScintPlnNode * GeoGeometry::GetScintPlnNode

(

PlexPlaneId

planeId

)

const [virtual]

Definition at line 380 of file GeoGeometry.cxx.

References PlexPlaneId::AsString(), fPlaneMap, PlexPlaneId::IsSteel(), Msg::kDebug, Msg::kWarning, MSG, and UpdateGlobalManager().

Referenced by UgliGeomHandle::GetScintPlnHandle(), and GetStripNode().

                                                                       {
  // Public. Purpose:: Retrieve the node for a particular plane

  MSG("Geo",Msg::kDebug) << "GetScintPlnNode for plane " << planeid.AsString() 
                         << endl;

  UpdateGlobalManager();

  GeoScintPlnNode* plnnode = 0;
  if ( planeid.IsSteel() ) {
    MSG("Geo",Msg::kWarning) 
      << "GetScintPlnNode called with steel plane id " 
      << planeid.AsString() << endl;
    return 0;
  }
  
  PlaneMapConstItr citr = fPlaneMap.find(planeid);
  if ( citr != fPlaneMap.end() ) {
    plnnode = dynamic_cast<GeoScintPlnNode*>(citr->second);
  }
  
  return plnnode;

}

const vector< GeoScintPlnNode * > & GeoGeometry::GetScintPlnNodePtrVector

(

)

const

Definition at line 406 of file GeoGeometry.cxx.

References fPlaneMap, fScintPlnNodes, Msg::kDebug, MSG, and UpdateGlobalManager().

Referenced by UgliGeomHandle::GetScintPlnHandleVector().

                                                                            {
  // Purpose:: Return collection of ptrs for all scint pln nodes in detector

  MSG("Geo",Msg::kDebug) << "GetScintPlnNodePtrVector" << endl;

  UpdateGlobalManager();

  if ( fScintPlnNodes.empty() ) {
    PlaneMapConstItr plnItr;
    for ( plnItr = fPlaneMap.begin(); plnItr != fPlaneMap.end(); ++plnItr ){
      if ( !(plnItr->first).IsSteel() ) {
        fScintPlnNodes.push_back(
                              dynamic_cast<GeoScintPlnNode*>(plnItr->second));
      }
    }
  }

  return fScintPlnNodes;

}

Int_t GeoGeometry::GetSMPlaneLimits	(	const VldContext &	vldc,
		Int_t *	plnMin,
		Int_t *	plnMax
	)			[private]

Definition at line 1662 of file GeoGeometry.cxx.

References bfld::AsString(), VldContext::GetDetector(), Detector::kCalDet, Msg::kError, Detector::kFar, Detector::kNear, and MSG.

Referenced by BuildDetector(), and BuildPlanePairVolumes().

                                                                  {
  // Private, but could be public?
  // Determine Super Module plane limits for specified vldc.  
  // Returns number of super modules.  plnMin/Max[0] is filled for
  // supermodule 0 and plnMin/Max[1] for supermodule 1 if applicable.

  Detector::Detector_t dettype = vldc.GetDetector();
  Int_t nSM = 0;
  switch (dettype) {
  case Detector::kFar: 
    nSM = 2;
    plnMin[0] = 0;
    plnMax[0] = 248;
    plnMin[1] = 249;
    plnMax[1] = 485;
    break;
  case Detector::kNear:
    nSM = 1;
    plnMin[0] = 0;
    plnMax[0] = 281;
    break;
  case Detector::kCalDet:
    nSM = 1;
    plnMin[0] = 0;
    plnMax[0] = 60; // main detector block, 61-64 on floor
    break;
  default:
    MSG("Geo",Msg::kError) 
    << "GetSMPlaneLimits failed for unknown detector type\n"
    << Detector::AsString(dettype) << "." << endl;
  } // end of switch

  return nSM;
  
}

GeoSteelPlnNode * GeoGeometry::GetSteelPlnNode

(

PlexPlaneId

planeId

)

const [virtual]

Definition at line 428 of file GeoGeometry.cxx.

References PlexPlaneId::AsString(), fPlaneMap, PlexPlaneId::IsSteel(), Msg::kDebug, Msg::kWarning, MSG, and UpdateGlobalManager().

Referenced by UgliGeomHandle::GetSteelPlnHandle().

                                                                       {
  // Public. Purpose:: Retrieve the node for a particular plane

  MSG("Geo",Msg::kDebug) << "GetSteelPlnNode for plane " << planeid.AsString() 
                         << endl;

  UpdateGlobalManager();

  GeoSteelPlnNode* plnnode = 0;
  if ( !planeid.IsSteel() ) {
    MSG("Geo",Msg::kWarning) 
      << "GetSteelPlnNode called with non steel plane id " 
      << planeid.AsString() << endl;
    return 0;
  }
  
  PlaneMapConstItr citr = fPlaneMap.find(planeid);
  if ( citr != fPlaneMap.end() ) {
    plnnode = dynamic_cast<GeoSteelPlnNode*>(citr->second);
  }
  
  return plnnode;

}

const std::map< Float_t, GeoSteelPlnNode * > & GeoGeometry::GetSteelPlnNodeMap

(

)

const

Definition at line 477 of file GeoGeometry.cxx.

References fPlaneMap, fSteelPlnNodeMap, Msg::kDebug, MSG, and UpdateGlobalManager().

Referenced by GetNearestSteelPlnNode().

                                                                           {
  // Public. Purpose:: Return collection of ptrs for all steel pln nodes 
  // in main body of detector, key'ed by z-position. 

  MSG("Geo",Msg::kDebug) << "GetSteelPlnNodeMap" << endl;

  UpdateGlobalManager();
  
  if ( fSteelPlnNodeMap.empty() ) {
    PlaneMapConstItr plnItr;
    for ( plnItr = fPlaneMap.begin(); plnItr != fPlaneMap.end(); plnItr++ ){
      if ( (plnItr->first).IsSteel() && !(plnItr->first).IsVetoShield()) {
        fSteelPlnNodeMap.insert(make_pair(plnItr->second->GetZ0(),
                             dynamic_cast<GeoSteelPlnNode*>(plnItr->second)));
      }
    }
  }
  
  return fSteelPlnNodeMap;

}

const vector< GeoSteelPlnNode * > & GeoGeometry::GetSteelPlnNodePtrVector

(

)

const

Definition at line 454 of file GeoGeometry.cxx.

References fPlaneMap, fSteelPlnNodes, Msg::kDebug, MSG, and UpdateGlobalManager().

Referenced by UgliGeomHandle::GetSteelPlnHandleVector().

                                                                            {
  // Public. Purpose:: Return collection of ptrs for all steel pln nodes 
  // in detector

  MSG("Geo",Msg::kDebug) << "GetSteelPlnNodePtrVector" << endl;

  UpdateGlobalManager();

  if ( fSteelPlnNodes.empty() ) {
    PlaneMapConstItr plnItr;
    for ( plnItr = fPlaneMap.begin(); plnItr != fPlaneMap.end(); ++plnItr ){
      if ( (plnItr->first).IsSteel() ) {
        fSteelPlnNodes.push_back(
                              dynamic_cast<GeoSteelPlnNode*>(plnItr->second));
      }
    }
  }
  
  return fSteelPlnNodes;

}

GeoStripNode * GeoGeometry::GetStripNode

(

const PlexStripEndId &

seid

)

const [virtual]

Definition at line 501 of file GeoGeometry.cxx.

References PlexStripEndId::AsString(), GetScintPlnNode(), Msg::kDebug, MSG, and UpdateGlobalManager().

Referenced by GeoStripNode::DistanceAlong(), UgliGeomHandle::GetStripHandle(), and GeoStripNode::Intersection().

                                                                        {
  // Public. Purpose:: Retrieve the node for a particular strip
 
  MSG("Geo",Msg::kDebug) << "GetStripNode for strip "  << seid.AsString() 
                         << endl;

  UpdateGlobalManager();

  GeoStripNode* stripnode = 0;

  // Retrieve the plane node and then the strip node
  GeoScintPlnNode* planenode = this -> GetScintPlnNode(seid);
  if ( planenode ) {
    stripnode = planenode -> GetStripNode(seid);
  }

  return stripnode;

}

void GeoGeometry::GetTransverseExtent	(	PlaneView::PlaneView_t	view,
		Double_t &	tmin,
		Double_t &	tmax
	)			const [virtual]

Definition at line 522 of file GeoGeometry.cxx.

References bfld::AsString(), fScale, fVldRange, VldRange::GetDetectorMask(), Detector::kCalib, Msg::kDebug, Msg::kError, Detector::kFar, Detector::kNear, Geo::kStripWidth, PlaneView::kU, PlaneView::kV, MSG, and UpdateGlobalManager().

                                                                            {
  // Public. Purpose: Retrieve transverse extent of detector
  // based on detector type and form.  These values are currently hardwired
  // as in UgliGeometry::GetTransverseExtent

  MSG("Geo",Msg::kDebug) << "GetTransverseExtent for view "  
                         << PlaneView::AsString(view) << endl;

  UpdateGlobalManager();

  tmin = -999; tmax=-999;

  Detector::Detector_t detector 
    = (Detector::Detector_t)fVldRange.GetDetectorMask();
  
  switch (detector) {
  case Detector::kNear:
    switch (view ) {
    case PlaneView::kU:
      tmin = -2.10 * fScale;
      tmax = +2.75 * fScale;
      break;
    case PlaneView::kV:
      tmin = -2.75 * fScale;
      tmax = +2.10 * fScale;
      break;
    default:
      MSG("Geo",Msg::kError)
        << "GeoGeometry::GetTransverseExtent undefined for "
        << Detector::AsString(detector) << " view "
        << PlaneView::AsString(view) << endl;
      break;
    }
  case Detector::kFar:
    tmin = -4.0 * fScale;
    tmax = +4.0 * fScale;
    break;
  case Detector::kCalib:
    tmin = -0.5 * fScale;
    tmax = +0.5 * fScale;
    break;
  default:
    MSG("Geo",Msg::kError) 
      << "GeoGeometry::GetTransverseExtent undefined for "
      << Detector::AsString(detector) << endl;
    break;
  }

  Float_t fuzz = 0.5*Geo::kStripWidth*fScale;
  tmin = tmin - fuzz;
  tmax = tmax + fuzz;
  
  return;
    
}

void GeoGeometry::GetTransverseExtent	(	PlaneView::PlaneView_t	view,
		Float_t &	tmin,
		Float_t &	tmax
	)			const [virtual]

Definition at line 580 of file GeoGeometry.cxx.

References UpdateGlobalManager().

Referenced by UgliGeomHandle::GetTransverseExtent().

                                                                          {
  // Public. Purpose: Retrieve transverse extent of detector in global (MARS)
  // coordinates.

  UpdateGlobalManager();
  
  Double_t tmind,tmaxd;
  GetTransverseExtent(view,tmind,tmaxd);
  tmin = (Float_t)tmind;
  tmax = (Float_t)tmaxd;

  return;
    
}

virtual const VldRange& GeoGeometry::GetVldRange

(

)

const [inline, virtual]

Definition at line 93 of file GeoGeometry.h.

References fVldRange.

Referenced by UgliGeomHandle::GetVldRange().

{ return fVldRange; }

void GeoGeometry::GetZExtent	(	Double_t &	zmin,
		Double_t &	zmax,
		Int_t	isup = -1
	)			const [virtual]

Definition at line 597 of file GeoGeometry.cxx.

References fSMZMax, fSMZMin, Msg::kDebug, Msg::kWarning, MSG, and UpdateGlobalManager().

                                                                            {
  // Public. Purpose: Retrieve zextent of specified isup supermodule in MARS
  // coordinates. If isup = -1 (default), returns zextent of entire detector.
 
  MSG("Geo",Msg::kDebug) << "GetZExtent for isup "  << isup << endl;

  UpdateGlobalManager();
 
  // The boundaries are calculated during geometry build 
  zmax =-999999;
  zmin =+999999; 
  if ( isup < 0 ) {
    zmin = fSMZMin[0];
    if ( fSMZMax[1] > 0 ) zmax = fSMZMax[1];
    else zmax = fSMZMax[0];
  }
  else if ( isup < 2 ) {
    zmin = fSMZMin[isup];
    zmax = fSMZMax[isup];
  }
  else {
    MSG("Geo",Msg::kWarning) << "GetZExtent failed. SuperModule "
                             << isup << " undefined." << endl;
  }

  return;
  
   
}

void GeoGeometry::GetZExtent	(	Float_t &	zmin,
		Float_t &	zmax,
		Int_t	isup = -1
	)			const [virtual]

Definition at line 628 of file GeoGeometry.cxx.

References UpdateGlobalManager().

Referenced by BuildFarCoil(), BuildNearCoil(), and UgliGeomHandle::GetZExtent().

                                                                           {
  // Public. Purpose:: Retrieve zextent of specified isup supermodule. If 
  // isup = -1 (default), returns zextent of entire detector.

  UpdateGlobalManager();
  
  Double_t zmind,zmaxd;
  GetZExtent(zmind,zmaxd,isup);
  zmin = (Float_t)zmind;
  zmax = (Float_t)zmaxd;

  return;
}

bool GeoGeometry::IsAlgorithmic

(

)

const [inline]

Definition at line 66 of file GeoGeometry.h.

Referenced by UgliGeomHandle::IsAlgorithmic().

{ return false; }

bool GeoGeometry::IsCompatible	(	const VldContext &	vldc,
		Geo::EAppType	apptype
	)			const

Definition at line 666 of file GeoGeometry.cxx.

References fAppType, fVldRange, VldRange::IsCompatible(), and UpdateGlobalManager().

Referenced by UgliLoanPool::GetExistingGeoGeometry().

                                                          {
  // Public. Test if vldc and apptype are in range of this geometry

  UpdateGlobalManager();

  bool iscompatible = false;
  if ( fVldRange.IsCompatible(vldc) && fAppType == apptype ) 
                                             iscompatible = true;
  return iscompatible; 
}

bool GeoGeometry::IsFrozen

(

)

const [inline]

Definition at line 67 of file GeoGeometry.h.

Referenced by UgliStripHandle::IsFrozen(), UgliScintMdlHandle::IsFrozen(), UgliScintPlnHandle::IsFrozen(), UgliGeomHandle::IsFrozen(), and UgliSteelPlnHandle::IsFrozen().

{ return true; }

void GeoGeometry::ls

(

Option_t *

option = ""

)

const [virtual]

Definition at line 679 of file GeoGeometry.cxx.

References fGeoManager, GetMediumMap(), medium, Print(), GeoMediumMap::Print(), PrintHeader(), and UpdateGlobalManager().

Referenced by UgliGeomHandle::ls().

                                           {
  // Public. list components of this geometry
  // Argument: option string is a concatenated list of char options, where:
  //           "m" => print list materials
  //           "M" => print list of media.  Default won't print swim media
  //                  Override with configopt == "a", e.g. ls("Ma").
  //           "d" => print MediumMap detector components and associated 
  //                  mediums and swim methods 
  //           "v" => print list of volumes 
  //           "a" => configuration option "all".  If present, may toggle
  //                  on a greater dump of information.
  // Example: An option argument to specify listing of materials and mediums
  //          is "mM"

  UpdateGlobalManager();
  PrintHeader();

  TString opt = option;
  bool isAll = false;
  if ( opt.Contains("a") ) isAll = true;
  
  if (opt.Contains("m")) {
    // Can't use ls() for TGeoMaterial because not supported
    fGeoManager->GetListOfMaterials()->Print(); 
  }
  if (opt.Contains("M")) {
    // Can't use ls() or Print() for TGeoMedium because not supported
    GeoMedium::PrintHeader();  // print media table header
    TIter medItr(fGeoManager->GetListOfMedia());
    GeoMedium* medium = 0;  
    while ( ( medium = dynamic_cast<GeoMedium*>(medItr()) ) ) {
      if ( !isAll ) {
        std::string medName = medium->GetName();
        if ( medName.find("_SWIM") != std::string::npos ) continue;
      }
      medium -> Print();
    }
  }
  if (opt.Contains("d")) {
    // Print list of detector components and associated mediums and
    // swim methods
    GetMediumMap().Print();
  }
  if (opt.Contains("v")) {
    // Print list of volumes in this geometry
    TIter volItr(fGeoManager->GetListOfUVolumes());
    TGeoVolume* volume = 0;
    while ( ( volume = dynamic_cast<TGeoVolume*>(volItr()) ) ) {
      cout << setiosflags(ios::left) << setw(30) << volume->GetName() 
           << setw(30) << volume->GetMedium()->GetName()
           << endl;
    }
  }    
  
}

void GeoGeometry::Print

(

Option_t *

option = ""

)

const [virtual]

Definition at line 736 of file GeoGeometry.cxx.

References DumpVolume(), PrintHeader(), and UpdateGlobalManager().

Referenced by ls(), UgliGeomHandle::Print(), and UgliLoanPool::Print().

                                              {
   // Public. Print something about this geometry (name + vldrange)

  UpdateGlobalManager();

  std::string stoption(option);
  if (stoption != "") DumpVolume(stoption);
  PrintHeader();
  
}

void GeoGeometry::PrintHeader

(

Option_t *

option = ""

)

const [virtual]

Definition at line 748 of file GeoGeometry.cxx.

References VldRange::AsString(), GeoRefCnt::CountRef(), fGeoManager, and fVldRange.

Referenced by ls(), and Print().

                                                          {
  // Print header info (name + vldrange) about this geometry.

  cout << "GeoGeometry " << fGeoManager->GetName() << " " 
       << fGeoManager->GetTitle() << endl;
  cout << "Has " << CountRef() << " reference" << ((CountRef()==1)?"":"s")
       << " VldRange:" << fVldRange.AsString("acs-") << endl;
  
}

void GeoGeometry::SwitchMedia

(

bool

toswim

)

[virtual]

Definition at line 759 of file GeoGeometry.cxx.

References fGeoManager, fIsSwimMedia, and GetMedium().

                                         {
  // Method to geometry to/from swim media to default media
  // Swim media are used during GeoSwimmer particle transport and
  // have a different set of physics process flags/energy threshold
  // cuts assigned to them when used with a concrete VMC.

  Int_t ntoadd = 0;
  Int_t nmedia = fGeoManager->GetListOfMedia()->GetSize();
  if ( toswim ) {
    if ( fIsSwimMedia ) return;  // already set up for swim media
    ntoadd = nmedia/2 - 1; // number to add to current medId to get swim twin  
  }
  else {
    if ( !fIsSwimMedia ) return; // already set up for default media
    ntoadd = -nmedia/2 - 1; // number to add to current medId to get def twin
  }
  
  TIter nextvol(fGeoManager->GetListOfVolumes());
  TGeoVolume* vol = 0;
  while ( ( vol = (TGeoVolume*)nextvol() ) ) {
    TGeoMedium* currentMed = vol -> GetMedium();
    Int_t twinMedId = currentMed->GetId() + ntoadd;
    TGeoMedium* twinMed = (TGeoMedium*)
                     (fGeoManager->GetListOfMedia()->At(twinMedId));
    vol -> SetMedium(twinMed);
  }

  fIsSwimMedia = toswim;

}

int GeoGeometry::Time2MinervaVersion

(

const VldTimeStamp &

vts

)

const [private, virtual]

Definition at line 1394 of file GeoGeometry.cxx.

References VldTimeStamp::AsString(), Msg::kInfo, and MSG.

Referenced by BuildGeometry().

                                                                   {
  // Private.  Translate a timestamp into a version number for Minerva
  int mversion = 0;
  // decisions go here!

  MSG("Geo",Msg::kInfo) << "GeoGeometry " << vts.AsString("c") 
                        << " translates to version " << mversion << endl;
  return mversion;

}

void GeoGeometry::TrimVldRange	(	const char *	tblName = "",
		const DbiValidityRec *	dbivrec = 0
	)			[private, virtual]

Definition at line 865 of file GeoGeometry.cxx.

References fVldRange, DbiValidityRec::GetVldRange(), Msg::kWarning, MSG, VldRange::TrimTo(), and UpdateGlobalManager().

Referenced by BuildVldRange().

                                                              {
  // Private. Trim VldRange based on DbiValidityRec range info

  UpdateGlobalManager();

  if ( dbivrec ) {
    fVldRange.TrimTo(dbivrec->GetVldRange());
  }
  else {
    MSG("Geo",Msg::kWarning) << "No DbiValidityRec for table " << tblName 
                             << endl;
  }
  
}

virtual void GeoGeometry::UpdateGlobalManager

(

)

const [inline, virtual]

Definition at line 63 of file GeoGeometry.h.

References fGeoManager, and gGeoManager.

Referenced by BuildAll(), BuildCoilAirGapVolume(), BuildDetector(), BuildFarCoil(), BuildFarCoilAirGapVolume(), BuildFarLeadStacks(), BuildFarMARS(), BuildGeometry(), BuildHallExtent(), BuildModules(), BuildNearCoil(), BuildNearCoilAirGapVolume(), BuildNearMARS(), BuildPlanePairVolumes(), BuildStrips(), BuildStripVolumes(), BuildVldRange(), Draw(), DumpVolume(), GeoGeometry(), GeoPlnNode::GeoPlnNode(), GeoStripNode::GeoStripNode(), GeoStripVolume::GeoStripVolume(), GetMedium(), GetNearestSteelPlnNode(), GetPlaneIdFromZ(), GetPlnNodePtrVector(), GetScintPlnNode(), GetScintPlnNodePtrVector(), GetSteelPlnNode(), GetSteelPlnNodeMap(), GetSteelPlnNodePtrVector(), GetStripNode(), GetTransverseExtent(), GetZExtent(), IsCompatible(), ls(), Print(), TrimVldRange(), UgliGeomHandle::UpdateGlobalManager(), GeoNode::UpdateGlobalManager(), GeoVolume::UpdateGlobalManager(), UpdateNodeMatrices(), and ~GeoGeometry().

{ gGeoManager = fGeoManager; }

void GeoGeometry::UpdateNodeMatrices

(

TGeoVolume *

volume

)

[private, virtual]

Definition at line 2276 of file GeoGeometry.cxx.

References Msg::kFatal, MSG, and UpdateGlobalManager().

Referenced by GeoGeometry().

                                                       {
  // Private method. Loop through all GeoNodes in geometry starting at volume 
  // and construct global matrices for use in local to global (MARS) 
  // coordinates

  UpdateGlobalManager();
  if (!volume) {
    MSG("Geo",Msg::kFatal) << "UpdateNodeMatrices called with null volume ptr "
                           << endl;
    abort();
  }
  
  Int_t ndaughter = volume -> GetNdaughters();
  for ( int id = 0; id < ndaughter; id++ ) {
    TGeoNode* daughternode = volume->GetNode(id);
    GeoNode* geonode = dynamic_cast<GeoNode*>(daughternode);
    if ( geonode ) geonode -> UpdateGlobalMatrix();
    
    TGeoVolume* daughtervol = daughternode->GetVolume();
    this -> UpdateNodeMatrices(daughtervol);
  }
  
}

---

Member Data Documentation

Geo::EAppType GeoGeometry::fAppType [private]

Definition at line 137 of file GeoGeometry.h.

Referenced by GetAppType(), and IsCompatible().

TGeoManager* GeoGeometry::fGeoManager [private]

Definition at line 145 of file GeoGeometry.h.

Referenced by BuildAll(), BuildDetector(), BuildFarCoil(), BuildFarLeadStacks(), BuildFarMARS(), BuildGeometry(), BuildModules(), BuildNearCoil(), BuildNearMARS(), BuildPlanePairVolumes(), BuildStrips(), BuildStripVolumes(), Draw(), DumpVolume(), GeoGeometry(), GetMedium(), GetNearestSteelPlnNode(), GetPlaneIdFromZ(), ls(), PrintHeader(), SwitchMedia(), UpdateGlobalManager(), and ~GeoGeometry().

GeoShield GeoGeometry::fGeoShield [private]

Definition at line 152 of file GeoGeometry.h.

Referenced by BuildDetector(), and BuildPlanePairVolumes().

TVector3 GeoGeometry::fHallMax [private]

Definition at line 143 of file GeoGeometry.h.

Referenced by BuildHallExtent(), and GetHallExtentMax().

TVector3 GeoGeometry::fHallMin [private]

Definition at line 142 of file GeoGeometry.h.

Referenced by BuildHallExtent(), and GetHallExtentMin().

std::string GeoGeometry::fHallPath [private]

Definition at line 141 of file GeoGeometry.h.

Referenced by BuildGeometry(), BuildHallExtent(), and BuildPlanePairVolumes().

Bool_t GeoGeometry::fIsSwimMedia [private]

Definition at line 153 of file GeoGeometry.h.

Referenced by SwitchMedia().

GeoMediumMap* GeoGeometry::fMediumMap [private]

Definition at line 154 of file GeoGeometry.h.

Referenced by GeoGeometry(), GetMediumMap(), and ~GeoGeometry().

std::map<PlexPlaneId,GeoPlnNode*> GeoGeometry::fPlaneMap [mutable, private]

Definition at line 146 of file GeoGeometry.h.

Referenced by BuildPlanePairVolumes(), GetPlaneIdFromZ(), GetPlnNodePtrVector(), GetScintPlnNode(), GetScintPlnNodePtrVector(), GetSteelPlnNode(), GetSteelPlnNodeMap(), GetSteelPlnNodePtrVector(), and ~GeoGeometry().

std::vector<GeoPlnNode*> GeoGeometry::fPlnNodes [mutable, private]

Definition at line 149 of file GeoGeometry.h.

Referenced by GetPlnNodePtrVector().

TGeoRotation* GeoGeometry::fRot315 [private]

Definition at line 157 of file GeoGeometry.h.

Referenced by BuildRotations(), and GetRot315().

TGeoRotation* GeoGeometry::fRot45 [private]

Definition at line 156 of file GeoGeometry.h.

Referenced by BuildRotations(), and GetRot45().

Float_t GeoGeometry::fScale [private]

Definition at line 140 of file GeoGeometry.h.

Referenced by BuildDetector(), BuildFarCoil(), BuildFarLeadStacks(), BuildFarMARS(), BuildGeometry(), BuildModules(), BuildNearCoil(), BuildNearMARS(), BuildPlanePairVolumes(), BuildStrips(), BuildStripVolumes(), GeoGeometry(), and GetTransverseExtent().

std::vector<GeoScintPlnNode*> GeoGeometry::fScintPlnNodes [mutable, private]

Definition at line 147 of file GeoGeometry.h.

Referenced by GetScintPlnNodePtrVector().

Float_t GeoGeometry::fSMZMax[2] [private]

Definition at line 139 of file GeoGeometry.h.

Referenced by BuildPlanePairVolumes(), GeoGeometry(), and GetZExtent().

Float_t GeoGeometry::fSMZMin[2] [private]

Definition at line 138 of file GeoGeometry.h.

Referenced by BuildPlanePairVolumes(), GeoGeometry(), and GetZExtent().

std::map<Float_t, GeoSteelPlnNode*> GeoGeometry::fSteelPlnNodeMap [mutable, private]

Definition at line 150 of file GeoGeometry.h.

Referenced by GetSteelPlnNodeMap().

std::vector<GeoSteelPlnNode*> GeoGeometry::fSteelPlnNodes [mutable, private]

Definition at line 148 of file GeoGeometry.h.

Referenced by GetSteelPlnNodePtrVector().

VldRange GeoGeometry::fVldRange [private]

Definition at line 136 of file GeoGeometry.h.

Referenced by BuildVldRange(), GetTransverseExtent(), GetVldRange(), IsCompatible(), PrintHeader(), and TrimVldRange().

---

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

• GeoGeometry.h
• GeoGeometry.cxx