GeoScintPlnVolume.cxx

Go to the documentation of this file.

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

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

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

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

//_____________________________________________________________________________
GeoScintPlnVolume::GeoScintPlnVolume() : GeoVolume(),
    fDetector(Detector::kUnknown),
    fCoverage(PlaneCoverage::kUnknown),fView(PlaneView::kUnknown),
    fVetoShield(false), fThick(0) {
  // Default constructor, for i/o
  
}

//_____________________________________________________________________________
GeoScintPlnVolume::GeoScintPlnVolume(GeoGeometry* geo, 
                                     const PlexPlaneId& plnid,
                                     Float_t plnthick) : GeoVolume(geo,
            (GeoGeometry::GetGeoCompatibleName(plnid.AsString())).c_str(),0),
    fDetector(plnid.GetDetector()),
    fCoverage(plnid.GetPlaneCoverage()),fView(plnid.GetPlaneView()),
    fVetoShield(plnid.IsVetoShield()),
    fThick(plnthick) {
  // Normal constructor
  // Protected because responsible use of gGeoManager pointer is
  // required.
  
  const GeoMediumMap& medMap = fGeoGeometry->GetMediumMap();
  if ( fVetoShield ) SetMedium(medMap.GetMedium(Geo::kVSPlnScint));
  else SetMedium(medMap.GetMedium(Geo::kPlnScint));
  
  fShpName = string(GetName());
  if ( fVetoShield && fShpName.size() >= 4 ) {
    fShpName.erase(0,fShpName.size() - 4);
  }
  else 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 near and far detector
  AddCoilNode();
  
}

//_____________________________________________________________________________
Int_t GeoScintPlnVolume::NumberOfStrips() const {
  // Return number of strips in plane

  UpdateGlobalManager();

  Int_t nstrip = 0;
  Int_t nmodule = GetNdaughters();
  for ( int imdl = 0; imdl < nmodule; imdl++ ) {
    GeoScintMdlNode* mdlNode = dynamic_cast<GeoScintMdlNode*>(GetNode(imdl));
    if ( mdlNode ) nstrip += mdlNode -> NumberOfStrips();
  }

  return nstrip;
  
}

//_____________________________________________________________________________
std::vector<GeoStripNode*> GeoScintPlnVolume::GetStripNodePtrVector() const {
  // Return vector of GeoStripNode's in this plane 

  UpdateGlobalManager();
  
  std::vector<GeoStripNode*> stpnodes;
  Int_t nmodule = GetNdaughters();
  for ( int imdl = 0; imdl < nmodule; imdl++ ) {
    GeoScintMdlNode* mdlNode = dynamic_cast<GeoScintMdlNode*>(GetNode(imdl));
    if ( mdlNode ) {
      std::vector<GeoStripNode*> mdlstpnodes=mdlNode->GetStripNodePtrVector();
      std::vector<GeoStripNode*>::const_iterator mdlstpitr=mdlstpnodes.begin();
      while (mdlstpitr != mdlstpnodes.end()) {
        stpnodes.push_back(*mdlstpitr);
        mdlstpitr++;
      }
    }
    
  }
  
  return stpnodes;
  
}

//_____________________________________________________________________________
std::vector<GeoScintMdlNode*> GeoScintPlnVolume::GetScintMdlNodePtrVector() 
                                                                      const {
  // Return vector of GeoScintMdlNode's in this plane 

  UpdateGlobalManager();

  std::vector<GeoScintMdlNode*> mdlnodes;
  Int_t nmodule = GetNdaughters();
  for ( int imdl = 0; imdl < nmodule; imdl++ ) {
    GeoScintMdlNode* mdlNode = dynamic_cast<GeoScintMdlNode*>(GetNode(imdl));
    if ( mdlNode ) mdlnodes.push_back(mdlNode);
  }

  return mdlnodes;
  
}

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

  UpdateGlobalManager();

  cout << "GeoScintPlnVolume::Print\n"
       << GetName() << endl;
  cout << "Det " << Detector::AsString(fDetector) << " Cover " 
       << PlaneCoverage::AsString(fCoverage) << " View " 
       << PlaneView::AsString(fView) << endl;
  cout << " Thick " << fThick << endl;
  
}

