dc/dee/V3Cage_8cxx_source.html

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.

// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.

// All rights not expressly granted are reserved.

//

// This software is distributed under the terms of the GNU General Public

// License v3 (GPL Version 3), copied verbatim in the file "COPYING".

//

// In applying this license CERN does not waive the privileges and immunities

// granted to it by virtue of its status as an Intergovernmental Organization

// or submit itself to any jurisdiction.


#include "ITSSimulation/V3Cage.h"

#include "ITSSimulation/V11Geometry.h"

#include "ITSBase/GeometryTGeo.h"


#include <fairlogger/Logger.h> // for LOG


#include <TGeoArb8.h>    // for TGeoArb8

#include <TGeoBBox.h>    // for TGeoBBox

#include <TGeoCone.h>    // for TGeoConeSeg, TGeoCone

#include <TGeoPcon.h>    // for TGeoPcon

#include <TGeoManager.h> // for TGeoManager, gGeoManager

#include <TGeoMatrix.h>  // for TGeoCombiTrans, TGeoRotation, etc

// #include <TGeoTrd1.h>           // for TGeoTrd1

#include <TGeoTube.h>           // for TGeoTube, TGeoTubeSeg

#include <TGeoVolume.h>         // for TGeoVolume, TGeoVolumeAssembly

#include <TGeoXtru.h>           // for TGeoXtru

#include <TGeoCompositeShape.h> // for TGeoCompositeShape

#include <TMathBase.h>          // for Abs

#include <TMath.h>              // for Sin, RadToDeg, DegToRad, Cos, Tan, etc


#include <cstdio> // for snprintf


class TGeoMedium;


using namespace TMath;

using namespace o2::its;


// Parameters

const Double_t V3Cage::sCageYInBarrel = 30. * sCm; // This is hardcoded in Detector.cxx


// Cover element (each)

const Double_t V3Cage::sCageCoverZLength = 586.0 * sMm;

const Double_t V3Cage::sCageCoverRint = 540.0 * sMm;

const Double_t V3Cage::sCageCoverRext = 550.0 * sMm;

const Double_t V3Cage::sCageCoverXWidth = 982.0 * sMm;

const Double_t V3Cage::sCageCoverXBaseInt = 944.0 * sMm;

const Double_t V3Cage::sCageCoverXBaseExt = 948.0 * sMm;

const Double_t V3Cage::sCageCoverYBaseHeight = 245.0 * sMm;

const Double_t V3Cage::sCageCoverCoreRint = 541.0 * sMm;

const Double_t V3Cage::sCageCoverCoreRext = 549.0 * sMm;

const Double_t V3Cage::sCageCoverSheetThick = 2 * sMm;

const Double_t V3Cage::sCageCoverRibZLength = 25.0 * sMm;

const Double_t V3Cage::sCageCoverRibRint = 540.0 * sMm;

const Double_t V3Cage::sCageCoverRibRext = 548.0 * sMm;

const Double_t V3Cage::sCageCoverRibXWidth = 984.8 * sMm;

const Double_t V3Cage::sCageCoverRibXBaseInt = 944.0 * sMm;

const Double_t V3Cage::sCageCoverRibYBaseHi = 245.0 * sMm;

const Double_t V3Cage::sCageCoverRibFoldHi = 31.5 * sMm;


const Double_t V3Cage::sCageSidePanelLength = 3457.0 * sMm;

const Double_t V3Cage::sCageSidePanelWidth = 490.0 * sMm;

const Double_t V3Cage::sCageSidePanelFoilThick = 1.0 * sMm;

const Double_t V3Cage::sCageSidePanelCoreThick = 20.0 * sMm;

const Double_t V3Cage::sCageSidePanelXDist = 988.0 * sMm;

const Double_t V3Cage::sCageSidePanelRail1Len = 3320.0 * sMm;

const Double_t V3Cage::sCageSidePanelRail2Len = 1550.0 * sMm;

const Double_t V3Cage::sCageSidePanelRail3Len = 302.0 * sMm;

const Double_t V3Cage::sCageSidePanelRailWidth = 25.0 * sMm;

const Double_t V3Cage::sCageSidePanelRailSpan = 20.0 * sMm;

const Double_t V3Cage::sCageSidePanelRailHThik = 5.0 * sMm;

const Double_t V3Cage::sCageSidePanelRailVThik = 2.5 * sMm;

const Double_t V3Cage::sCageSidePanelGuideLen = 3587.0 * sMm;

const Double_t V3Cage::sCageSidePanelGuideInHi = 204.0 * sMm;

const Double_t V3Cage::sCageSidePanelGuideWide = 44.0 * sMm;

const Double_t V3Cage::sCageSidePanelGuidThik1 = 6.0 * sMm;

const Double_t V3Cage::sCageSidePanelGuidThik2 = 8.0 * sMm;

const Double_t V3Cage::sCageSidePanelMidBarWid = 15.0 * sMm;

const Double_t V3Cage::sCageSidePanelSidBarWid = 15.0 * sMm;


const Double_t V3Cage::sCageSidePanelRail1Ypos[2] = {226.5 * sMm, 147.5 * sMm};

const Double_t V3Cage::sCageSidePanelRail2Ypos = 74.5 * sMm;

const Double_t V3Cage::sCageSidePanelRail3Ypos[3] = {180.0 * sMm, 107.0 * sMm, 24.0 * sMm};


const Double_t V3Cage::sCageEndCapDext = 1096.0 * sMm;

const Double_t V3Cage::sCageEndCapDint = 304.0 * sMm;

const Double_t V3Cage::sCageEndCapFoamThick = 8.0 * sMm;

const Double_t V3Cage::sCageEndCapFabThick = 1.0 * sMm;

const Double_t V3Cage::sCageEndCapXWidth = 988.0 * sMm;

const Double_t V3Cage::sCageEndCapSideHoleR = 32.0 * sMm;

const Double_t V3Cage::sCageEndCapSideHoleX = 532.0 * sMm;

const Double_t V3Cage::sCageEndCapCableCutWid = 268.0 * sMm;

const Double_t V3Cage::sCageEndCapCableCutR = 408.5 * sMm;

const Double_t V3Cage::sCageEndCapCableCutPhi = 25.0; // Deg

const Double_t V3Cage::sCageECRoundCrossDmin = 300 * sMm;

const Double_t V3Cage::sCageECRoundCrossDmid = 303 * sMm;

const Double_t V3Cage::sCageECRoundCrossDmax = 312 * sMm;

const Double_t V3Cage::sCageECRoundCrossZext = 6 * sMm;

const Double_t V3Cage::sCageECRoundCrossZint = 5 * sMm;

const Double_t V3Cage::sCageECCableCrosTotHi = 139.0 * sMm;

const Double_t V3Cage::sCageECCableCrosTotZ = 12 * sMm;

const Double_t V3Cage::sCageECCableCrosInXWid = 266.8 * sMm;

const Double_t V3Cage::sCageECCableCrosInThik = 4 * sMm;

const Double_t V3Cage::sCageECCableCrosInZLen = 10.2 * sMm;

const Double_t V3Cage::sCageECCableCrosSidWid = 8 * sMm;


const Double_t V3Cage::sBPSuppCollarIntD = 53 * sMm;

const Double_t V3Cage::sBPSuppCollarExtD = 57 * sMm;

const Double_t V3Cage::sBPSuppCollarBushD = 52 * sMm;

const Double_t V3Cage::sBPSuppUpperCollarLen = 78 * sMm;

const Double_t V3Cage::sBPSuppUpperCollarHei = 4 * sMm;

const Double_t V3Cage::sBPSuppLowerCollarLen = 151 * sMm;

const Double_t V3Cage::sBPSuppLowerCollarTlX = 40.5 * sMm;

const Double_t V3Cage::sBPSuppLowCollHolDist = 100 * sMm;

const Double_t V3Cage::sBPSuppLowCollTailHei = 6 * sMm;

const Double_t V3Cage::sBPSuppCollarBeamLen = 370 * sMm;

const Double_t V3Cage::sBPSuppCollarBeamWid = 40 * sMm;

const Double_t V3Cage::sBPSuppCollarBeamHei = 12 * sMm;

const Double_t V3Cage::sBPSuppBracketTotLen = 57 * sMm;

const Double_t V3Cage::sBPSuppBracketWidth = 25 * sMm;

const Double_t V3Cage::sBPSuppBracketInLen = 20 * sMm;

const Double_t V3Cage::sBPSuppBracketInHei = 8 * sMm;

const Double_t V3Cage::sBPSuppBracketTailLen = 18.5 * sMm;

const Double_t V3Cage::sBPSuppBracketTailHei = 3 * sMm;

const Double_t V3Cage::sBPSuppBrktCentHoleX = 31.5 * sMm;

const Double_t V3Cage::sBPSuppBrktCentHoleD = 6 * sMm;

const Double_t V3Cage::sBPSuppBrktLatHoleX = 24.5 * sMm;

const Double_t V3Cage::sBPSuppBrktLatHoleD = 3.2 * sMm;

const Double_t V3Cage::sBPSuppBrktLatHoleW = 4 * sMm;

const Double_t V3Cage::sBPSuppBrktLatHoleH = 2.5 * sMm;

const Double_t V3Cage::sBPSuppBrktHolesY = 0.5 * sMm;

const Double_t V3Cage::sBPSuppCollarM4High = 2.2 * sMm;

const Double_t V3Cage::sBPSuppCollarM4Diam = 7.5 * sMm;

const Double_t V3Cage::sBPSuppCollarM4XDist = 68 * sMm;

const Double_t V3Cage::sBPSuppCollarM4ZPos = 7 * sMm;

const Double_t V3Cage::sBPSuppClampTotLen = 55 * sMm;

const Double_t V3Cage::sBPSuppClampTotWid = 23 * sMm;

const Double_t V3Cage::sBPSuppClampTotHei = 13 * sMm;

const Double_t V3Cage::sBPSuppClampLatThick = 5 * sMm;

const Double_t V3Cage::sBPSuppClampShelfLen = 25 * sMm;

const Double_t V3Cage::sBPSuppClampShelfHei = 4.5 * sMm;

const Double_t V3Cage::sBPSuppClampsXDist = 944 * sMm;

const Double_t V3Cage::sBPSuppClampInsDmin = 7 * sMm;

const Double_t V3Cage::sBPSuppClampInsDmax = 11 * sMm;

const Double_t V3Cage::sBPSuppClampInsH = 2.9 * sMm;

const Double_t V3Cage::sBPSuppClampInsXPos = 15 * sMm;

const Double_t V3Cage::sBPSuppClampInsZPos = 7 * sMm;

const Double_t V3Cage::sBPSuppClampShimLen = 26 * sMm;

const Double_t V3Cage::sBPSuppClampShimWid = 15 * sMm;

const Double_t V3Cage::sBPSuppClampShimThick = 2.5 * sMm;

const Double_t V3Cage::sBPSuppClampM5High = 2.7 * sMm;

const Double_t V3Cage::sBPSuppClampM5Diam = 8.5 * sMm;

const Double_t V3Cage::sBPSuppClampM5ZPos = 20 * sMm;

const Double_t V3Cage::sBPSuppZPos = 1801 * sMm;


const Double_t V3Cage::sCageCrossXWidthTot = 973 * sMm;

const Double_t V3Cage::sCageCrossXWidthExt = 944 * sMm;

const Double_t V3Cage::sCageCrossXWidthInt = 904 * sMm;

const Double_t V3Cage::sCageCrossYHeightTot = 244 * sMm;

const Double_t V3Cage::sCageCrossYHeightInt = 220 * sMm;

const Double_t V3Cage::sCageCrossYMid = (126 + 5.5) * sMm;

const Double_t V3Cage::sCageCrossZLength = 8 * sMm;

const Double_t V3Cage::sCageCrossBarThick = 20 * sMm;

const Double_t V3Cage::sCageCrossBarPhi = 25; // Deg


// MFT rails inside Cage

const Double_t V3Cage::sCageMFTRailZLen = 1874 * sMm;

const Double_t V3Cage::sCageMFTRailZPos = 6.3 * sMm;

