GeoSteelPlnVolume.cxx

Go to the documentation of this file.

// $Id: GeoSteelPlnVolume.cxx,v 1.20 2008/01/09 06:38:11 schubert Exp $
//
// GeoSteelPlnVolume
//
// GeoSteelPlnVolume is a scint plane volume
//
// Author:  S. Kasahara 07/04

#include <iostream>
using namespace std;
#include <TGeoPgon.h>
#include <TGeoTube.h>
#include <TGeoArb8.h>
#include <TGeoXtru.h>
#include <TGeoManager.h>
#include <TGeoMatrix.h>
#include <TGeoShape.h>

#include "GeoGeometry/GeoSteelPlnVolume.h"
#include "GeoGeometry/GeoGeometry.h"
#include "GeoGeometry/GeoMediumMap.h"
#include "GeoGeometry/GeoMedium.h"
#include "Plex/PlexPlaneId.h"
#include "MessageService/MsgService.h"

ClassImp(GeoSteelPlnVolume)
CVSID("$Id: GeoSteelPlnVolume.cxx,v 1.20 2008/01/09 06:38:11 schubert Exp $");

//_____________________________________________________________________________
GeoSteelPlnVolume::GeoSteelPlnVolume() : GeoVolume(),
    fDetector(Detector::kUnknown), fThick(0) {
  // Default constructor, for i/o
  
}

//_____________________________________________________________________________
GeoSteelPlnVolume::GeoSteelPlnVolume(GeoGeometry* geo,const PlexPlaneId& plnid,
                                     Float_t plnthick) :
    GeoVolume(geo,
            (GeoGeometry::GetGeoCompatibleName(plnid.AsString())).c_str(),
             geo->GetMediumMap().GetMedium(Geo::kPlnSteel)),
            fDetector(plnid.GetDetector()),fThick(plnthick) {
  // Normal constructor
  // Protected

  UpdateGlobalManager();
  
  fShpName = string(GetName());
  // Uncomment the following lines if a perfect geometry allows steel planes
  // of identical size & shape for a given shape type.  The real detector
  // has steel planes of non-uniform thickness.
  //if ( fShpName.size() >= 3 ) {
  //  fShpName.erase(0,fShpName.size() - 3);
  //}

  TGeoShape* shape = GetExistingShape();
  if (!shape) shape = BuildPlaneShape();
  
  SetShape(shape);

  // Because shape was unknown at time of TGeoVolume construction, volume
  // was added to run-time list of volumes. Remove and add to normal list
  gGeoManager -> GetListOfGVolumes() -> Remove(this);
  Int_t index = gGeoManager->GetListOfVolumes() -> GetEntriesFast();
  gGeoManager -> GetListOfVolumes() 
              -> AddAtAndExpand(this,index);

  // Add coil node for far & near detector.   
  AddCoilNode();
  
}

