LArGeo::HECClampConstruction Class Reference

#include <HECClampConstruction.h>

Collaboration diagram for LArGeo::HECClampConstruction:

Public Member Functions
	HECClampConstruction (bool front=true, bool posZSide=true)
virtual	~HECClampConstruction ()
void	AddClamps (GeoIntrusivePtr< GeoFullPhysVol > physiHECWheel)

Private Member Functions
PVLink	GetClampingBar (bool rail=false, bool left=false)

Private Attributes
bool	m_front
bool	m_posZSide
int	m_moduleNumber
double	m_moduleRouter
double	m_modulePhistart
double	m_rOuter
double	m_moduleDeltaPhi

Detailed Description

Definition at line 22 of file HECClampConstruction.h.

Constructor & Destructor Documentation

HECClampConstruction()

LArGeo::HECClampConstruction::HECClampConstruction	(	bool	front = true,
		bool	posZSide = true
	)

Definition at line 62 of file HECClampConstruction.cxx.

  : m_moduleNumber(0),
    m_moduleRouter(0),
    m_modulePhistart(0),
    m_rOuter(0),
    m_moduleDeltaPhi(0)
{
  m_front    = front;
  m_posZSide = posZSide;
}

~HECClampConstruction()

LArGeo::HECClampConstruction::~HECClampConstruction ( )

virtualdefault

Member Function Documentation

AddClamps()

void LArGeo::HECClampConstruction::AddClamps

(

GeoIntrusivePtr< GeoFullPhysVol >

physiHECWheel

)

Definition at line 329 of file HECClampConstruction.cxx.