const Double_t V3Cage::sCageMFTRailTotWidth = 27 * sMm;

const Double_t V3Cage::sCageMFTRailExtWidth = 24 * sMm;

const Double_t V3Cage::sCageMFTRailIntWidth = 17.5 * sMm;

const Double_t V3Cage::sCageMFTRailBaseWidth = 22 * sMm;

const Double_t V3Cage::sCageMFTRailTotHeight = 8.9 * sMm;

const Double_t V3Cage::sCageMFTRailExtHeight = 5.9 * sMm;

const Double_t V3Cage::sCageMFTRailIntHeight = 3.5 * sMm;

const Double_t V3Cage::sCageMFTRailsXDist = 44 * sMm;


const Double_t V3Cage::sCageMFTHingeTotWid = 164 * sMm;

const Double_t V3Cage::sCageMFTHingeIntWid = 141.3 * sMm;

const Double_t V3Cage::sCageMFTHingeHeight = 8 * sMm;

const Double_t V3Cage::sCageMFTHingeIntHei = 6 * sMm;

const Double_t V3Cage::sCageMFTHingeTotLen = 41 * sMm;

const Double_t V3Cage::sCageMFTHingeIntLen = 28 * sMm;

const Double_t V3Cage::sCageMFTHingeBulgeWid = 10 * sMm;

const Double_t V3Cage::sCageMFTHingeBulgeHei = 10 * sMm;

const Double_t V3Cage::sCageMFTHingeBulgePos = 7 * sMm;


ClassImp(V3Cage);


V3Cage::V3Cage()

  : V11Geometry()

{

}


V3Cage::V3Cage(const char* name)

  : V11Geometry(0, name)

{

}


V3Cage::~V3Cage() = default;


void V3Cage::createAndPlaceCage(TGeoVolume* mother, const TGeoManager* mgr)

{

  //

  // Creates the Cage elements and place them into the mother volume

  //

  // Input:

  //         mother : the mother volume hosting the whole Cage

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //

  // Created:      22 Apr 2022  Mario Sitta

  //


  // Local variables

  Double_t zunit, xpos, ypos, zpos;


  // Create the cover elements

  TGeoVolume* cageCover = createCageCover(mgr);

  TGeoVolume* cageCoverRib = createCageCoverRib(mgr);

  TGeoVolume* cageEndCap = createCageEndCap(mgr);

  TGeoVolume* cageSidePanel = createCageSidePanel(mgr);

  TGeoVolume* cageBPSupport = createBeamPipeSupport(mgr);

  TGeoVolume* cageClosingCross = createCageClosingCross(mgr);


  // Now place all elements

  mother->AddNode(cageCover, 1, new TGeoTranslation(0, sCageYInBarrel, 0));

  mother->AddNode(cageCover, 2, new TGeoCombiTrans(0, sCageYInBarrel, 0, new TGeoRotation("", 180, 0, 0)));


  zunit = (sCageCoverZLength + sCageCoverRibZLength) / 2.;


  zpos = zunit;

  mother->AddNode(cageCoverRib, 1, new TGeoTranslation(0, sCageYInBarrel, zpos));

  mother->AddNode(cageCoverRib, 2, new TGeoCombiTrans(0, sCageYInBarrel, zpos, new TGeoRotation("", 180, 0, 0)));

  mother->AddNode(cageCoverRib, 3, new TGeoTranslation(0, sCageYInBarrel, -zpos));

  mother->AddNode(cageCoverRib, 4, new TGeoCombiTrans(0, sCageYInBarrel, -zpos, new TGeoRotation("", 180, 0, 0)));


  zpos = 2 * zunit;

  mother->AddNode(cageCover, 3, new TGeoTranslation(0, sCageYInBarrel, zpos));

  mother->AddNode(cageCover, 4, new TGeoCombiTrans(0, sCageYInBarrel, zpos, new TGeoRotation("", 180, 0, 0)));

  mother->AddNode(cageCover, 5, new TGeoTranslation(0, sCageYInBarrel, -zpos));

  mother->AddNode(cageCover, 6, new TGeoCombiTrans(0, sCageYInBarrel, -zpos, new TGeoRotation("", 180, 0, 0)));


  zpos += sCageCoverZLength / 2;


  Double_t zposSP = -zpos + sCageSidePanelLength / 2;

  xpos = sCageSidePanelXDist / 2 - sCageSidePanelCoreThick / 2 - sCageSidePanelFoilThick;

  mother->AddNode(cageSidePanel, 1, new TGeoTranslation(xpos, sCageYInBarrel, zposSP));

  mother->AddNode(cageSidePanel, 2, new TGeoCombiTrans(-xpos, sCageYInBarrel, zposSP, new TGeoRotation("", 180, 0, 0)));


  Double_t zposCC = -zpos + sCageSidePanelLength + sCageCrossZLength / 2;

  mother->AddNode(cageClosingCross, 1, new TGeoTranslation(0, sCageYInBarrel, zposCC));

  mother->AddNode(cageClosingCross, 2, new TGeoCombiTrans(0, sCageYInBarrel, zposCC, new TGeoRotation("", 0, 180, 0)));


  // The end cap is only on C side

  zpos += sCageECCableCrosTotZ / 2;

  mother->AddNode(cageEndCap, 1, new TGeoTranslation(0, sCageYInBarrel, -zpos));


  // Third ribs are only on A side

  zpos = 3 * zunit;

  mother->AddNode(cageCoverRib, 5, new TGeoTranslation(0, sCageYInBarrel, zpos));

  mother->AddNode(cageCoverRib, 6, new TGeoCombiTrans(0, sCageYInBarrel, zpos, new TGeoRotation("", 180, 0, 0)));


  // The Beam Pipe Support on A side

  ypos = sCageYInBarrel - sBPSuppLowCollTailHei / 2;

  zpos = sBPSuppZPos + sBPSuppCollarBeamWid / 2;

  mother->AddNode(cageBPSupport, 1, new TGeoTranslation(0, ypos, zpos));


  // The MFT Rails inside the Cage

  createAndPlaceMFTRailsInsideCage(mother, mgr);


  return;

}


TGeoVolume* V3Cage::createCageCover(const TGeoManager* mgr)

{

  //

  // Creates a Cage cover element (from drawings ALIITSUP0226, ALIITSUP0225)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The cover as a TGeoVolume

  //

  // Created:      22 Apr 2022  Mario Sitta

  //


  // Local variables

  static const Int_t coverFoldNVert = 6;


  Double_t xvert[coverFoldNVert], yvert[coverFoldNVert];

  Double_t halfBase, zlen, alpha;


  zlen = 0.5 * sCageCoverZLength;


  // The cover core: a TGeoTubeSeg

  halfBase = 0.5 * sCageCoverXBaseInt - sCageCoverSheetThick;

  alpha = TMath::ACos(halfBase / sCageCoverCoreRext) * TMath::RadToDeg();

  TGeoTubeSeg* coreSh = new TGeoTubeSeg("coverCore", sCageCoverCoreRint, sCageCoverCoreRext, zlen, alpha, 180. - alpha);


  // The upper and lower sheets: a TGeoTubeSeg

  // (as a whole volume - will become a sheet when the core is inserted inside)

  halfBase = 0.5 * sCageCoverXBaseInt;

  alpha = TMath::ACos(halfBase / sCageCoverRint) * TMath::RadToDeg();

  TGeoTubeSeg* sheet = new TGeoTubeSeg("coverSheet", sCageCoverRint, sCageCoverCoreRext, zlen, alpha, 180. - alpha);


  // The lateral fold: a Xtru

  xvert[0] = sCageCoverXBaseExt / 2.;

  yvert[0] = sCageCoverYBaseHeight + sCageCoverSheetThick;

  xvert[1] = sCageCoverXWidth / 2.;

  yvert[1] = yvert[0];

  xvert[2] = xvert[1];

  yvert[2] = sCageCoverYBaseHeight;

  xvert[3] = sCageCoverXBaseInt / 2.;

  yvert[3] = yvert[2];

  xvert[4] = xvert[3];

  yvert[4] = TMath::Sqrt(sCageCoverRint * sCageCoverRint - sCageCoverXBaseInt * sCageCoverXBaseInt / 4) + sCageCoverSheetThick;

  xvert[5] = xvert[0];

  yvert[5] = yvert[4];


  TGeoXtru* fold = new TGeoXtru(2);

  fold->SetName("coverFold");

  fold->DefinePolygon(coverFoldNVert, xvert, yvert);

  fold->DefineSection(0, -zlen);

  fold->DefineSection(1, zlen);


  // A BBox to cut away the curved portion above the fold

  TGeoBBox* cutfold = new TGeoBBox("cutFold", xvert[1] - xvert[0], yvert[5] - yvert[1], 1.05 * zlen);


  // Some matrices to create the composite shape

  TGeoRotation* rotfold = new TGeoRotation("rotFold", 180, 180, 0);

  rotfold->RegisterYourself();


  TGeoTranslation* cutbox1 = new TGeoTranslation("cutBox1", xvert[1], yvert[5], 0);

  cutbox1->RegisterYourself();


  TGeoTranslation* cutbox2 = new TGeoTranslation("cutBox2", -xvert[1], yvert[5], 0);

  cutbox2->RegisterYourself();


  // The cover shape: a CompositeShape

  TGeoCompositeShape* coverSh = new TGeoCompositeShape("coverSheet-cutFold:cutBox1-cutFold:cutBox2+coverFold+coverFold:rotFold");


  // We have all shapes: now create the real volumes

  TGeoMedium* medRohacell = mgr->GetMedium(Form("%s_ROHACELL$", GetDetName()));

  TGeoMedium* medPrepreg = mgr->GetMedium(Form("%s_M46J6K$", GetDetName()));


  TGeoVolume* coverVol = new TGeoVolume("CageCover", coverSh, medPrepreg);

  coverVol->SetFillColor(kBlue);

  coverVol->SetLineColor(kBlue);


  TGeoVolume* coverCoreVol = new TGeoVolume("CageCoverCore", coreSh, medRohacell);

  coverCoreVol->SetFillColor(kYellow);

  coverCoreVol->SetLineColor(kYellow);


  coverVol->AddNode(coverCoreVol, 1, nullptr);


  // Finally return the cover volume

  return coverVol;

}


TGeoVolume* V3Cage::createCageCoverRib(const TGeoManager* mgr)

{

  //

  // Creates a Cage cover rib element (from drawing ALIITSUP0228)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The cover rib as a TGeoVolume

  //

  // Created:      22 Apr 2022  Mario Sitta

  //


  // Local variables

  static const Int_t ribFoldNVert = 3;


  Double_t xvert[ribFoldNVert], yvert[ribFoldNVert];

  Double_t halfBase, zlen, alpha;


  zlen = 0.5 * sCageCoverRibZLength;


  // The rib main segment: a TGeoTubeSeg

  halfBase = 0.5 * sCageCoverRibXBaseInt;

  alpha = TMath::ACos(halfBase / sCageCoverRibRint) * TMath::RadToDeg();

  TGeoTubeSeg* mainSh = new TGeoTubeSeg("coverRibMain", sCageCoverRibRint, sCageCoverRibRext, zlen, alpha, 180. - alpha);


  // The lateral fold: a Xtru

  xvert[0] = sCageCoverRibXWidth / 2.;

  yvert[0] = sCageCoverRibYBaseHi;

  xvert[1] = sCageCoverRibXBaseInt / 2.;

  yvert[1] = yvert[0];

  xvert[2] = xvert[1];

  yvert[2] = yvert[1] + sCageCoverRibFoldHi;


  TGeoXtru* fold = new TGeoXtru(2);

  fold->SetName("coverRibFold");

  fold->DefinePolygon(ribFoldNVert, xvert, yvert);

  fold->DefineSection(0, -zlen);

  fold->DefineSection(1, zlen);


  // Some matrices to create the composite shape

  TGeoRotation* rotfold = new TGeoRotation("rotRibFold", 180, 180, 0);

  rotfold->RegisterYourself();


  // The cover rib shape: a CompositeShape

  TGeoCompositeShape* ribSh = new TGeoCompositeShape("coverRibMain+coverRibFold+coverRibFold:rotRibFold");


  // We have all shapes: now create the real volume

  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));


  TGeoVolume* ribVol = new TGeoVolume("CageCoverRib", ribSh, medAl);

  ribVol->SetFillColor(kGray);

  ribVol->SetLineColor(kGray);


  // Finally return the cover rib volume

  return ribVol;

}