//_____________________________________________________________________________
TGeoShape* GeoScintPlnVolume::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)<< "Scint Pln shape construction for detector type\n"
    << Detector::AsString(fDetector)
    << " not yet supported." << endl;

  } // end of switch

  return shape;

} 

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

  UpdateGlobalManager();
  
  if ( fVetoShield ) {
    return BuildFarVetoActive();
  }

  return BuildFarActive();

} 

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

  UpdateGlobalManager();
  
  Double_t scale = GetScale();

  Float_t halfx = scale*(0.5*Geo::kCalDetSteelWidth
                        +Geo::kModuleSkinThick); 
  Float_t halfy = halfx;  // square
  Float_t halfz = 0.5*fThick;

  MSG("Geo",Msg::kDebug)
    << "Build cal detector scint pln shape " << fShpName.c_str() 
    << " w/halfthick " << halfz << " and halfwidth " << halfx 
    << "." << endl;

  // Shape is automatically adopted by gGeoManager
  TGeoBBox* plnShape = new TGeoBBox(fShpName.c_str(),halfx,halfy,halfz);

  return plnShape;


} 

//_____________________________________________________________________________
TGeoShape* GeoScintPlnVolume::BuildFarVetoActive() const {
 // Private method used to build shape for far detector veto shield plane. 
 // Generic shape of a far detector shield plane is built as a TGeoBBox

  UpdateGlobalManager();
  
  MSG("Geo",Msg::kDebug)
         << "Build far detector veto active plane shape " << endl;

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

  Float_t halfx = scale*(0.5*Geo::kFarSteelWidth+Geo::kModuleSkinThick); 
  Float_t halfy = scale*(0.5*20.*Geo::kStripWidth+Geo::kModuleSkinThick);  
  Float_t halfz = 0.5*fThick;

  // Shape is automatically adopted by gGeoManager
  TGeoBBox* plnShape = new TGeoBBox(fShpName.c_str(),halfx,halfy,halfz);

  return plnShape;


} 

//_____________________________________________________________________________
TGeoShape* GeoScintPlnVolume::BuildFarActive() const {
 // Private method used to build shape for far detector active plane. 
 // Generic shape of a far detector active plane is built as a 
 // TGeoPgon

  UpdateGlobalManager();
  
  MSG("Geo",Msg::kDebug)
         << "Build far detector active plane shape " << endl;

  Double_t scale = GetScale();

  // Scale up scint plane size by 2% to completely enclose strips
  // Scint pln medium is Air, e.g. acts as empty shell to enclose
  // strip nodes.
  Double_t r_inscribed = scale*(0.5*Geo::kFarSteelWidth*1.02
                                   +Geo::kModuleSkinThick);
  Double_t r_coil = 0.; // No coil hole since coil is inserted as node
  
  // Shape is automatically adopted by gGeoManager
  TGeoPgon* plnShape = new TGeoPgon(fShpName.c_str(),22.5,360.,8,2);

  plnShape -> DefineSection(0,-0.5*fThick,r_coil,r_inscribed);
  plnShape -> DefineSection(1,+0.5*fThick,r_coil,r_inscribed);

  return plnShape;

} 

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

  UpdateGlobalManager();
  
  switch ( fCoverage ) {
  case ( PlaneCoverage::kNearFull ) :
    return BuildNearFullActive();
  case ( PlaneCoverage::kNearPartial ) :
    return BuildNearPartialActive();
  default:
    MSG("Geo",Msg::kWarning)
      << "Unable to construct near active plane w/ coverage "
      << PlaneCoverage::AsString(fCoverage) << endl;
  }

  return 0;

} 

//_____________________________________________________________________________
TGeoShape* GeoScintPlnVolume::BuildNearPartialActive() const {
  // Private method used to build shape for near detector partial active 
  // plane. 

  UpdateGlobalManager();
  
  MSG("Geo",Msg::kDebug) <<
    "Build near detector partial active plane shape " << endl;

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

  // Shape is automatically adopted by gGeoManager
  Float_t halfz = 0.5*fThick;
  Double_t r_coil = 0.; // No coil hole since coil is inserted as node
  // former r_inscribed of 2.977 (r_inscribed of steel + nearoffset)
  // was too big to fit in hall. reduced 10/11/05. s.k.
  // this is still big enough to enclose plane modules.
  Double_t  r_inscribed = 2.9*scale;
  TGeoPgon* plnShape = new TGeoPgon(fShpName.c_str(),22.5,360.,8,2);
  plnShape -> DefineSection(0,-halfz, r_coil, r_inscribed);
  plnShape -> DefineSection(1,+halfz, r_coil, r_inscribed);

  return plnShape;

} 