//_____________________________________________________________________________
void GeoSteelPlnVolume::Print(Option_t* /* option */) const {
   // print to cout

  UpdateGlobalManager();

  cout << "GeoSteelPlnVolume::Print\n"
       << GetName() << endl;
  cout << "Det " << Detector::AsString(fDetector) << endl;
  cout << " Thick " << fThick << endl;
  
}

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildPlaneShape() const {
  // Private method used to build shape for this plane. 

  UpdateGlobalManager();
  
  TGeoShape* shape = 0;
  
  switch ( fDetector ) {

  case Detector::kFar:

    shape = BuildFar();
    break;
    
  case Detector::kNear:

    shape = BuildNear();
    break;

  case Detector::kCalDet:

    shape = BuildCalDet();
    break;

  default:

    MSG("Geo",Msg::kError)<< "Steel Pln shape construction for detector type\n"
    << Detector::AsString(fDetector)
    << " not yet supported." << endl;

  } // end of switch

  return shape;

} 

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildFar() const {
  // Private method used to build shape for far detector steel plane. 

  UpdateGlobalManager();

  return BuildFarSteelXtru();

} 

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildNear() const {
  // Private method used to build shape for near detector steel plane. 

  UpdateGlobalManager();

  return BuildNearSteelXtru();

} 

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildCalDet() const {
  // Private method used to build shape for cal detector steel plane. 

  UpdateGlobalManager();

  return BuildCalDetSteelBasic();

} 

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildFarSteelPgon() const {
  // Private method to build simple shape for far detector steel plane

  UpdateGlobalManager();
  
  Double_t scale = GetScale();
  // Shape is automatically adopted by gGeoManager

  TGeoPgon* shape = new TGeoPgon(fShpName.c_str(),22.5,360.,8,2);
  
  Double_t halfz = 0.5*fThick;
  Double_t r_inscribed = scale*(0.5*Geo::kFarSteelWidth);
  
  shape -> DefineSection(0,-halfz,0.,r_inscribed);
  shape -> DefineSection(1,+halfz,0.,r_inscribed);
  
  MSG("Geo",Msg::kDebug)
  << "Build far detector steel plane shape as simple octagon w/halfthick " 
  << halfz << "." << endl;

  return shape;
  
}

  
//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildFarSteelXtru() const {
 // Private method used to build shape for far detector steel plane. 
 // Generic shape of a far detector steel plane is built as a 
 // TGeoXtru

  UpdateGlobalManager();

  Double_t scale = GetScale();

  // Shape is automatically adopted by gGeoManager
  std::string xtruname = fShpName;
  TGeoXtru* shape = new TGeoXtru(2); // odd not to have a ctor w/name arg
  shape -> SetName(xtruname.c_str());
  
  const int nv = 32;
  Double_t x[nv] = {0};
  Double_t y[nv] = {0};
  // Points must be defined clockwise? 
  x[31] = 421.8893*Munits::cm; y[31] = -142.8876*Munits::cm;
  x[30] = 421.8893*Munits::cm; y[30] = -138.3342*Munits::cm;
  x[29] = 400.1614*Munits::cm; y[29] = -115.9855*Munits::cm;
  x[28] = 400.7823*Munits::cm; y[28] =   87.6358*Munits::cm;
  x[27] = 406.9902*Munits::cm; y[27] =   94.0507*Munits::cm;
  x[26] = 429.1319*Munits::cm; y[26] =  101.5003*Munits::cm;
  x[25] = 447.1350*Munits::cm; y[25] =  101.5003*Munits::cm;
  x[24] = 454.7915*Munits::cm; y[24] =   94.2577*Munits::cm;
  x[23] = 457.6886*Munits::cm; y[23] =   94.2577*Munits::cm;
  x[22] = 457.6886*Munits::cm; y[22] =  109.3637*Munits::cm;
  x[21] = 143.7724*Munits::cm; y[21] = 423.2799*Munits::cm;
  x[20] = 139.4268*Munits::cm; y[20] = 423.2799*Munits::cm;
  x[19] = 117.2850*Munits::cm; y[19] = 401.1382*Munits::cm;
  x[18] =-116.9622*Munits::cm; y[18] = 401.1382*Munits::cm;
  x[17] =-139.1040*Munits::cm; y[17] = 423.2799*Munits::cm;
  x[16] =-143.4496*Munits::cm; y[16] = 423.2799*Munits::cm;
  x[15] =-457.3658*Munits::cm; y[15] = 109.3637*Munits::cm;
  x[14] =-457.3658*Munits::cm; y[14] =  94.2577*Munits::cm;
  x[13] =-454.4687*Munits::cm; y[13] =  94.2577*Munits::cm;
  x[12] =-439.9834*Munits::cm; y[12] = 101.9141*Munits::cm;
  x[11] =-429.8438*Munits::cm; y[11] = 101.9141*Munits::cm;
  x[10] =-406.6674*Munits::cm; y[10] =  94.2577*Munits::cm;
  x[9] =-399.8386*Munits::cm; y[9] =  84.7388*Munits::cm;
  x[8] =-399.8386*Munits::cm; y[8] =-115.9855*Munits::cm;
  x[7] =-421.5665*Munits::cm; y[7] =-137.7134*Munits::cm;
  x[6] =-421.5665*Munits::cm; y[6] =-142.8867*Munits::cm;
  x[5] =-143.4496*Munits::cm; y[5] =-421.0036*Munits::cm;
  x[4] =-139.1040*Munits::cm; y[4] =-421.0036*Munits::cm;
  x[3] =-116.9622*Munits::cm; y[3] =-398.8619*Munits::cm;
  x[2] = 116.8712*Munits::cm; y[2] =-398.8619*Munits::cm;
  x[1] = 139.4268*Munits::cm; y[1] =-421.0036*Munits::cm;
  x[0] = 143.7724*Munits::cm; y[0] =-421.0036*Munits::cm;

  for ( int iv = 0; iv < nv; iv++ ) {
    x[iv] *= scale;
    y[iv] *= scale;
  }
  
  shape -> DefinePolygon(32,x,y);

  // Define section must be called after DefinePolygon
  Double_t halfz = fThick/2.;
  shape -> DefineSection(0,-halfz);
  shape -> DefineSection(1,+halfz);
 
  MSG("Geo",Msg::kDebug)
  << "Build far detector steel plane shape w/ears using TGeoXtru w/halfthick " 
  << halfz << "." << endl;
  
  return shape;

} 

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildNearSteelXtru() const {
 // Private method used to build shape for near detector steel plane. 
 // Generic shape of a near detector steel plane is built as a 
 // TGeoXtru

  UpdateGlobalManager();

  MSG("Geo",Msg::kDebug)
         << "Build near detector steel plane shape using TGeoXtru" 
         << endl;
  
  Double_t scale = GetScale();

  // Shape is automatically adopted by gGeoManager
  std::string xtruname = fShpName;
  TGeoXtru* shape = new TGeoXtru(2); // odd not to have a ctor w/name arg
  shape -> SetName(xtruname.c_str());

  const int nv = 22;
  Double_t x[nv] = {0};
  Double_t y[nv] = {0};

  // Points must be defined clockwise? 
  x[21] = -121.43*Munits::inch; y[21] =  0.47*Munits::inch;
  x[20] = -120.25*Munits::inch; y[20] =  0.47*Munits::inch;
  x[19] = -115.14*Munits::inch; y[19] =  3.42*Munits::inch;
  x[18] = -110.24*Munits::inch; y[18] =  3.42*Munits::inch;
  x[17] =  -95.24*Munits::inch; y[17] = -1.48*Munits::inch;
  x[16] =  -95.24*Munits::inch; y[16] =-35.47*Munits::inch;
  x[15] =  -69.80*Munits::inch; y[15] =-60.91*Munits::inch;
  x[14] =  -69.80*Munits::inch; y[14] =-75.04*Munits::inch;
  x[13] =   69.80*Munits::inch; y[13] =-75.04*Munits::inch;
  x[12] =   69.80*Munits::inch; y[12] =-60.91*Munits::inch;
  x[11] =  95.24*Munits::inch; y[11] = -35.47*Munits::inch;
  x[10] =  95.24*Munits::inch; y[10] =  -1.48*Munits::inch;
  x[9] = 110.16*Munits::inch; y[9] =   3.42*Munits::inch;
  x[8] = 117.30*Munits::inch; y[8] =   3.42*Munits::inch;
  x[7] = 120.25*Munits::inch; y[7] =   0.47*Munits::inch;
  x[6] = 121.43*Munits::inch; y[6] =   0.47*Munits::inch;
  x[5] = 121.43*Munits::inch; y[5] =   9.28*Munits::inch;
  x[4] =  69.80*Munits::inch; y[4] =  60.91*Munits::inch;
  x[3] =  69.80*Munits::inch; y[3] =  75.04*Munits::inch;
  x[2] = -69.80*Munits::inch; y[2] =  75.04*Munits::inch;
  x[1] = -69.80*Munits::inch; y[1] =  60.91*Munits::inch;
  x[0] =-121.43*Munits::inch; y[0] =   9.28*Munits::inch;

  Float_t xnearoffset = scale*Geo::kNearXOffset;
  for ( int iv = 0; iv < nv; iv++ ) {
    x[iv] = x[iv]*scale - xnearoffset;
    y[iv] = y[iv]*scale;
  }
  
  shape -> DefinePolygon(22,x,y);

  // Define section must be called after DefinePolygon
  Double_t halfz = fThick/2.;
  shape -> DefineSection(0,-halfz);
  shape -> DefineSection(1,+halfz);

  MSG("Geo",Msg::kDebug)
       << "Build near detector steel plane shape using TGeoXtru w/halfthick " 
       << halfz << endl;

  return shape;

} 