{
  //----------------------------------------------------------------
  //   Add Outer Connecting Bars to HEC Wheel
  //----------------------------------------------------------------
 
  double shrinkCold = 1.0 ; // thermal expansion factor: 1.0 = warm
 
  std::string clampName = "LAr::HEC::Clamp";
  std::string larName   = "LAr::HEC::Clamp::LiquidArgon";
  // cppcheck-suppress duplicateAssignExpression
  double    clampLength =  shrinkCold * 815.*mm;  
  double    railLength  =  shrinkCold * 815.*mm;  
  double    railOffset  =  shrinkCold * 0.*mm;  
  if (!m_front) { 
    clampLength =  shrinkCold * 960.*mm;  
    railLength  =  shrinkCold * 960.*mm;
    railOffset  =  shrinkCold * 0.*mm;  
  }
 
  GeoIntrusivePtr<GeoVPhysVol> clampingBar   = GetClampingBar(false,false);
  GeoIntrusivePtr<GeoVPhysVol> clampingRailR = GetClampingBar(true,false);
  GeoIntrusivePtr<GeoVPhysVol> clampingRailL = GetClampingBar(true,true);
 
 
 
  // In the below positioning sequence, the ORDER MATTERS!
  // 
 
  GeoIntrusivePtr<GeoTransform> xt{new GeoTransform(TranslateZ3D(clampLength/2.))};
  physiHECWheel->add(xt);
 
  GeoIntrusivePtr<GeoSerialIdentifier> sIC{new GeoSerialIdentifier(0)};
  GeoGenfun::Variable    IndexC;
 
  if (m_posZSide)
    {
      GeoGenfun::GENFUNCTION ModuleRotationAngleC = -m_modulePhistart+m_moduleDeltaPhi + m_moduleDeltaPhi*IndexC;
      GeoXF::TRANSFUNCTION tC   = GeoXF::Pow(RotateZ3D(1.0),ModuleRotationAngleC);
      GeoIntrusivePtr<GeoSerialTransformer> sTC{new GeoSerialTransformer (clampingBar,&tC,((m_moduleNumber/2)-1))};
      physiHECWheel->add(sIC);
      physiHECWheel->add(sTC);
    }
  else
    {
      GeoGenfun::GENFUNCTION ModuleRotationAngleC = -m_modulePhistart-m_moduleDeltaPhi+180*deg -  m_moduleDeltaPhi*IndexC;
      GeoXF::TRANSFUNCTION tC   = GeoXF::Pow(RotateZ3D(1.0),ModuleRotationAngleC);
      GeoIntrusivePtr<GeoSerialTransformer> sTC{new GeoSerialTransformer (clampingBar,&tC,((m_moduleNumber/2)-1))};
      physiHECWheel->add(sIC);
      physiHECWheel->add(sTC);
    }
 
 
  physiHECWheel->add(new GeoTransform(TranslateZ3D(railLength/2.-railOffset)*RotateZ3D(-m_modulePhistart-(180.*deg))));
  //GeoSerialIdentifier  *sIR = new GeoSerialIdentifier(15); // For the pos z-side this is the position of module no.15
  //physiHECWheel->add(sIR);                                 // No need to aplly it if we position clamps in this order
  if (!m_posZSide)
    {
      GeoSerialIdentifier  *sIR = new GeoSerialIdentifier(31); 
      physiHECWheel->add(sIR);                                 
    }
  physiHECWheel->add(clampingRailL);
 
 
  physiHECWheel->add(xt);
  GeoGenfun::Variable    IndexC2;
 
  if (m_posZSide)
    {
      GeoGenfun::GENFUNCTION ModuleRotationAngleC2 = -m_modulePhistart+m_moduleDeltaPhi-(180.*deg) + m_moduleDeltaPhi*IndexC2;
      GeoXF::TRANSFUNCTION tC2   = GeoXF::Pow(RotateZ3D(1.0),ModuleRotationAngleC2);
      GeoIntrusivePtr<GeoSerialTransformer> sTC2{new GeoSerialTransformer (clampingBar,&tC2,((m_moduleNumber/2)-1))};
      physiHECWheel->add(sTC2);
    }
  else
    {
      GeoGenfun::GENFUNCTION ModuleRotationAngleC2 = -m_modulePhistart-m_moduleDeltaPhi -  m_moduleDeltaPhi*IndexC2;
      GeoXF::TRANSFUNCTION tC2   = GeoXF::Pow(RotateZ3D(1.0),ModuleRotationAngleC2);
      GeoIntrusivePtr<GeoSerialTransformer> sTC2{new GeoSerialTransformer (clampingBar,&tC2,((m_moduleNumber/2)-1))};
      physiHECWheel->add(sTC2);
    }
 
  physiHECWheel->add(new GeoTransform(TranslateZ3D(railLength/2.)*RotateZ3D(-m_modulePhistart))); 
  if (!m_posZSide)
    {
      GeoSerialIdentifier  *sIR = new GeoSerialIdentifier(15); 
      physiHECWheel->add(sIR);                                 
    }
  physiHECWheel->add(clampingRailR);
 
}

GetClampingBar()

PVLink LArGeo::HECClampConstruction::GetClampingBar ( bool  rail = false, bool  left = false  )

private

Definition at line 77 of file HECClampConstruction.cxx.