TGeoVolume* V3Cage::createCageSidePanel(const TGeoManager* mgr)

{

  //

  // Creates the Cage Side Panel (from drawings ALIITSUP0247, ALIITSUP0248,

  // ALIITSUP0243, ALIITSUP0244, ALIITSUP0280, ALIITSUP0245)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The side panel as a TGeoVolumeAssembly

  //

  // Created:      30 Sep 2022  Mario Sitta

  // Updated:      20 May 2023  Mario Sitta  Mid and side bars added

  //


  // Local variables

  Double_t xlen, ylen, zlen;

  Double_t xpos, ypos, zpos;


  // The TGeoVolumeAssembly holding all elements

  TGeoVolumeAssembly* sidePanelVol = new TGeoVolumeAssembly("CageSidePanel");


  // The inner foil: a TGeoCompositeShape

  TGeoCompositeShape* inFoilSh = createCageSidePanelCoreFoil(sCageSidePanelFoilThick, "foil");


  // The outer foil: a BBox (each)

  xlen = sCageSidePanelFoilThick / 2;

  ylen = sCageSidePanelWidth / 2;

  zlen = sCageSidePanelLength / 2;

  TGeoBBox* outFoilSh = new TGeoBBox(xlen, ylen, zlen);


  // The intermediate core layer: a TGeoCompositeShape

  TGeoCompositeShape* coreSh = createCageSidePanelCoreFoil(sCageSidePanelCoreThick, "core");


  // The longest rails

  TGeoCompositeShape* rail1Sh = createCageSidePanelRail(sCageSidePanelRail1Len, 1);


  // The intermediate rails

  TGeoCompositeShape* rail2Sh = createCageSidePanelRail(sCageSidePanelRail2Len, 2);


  // The shortest rails

  TGeoCompositeShape* rail3Sh = createCageSidePanelRail(sCageSidePanelRail3Len, 3);


  // The middle bar: a BBox

  xlen = sCageSidePanelCoreThick / 2;

  ylen = sCageSidePanelMidBarWid / 2;

  zlen = (sCageSidePanelLength - sCageSidePanelRail3Len - sCageSidePanelSidBarWid) / 2;

  TGeoBBox* midBarSh = new TGeoBBox(xlen, ylen, zlen);


  // The side bar: a BBox

  xlen = sCageSidePanelCoreThick / 2;

  ylen = sCageSidePanelWidth / 2;

  zlen = sCageSidePanelSidBarWid / 2;

  TGeoBBox* sidBarSh = new TGeoBBox(xlen, ylen, zlen);


  // The elements of the guide:

  // - the vertical part: a BBox

  xlen = sCageSidePanelGuidThik2 / 2;

  ylen = sCageSidePanelGuideInHi / 2;

  zlen = sCageSidePanelGuideLen / 2;

  TGeoBBox* guideVert = new TGeoBBox(xlen, ylen, zlen);

  guideVert->SetName("guidevert");


  // - the horizontal part: a BBox

  xlen = sCageSidePanelGuideWide / 2;

  ylen = sCageSidePanelGuidThik1 / 2;

  TGeoBBox* guideHor = new TGeoBBox(xlen, ylen, zlen);

  guideHor->SetName("guidehor");


  xpos = (sCageSidePanelGuideWide - sCageSidePanelGuidThik2) / 2;

  ypos = (sCageSidePanelGuidThik1 + sCageSidePanelGuideInHi) / 2;

  TGeoTranslation* guideHorMat1 = new TGeoTranslation(xpos, ypos, 0);

  guideHorMat1->SetName("guidehormat1");

  guideHorMat1->RegisterYourself();


  TGeoTranslation* guideHorMat2 = new TGeoTranslation(xpos, -ypos, 0);

  guideHorMat2->SetName("guidehormat2");

  guideHorMat2->RegisterYourself();


  // The actual guide: a CompositeShape

  TGeoCompositeShape* guideSh = new TGeoCompositeShape("guidevert+guidehor:guidehormat1+guidehor:guidehormat2");


  // We have all shapes: now create the real volume

  TGeoMedium* medFabric = mgr->GetMedium(Form("%s_M46J6K$", GetDetName()));

  TGeoMedium* medFoam = mgr->GetMedium(Form("%s_ROHACELL$", GetDetName()));

  TGeoMedium* medAlAlloy = mgr->GetMedium(Form("%s_ENAW7075$", GetDetName()));


  TGeoVolume* inFoilVol = new TGeoVolume("CageSidePanelInFoil", inFoilSh, medFabric);

  inFoilVol->SetFillColor(kBlue);

  inFoilVol->SetLineColor(kBlue);


  TGeoVolume* outFoilVol = new TGeoVolume("CageSidePanelOutFoil", outFoilSh, medFabric);

  outFoilVol->SetFillColor(kBlue);

  outFoilVol->SetLineColor(kBlue);


  TGeoVolume* coreVol = new TGeoVolume("CageSidePanelCore", coreSh, medFoam);

  coreVol->SetFillColor(kYellow);

  coreVol->SetLineColor(kYellow);


  TGeoVolume* rail1Vol = new TGeoVolume("CageSidePanelRail1st", rail1Sh, medAlAlloy);

  rail1Vol->SetFillColor(kGray);

  rail1Vol->SetLineColor(kGray);


  TGeoVolume* rail2Vol = new TGeoVolume("CageSidePanelRail2nd", rail2Sh, medAlAlloy);

  rail2Vol->SetFillColor(kGray);

  rail2Vol->SetLineColor(kGray);


  TGeoVolume* rail3Vol = new TGeoVolume("CageSidePanelRail3rd", rail3Sh, medAlAlloy);

  rail3Vol->SetFillColor(kGray);

  rail3Vol->SetLineColor(kGray);


  TGeoVolume* midBarVol = new TGeoVolume("CageSidePanelMiddleBar", midBarSh, medAlAlloy);

  midBarVol->SetFillColor(kGray);

  midBarVol->SetLineColor(kGray);


  TGeoVolume* sidBarVol = new TGeoVolume("CageSidePanelSideBar", sidBarSh, medAlAlloy);

  sidBarVol->SetFillColor(kGray);

  sidBarVol->SetLineColor(kGray);


  TGeoVolume* guideVol = new TGeoVolume("CageSidePanelGuide", guideSh, medFabric);

  guideVol->SetFillColor(kViolet);

  guideVol->SetLineColor(kViolet);


  // Then build up the panel

  sidePanelVol->AddNode(coreVol, 1, nullptr);


  xpos = (sCageSidePanelCoreThick + sCageSidePanelFoilThick) / 2;

  sidePanelVol->AddNode(inFoilVol, 1, new TGeoTranslation(-xpos, 0, 0));

  sidePanelVol->AddNode(outFoilVol, 1, new TGeoTranslation(xpos, 0, 0));


  xpos = (sCageSidePanelCoreThick - sCageSidePanelRailVThik) / 2;

  zpos = (sCageSidePanelLength - sCageSidePanelRail1Len) / 2;

  for (Int_t j = 0; j < 2; j++) {

    ypos = sCageSidePanelRail1Ypos[j];

    sidePanelVol->AddNode(rail1Vol, j + 1, new TGeoTranslation(xpos, ypos, zpos));

    sidePanelVol->AddNode(rail1Vol, j + 3, new TGeoTranslation(xpos, -ypos, zpos));

  }


  zpos = (sCageSidePanelLength - sCageSidePanelRail2Len) / 2;

  ypos = sCageSidePanelRail2Ypos;

  sidePanelVol->AddNode(rail2Vol, 1, new TGeoTranslation(xpos, ypos, zpos));

  sidePanelVol->AddNode(rail2Vol, 2, new TGeoTranslation(xpos, -ypos, zpos));


  zpos = (sCageSidePanelLength - sCageSidePanelRail3Len) / 2;

  for (Int_t j = 0; j < 3; j++) {

    ypos = sCageSidePanelRail3Ypos[j];

    sidePanelVol->AddNode(rail3Vol, j + 1, new TGeoTranslation(xpos, ypos, zpos));

    sidePanelVol->AddNode(rail3Vol, j + 4, new TGeoTranslation(xpos, -ypos, zpos));

  }


  zpos = sCageSidePanelLength / 2 - midBarSh->GetDZ() - sCageSidePanelSidBarWid;

  sidePanelVol->AddNode(midBarVol, 1, new TGeoTranslation(0, 0, -zpos));


  zpos = sCageSidePanelLength / 2 - sidBarSh->GetDZ();

  sidePanelVol->AddNode(sidBarVol, 1, new TGeoTranslation(0, 0, -zpos));


  xpos = sCageSidePanelCoreThick / 2 + sCageSidePanelFoilThick + sCageSidePanelGuidThik2 / 2;

  zpos = (sCageSidePanelLength - sCageSidePanelGuideLen) / 2;

  sidePanelVol->AddNode(guideVol, 1, new TGeoTranslation(xpos, 0, -zpos));


  // Finally return the side panel volume

  return sidePanelVol;

}


TGeoCompositeShape* V3Cage::createCageSidePanelCoreFoil(const Double_t xthick, const char* shpref)