//_____________________________________________________________________________
TGeoShape* GeoSteelPlnVolume::BuildCalDetSteelBasic() const {
 // Private method used to build shape for cal detector steel plane. 
 // Generic shape of a cal detector steel plane is built as a 
 // TGeoBBox

  UpdateGlobalManager();

  Double_t scale = Geo::GetScale(fGeoGeometry -> GetAppType());

  // Shape is automatically adopted by gGeoManager
  Double_t halfwidth = scale*0.5*Geo::kCalDetSteelWidth;
  Double_t halfz = fThick/2.;
  MSG("Geo",Msg::kDebug)
         << "Build cal detector steel plane shape using TGeoBBox w/halfthick " 
         << halfz << " and halfwidth " << halfwidth << endl;
  
  TGeoBBox* shape = new TGeoBBox(fShpName.c_str(),halfwidth,halfwidth,
                                 halfz); 

  return shape;

} 
//____________________________________________________________________________
void GeoSteelPlnVolume::AddCoilNode() {
  // Build steel coil volume and insert it as node in this steel plane.
  
  UpdateGlobalManager();
  
  switch ( fDetector ) {

  case Detector::kFar:
    {
      TGeoVolume* volCoil = BuildFarCoilVolume();
      this -> AddNode(volCoil,1,gGeoIdentity);
    }
    break;
    
  case Detector::kNear:
    {
      TGeoVolume* volCoil = BuildNearCoilVolume();
      TGeoRotation* rot45 = fGeoGeometry->GetRot45();
      this -> AddNode(volCoil,1,rot45);
    }
    break;

  default:
    // no coil
    break;
    
  } // end of switch

  return;

}