{
  
  ISvcLocator *svcLocator = Gaudi::svcLocator();
 
  MsgStream log(Athena::getMessageSvc(),"HECClampConstruction " );
  log << MSG::DEBUG << " In HECClampConstruction " << endmsg;
  
 
  SmartIF<StoreGateSvc> detStore{svcLocator->service("DetectorStore")};
  if(!detStore.isValid()) {
    throw std::runtime_error("Error in HECModuleConstruction(ClampBar), cannot access DetectorStore");
  }
  
 
  // Get access to the material manager:
  StoredMaterialManager* materialManager = nullptr;
  if (StatusCode::SUCCESS != detStore->retrieve(materialManager, std::string("MATERIALS"))) {
    throw std::runtime_error("Error in HECModuleConstruction(ClampBar), cannot access Material Manager");
  }  
  const GeoMaterial *LAr  = materialManager->getMaterial("std::LiquidArgon");
  if (!LAr) throw std::runtime_error("Error in HECModuleConstruction(ClampBar), std::LiquidArgon is not found.");  
  const GeoMaterial *Iron  = materialManager->getMaterial("std::Iron");
  if (!Iron) throw std::runtime_error("Error in HECModuleConstruction(ClampBar), std::Iron is not found.");
 
 
  SmartIF<IRDBAccessSvc> pAccessSvc{svcLocator->service("RDBAccessSvc")};
  if(!pAccessSvc.isValid()) {
    throw std::runtime_error ("Cannot locate RDBAccessSvc!!");
  }
 
  SmartIF<IGeoModelSvc> geoModel{svcLocator->service("GeoModelSvc")};
  if(!geoModel.isValid()) {
    throw std::runtime_error ("Cannot locate GeoModelSvc!!");
  }
  
  std::string AtlasVersion = geoModel->atlasVersion();
  std::string LArVersion = geoModel->LAr_VersionOverride();
 
  std::string detectorKey  = LArVersion.empty() ? AtlasVersion : LArVersion;
  std::string detectorNode = LArVersion.empty() ? "ATLAS" : "LAr";
 
  IRDBRecordset_ptr hecLongitudinalBlock = pAccessSvc->getRecordsetPtr("HecLongitudinalBlock",detectorKey, detectorNode); 
  IRDBRecordset_ptr hadronicEndcap       = pAccessSvc->getRecordsetPtr("HadronicEndcap",detectorKey, detectorNode); 
  
 
  //----------------------------------------------------------------
  // Collect all the numbers we need from the database: 
  //----------------------------------------------------------------
  //
  // NOT READY YET
  //
  
  //----------------------------------------------------------------
  //   Add outer clamping bars for Atlas wheels
  //----------------------------------------------------------------
  // NB.: The outer clamping bars have notches for the HEC cables.
  //      that sit at different levels for Front/Rear Wheel
  //  
  double shrinkCold = 1.0;   // thermal expansion factor: 1.0 = warm
 
  int    moduleNumber   = (*hadronicEndcap)[0]->getInt("NSCT");
  double moduleRouter   = shrinkCold * (*hecLongitudinalBlock)[0]->getDouble("BLRMX")*cm;
  double modulePhistart = 264.375*deg;          // (270.-11.25/2.)*deg
  double rOuter         = shrinkCold * (*hecLongitudinalBlock)[0]->getDouble("BLRMX")*cm;
  double moduleDeltaPhi = 2*M_PI/moduleNumber; //11.25*deg;  
  m_moduleNumber  = moduleNumber;
  m_moduleRouter  = moduleRouter;
  m_modulePhistart= modulePhistart;
  m_rOuter        = rOuter;
  m_moduleDeltaPhi= moduleDeltaPhi ;
 
  std::string clampName = "LAr::HEC::Clamp";
  std::string larName = "LAr::HEC::Clamp::LiquidArgon";
  double    g4allow     =   0.01 *mm;
  double    extThick    = shrinkCold *   37.*mm;
  double    extLength   = shrinkCold *   84.*mm;
  double    clampWidth  = shrinkCold *  147.0 *mm;
  double    clampThick  = shrinkCold *   50.*mm;
  double    notchLevel  = shrinkCold *   25.*mm;
  double    notchHeight = shrinkCold *   15.*mm;
  // cppcheck-suppress duplicateAssignExpression
  double    notchWidth  = shrinkCold *   20.*mm;
  double    slotWidth   = shrinkCold *   20.*mm;
  double    clampLength = shrinkCold *  815.*mm;  
  double    clampAngle  =  2.* asin(clampWidth/(2.*(moduleRouter+clampThick/2.)));
  double    slotAngle   =  2.* asin(notchWidth/(2.*(moduleRouter+clampThick/2.)));
 
  std::vector<double>  notchLocation;
  if (m_front){
    if (!rail){
//       notchLocation.push_back(shrinkCold * 201.*mm);
//       notchLocation.push_back(shrinkCold * 469.*mm);
//       notchLocation.push_back(shrinkCold * 737.*mm);
      notchLocation.push_back(shrinkCold * 200.*mm); // adjust for shortened clamp
      notchLocation.push_back(shrinkCold * 468.*mm);
      notchLocation.push_back(shrinkCold * 736.*mm);
    } 
    else {
//       notchLocation.push_back(shrinkCold * 206.*mm);
//       notchLocation.push_back(shrinkCold * 474.*mm);
//       notchLocation.push_back(shrinkCold * 742.*mm);
      notchLocation.push_back(shrinkCold * 201.*mm); // adjust for shortened rail
      notchLocation.push_back(shrinkCold * 469.*mm);
      notchLocation.push_back(shrinkCold * 737.*mm);
      clampWidth  =  shrinkCold * 148.5 *mm;
      clampThick  =  shrinkCold *  98.*mm;   //  98.*mm   (this is the total overall rail thickness)
      clampLength =  shrinkCold * 815.*mm;
    } 
  } 
  else {
    if (!rail){
//       notchLocation.push_back(shrinkCold * 364.0*mm); 
//       notchLocation.push_back(shrinkCold * 832.0*mm); 
      notchLocation.push_back(shrinkCold * 363.0*mm); // adjust for shortened clamp
      notchLocation.push_back(shrinkCold * 831.0*mm); 
      clampLength =  shrinkCold * 960.*mm;
    } 
    else {
//       notchLocation.push_back(shrinkCold * 372.5*mm); 
//       notchLocation.push_back(shrinkCold * 840.5*mm); 
      notchLocation.push_back(shrinkCold * 364.*mm);  // adjust for shortened rail
      notchLocation.push_back(shrinkCold * 832.*mm); 
      clampWidth  =  shrinkCold * 148.5 *mm;
      clampThick  =  shrinkCold *  98.*mm;   
      clampLength =  shrinkCold * 960.*mm;
      extLength   =  shrinkCold * 132.*mm;
    } 
    notchWidth  = shrinkCold * 16.*mm;
    notchHeight = shrinkCold * 16.*mm;
    notchLevel  = shrinkCold * 0.*mm;
  }
  
 
 
 
  // Construct the the slots and notches here. For the support rails, they have to be inserted
  // into the physExt[0] volume. For the regular clamps they go into physClamp.
  std::array<GeoIntrusivePtr<GeoTubs>, 3>    clampExt;
  std::array<GeoIntrusivePtr<GeoLogVol>, 3>  logExt;
  std::array<GeoIntrusivePtr<GeoPhysVol>, 3> physExt;
 
  GeoIntrusivePtr<GeoTubs> Notch{new GeoTubs(moduleRouter+notchLevel+g4allow, moduleRouter+notchLevel+notchHeight-g4allow, 
                                                       notchWidth/2.,
                                                       modulePhistart-(clampAngle/2.) , clampAngle)};
  GeoIntrusivePtr<GeoLogVol>   logNotch  {new GeoLogVol(larName, Notch, LAr)};  
  GeoIntrusivePtr<GeoPhysVol>  physiNotch{new GeoPhysVol(logNotch)};
  
  GeoIntrusivePtr<GeoTubs> Slot {new GeoTubs(moduleRouter+g4allow, moduleRouter+notchLevel-g4allow, slotWidth/2. ,
                                                      modulePhistart-(slotAngle/2.) , slotAngle)};
  GeoIntrusivePtr<GeoLogVol> logSlot{new GeoLogVol(larName, Slot, LAr)};  
  GeoIntrusivePtr<GeoPhysVol> physiSlot{new GeoPhysVol(logSlot)};
 
 
 
  GeoIntrusivePtr<GeoTubs>     clampBar{};
  GeoIntrusivePtr<GeoLogVol>  logClamp{};
  GeoIntrusivePtr<GeoPhysVol> physClamp{};
 
  if(!rail){
    clampBar = new GeoTubs(moduleRouter, moduleRouter+clampThick, clampLength/2. ,
               modulePhistart-(clampAngle/2.) , clampAngle);
    logClamp = new GeoLogVol(clampName, clampBar, Iron);  
    physClamp= new GeoPhysVol(logClamp);
  }
  else{
 
    //For the support rails, make the mother LAr and the place the steel inside: 
 
    clampBar = new GeoTubs(moduleRouter, moduleRouter+clampThick, clampLength/2. ,
               modulePhistart-(clampAngle/2.) , clampAngle);
    logClamp = new GeoLogVol(larName, clampBar, LAr);  
    physClamp= new GeoPhysVol(logClamp);
 
 
    clampExt[0] = new GeoTubs(moduleRouter+g4allow,                     moduleRouter+clampThick-extThick, 
                  clampLength/2. , modulePhistart-(clampAngle/2.), clampAngle);
    clampExt[1] = new GeoTubs(moduleRouter+clampThick-extThick+g4allow, moduleRouter+clampThick-g4allow, 
                  clampLength/2. , modulePhistart,                 clampAngle/2.);
    clampExt[2] = new GeoTubs(moduleRouter+clampThick-extThick+g4allow, moduleRouter+clampThick-g4allow, 
                  extLength/2. , modulePhistart,                   clampAngle/2.);
 
 
 
 
    for (int iext=0; iext<3; iext++){
 
      logExt[iext] = new GeoLogVol(clampName, clampExt[iext], Iron);  
      physExt[iext]= new GeoPhysVol(logExt[iext]);
 
      
      if   (iext==0) {
    for ( unsigned int i = 0; i < notchLocation.size(); i++ ) 
      {
        physExt[0]->add( new GeoIdentifierTag(i) );
        physExt[0]->add( new GeoTransform(Translate3D(0,0,-clampLength/2.+notchLocation[i])) );  
        physExt[0]->add( physiNotch );
        if (m_front){
          physExt[0]->add( new GeoIdentifierTag(i) );
          physExt[0]->add( new GeoTransform(Translate3D(0,0,-clampLength/2.+notchLocation[i])) );  
          physExt[0]->add( physiSlot );
        }
      }
      }
 
 
      if     (iext==1 && !left) physClamp->add(new GeoTransform(RotateZ3D(-clampAngle/2.)));
      else if(iext==2 && left)  physClamp->add(new GeoTransform(TranslateZ3D((clampLength-extLength)/2.)
                                *RotateZ3D(-clampAngle/2.)));
      else if(iext==2)          physClamp->add(new GeoTransform(TranslateZ3D((clampLength-extLength)/2.)
                                *RotateZ3D( 0.)));
 
      if (left) physClamp->add( new GeoIdentifierTag(16) );
      else      physClamp->add( new GeoIdentifierTag(32) );
 
 
      physClamp->add(physExt[iext]);
 
    }
 
 
  }
    
 
  for ( unsigned int i = 0; i < notchLocation.size(); i++ ) 
    {
      if(!rail){
    physClamp->add( new GeoIdentifierTag(i) );
    physClamp->add( new GeoTransform(Translate3D(0,0,-clampLength/2.+notchLocation[i])) );  
    physClamp->add( physiNotch );
      }
    }
  
  if(m_front)  
    {      
      for ( unsigned int i = 0; i < notchLocation.size(); i++ ) 
    {
      if(!rail){
        physClamp->add( new GeoIdentifierTag(i) );
        physClamp->add( new GeoTransform(Translate3D(0,0,-clampLength/2.+notchLocation[i])) );  
        physClamp->add( physiSlot );
      }
    }
      
    }
  
 
  return physClamp;
}

Member Data Documentation

m_front

bool LArGeo::HECClampConstruction::m_front

private

Definition at line 32 of file HECClampConstruction.h.

m_moduleDeltaPhi

double LArGeo::HECClampConstruction::m_moduleDeltaPhi

private

Definition at line 40 of file HECClampConstruction.h.

m_moduleNumber

int LArGeo::HECClampConstruction::m_moduleNumber

private

Definition at line 36 of file HECClampConstruction.h.

m_modulePhistart

double LArGeo::HECClampConstruction::m_modulePhistart

private

Definition at line 38 of file HECClampConstruction.h.

m_moduleRouter

double LArGeo::HECClampConstruction::m_moduleRouter

private

Definition at line 37 of file HECClampConstruction.h.

m_posZSide

bool LArGeo::HECClampConstruction::m_posZSide

private

Definition at line 35 of file HECClampConstruction.h.

m_rOuter

double LArGeo::HECClampConstruction::m_rOuter

private

Definition at line 39 of file HECClampConstruction.h.

---

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

• HECClampConstruction.h
• HECClampConstruction.cxx