{

  //

  // Creates the shape of the core and the internal foil of the

  // Cage Side Panel, which contain proper cuts to host the rails

  //

  // Input:

  //         xthick : the shape thickness along X

  //         shpref : prefix of the shape name

  //

  // Output:

  //

  // Return:

  //         The side panel core or foil as a TGeoCompositeShape

  //

  // Created:      07 Oct 2022  Mario Sitta

  // Updated:      20 May 2023  Mario Sitta  Mid and side bars added

  //


  // Local variables

  Double_t xlen, ylen, zlen;

  Double_t ypos, zpos;


  // The main body: a BBox

  xlen = xthick / 2;

  ylen = sCageSidePanelWidth / 2;

  zlen = sCageSidePanelLength / 2;

  TGeoBBox* bodySh = new TGeoBBox(xlen, ylen, zlen);

  bodySh->SetName(Form("%sbodyshape", shpref));


  // The hole for the longest rails (approx): a BBox

  xlen = 1.1 * xthick / 2;

  ylen = sCageSidePanelRailWidth / 2;

  zlen = sCageSidePanelRail1Len;

  TGeoBBox* rail1Sh = new TGeoBBox(xlen, ylen, zlen);

  rail1Sh->SetName(Form("%slongrail", shpref));


  zpos = sCageSidePanelLength / 2;

  TGeoTranslation* rail1Mat[4];

  for (Int_t j = 0; j < 2; j++) {

    ypos = sCageSidePanelRail1Ypos[j];

    rail1Mat[j] = new TGeoTranslation(0, ypos, zpos);

    rail1Mat[j]->SetName(Form("longrailmat%d", j));

    rail1Mat[j]->RegisterYourself();

    rail1Mat[j + 2] = new TGeoTranslation(0, -ypos, zpos);

    rail1Mat[j + 2]->SetName(Form("longrailmat%d", j + 2));

    rail1Mat[j + 2]->RegisterYourself();

  }


  // The hole for the intermediate rails (approx): a BBox

  zlen = sCageSidePanelRail2Len;

  TGeoBBox* rail2Sh = new TGeoBBox(xlen, ylen, zlen);

  rail2Sh->SetName(Form("%smedrail", shpref));


  ypos = sCageSidePanelRail2Ypos;

  TGeoTranslation* rail2Mat[2];

  rail2Mat[0] = new TGeoTranslation(0, ypos, zpos);

  rail2Mat[0]->SetName("medrailmat0");

  rail2Mat[0]->RegisterYourself();

  rail2Mat[1] = new TGeoTranslation(0, -ypos, zpos);

  rail2Mat[1]->SetName("medrailmat1");

  rail2Mat[1]->RegisterYourself();


  // The hole for the shortest rails (approx): a BBox

  zlen = sCageSidePanelRail3Len;

  TGeoBBox* rail3Sh = new TGeoBBox(xlen, ylen, zlen);

  rail3Sh->SetName(Form("%sshortrail", shpref));


  TGeoTranslation* rail3Mat[6];

  for (Int_t j = 0; j < 3; j++) {

    ypos = sCageSidePanelRail3Ypos[j];

    rail3Mat[j] = new TGeoTranslation(0, ypos, zpos);

    rail3Mat[j]->SetName(Form("shortrailmat%d", j));

    rail3Mat[j]->RegisterYourself();

    rail3Mat[j + 3] = new TGeoTranslation(0, -ypos, zpos);

    rail3Mat[j + 3]->SetName(Form("shortrailmat%d", j + 3));

    rail3Mat[j + 3]->RegisterYourself();

  }


  // The hole for the middle bar: a BBox

  xlen = 1.1 * sCageSidePanelCoreThick / 2;

  ylen = sCageSidePanelMidBarWid / 2;

  zlen = (sCageSidePanelLength - sCageSidePanelRail3Len) / 2;

  TGeoBBox* midBarHol = new TGeoBBox(xlen, ylen, zlen);

  midBarHol->SetName("midbar");


  zpos = sCageSidePanelRail3Len / 2;

  TGeoTranslation* midBarMat = new TGeoTranslation(0, 0, -zpos);

  midBarMat->SetName("midbarmat");

  midBarMat->RegisterYourself();


  // The hole for the side bar: a BBox

  xlen = 1.1 * sCageSidePanelCoreThick / 2;

  ylen = 1.1 * sCageSidePanelWidth / 2;

  zlen = sCageSidePanelSidBarWid;

  TGeoBBox* sidBarHol = new TGeoBBox(xlen, ylen, zlen);

  sidBarHol->SetName("sidebar");


  zpos = sCageSidePanelLength / 2;

  TGeoTranslation* sidBarMat = new TGeoTranslation(0, 0, -zpos);

  sidBarMat->SetName("sidebarmat");

  sidBarMat->RegisterYourself();


  // The actual shape: a CompositeShape

  TString compoShape = Form("%sbodyshape", shpref);

  for (Int_t j = 0; j < 4; j++) {

    compoShape += Form("-%slongrail:longrailmat%d", shpref, j);

  }

  for (Int_t j = 0; j < 2; j++) {

    compoShape += Form("-%smedrail:medrailmat%d", shpref, j);

  }

  for (Int_t j = 0; j < 6; j++) {

    compoShape += Form("-%sshortrail:shortrailmat%d", shpref, j);

  }


  // The mid and side bar holes are present only in the core shape

  if (strcmp(shpref, "core") == 0) {

    compoShape += "-midbar:midbarmat-sidebar:sidebarmat";

  }


  TGeoCompositeShape* corefoilSh = new TGeoCompositeShape(compoShape);


  // Now return the shape

  return corefoilSh;

}


TGeoCompositeShape* V3Cage::createCageSidePanelRail(const Double_t zlength, const Int_t index)

{

  //

  // Creates the shape of a Cage Side Panel rail

  // (slightly approximated as a linear structure)

  //

  // Input:

  //         zlength : the rail length along Z

  //         index : an integer to distinguish subvolume names

  //

  // Output:

  //

  // Return:

  //         The side panel rail as a TGeoCompositeShape

  //

  // Created:      08 Oct 2022  Mario Sitta

  //


  // Local variables

  Double_t xlen, ylen;

  Double_t xpos, ypos;


  // The elements of the rail:

  // - the vertical part: a BBox

  xlen = sCageSidePanelRailVThik / 2;

  ylen = (sCageSidePanelRailWidth - 2 * sCageSidePanelRailHThik) / 2;

  TGeoBBox* railVert = new TGeoBBox(xlen, ylen, zlength / 2);

  railVert->SetName(Form("railvert%d", index));


  // - the horizontal part: a BBox

  xlen = sCageSidePanelRailSpan / 2;

  ylen = sCageSidePanelRailHThik / 2;

  TGeoBBox* railHor = new TGeoBBox(xlen, ylen, zlength / 2);

  railHor->SetName(Form("railhor%d", index));


  // The relative matrices

  xpos = (sCageSidePanelRailVThik - sCageSidePanelRailSpan) / 2;

  ypos = (sCageSidePanelRailWidth - sCageSidePanelRailHThik) / 2;

  TGeoTranslation* railHorMat1 = new TGeoTranslation(xpos, ypos, 0);

  railHorMat1->SetName("railhormat1");

  railHorMat1->RegisterYourself();


  TGeoTranslation* railHorMat2 = new TGeoTranslation(xpos, -ypos, 0);

  railHorMat2->SetName("railhormat2");

  railHorMat2->RegisterYourself();


  // The actual guide: a CompositeShape

  TString compoShape = Form("railvert%d", index);

  compoShape += Form("+railhor%d:railhormat1", index);

  compoShape += Form("+railhor%d:railhormat2", index);


  TGeoCompositeShape* railSh = new TGeoCompositeShape(compoShape);


  // Now return the shape

  return railSh;

}


TGeoVolume* V3Cage::createCageEndCap(const TGeoManager* mgr)

{

  //

  // Creates the Cage End Cap (from drawings ALIITSUP0235, ALIITSUP0229)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The end cap as a TGeoVolumeAssembly

  //

  // Created:      30 Jun 2022  Mario Sitta

  //


  // Local variables

  Double_t rmin, rmid, rmax;

  Double_t xlen, ylen, zlen;

  Double_t xpos, ypos, zpos;


  // The TGeoVolumeAssembly holding all elements

  TGeoVolumeAssembly* endCapVol = new TGeoVolumeAssembly("CageEndCap");


  // The basic fabric disk: a Tube

  rmin = sCageEndCapDint / 2;

  rmax = sCageEndCapDext / 2;

  zlen = sCageEndCapFabThick / 2;


  TGeoTube* baseFabric = new TGeoTube(rmin, rmax, zlen);

  baseFabric->SetName("endCapBaseFabric");


  // The basic foam disk: a Tube

  zlen = sCageEndCapFoamThick / 2;


  TGeoTube* baseFoam = new TGeoTube(rmin, rmax, zlen);

  baseFoam->SetName("endCapBaseFoam");


  // Common cut-out shapes

  xlen = (sCageEndCapDext - sCageEndCapXWidth) / 2;

  ylen = 0.6 * rmax;


  TGeoBBox* sideCut = new TGeoBBox(xlen, ylen, 2 * zlen);

  sideCut->SetName("endCapBoxCut");


  TGeoTube* sideHole = new TGeoTube(0, sCageEndCapSideHoleR, 2 * zlen);

  sideHole->SetName("endCapSideHole");


  xlen = sCageEndCapCableCutWid / 2;

  ylen = rmax - sCageEndCapCableCutR;


  TGeoBBox* cableCut = new TGeoBBox(xlen, ylen, 2 * zlen);

  cableCut->SetName("endCapCableCut");


  // Some matrices to create the composite shapes

  xpos = rmax;


  TGeoTranslation* boxCutTr1 = new TGeoTranslation("boxCutTr1", xpos, 0, 0);

  boxCutTr1->RegisterYourself();


  TGeoTranslation* boxCutTr2 = new TGeoTranslation("boxCutTr2", -xpos, 0, 0);

  boxCutTr2->RegisterYourself();


  xpos = sCageEndCapSideHoleX / 2;


  TGeoTranslation* sidHolTr1 = new TGeoTranslation("sideHoleTr1", xpos, 0, 0);

  sidHolTr1->RegisterYourself();


  TGeoTranslation* sidHolTr2 = new TGeoTranslation("sideHoleTr2", -xpos, 0, 0);

  sidHolTr2->RegisterYourself();


  xpos = rmax * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());

  ypos = rmax * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad());


  TGeoCombiTrans* cableMat1 = new TGeoCombiTrans(xpos, ypos, 0, new TGeoRotation("", -sCageEndCapCableCutPhi, 0, 0));

  cableMat1->SetName("cableMat1");

  cableMat1->RegisterYourself();


  TGeoCombiTrans* cableMat2 = new TGeoCombiTrans(-xpos, ypos, 0, new TGeoRotation("", sCageEndCapCableCutPhi, 0, 0));

  cableMat2->SetName("cableMat2");

  cableMat2->RegisterYourself();


  TGeoCombiTrans* cableMat3 = new TGeoCombiTrans(xpos, -ypos, 0, new TGeoRotation("", -180 + sCageEndCapCableCutPhi, 0, 0));

  cableMat3->SetName("cableMat3");

  cableMat3->RegisterYourself();


  TGeoCombiTrans* cableMat4 = new TGeoCombiTrans(-xpos, -ypos, 0, new TGeoRotation("", 180 - sCageEndCapCableCutPhi, 0, 0));

  cableMat4->SetName("cableMat4");

  cableMat4->RegisterYourself();


  // The external fabric panel (each): a CompositeShape

  TGeoCompositeShape* fabricSh = new TGeoCompositeShape("endCapBaseFabric-endCapBoxCut:boxCutTr1-endCapBoxCut:boxCutTr2-endCapSideHole:sideHoleTr1-endCapSideHole:sideHoleTr2-endCapCableCut:cableMat1-endCapCableCut:cableMat2-endCapCableCut:cableMat3-endCapCableCut:cableMat4");


  // The internal foam panel: a CompositeShape

  TGeoCompositeShape* foamSh = new TGeoCompositeShape("endCapBaseFoam-endCapBoxCut:boxCutTr1-endCapBoxCut:boxCutTr2-endCapSideHole:sideHoleTr1-endCapSideHole:sideHoleTr2-endCapCableCut:cableMat1-endCapCableCut:cableMat2-endCapCableCut:cableMat3-endCapCableCut:cableMat4");


  // The round crossing ring: a Pcon (ALIITSUP0281)

  // (in real world it is made of two rimmed rings placed face-to-face;

  // for simplicity and to spare volumes it is implemented as a single

  // Pcon encompassing both rings as mounted in the final setup)

  TGeoPcon* rndCrosSh = new TGeoPcon(0, 360, 6);


  rmin = sCageECRoundCrossDmin / 2;

  rmid = sCageECRoundCrossDmid / 2;

  rmax = sCageECRoundCrossDmax / 2;


  rndCrosSh->DefineSection(0, -sCageECRoundCrossZext, rmin, rmax);

  rndCrosSh->DefineSection(1, -sCageECRoundCrossZint, rmin, rmax);

  rndCrosSh->DefineSection(2, -sCageECRoundCrossZint, rmin, rmid);

  rndCrosSh->DefineSection(3, sCageECRoundCrossZint, rmin, rmid);

  rndCrosSh->DefineSection(4, sCageECRoundCrossZint, rmin, rmax);

  rndCrosSh->DefineSection(5, sCageECRoundCrossZext, rmin, rmax);


  // The (weirdly shaped) cable crossing: a CompositeShape

  TGeoCompositeShape* cblCrosSh = createCageEndCapCableCross(mgr);


  // We have all shapes: now create the real volume

  TGeoMedium* medFabric = mgr->GetMedium(Form("%s_M46J6K$", GetDetName()));

  TGeoMedium* medFoam = mgr->GetMedium(Form("%s_ROHACELL$", GetDetName()));

  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));


  TGeoVolume* fabVol = new TGeoVolume("CageEndCapFabric", fabricSh, medFabric);

  fabVol->SetFillColor(kBlue);

  fabVol->SetLineColor(kBlue);


  TGeoVolume* foamVol = new TGeoVolume("CageEndCapFoam", foamSh, medFoam);

  foamVol->SetFillColor(kYellow);

  foamVol->SetLineColor(kYellow);


  TGeoVolume* rndCrosVol = new TGeoVolume("CageEndCapRoundCross", rndCrosSh, medAl);

  rndCrosVol->SetFillColor(kGray);

  rndCrosVol->SetLineColor(kGray);


  TGeoVolume* cblCrosVol = new TGeoVolume("CageEndCapCableCross", cblCrosSh, medAl);

  cblCrosVol->SetFillColor(kGray);

  cblCrosVol->SetLineColor(kGray);


  // Then build up the end cap

  endCapVol->AddNode(foamVol, 1, nullptr);


  zpos = (sCageEndCapFoamThick + sCageEndCapFabThick) / 2;

  endCapVol->AddNode(fabVol, 1, new TGeoTranslation(0, 0, zpos));

  endCapVol->AddNode(fabVol, 2, new TGeoTranslation(0, 0, -zpos));


  endCapVol->AddNode(rndCrosVol, 1, nullptr);


  rmax = sCageEndCapDext / 2 - sCageECCableCrosTotHi;

  xpos = rmax * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());

  ypos = rmax * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad());

  endCapVol->AddNode(cblCrosVol, 1, new TGeoCombiTrans(xpos, ypos, 0, new TGeoRotation("", -sCageEndCapCableCutPhi, 0, 0)));

  endCapVol->AddNode(cblCrosVol, 2, new TGeoCombiTrans(-xpos, ypos, 0, new TGeoRotation("", sCageEndCapCableCutPhi, 0, 0)));

  endCapVol->AddNode(cblCrosVol, 3, new TGeoCombiTrans(xpos, -ypos, 0, new TGeoRotation("", -180 + sCageEndCapCableCutPhi, 0, 0)));

  endCapVol->AddNode(cblCrosVol, 4, new TGeoCombiTrans(-xpos, -ypos, 0, new TGeoRotation("", 180 - sCageEndCapCableCutPhi, 0, 0)));


  // Finally return the end cap volume

  return endCapVol;

}