//____________________________________________________________________________
TGeoVolume* GeoSteelPlnVolume::BuildFarCoilVolume() const {
  //
  // Build far steel "detail coil disk".  This is built in the
  // following way, per instruction from R. Hatcher:
  //  1)Insert a "detail disk" (r=Geo::kDetailRad) into the steel plane, made
  //    of the same material as the plane.  This defines the region
  //    in which the detailed b-field map is used.
  //  2)Insert into the "detail disk" a "hole" (r=Geo::kFeHoleRad) of 
  //    magnetized air.
  //  3)Insert into the "hole" a "neck" (r=Geo::kNeckRad) of magnetized iron.
  //  4)Insert into the "neck" a "throat" (r=Geo::kThroatRad) made of 
  //    magnetized air.
  //  5)Insert into the "throat" a "coil" (r=Geo::kCoilRad) of 
  //    magnetized FARCOIL medium.  The coil 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 steel plane, the volumemulti shape will take on the thickness of
  // its parent.  This allows for variable thickness of the steel plane in 
  // a non-perfect geometry. 
  //

  UpdateGlobalManager();

  const GeoMediumMap& medMap = fGeoGeometry -> GetMediumMap();
  
  // First check to see if volumemulti has been built. Need only build once.
  TGeoVolume* volDetail = gGeoManager->GetVolume("FPDE");
  if ( volDetail ) return volDetail;
  
  Double_t scale = Geo::GetScale(fGeoGeometry -> GetAppType());

  // The nomenclature used here is "F" (far), "P" (steel), followed by
  // a two letter code to indicate the coil part type.
  TGeoVolume* volCoil 
     = gGeoManager->MakeTube("FPCO",medMap.GetMedium(Geo::kCRStlCoil),
                              0,Geo::kCoilRad*scale,-1.); // coil
  volCoil -> SetLineColor(42); // tan
  
  TGeoVolume* volThroat = gGeoManager->MakeTube("FPTR",
                                       medMap.GetMedium(Geo::kCRStlThroat),
                                       0,Geo::kThroatRad*scale,-1.); // throat
  volThroat -> SetLineColor(kBlue);
  
  TGeoVolume* volNeck = gGeoManager->MakeTube("FPNK",
                                       medMap.GetMedium(Geo::kCRStlNeck),
                                       0,Geo::kNeckRad*scale,-1.); // neck
  volNeck -> SetLineColor(46); // rust 
  
  TGeoVolume* volHole
     = gGeoManager->MakeTube("FPHO",medMap.GetMedium(Geo::kCRStlHole),
                                    0,Geo::kFeHoleRad*scale,-1.);  // hole
  volHole -> SetLineColor(kBlue);
  
  volDetail
     = gGeoManager->MakeTube("FPDE",medMap.GetMedium(Geo::kCRStlDetail),
                                   0,Geo::kDetailRad*scale,-1.); // detail disk
  volDetail -> SetLineColor(kRed);
  volDetail -> SetLineStyle(2); // dashed
  volDetail -> SetVisibility(kFALSE); // invisible by default

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

  return volDetail;
  
}