//_____________________________________________________________________________
TGeoShape* GeoScintPlnVolume::BuildNearFullActive() const {
  // Private method used to build shape for near detector full active 
  // plane. 

  UpdateGlobalManager();
  
  MSG("Geo",Msg::kDebug) <<
    "Build near detector full active plane shape " << endl;

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

  // Shape is automatically adopted by gGeoManager
  Float_t halfz = 0.5*fThick;
  Double_t r_coil = 0.; // No coil hole since coil is inserted as node
  // former r_inscribed of 2.977 (r_inscribed of steel + nearoffset)
  // was too big to fit in hall. reduced 10/11/05. s.k.
  // this is still big enough to enclose plane modules
  // Expand to 2.91 to fit imperfect geometry.  Fix me.  The polygon
  // needs to be done away with in favor of a "squashed" or truncated
  // polygon shape in y to avoid extrusion with floor of hall.
  Double_t  r_inscribed = 2.91*scale; 

  TGeoPgon* plnShape = new TGeoPgon(fShpName.c_str(),22.5,360.,8,2);
  plnShape -> DefineSection(0,-halfz, r_coil, r_inscribed);
  plnShape -> DefineSection(1,+halfz, r_coil, r_inscribed);

  return plnShape;

} 

//____________________________________________________________________________
void GeoScintPlnVolume::AddCoilNode() {
  // Build scint coil volume and insert it as node in this scint plane.

  UpdateGlobalManager();

  switch ( fDetector ) {

  case Detector::kFar:
    {
      if ( !fVetoShield ) {
        TGeoVolume* volCoil = BuildFarCoilVolume();
        if ( fView == PlaneView::kU ) {
          TGeoRotation* rot45 = fGeoGeometry->GetRot45();
          this -> AddNode(volCoil,1,rot45);
        }
        else {
          TGeoRotation* rot315 = fGeoGeometry->GetRot315();
          this -> AddNode(volCoil,1,rot315);
        }
      }
    }
    break;

  case Detector::kNear:
    {
      TGeoVolume* volCoil = BuildNearCoilVolume();
      this -> AddNode(volCoil,1,gGeoIdentity);
    }
    break;

  default:
    // no coil
    break;

  } // end of switch

  return;

}

//_____________________________________________________________________________
TGeoVolume* GeoScintPlnVolume::BuildFarCoilVolume() const {
  //
  // Build far scint coil region.  This is built in the following
  // way, per instruction from R. Hatcher:
  //   1)Insert a "bypass" (r=Geo::kFarBypassRad) region (not to be confused 
  //     with the bypass plastic insert).  This is constructed of magnetized 
  //     air.  
  //   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 scint plane 
  // volume, 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 = fGeoGeometry -> GetMediumMap();
  
  // The nomenclature used here is "F" (far), "A" (active), followed by
  // the two letter code to indicate the coil part type.

  // First check to see if volumemulti has been built. Need only build once.
  // The following is expensive, fix me.
  TGeoVolume* volBypass = gGeoManager->GetVolume("FABY");
  if ( volBypass ) return volBypass;
  
  Double_t scale = Geo::GetScale(fGeoGeometry -> GetAppType());
  
  Float_t halfz = 0.5*fThick; // -1. to use volumemulti

  TGeoVolume* volCoil
    = gGeoManager->MakeTube("FACO",medMap.GetMedium(Geo::kCRSctCoil),
                             0,Geo::kCoilRad*scale,halfz); //coil
  volCoil -> SetLineColor(42); // tan
  
  TGeoVolume* volThroat
    = gGeoManager->MakeTube("FATR",medMap.GetMedium(Geo::kCRSctThroat),
                            0,Geo::kThroatRad*scale,halfz); // throat
  volThroat -> SetLineColor(kBlue);
  
  TGeoVolume* volFlange
    = gGeoManager->MakeTube("FAFL",medMap.GetMedium(Geo::kCRSctFlange),
                             0,Geo::kFlangeRad*scale,halfz); // flange
  volFlange -> SetLineColor(46); // rust
  
  volBypass
    = gGeoManager->MakeTube("FABY",medMap.GetMedium(Geo::kCRSctBypass),
                             0,Geo::kFarBypassRad*scale,halfz); // 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;

}