TGeoCompositeShape* V3Cage::createCageEndCapCableCross(const TGeoManager* mgr)

{

  //

  // Creates the Cable Crossing frame for the Cage End Cap (ALIITSUP0282)

  // Since it is pretty cumbersome, we create it in a separate method

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The cable crossing frame as a TGeoCompositeShape

  //

  // Created:      01 Jul 2022  Mario Sitta

  //


  // Local variables

  Double_t rmin, rmid, rmax;

  Double_t xlen, ylen, zlen;

  Double_t xpos, ypos, zpos;


  // The string holding the complex crossing cable structure

  TString crossShape = "";


  // The inner lower part: a BBox and its matrix

  xlen = sCageECCableCrosInXWid / 2;

  ylen = sCageECCableCrosInThik / 2;

  zlen = sCageECCableCrosInZLen / 2;

  TGeoBBox* cabCrosLow = new TGeoBBox(xlen, ylen, zlen);

  cabCrosLow->SetName("CabCrosLow");


  TGeoTranslation* matCrosLow = new TGeoTranslation("MatCrosLow", 0, ylen, 0);

  matCrosLow->RegisterYourself();


  crossShape = "CabCrosLow:MatCrosLow";


  // The side wall of lower part: a BBox and its two matrices

  xlen = (sCageECCableCrosInXWid + 2 * (sCageECCableCrosSidWid - sCageECCableCrosInThik)) / 2;

  ylen = sCageECCableCrosSidWid / 2;

  zlen = (sCageECCableCrosTotZ - sCageECCableCrosInZLen) / 4; // We have 2 sides

  TGeoBBox* cabCrosSide = new TGeoBBox(xlen, ylen, zlen);

  cabCrosSide->SetName("CabCrosSide");


  ypos = 2 * cabCrosLow->GetDY() - cabCrosSide->GetDY();

  zpos = cabCrosLow->GetDZ() + cabCrosSide->GetDZ();

  TGeoTranslation* matCrosSid1 = new TGeoTranslation("MatCrosSid1", 0, ypos, zpos);

  matCrosSid1->RegisterYourself();

  TGeoTranslation* matCrosSid2 = new TGeoTranslation("MatCrosSid2", 0, ypos, -zpos);

  matCrosSid2->RegisterYourself();


  crossShape += "+CabCrosSide:MatCrosSid1+CabCrosSide:MatCrosSid2";


  // The inner lateral part: a BBox and its two matrices

  // (in blueprint the lateral height is not specified, we have to compute it)

  rmax = sCageEndCapDext / 2;

  xlen = sCageECCableCrosInXWid / 2;


  Double_t apothem = TMath::Sqrt(rmax * rmax - xlen * xlen);

  Double_t sagitta = rmax - apothem;


  xlen = sCageECCableCrosInThik / 2;

  ylen = (sCageECCableCrosTotHi - sagitta - sCageECCableCrosInThik) / 2;

  zlen = sCageECCableCrosInZLen / 2;

  TGeoBBox* cabCrosLat = new TGeoBBox(xlen, ylen, zlen);

  cabCrosLat->SetName("CabCrosLateral");


  xpos = 0.5 * sCageECCableCrosInXWid - cabCrosLat->GetDX();

  ypos = cabCrosLat->GetDY() + sCageECCableCrosInThik;

  TGeoTranslation* matCrosLat1 = new TGeoTranslation("MatCrosLat1", xpos, ypos, 0);

  matCrosLat1->RegisterYourself();

  TGeoTranslation* matCrosLat2 = new TGeoTranslation("MatCrosLat2", -xpos, ypos, 0);

  matCrosLat2->RegisterYourself();


  crossShape += "+CabCrosLateral:MatCrosLat1+CabCrosLateral:MatCrosLat2";


  // The side wall of lateral part: a BBox and its four matrices

  xlen = sCageECCableCrosSidWid / 2;

  zlen = cabCrosSide->GetDZ();

  TGeoBBox* cabCrosLatSide = new TGeoBBox(xlen, ylen, zlen);

  cabCrosLatSide->SetName("CabCrosLatSide");


  xpos = cabCrosSide->GetDX() - cabCrosLatSide->GetDX();

  zpos = cabCrosLat->GetDZ() + cabCrosLatSide->GetDZ();

  TGeoTranslation* matCrosLatSid1 = new TGeoTranslation("MatCrosLatSid1", xpos, ypos, zpos);

  matCrosLatSid1->RegisterYourself();

  TGeoTranslation* matCrosLatSid2 = new TGeoTranslation("MatCrosLatSid2", xpos, ypos, -zpos);

  matCrosLatSid2->RegisterYourself();

  TGeoTranslation* matCrosLatSid3 = new TGeoTranslation("MatCrosLatSid3", -xpos, ypos, zpos);

  matCrosLatSid3->RegisterYourself();

  TGeoTranslation* matCrosLatSid4 = new TGeoTranslation("MatCrosLatSid4", -xpos, ypos, -zpos);

  matCrosLatSid4->RegisterYourself();


  crossShape += "+CabCrosLatSide:MatCrosLatSid1+CabCrosLatSide:MatCrosLatSid2+CabCrosLatSide:MatCrosLatSid3+CabCrosLatSide:MatCrosLatSid4";


  // The top rounded part: a TubeSeg and its matrix

  xlen = sCageECCableCrosInXWid / 2;

  Double_t phi = TMath::ASin(xlen / rmax) * TMath::RadToDeg();

  rmin = rmax - sCageECCableCrosSidWid;

  zlen = sCageECCableCrosTotZ / 2;

  TGeoTubeSeg* cabCrosRnd = new TGeoTubeSeg(rmin, rmax, zlen, 90 - phi, 90 + phi);

  cabCrosRnd->SetName("CabCrosRoundTop");


  ypos = -rmax + sCageECCableCrosTotHi;

  TGeoTranslation* matCrosRnd = new TGeoTranslation("MatCrosRound", 0, ypos, 0);

  matCrosRnd->RegisterYourself();


  crossShape += "+CabCrosRoundTop:MatCrosRound";


  // Finally create and return the cable crossing shape

  // (the origin of its reference system is below the lower face of cabCrosLow)

  TGeoCompositeShape* cableCross = new TGeoCompositeShape(crossShape.Data());


  return cableCross;

}


TGeoVolume* V3Cage::createBeamPipeSupport(const TGeoManager* mgr)