//____________________________________________________________________________
TGeoVolume* GeoSteelPlnVolume::BuildNearCoilVolume() const {
  //
  // Build near steel "detail coil disk".  This is built in the
  // following way, per instruction from R. Hatcher:
  //  1)Insert a "detail disk" (r=Geo::kDetailRad) into the steel plane, made
  //    of the same material as the plane.  This defines the region
  //    in which the detailed b-field map is used.
  //  2)Insert into the "detail disk" a "hole" (box of halfx/y 
  //    = Geo::kFeHoleRad) of magnetized air.
  //  3)Insert into the "hole" a "neck" (box of halfx/y = Geo::kNeckRad) of 
  //    magnetized iron.
  //  4)Insert into the "neck" a "throat" (box of halfx/y =Geo::kThroatRad) 
  //    made of magnetized air.
  //  5)Insert into the "throat" a "coil" (box of halfx/y=Geo::kCoilRad) of 
  //    magnetized aluminum.  The coil segment is set to rest on
  //    the throat.
  //  6)Insert into the "coil" cooling tubes (r=Geo::kNearCoolRad) of 
  //    magnetized water, arranged 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 steel plane, the volumemulti shape will take on the thickness of
  // its parent.  This allows for variable thickness of the steel plane in 
  // a non-perfect geometry. 
  //

  UpdateGlobalManager();

  const GeoMediumMap& medMap = fGeoGeometry -> GetMediumMap();
  
  // First check to see if volumemulti has been built. Need only build once.
  TGeoVolume* volDetail = gGeoManager->GetVolume("NPDE");
  if ( volDetail ) return volDetail;
  
  Double_t scale = Geo::GetScale(fGeoGeometry -> GetAppType());

  // The nomenclature used here is "N" (near), "P" (steel), followed by
  // a two letter code to indicate the coil part type.
  TGeoVolume* volWater
    = gGeoManager->MakeTube("NPWA",medMap.GetMedium(Geo::kCRStlWater),
                             0,Geo::kNearCoolRad*scale,-1.); // water
  volWater -> SetLineColor(kGreen);
  
  TGeoVolume* volCoil 
     = gGeoManager->MakeBox("NPCO",medMap.GetMedium(Geo::kCRStlCoil),
                         Geo::kCoilRad*scale,Geo::kCoilRad*scale,-1.); // coil
  volCoil -> SetLineColor(kBlack);
  
  TGeoVolume* volThroat
     = gGeoManager->MakeBox("NPTR",medMap.GetMedium(Geo::kCRStlThroat),
                     Geo::kThroatRad*scale,Geo::kThroatRad*scale,-1.);//throat
  volThroat -> SetLineColor(kBlue);
  
  TGeoVolume* volNeck
     = gGeoManager->MakeBox("NPNK",medMap.GetMedium(Geo::kCRStlNeck),
                         Geo::kNeckRad*scale,Geo::kNeckRad*scale,-1.); //neck
  volNeck -> SetLineColor(kBlack); 
  
  TGeoVolume* volHole
     = gGeoManager->MakeBox("NPHO",medMap.GetMedium(Geo::kCRStlHole),
                      Geo::kFeHoleRad*scale,Geo::kFeHoleRad*scale,-1.); //hole
  volHole -> SetLineColor(kBlue);
  
  volDetail
     = gGeoManager->MakeTube("NPDE",medMap.GetMedium(Geo::kCRStlDetail),
                      0,Geo::kDetailRad*scale,-1.); // detail disk
  volDetail -> SetLineColor(kRed);
  volDetail -> SetLineStyle(2); // dashed

  // The following is not allowed with TGeoVolumeMultis. The rotation must
  // be done at the detail node insertion into the steel plane level.  
  //volDetail -> AddNode(volHole,1,new TGeoRotation("NPHO",90,45,90,135,0,0));

  volDetail -> AddNode(volHole,  1,gGeoIdentity);
  volHole   -> AddNode(volNeck  ,1,gGeoIdentity);
  volNeck   -> 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 xy
  // 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 volDetail;
  
}

  

---