//_____________________________________________________________________________
TGeoVolume* GeoScintPlnVolume::BuildNearCoilVolume() const {
  //
  // Build near scint coil region for full coverage planes.  This is built 
  // in the following way, per instruction from R. Hatcher:
  //   1)For full coverage planes, insert a "bypass" tube 
  //     (r=Geo::kNearFullBypassRad) region (not to be confused with the 
  //     bypass plastic insert).  This is constructed of magnetized air, 
  //     else...  
  //     For partial coverage planes, insert a "bypass" box
  //     (halfx/y = Geo::kNearPartialBypassRad) region.  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 = fGeoGeometry -> GetMediumMap();
  
  // The nomenclature used here is "N" (near), "A" (active), "U" or "V"
  // for view, "f" or "p" for full or partial coverage, followed by
  // the two letter code to indicate the coil part type.
  std::string preface = "NAV";
  if ( fView == PlaneView::kU ) preface = "NAU";
  if ( fCoverage == PlaneCoverage::kNearFull ) preface += "f";
  else preface += "p";
  
  // First check to see if volumemulti has been built. Need only build once
  // per view/coverage combination.
  // The following search is expensive. Fix me.
  TGeoVolume* volBypass
    = gGeoManager->GetVolume(std::string(preface+"BY").c_str());
  if ( volBypass ) return volBypass;
  
  Double_t scale = Geo::GetScale(fGeoGeometry -> GetAppType());
  
  Float_t halfz = 0.5*fThick; // -1.

  TGeoVolume* volWater
    = gGeoManager->MakeTube(std::string(preface+"WA").c_str(),
                            medMap.GetMedium(Geo::kCRSctWater),
                            0,Geo::kNearCoolRad*scale,halfz); // water
  volWater -> SetLineColor(kGreen);
  
  TGeoVolume* volCoil
    = gGeoManager->MakeBox(std::string(preface+"CO").c_str(),
                           medMap.GetMedium(Geo::kCRSctCoil),
                      Geo::kCoilRad*scale,Geo::kCoilRad*scale,halfz); // coil
  volCoil -> SetLineColor(kBlack);
  
  TGeoVolume* volThroat
    = gGeoManager->MakeBox(std::string(preface+"TR").c_str(),
                           medMap.GetMedium(Geo::kCRSctThroat),
                   Geo::kThroatRad*scale,Geo::kThroatRad*scale,halfz);//throat
  volThroat -> SetLineColor(kBlue);
  
  TGeoVolume* volFlange
    = gGeoManager->MakeBox(std::string(preface+"FL").c_str(),
                           medMap.GetMedium(Geo::kCRSctFlange),
                   Geo::kFlangeRad*scale,Geo::kFlangeRad*scale,halfz); //flange
  volFlange -> SetLineColor(kBlack);
  
  // Bypass region is built according to full or partial coverage
  if ( fCoverage == PlaneCoverage::kNearPartial ) {
    volBypass = gGeoManager->MakeBox(std::string(preface+"BY").c_str(),
                             medMap.GetMedium(Geo::kCRSctBypass),
                             Geo::kNearPartialBypassRad*scale,
                             Geo::kNearPartialBypassRad*scale,halfz);// bypass
  }
  else {
    // full coverage
    volBypass
      = gGeoManager->MakeTube(std::string(preface+"BY").c_str(),
                              medMap.GetMedium(Geo::kCRSctBypass),
                              0,Geo::kNearFullBypassRad*scale,halfz); // bypass
  }
  
  volBypass -> SetLineColor(kBlue);
  volBypass -> SetLineStyle(2); // dashed

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

  // Coil addition depends on view, because U&V scint planes are rotated
  // in opposite directions when placed in detector.
  if ( fView == PlaneView::kU ) {
    volThroat -> AddNode(volCoil,1,
                         new TGeoTranslation(+0.01*scale,-0.01*scale,0));
  }
  else {
    // v-view
    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;
      if ( fView == PlaneView::kU ) {
        volCoil -> AddNode(volWater,itube,new TGeoTranslation(ypos,xpos,0));
      }
      else {
        // v-view
        volCoil -> AddNode(volWater,itube,new TGeoTranslation(xpos,ypos,0));
      }
    }
  }
  
  return volBypass;

}

---