{

  //

  // Creates the Beam Pipe Support inside the Cage on the A side

  // (from drawings ALIITSUP1064, ALIITSUP1059, ALIITSUP1057, ALIITSUP1058,

  // ALIITSUP1056, ALIITSUP0823, ALIITSUP0273, ALIITSUP1060, ALIITSUP1062)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The beam pipe support as a TGeoVolumeAssembly

  //

  // Created:      03 Jun 2023  Mario Sitta

  //


  // Local variables

  const Int_t nv = 8;

  Double_t xv[nv], yv[nv];

  Double_t xpos, ypos, zpos;


  // The TGeoVolumeAssembly holding all elements

  TGeoVolumeAssembly* bpSuppVol = new TGeoVolumeAssembly("CageBeamPipeSupport");


  // The lower collar

  TGeoCompositeShape* lowCollarSh = createBPSuppLowerCollar();


  // The upper collar

  TGeoCompositeShape* upCollarSh = createBPSuppUpperCollar();


  // Each one of the collar beams

  TGeoCompositeShape* collarBeamSh = createBPSuppCollarBeam();


  // Each one of the lateral brackets

  TGeoCompositeShape* bracketSh = createBPSuppBracket();


  // Each one of the lateral clamps

  TGeoCompositeShape* clampSh = createBPSuppClamp();


  // The Vespel bushing: a Tube

  TGeoTube* bushSh = new TGeoTube(0.5 * sBPSuppCollarBushD, 0.5 * sBPSuppCollarIntD, 0.5 * sBPSuppBracketWidth);


  // The clamp shim: a BBox

  TGeoBBox* shimSh = new TGeoBBox(0.5 * sBPSuppClampShimWid, 0.5 * sBPSuppClampShimThick, 0.5 * sBPSuppClampShimLen);


  // The M4 screw head: a Tube

  TGeoTube* m4ScrewSh = new TGeoTube(0, 0.5 * sBPSuppCollarM4Diam, 0.5 * sBPSuppCollarM4High);


  // The M5 screw head: a Tube

  TGeoTube* m5ScrewSh = new TGeoTube(0, 0.5 * sBPSuppClampM5Diam, 0.5 * sBPSuppClampM5High);


  // The threaded insert head: a Cone

  TGeoCone* insHeadSh = new TGeoCone(0.5 * sBPSuppClampInsH, 0, 0.5 * sBPSuppClampInsDmin, 0, 0.5 * sBPSuppClampInsDmax);


  // We have all the shapes: now create the real volumes

  TGeoMedium* medCFRP = mgr->GetMedium(Form("%s_CFRP$", GetDetName()));

  TGeoMedium* medTitanium = mgr->GetMedium(Form("%s_TITANIUM$", GetDetName()));

  TGeoMedium* medSteel = mgr->GetMedium(Form("%s_INOX304$", GetDetName()));

  TGeoMedium* medBrass = mgr->GetMedium(Form("%s_BRASS$", GetDetName()));

  TGeoMedium* medVespel = mgr->GetMedium(Form("%s_VESPEL$", GetDetName()));


  Color_t kTitanium = kGray + 1; // Darker gray


  TGeoVolume* lowCollarVol = new TGeoVolume("BPSupportLowerCollar", lowCollarSh, medTitanium);

  lowCollarVol->SetFillColor(kTitanium);

  lowCollarVol->SetLineColor(kTitanium);


  TGeoVolume* upCollarVol = new TGeoVolume("BPSupportUpperCollar", upCollarSh, medTitanium);

  upCollarVol->SetFillColor(kTitanium);

  upCollarVol->SetLineColor(kTitanium);


  TGeoVolume* bushVol = new TGeoVolume("BPSupportCollarBushing", bushSh, medVespel);

  bushVol->SetFillColor(kGreen);

  bushVol->SetLineColor(kGreen);


  TGeoVolume* collarBeamVol = new TGeoVolume("BPSupportCollarBeam", collarBeamSh, medCFRP);

  collarBeamVol->SetFillColor(kBlue);

  collarBeamVol->SetLineColor(kBlue);


  TGeoVolume* bracketVol = new TGeoVolume("BPSupportBracket", bracketSh, medTitanium);

  bracketVol->SetFillColor(kTitanium);

  bracketVol->SetLineColor(kTitanium);


  TGeoVolume* clampVol = new TGeoVolume("BPSupportClamp", clampSh, medTitanium);

  clampVol->SetFillColor(kTitanium);

  clampVol->SetLineColor(kTitanium);


  TGeoVolume* shimVol = new TGeoVolume("BPSupportClampShim", shimSh, medBrass);

  shimVol->SetFillColor(kOrange - 4); // Brownish

  shimVol->SetLineColor(kOrange - 4);


  TGeoVolume* m4ScrewVol = new TGeoVolume("BPSupportCollarScrew", m4ScrewSh, medTitanium);

  m4ScrewVol->SetFillColor(kTitanium);

  m4ScrewVol->SetLineColor(kTitanium);


  TGeoVolume* m5ScrewVol = new TGeoVolume("BPSupportClampScrew", m5ScrewSh, medSteel);

  m5ScrewVol->SetFillColor(kGray);

  m5ScrewVol->SetLineColor(kGray);


  TGeoVolume* insHeadVol = new TGeoVolume("BPSupportClampInsert", insHeadSh, medSteel);

  insHeadVol->SetFillColor(kGray);

  insHeadVol->SetLineColor(kGray);


  // Then build up the beam support

  bpSuppVol->AddNode(lowCollarVol, 1, nullptr);


  ypos = sBPSuppLowCollTailHei / 2;

  bpSuppVol->AddNode(upCollarVol, 1, new TGeoTranslation(0, ypos, 0));


  bpSuppVol->AddNode(bushVol, 1, new TGeoTranslation(0, ypos, 0));


  xpos = sBPSuppCollarM4XDist / 2;

  ypos += (sBPSuppUpperCollarHei + m4ScrewSh->GetDz());

  zpos = sBPSuppCollarM4ZPos;

  bpSuppVol->AddNode(m4ScrewVol, 1, new TGeoCombiTrans(xpos, ypos, zpos, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(m4ScrewVol, 2, new TGeoCombiTrans(-xpos, ypos, zpos, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(m4ScrewVol, 3, new TGeoCombiTrans(xpos, ypos, -zpos, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(m4ScrewVol, 4, new TGeoCombiTrans(-xpos, ypos, -zpos, new TGeoRotation("", 0, 90, 0)));


  xpos = sBPSuppLowerCollarLen / 2 - sBPSuppBracketInLen + sBPSuppCollarBeamLen / 2;

  bpSuppVol->AddNode(collarBeamVol, 1, new TGeoCombiTrans(xpos, 0, 0, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(collarBeamVol, 2, new TGeoCombiTrans(-xpos, 0, 0, new TGeoRotation("", 0, 90, 0)));


  xpos += (sBPSuppCollarBeamLen / 2 - sBPSuppBracketInLen);

  bpSuppVol->AddNode(bracketVol, 1, new TGeoTranslation(xpos, 0, 0));

  bpSuppVol->AddNode(bracketVol, 2, new TGeoCombiTrans(-xpos, 0, 0, new TGeoRotation("", 90, 180, -90)));


  xpos = 0.5 * sBPSuppClampsXDist - sBPSuppClampTotWid + shimSh->GetDX();

  ypos = -shimSh->GetDY();

  bpSuppVol->AddNode(shimVol, 1, new TGeoTranslation(xpos, ypos, 0));

  bpSuppVol->AddNode(shimVol, 2, new TGeoTranslation(-xpos, ypos, 0));


  xpos = 0.5 * sBPSuppClampsXDist - sBPSuppClampLatThick;

  ypos -= shimSh->GetDY();

  bpSuppVol->AddNode(clampVol, 1, new TGeoTranslation(-xpos, ypos, 0));

  bpSuppVol->AddNode(clampVol, 2, new TGeoCombiTrans(xpos, ypos, 0, new TGeoRotation("", 90, 180, -90)));


  xpos -= m5ScrewSh->GetDz();

  ypos += (0.5 * sBPSuppClampTotHei - sBPSuppClampShelfHei);

  zpos = sBPSuppClampM5ZPos;

  bpSuppVol->AddNode(m5ScrewVol, 1, new TGeoCombiTrans(xpos, ypos, zpos, new TGeoRotation("", 90, 90, -90)));

  bpSuppVol->AddNode(m5ScrewVol, 2, new TGeoCombiTrans(xpos, ypos, -zpos, new TGeoRotation("", 90, 90, -90)));

  bpSuppVol->AddNode(m5ScrewVol, 3, new TGeoCombiTrans(-xpos, ypos, zpos, new TGeoRotation("", 90, 90, -90)));

  bpSuppVol->AddNode(m5ScrewVol, 4, new TGeoCombiTrans(-xpos, ypos, -zpos, new TGeoRotation("", 90, 90, -90)));


  xpos = 0.5 * sBPSuppClampsXDist - sBPSuppClampInsXPos;

  ypos = sBPSuppBracketTailHei + insHeadSh->GetDz();

  zpos = sBPSuppClampInsZPos;

  bpSuppVol->AddNode(insHeadVol, 1, new TGeoCombiTrans(xpos, ypos, zpos, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(insHeadVol, 2, new TGeoCombiTrans(-xpos, ypos, zpos, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(insHeadVol, 3, new TGeoCombiTrans(xpos, ypos, -zpos, new TGeoRotation("", 0, 90, 0)));

  bpSuppVol->AddNode(insHeadVol, 4, new TGeoCombiTrans(-xpos, ypos, -zpos, new TGeoRotation("", 0, 90, 0)));


  // Finally return the beam pipe support volume

  return bpSuppVol;

}


TGeoCompositeShape* V3Cage::createBPSuppLowerCollar()

{

  //

  // Creates the lower collar which actually supports the Beam Pipe

  // (ALIITSUP1056)

  //

  // Input:

  //

  // Output:

  //

  // Return:

  //         The lower collar as a TGeoCompositeShape

  //

  // Created:      06 Jun 2023  Mario Sitta

  //


  // Local variables

  const Int_t nv = 12;

  Double_t xv[nv], yv[nv], xy8[16];

  Double_t zlen;

  Double_t xpos, ypos;


  // The lateral bracket: a Xtru

  Double_t totlen = (sBPSuppLowerCollarLen - sBPSuppCollarIntD) / 2;

  Double_t xtail = (sBPSuppLowCollHolDist - sBPSuppCollarIntD) / 2;

  Double_t taillen = sBPSuppLowerCollarTlX - sBPSuppCollarIntD / 2;


  xv[0] = 0;

  yv[0] = -sBPSuppCollarBeamHei / 2;

  xv[1] = totlen - xtail;

  yv[1] = yv[0];

  xv[2] = totlen - taillen;

  yv[2] = -sBPSuppLowCollTailHei / 2;

  xv[3] = totlen;

  yv[3] = yv[2];

  xv[4] = xv[3];

  yv[4] = sBPSuppLowCollTailHei / 2;

  xv[5] = xv[2];

  yv[5] = yv[4];

  xv[6] = xv[1];

  yv[6] = -yv[1];

  xv[7] = xv[0];

  yv[7] = yv[6];

  xv[8] = xv[7];

  yv[8] = sBPSuppBracketInHei / 2;

  xv[9] = sBPSuppBracketInLen;

  yv[9] = yv[8];

  xv[10] = xv[9];

  yv[10] = -yv[9];

  xv[11] = xv[0];

  yv[11] = yv[10];


  zlen = sBPSuppBracketWidth / 2;

  TGeoXtru* brktlat = new TGeoXtru(2);

  brktlat->DefinePolygon(nv, xv, yv);

  brktlat->DefineSection(0, -zlen);

  brktlat->DefineSection(1, zlen);

  brktlat->SetName("latBrackBody");


  // The central hole in lateral bracket: a Tube

  zlen = sBPSuppBracketWidth / 2 + 0.001;

  TGeoTube* brktcenthole = new TGeoTube(0, sBPSuppBrktCentHoleD / 2, zlen);

  brktcenthole->SetName("latBrackCentHole");


  xpos = totlen - xtail;

  TGeoTranslation* brktcenthmat = new TGeoTranslation(xpos, 0, 0);

  brktcenthmat->SetName("latCentHoleMat");

  brktcenthmat->RegisterYourself();


  // The lateral hole in lateral bracket: an Arb8

  // (array of vertices is in the form (x0, y0, x1, y1, ..., x7, y7) )

  xy8[0] = 0;

  xy8[1] = 0;

  xy8[2] = -sBPSuppBrktLatHoleW;

  xy8[3] = -sBPSuppBrktLatHoleH / 2;

  xy8[4] = xy8[2];

  xy8[5] = -xy8[3];

  xy8[6] = xy8[0];

  xy8[7] = xy8[1];

  for (Int_t i = 0; i < 8; i++) { // The opposite face

    xy8[8 + i] = xy8[i];

  }

  TGeoArb8* brktlathole = new TGeoArb8(zlen, xy8);

  brktlathole->SetName("latBrackLatHole");


  xpos = totlen - taillen;

  TGeoTranslation* brktlathmat = new TGeoTranslation(xpos, 0, 0);

  brktlathmat->SetName("latLatHoleMat");

  brktlathmat->RegisterYourself();


  // The lateral bracket: a CompositeShape

  TGeoCompositeShape* latbrkt = new TGeoCompositeShape("latBrackBody-latBrackCentHole:latCentHoleMat-latBrackLatHole:latLatHoleMat");

  latbrkt->SetName("lateralBracket");


  // The lateral bracket matrices

  xpos = sBPSuppLowerCollarLen / 2;

  TGeoTranslation* latmat1 = new TGeoTranslation(-xpos, 0, 0);

  latmat1->SetName("latBrackMat1");

  latmat1->RegisterYourself();


  TGeoCombiTrans* latmat2 = new TGeoCombiTrans(xpos, 0, 0, new TGeoRotation("", 90, 180, -90));

  latmat2->SetName("latBrackMat2");

  latmat2->RegisterYourself();


  // The collar: a TubeSeg

  TGeoTubeSeg* collar = new TGeoTubeSeg(0.5 * sBPSuppCollarIntD, 0.5 * sBPSuppCollarExtD, 0.5 * sBPSuppBracketWidth, 180, 360);

  collar->SetName("lowerCollar");


  ypos = brktlat->GetY(4); // The upper face of the tail

  TGeoTranslation* collmat = new TGeoTranslation(0, ypos, 0);

  collmat->SetName("lowerCollMat");

  collmat->RegisterYourself();


  // Finally create and return the lower collar

  // (the origin of its reference system is at its center)

  TGeoCompositeShape* collarShape = new TGeoCompositeShape("lowerCollar:lowerCollMat+lateralBracket:latBrackMat1+lateralBracket:latBrackMat2");


  return collarShape;

}


TGeoCompositeShape* V3Cage::createBPSuppUpperCollar()

{

  //

  // Creates the upper collar of the Beam Pipe Support (ALIITSUP0823)

  //

  // Input:

  //

  // Output:

  //

  // Return:

  //         The upper collar as a TGeoCompositeShape

  //

  // Created:      07 Jun 2023  Mario Sitta

  //


  // Local variables

  Double_t xlen;

  Double_t xpos, ypos;


  // The lateral plate: a BBox

  xlen = (sBPSuppUpperCollarLen - sBPSuppCollarIntD) / 2;

  TGeoBBox* plate = new TGeoBBox(0.5 * xlen, 0.5 * sBPSuppUpperCollarHei, 0.5 * sBPSuppBracketWidth);

  plate->SetName("lateralPlate");


  xpos = sBPSuppUpperCollarLen / 2 - plate->GetDX();

  ypos = plate->GetDY();

  TGeoTranslation* latplmat1 = new TGeoTranslation(xpos, ypos, 0);

  latplmat1->SetName("lateralPlateMat1");

  latplmat1->RegisterYourself();


  TGeoTranslation* latplmat2 = new TGeoTranslation(-xpos, ypos, 0);

  latplmat2->SetName("lateralPlateMat2");

  latplmat2->RegisterYourself();


  // The collar: a TubeSeg

  TGeoTubeSeg* collar = new TGeoTubeSeg(0.5 * sBPSuppCollarIntD, 0.5 * sBPSuppCollarExtD, 0.5 * sBPSuppBracketWidth, 0, 180);

  collar->SetName("upperCollar");


  // Finally create and return the upper collar

  // (the origin of its reference system is at its center)

  TGeoCompositeShape* collarShape = new TGeoCompositeShape("upperCollar+lateralPlate:lateralPlateMat1+lateralPlate:lateralPlateMat2");


  return collarShape;

}


TGeoCompositeShape* V3Cage::createBPSuppCollarBeam()

{

  //

  // Creates the collar beam (i.e. the lateral support bar) of the

  // Beam Pipe Support (ALIITSUP1057)

  //

  // Input:

  //

  // Output:

  //

  // Return:

  //         The collar beam as a TGeoCompositeShape

  //

  // Created:      03 Jun 2023  Mario Sitta

  //


  // Local variables

  const Int_t nv = 8;

  Double_t xv[nv], yv[nv];

  Double_t xlen, xwid, ylen, zlen;

  Double_t xpos;


  // The central part: a Xtru

  xlen = (sBPSuppCollarBeamLen - 2 * sBPSuppBracketInLen) / 2;

  xwid = (sBPSuppCollarBeamWid - sBPSuppBracketWidth) / 2;

  xv[0] = -xlen;

  yv[0] = -sBPSuppBracketWidth / 2;

  xv[1] = xv[0] + xwid;

  yv[1] = -sBPSuppCollarBeamWid / 2;

  xv[2] = -xv[1];

  yv[2] = yv[1];

  xv[3] = -xv[0];

  yv[3] = yv[0];

  for (Int_t i = 0; i < 4; i++) { // Reflect the lower half to the upper half

    xv[4 + i] = xv[3 - i];

    yv[4 + i] = -yv[3 - i];

  }


  zlen = sBPSuppCollarBeamHei / 2;

  TGeoXtru* colcent = new TGeoXtru(2);

  colcent->SetName("collarCentral");

  colcent->DefinePolygon(nv, xv, yv);

  colcent->DefineSection(0, -zlen);

  colcent->DefineSection(1, zlen);


  // Each bracket insert: a BBox

  xlen = sBPSuppBracketInLen / 2;

  ylen = sBPSuppBracketWidth / 2;

  zlen = sBPSuppBracketInHei / 2;

  TGeoBBox* colins = new TGeoBBox("collarInsert", xlen, ylen, zlen);


  xpos = colcent->GetX(0) - colins->GetDX();

  TGeoTranslation* insmat1 = new TGeoTranslation(-xpos, 0, 0);

  insmat1->SetName("colInsMat1");

  insmat1->RegisterYourself();


  TGeoTranslation* insmat2 = new TGeoTranslation(xpos, 0, 0);

  insmat2->SetName("colInsMat2");

  insmat2->RegisterYourself();


  // Finally create and return the collar beam

  // (the origin of its reference system is at its center)

  TGeoCompositeShape* beamShape = new TGeoCompositeShape("collarCentral+collarInsert:colInsMat1+collarInsert:colInsMat2");


  return beamShape;

}


TGeoCompositeShape* V3Cage::createBPSuppBracket()

{

  //

  // Creates the lateral Titanium bracket of the Beam Pipe Support

  // (ALIITSUP1058)

  //

  // Input:

  //

  // Output:

  //

  // Return:

  //         The bracket as a TGeoCompositeShape

  //

  // Created:      04 Jun 2023  Mario Sitta

  //


  // Local variables

  const Int_t nv = 12;

  Double_t xv[nv], yv[nv];

  Double_t zlen;

  Double_t xpos;


  // The main body: a Xtru

  xv[0] = 0;

  yv[0] = -sBPSuppCollarBeamHei / 2;

  xv[1] = sBPSuppBracketTotLen - sBPSuppBrktCentHoleX;

  yv[1] = yv[0];

  xv[2] = sBPSuppBracketTotLen - sBPSuppBracketTailLen;

  yv[2] = 0;

  xv[3] = sBPSuppBracketTotLen;

  yv[3] = yv[2];

  xv[4] = xv[3];

  yv[4] = sBPSuppBracketTailHei;

  xv[5] = xv[2];

  yv[5] = yv[4];

  xv[6] = xv[1];

  yv[6] = -yv[1];

  xv[7] = xv[0];

  yv[7] = yv[6];

  xv[8] = xv[7];

  yv[8] = sBPSuppBracketInHei / 2;

  xv[9] = sBPSuppBracketInLen;

  yv[9] = yv[8];

  xv[10] = xv[9];

  yv[10] = -yv[9];

  xv[11] = xv[0];

  yv[11] = yv[10];


  zlen = sBPSuppBracketWidth / 2;

  TGeoXtru* brktbody = new TGeoXtru(2);

  brktbody->DefinePolygon(nv, xv, yv);

  brktbody->DefineSection(0, -zlen);

  brktbody->DefineSection(1, zlen);

  brktbody->SetName("bracketBody");


  // The central hole: a Tube

  zlen = sBPSuppBracketWidth / 2 + 0.001;

  TGeoTube* brktcenthole = new TGeoTube(0, sBPSuppBrktCentHoleD / 2, zlen);

  brktcenthole->SetName("bracketCentHole");


  xpos = sBPSuppBracketTotLen - sBPSuppBrktCentHoleX;

  TGeoTranslation* brktcenthmat = new TGeoTranslation(xpos, -sBPSuppBrktHolesY, 0);

  brktcenthmat->SetName("bracketCentHMat");

  brktcenthmat->RegisterYourself();


  // The lateral hole: a Tube

  TGeoTube* brktlathole = new TGeoTube(0, sBPSuppBrktLatHoleD / 2, zlen);

  brktlathole->SetName("bracketLatHole");


  xpos = sBPSuppBracketTotLen - sBPSuppBrktLatHoleX;

  TGeoTranslation* brktlathmat = new TGeoTranslation(xpos, sBPSuppBrktHolesY, 0);

  brktlathmat->SetName("bracketLatHMat");

  brktlathmat->RegisterYourself();


  // Finally create and return the bracket

  // (the origin of its reference system is opposite to its tail)

  TGeoCompositeShape* bracketShape = new TGeoCompositeShape("bracketBody-bracketCentHole:bracketCentHMat-bracketLatHole:bracketLatHMat");


  return bracketShape;

}


TGeoCompositeShape* V3Cage::createBPSuppClamp()

{

  //

  // Creates the lateral Titanium clamp holding the Beam Pipe Support

  // to the ITS Cage (ALIITSUP1060)

  //

  // Input:

  //

  // Output:

  //

  // Return:

  //         The clamp as a TGeoCompositeShape

  //

  // Created:      08 Jun 2023  Mario Sitta

  //


  // Local variables

  Double_t xlen, ylen, zlen;

  Double_t xpos, ypos;


  // The vertical wall: a BBox

  xlen = sBPSuppClampLatThick / 2;

  ylen = sBPSuppClampTotHei / 2;

  zlen = sBPSuppClampTotLen / 2;

  TGeoBBox* clampwall = new TGeoBBox(xlen, ylen, zlen);

  clampwall->SetName("clampWall");


  xpos = -clampwall->GetDX();

  ypos = clampwall->GetDY() - sBPSuppClampShelfHei;

  TGeoTranslation* clampwallmat = new TGeoTranslation(xpos, ypos, 0);

  clampwallmat->SetName("clampWallMat");

  clampwallmat->RegisterYourself();


  // The horizontal shelf: a BBox

  xlen = (sBPSuppClampTotWid - sBPSuppClampLatThick) / 2;

  ylen = sBPSuppClampShelfHei / 2;

  zlen = sBPSuppClampShelfLen / 2;

  TGeoBBox* clampshelf = new TGeoBBox(xlen, ylen, zlen);

  clampshelf->SetName("clampShelf");


  xpos = clampshelf->GetDX();

  ypos = -clampshelf->GetDY();

  TGeoTranslation* clampshelfmat = new TGeoTranslation(xpos, ypos, 0);

  clampshelfmat->SetName("clampShelfMat");

  clampshelfmat->RegisterYourself();


  // Finally create and return the clamp

  // (the origin of its reference system is at the conjunction

  // of the vertical wall with the horizontal shelf)

  TGeoCompositeShape* clampShape = new TGeoCompositeShape("clampWall:clampWallMat+clampShelf:clampShelfMat");


  return clampShape;

}


TGeoVolume* V3Cage::createCageClosingCross(const TGeoManager* mgr)

{

  //

  // Creates the Cage Closing Cross (from drawings ALIITSUP0242)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         The closing cross as a TGeoVolume

  //

  // Created:      29 May 2023  Mario Sitta

  //


  // Local variables

  const Int_t nv = 8;

  Double_t xv[nv], yv[nv];

  Double_t xlen, ylen, zlen;

  Double_t xpos, ypos;


  TString compoShape;


  // A single vertical post: a Xtru

  xv[0] = 0.;

  yv[0] = 0.;

  xv[1] = (sCageCrossXWidthTot - sCageCrossXWidthInt) / 2;

  yv[1] = yv[0];

  xv[2] = xv[1];

  yv[2] = (sCageCrossYHeightTot - sCageCrossYHeightInt) / 2;

  xv[3] = (sCageCrossXWidthExt - sCageCrossXWidthInt) / 2;

  yv[3] = yv[2];

  xv[4] = xv[3];

  yv[4] = yv[3] + sCageCrossYHeightInt;

  xv[5] = xv[2];

  yv[5] = yv[4];

  xv[6] = xv[5];

  yv[6] = sCageCrossYHeightTot;

  xv[7] = xv[0];

  yv[7] = yv[6];


  zlen = sCageCrossZLength / 2;


  TGeoXtru* vpost = new TGeoXtru(2);

  vpost->SetName("crossvertpost");

  vpost->DefinePolygon(nv, xv, yv);

  vpost->DefineSection(0, -zlen);

  vpost->DefineSection(1, zlen);


  // The vertical post matrices

  xpos = sCageCrossXWidthInt / 2;

  TGeoTranslation* vpostmat1 = new TGeoTranslation("vertpostmat1", xpos, 0, 0);

  vpostmat1->RegisterYourself();


  TGeoCombiTrans* vpostmat2 = new TGeoCombiTrans(-xpos, 0, 0, new TGeoRotation("", 90, 180, -90));

  vpostmat2->SetName("vertpostmat2");

  vpostmat2->RegisterYourself();


  compoShape = Form("crossvertpost:vertpostmat1+crossvertpost:vertpostmat2");


  // A single oblique post: a BBox

  Double_t leg = vpost->GetY(4);

  xlen = TMath::Sqrt(sCageCrossXWidthInt * sCageCrossXWidthInt + leg * leg) / 2;

  ylen = sCageCrossBarThick / 2;

  TGeoBBox* xpost = new TGeoBBox("crossoblqpost", xlen, ylen, zlen);


  // The oblique post matrices

  Double_t phi = sCageCrossBarPhi / 2;

  ypos = sCageCrossYHeightTot - sCageCrossYMid;


  TGeoCombiTrans* xpostmat1 = new TGeoCombiTrans(0, ypos, 0, new TGeoRotation("", phi, 0, 0));

  xpostmat1->SetName("oblqpostmat1");

  xpostmat1->RegisterYourself();


  TGeoCombiTrans* xpostmat2 = new TGeoCombiTrans(0, ypos, 0, new TGeoRotation("", -phi, 0, 0));

  xpostmat2->SetName("oblqpostmat2");

  xpostmat2->RegisterYourself();


  compoShape += Form("+crossoblqpost:oblqpostmat1+crossoblqpost:oblqpostmat2");


  // The actual closing cross shape: a CompositeShape

  TGeoCompositeShape* closCrossSh = new TGeoCompositeShape(compoShape);


  // We have the shape: now create the real volume

  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));


  TGeoVolume* closCrossVol = new TGeoVolume("CageClosingCross", closCrossSh, medAl);

  closCrossVol->SetFillColor(kGray);

  closCrossVol->SetLineColor(kGray);


  // Finally return the closing cross volume

  return closCrossVol;

}


void V3Cage::createAndPlaceMFTRailsInsideCage(TGeoVolume* mother, const TGeoManager* mgr)

{

  //

  // Creates the MFT Rails located inside the Cage and place them

  //

  // Input:

  //         motmat : the material of the mother volume (for the container box)

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //

  // Created:      10 May 2025  Mario Sitta

  // Updated:      20 May 2025  Mario Sitta   Hinges added

  //


  // Local variables

  Double_t rdist, rpos, xpos, yposup, yposdw, zpos, alpha;

  Double_t xbox, ybox;


  // Create a pair of rails (a BBox container is returned)

  TGeoVolume* cageMFTRails = createMFTRailsPair(mother->GetMedium(), mgr);


  // Create hinge holding a pair of rails

  TGeoVolume* cageMFTRailsHinge = createMFTRailsHinge(mgr);


  // Now compute the radial distance and the XY position of the box

  xbox = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDX();

  ybox = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDY();


  rdist = TMath::Sqrt(sCageCoverRint * sCageCoverRint - xbox * xbox);

  rpos = rdist - ybox;


  // Finally place the four pairs of rails inside the mother volume

  xpos = rpos * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());

  yposup = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) + sCageYInBarrel;

  yposdw = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) - sCageYInBarrel;

  zpos = sCageMFTRailZPos;


  alpha = -sCageEndCapCableCutPhi + 180;

  mother->AddNode(cageMFTRails, 1, new TGeoCombiTrans(xpos, yposup, zpos, new TGeoRotation("", alpha, 0, 0)));

  alpha = sCageEndCapCableCutPhi + 180;

  mother->AddNode(cageMFTRails, 2, new TGeoCombiTrans(-xpos, yposup, zpos, new TGeoRotation("", alpha, 0, 0)));


  alpha = sCageEndCapCableCutPhi;

  mother->AddNode(cageMFTRails, 3, new TGeoCombiTrans(xpos, -yposdw, zpos, new TGeoRotation("", alpha, 0, 0)));

  alpha = -sCageEndCapCableCutPhi;

  mother->AddNode(cageMFTRails, 4, new TGeoCombiTrans(-xpos, -yposdw, zpos, new TGeoRotation("", alpha, 0, 0)));


  // And the hinges too

  xpos = rdist * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());

  yposup = rdist * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) + sCageYInBarrel;

  yposdw = rdist * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) - sCageYInBarrel;

  zpos = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDZ() + sCageMFTRailZPos;


  alpha = sCageEndCapCableCutPhi;

  mother->AddNode(cageMFTRailsHinge, 1, new TGeoCombiTrans(xpos, yposup, zpos, new TGeoRotation("", -alpha, 0, 0)));

  mother->AddNode(cageMFTRailsHinge, 2, new TGeoCombiTrans(-xpos, yposup, zpos, new TGeoRotation("", alpha, 0, 0)));


  mother->AddNode(cageMFTRailsHinge, 3, new TGeoCombiTrans(xpos, -yposdw, zpos, new TGeoRotation("", 180 + alpha, 0, 0)));

  mother->AddNode(cageMFTRailsHinge, 4, new TGeoCombiTrans(-xpos, -yposdw, zpos, new TGeoRotation("", 180 - alpha, 0, 0)));


  zpos = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDZ() - sCageMFTRailZPos;

  mother->AddNode(cageMFTRailsHinge, 5, new TGeoCombiTrans(xpos, yposup, -zpos, new TGeoRotation("", 90, 180, -90 + alpha))); // On Z<0 apply 180deg rotation on Y axis

  mother->AddNode(cageMFTRailsHinge, 6, new TGeoCombiTrans(-xpos, yposup, -zpos, new TGeoRotation("", 90, 180, -90 - alpha)));


  mother->AddNode(cageMFTRailsHinge, 7, new TGeoCombiTrans(xpos, -yposdw, -zpos, new TGeoRotation("", 90, 180, 90 - alpha)));

  mother->AddNode(cageMFTRailsHinge, 8, new TGeoCombiTrans(-xpos, -yposdw, -zpos, new TGeoRotation("", 90, 180, 90 + alpha)));


  return;

}


TGeoVolume* V3Cage::createMFTRailsPair(const TGeoMedium* motmed, const TGeoManager* mgr)

{

  //

  // Creates a pair of MFT Rails located inside the Cage (from drawings

  // ALI-MFT-DF-0057 and elements therein)

  // A box containing a pair of rails is returned (a physical box

  // is preferred over an Assembly for better performance)

  //

  // Input:

  //         motmed : the medium of the mother volume (for the container box)

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         A rail pair as a TGeoVolume

  //

  // Created:      10 May 2025  Mario Sitta

  //


  // Local variables

  const Int_t nv = 16;

  Double_t xv[nv], yv[nv];

  Double_t deltah, xlen, ylen, zlen;

  Double_t xpos, ypos;


  // The shape of a single rail: a Xtru

  xv[0] = sCageMFTRailBaseWidth / 2;

  yv[0] = 0.;

  xv[1] = xv[0];

  yv[1] = sCageMFTRailTotHeight - sCageMFTRailExtHeight;

  xv[2] = sCageMFTRailTotWidth / 2;

  yv[2] = yv[1];

  xv[3] = xv[2];

  yv[3] = sCageMFTRailTotHeight;

  xv[4] = sCageMFTRailIntWidth / 2;

  yv[4] = yv[3];

  deltah = (sCageMFTRailExtHeight - sCageMFTRailIntHeight) / 2;

  xv[5] = xv[4];

  yv[5] = yv[4] - deltah;

  xv[6] = sCageMFTRailExtWidth / 2;

  yv[6] = yv[5];

  xv[7] = xv[6];

  yv[7] = yv[6] - sCageMFTRailIntHeight;


  for (Int_t i = 8; i < nv; i++) {

    xv[i] = -xv[15 - i];

    yv[i] = yv[15 - i];

  }


  zlen = sCageMFTRailZLen / 2;


  TGeoXtru* mftRailSh = new TGeoXtru(2);

  mftRailSh->SetName("mftrailshape");

  mftRailSh->DefinePolygon(nv, xv, yv);

  mftRailSh->DefineSection(0, -zlen);

  mftRailSh->DefineSection(1, zlen);


  // The air container: a BBox

  xlen = 2 * sCageMFTRailTotWidth + sCageMFTRailsXDist;

  ylen = sCageMFTRailTotHeight / 2;

  zlen = sCageMFTRailZLen / 2;

  TGeoBBox* mftRailBoxSh = new TGeoBBox(xlen / 2, ylen, zlen);


  // We have the shape: now create the real volume

  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));


  TGeoVolume* mftRailVol = new TGeoVolume("MFTRailInsideCage", mftRailSh, medAl);

  mftRailVol->SetFillColor(kGray);

  mftRailVol->SetLineColor(kGray);


  TGeoVolume* mftRailBoxVol = new TGeoVolume("MFTRailPairInsideCage", mftRailBoxSh, motmed);


  // Put the two rails inside the holding box

  // (rail Y origin is on its lower face)

  xpos = mftRailBoxSh->GetDX() - 0.5 * sCageMFTRailTotWidth;

  ypos = mftRailBoxSh->GetDY();

  mftRailBoxVol->AddNode(mftRailVol, 1, new TGeoTranslation(xpos, -ypos, 0));

  mftRailBoxVol->AddNode(mftRailVol, 2, new TGeoTranslation(-xpos, -ypos, 0));


  // Finally return the rails volume

  return mftRailBoxVol;

}


TGeoVolume* V3Cage::createMFTRailsHinge(const TGeoManager* mgr)

{

  //

  // Creates a hinge holding a pair of MFT Rails to the Cage (from drawing

  // ALIMFT-0042 and elements inside CAD files)

  //

  // Input:

  //         mgr : the GeoManager (used only to get the proper material)

  //

  // Output:

  //

  // Return:

  //         A rail hinge as a TGeoVolume

  //

  // Created:      19 May 2025  Mario Sitta

  //


  // Local variables

  const Int_t nv = 6;

  Double_t xv[nv], yv[nv];

  Double_t xlen, ylen, zlen;

  Double_t xpos, ypos, zpos;


  TString compoShape;


  // The main body: a Xtru

  xv[0] = sCageMFTHingeTotWid / 2;

  yv[0] = 0;

  xv[1] = xv[0];

  yv[1] = sCageMFTHingeIntHei;

  xv[2] = sCageMFTHingeIntWid / 2;

  yv[2] = sCageMFTHingeHeight;


  for (Int_t i = 3; i < nv; i++) {

    xv[i] = -xv[5 - i];

    yv[i] = yv[5 - i];

  }


  zlen = sCageMFTHingeIntLen / 2;


  TGeoXtru* mftHingeBodySh = new TGeoXtru(2);

  mftHingeBodySh->SetName("mfthingebodyshape");

  mftHingeBodySh->DefinePolygon(nv, xv, yv);

  mftHingeBodySh->DefineSection(0, -zlen);

  mftHingeBodySh->DefineSection(1, zlen);


  // The bulge: a BBox

  xlen = sCageMFTHingeBulgeWid / 2;

  ylen = sCageMFTHingeBulgeHei / 2;

  zlen = (sCageMFTHingeTotLen - sCageMFTHingeIntLen) / 2;

  TGeoBBox* mftHingeBulgeSh = new TGeoBBox("mfthingebulgeshape", xlen, ylen, zlen);


  // The actual hinge: a CompositeShape

  xpos = mftHingeBodySh->GetX(0) - (sCageMFTHingeBulgePos + mftHingeBulgeSh->GetDX());

  ypos = mftHingeBodySh->GetY(2) - mftHingeBulgeSh->GetDY();

  zpos = mftHingeBodySh->GetZ(1) + mftHingeBulgeSh->GetDZ();


  TGeoTranslation* bulgpos1 = new TGeoTranslation(xpos, ypos, zpos);

  bulgpos1->SetName("bulge1pos");

  bulgpos1->RegisterYourself();


  TGeoTranslation* bulgpos2 = new TGeoTranslation(-xpos, ypos, zpos);

  bulgpos2->SetName("bulge2pos");

  bulgpos2->RegisterYourself();


  compoShape = Form("mfthingebodyshape+mfthingebulgeshape:bulge1pos+mfthingebulgeshape:bulge2pos");


  TGeoCompositeShape* mftRailHingeSh = new TGeoCompositeShape(compoShape);


  // We have the shape: now create the real volume

  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));


  TGeoVolume* mftRailHingeVol = new TGeoVolume("MFTRailHingeInsideCage", mftRailHingeSh, medAl);

  mftRailHingeVol->SetFillColor(kGreen);

  mftRailHingeVol->SetLineColor(kGreen);


  // Finally return the hinge volume

  return mftRailHingeVol;

}

i
int32_t i
Definition GPUCommonAlgorithm.h:436

Color_t
int16_t Color_t
Definition GPUQA.h:32

leg
uint8_t leg
Definition GPUTPCGMMerger.cxx:1470

GeometryTGeo.h
Definition of the GeometryTGeo class.

j
uint32_t j
Definition RawData.h:0

V11Geometry.h
Definition of the V11Geometry class.

ClassImp
ClassImp(V3Cage)

V3Cage.h
Definition of the V3Cage class.

o2::its::V11Geometry
Definition V11Geometry.h:41

o2::its::V11Geometry::GetDetName
const char * GetDetName() const
Get detector name.
Definition V11Geometry.h:58

o2::its::V3Cage
This class defines the Geometry for the Cage of the ITS Upgrade using TGeo.
Definition V3Cage.h:38

o2::its::V3Cage::~V3Cage
~V3Cage() override
Default destructor.

o2::its::V3Cage::createAndPlaceCage
void createAndPlaceCage(TGeoVolume *mother, const TGeoManager *mgr=gGeoManager)
Definition V3Cage.cxx:206

o2::its::V3Cage::V3Cage
V3Cage()
Definition V3Cage.cxx:194

alpha
GLfloat GLfloat GLfloat alpha
Definition glcorearb.h:279

index
GLuint index
Definition glcorearb.h:781

name
GLuint const GLchar * name
Definition glcorearb.h:781

o2::its
Definition RecoContainer.h:64

o2::math_utils::detail::phi
T phi
Definition trigonometric.h:221