RICHRing.cxx

Go to the documentation of this file.

// 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 "RICHSimulation/RICHRing.h"
#include "RICHBase/GeometryTGeo.h"
#include "RICHBase/RICHBaseParam.h"
#include "Framework/Logger.h"
 
#include <TGeoManager.h>
#include <TGeoTube.h>
#include <TGeoVolume.h>
#include <TGeoArb8.h>
 
namespace o2
{
namespace rich
{
 
Ring::Ring(int rPosId,
           int nTilesPhi,
           float rMin,
           float rMax,
           float radThick,
           float radYmin,
           float radYmax,
           float radZ,
           float photThick,
           float photYmin,
           float photYmax,
           float photZ,
           float radRad0,
           float photR0,
           float aerDetDistance,
           float thetaB,
           const std::string motherName)
  : mNTiles{nTilesPhi}, mPosId{rPosId}, mRadThickness{radThick}
{
  TGeoManager* geoManager = gGeoManager;
  TGeoVolume* motherVolume = geoManager->GetVolume(motherName.c_str());
  TGeoMedium* medAerogel = gGeoManager->GetMedium("RCH_AEROGEL$");
  if (!medAerogel) {
    LOGP(fatal, "RICH: Aerogel medium not found");
  }
  TGeoMedium* medSi = gGeoManager->GetMedium("RCH_SILICON$");
  if (!medSi) {
    LOGP(fatal, "RICH: Silicon medium not found");
  }
  TGeoMedium* medAr = gGeoManager->GetMedium("RCH_ARGON$");
  if (!medAr) {
    LOGP(fatal, "RICH: Argon medium not found");
  }
  std::vector<TGeoArb8*> radiatorTiles(nTilesPhi), photoTiles(nTilesPhi), argonSectors(nTilesPhi);
  LOGP(info, "Creating ring: id: {} with {} tiles. ", rPosId, nTilesPhi);
  LOGP(info, "Rmin: {} Rmax: {} RadThick: {} RadYmin: {} RadYmax: {} RadZ: {} PhotThick: {} PhotYmin: {} PhotYmax: {} PhotZ: {}, zTransRad: {}, zTransPhot: {}, ThetaB: {}",
       rMin, rMax, radThick, radYmin, radYmax, radZ, photThick, photYmin, photYmax, photZ, radRad0, photR0, thetaB);
 
  float deltaPhiDeg = 360.0 / nTilesPhi; // Transformation are constructed in degrees...
  float thetaBDeg = thetaB * 180.0 / TMath::Pi();
  int radTileCount{0}, photTileCount{0}, argSectorsCount{0};
  // Radiator tiles
  for (auto& radiatorTile : radiatorTiles) {
    // Local Z is the thin (radial) dimension, looking outward from the IP
    // (previously this was local X, while for running with ACTS we need local Z).
    // The placement rotation below is adjusted by +90 deg about Y
    // to keep the tile in the same physical position.
    radiatorTile = new TGeoArb8(radThick / 2);
    radiatorTile->SetVertex(0, radZ / 2, -radYmin / 2);
    radiatorTile->SetVertex(1, -radZ / 2, -radYmax / 2);
    radiatorTile->SetVertex(2, -radZ / 2, radYmax / 2);
    radiatorTile->SetVertex(3, radZ / 2, radYmin / 2);
    radiatorTile->SetVertex(4, radZ / 2, -radYmin / 2);
    radiatorTile->SetVertex(5, -radZ / 2, -radYmax / 2);
    radiatorTile->SetVertex(6, -radZ / 2, radYmax / 2);
    radiatorTile->SetVertex(7, radZ / 2, radYmin / 2);
 
    TGeoVolume* radiatorTileVol = new TGeoVolume(Form("radTile_%d_%d", rPosId, radTileCount), radiatorTile, medAerogel);
    radiatorTileVol->SetLineColor(kOrange - 8);
    radiatorTileVol->SetLineWidth(1);
 
    auto* rotRadiator = new TGeoRotation(Form("radTileRotation_%d_%d", radTileCount, rPosId));
    rotRadiator->RotateY(90.0 - thetaBDeg); // +90 compensates the X->Z swap of the tile's local axes
    rotRadiator->RotateZ(radTileCount * deltaPhiDeg);
 
    auto* rotTransRadiator = new TGeoCombiTrans(radRad0 * TMath::Cos(radTileCount * TMath::Pi() / (nTilesPhi / 2)),
                                                radRad0 * TMath::Sin(radTileCount * TMath::Pi() / (nTilesPhi / 2)),
                                                radRad0 * TMath::Tan(thetaB),
                                                rotRadiator);
 
    motherVolume->AddNode(radiatorTileVol, 1, rotTransRadiator);
    radTileCount++;
  }
 
  // Photosensor tiles
  for (auto& photoTile : photoTiles) {
    // Local Z is the thin (radial) dimension, looking outward from the IP
    photoTile = new TGeoArb8(photThick / 2);
    photoTile->SetVertex(0, photZ / 2, -photYmin / 2);
    photoTile->SetVertex(1, -photZ / 2, -photYmax / 2);
    photoTile->SetVertex(2, -photZ / 2, photYmax / 2);
    photoTile->SetVertex(3, photZ / 2, photYmin / 2);
    photoTile->SetVertex(4, photZ / 2, -photYmin / 2);
    photoTile->SetVertex(5, -photZ / 2, -photYmax / 2);
    photoTile->SetVertex(6, -photZ / 2, photYmax / 2);
    photoTile->SetVertex(7, photZ / 2, photYmin / 2);
 
    TGeoVolume* photoTileVol = new TGeoVolume(Form("%s_%d_%d", GeometryTGeo::getRICHSensorPattern(), rPosId, photTileCount), photoTile, medSi);
    photoTileVol->SetLineColor(kOrange - 8);
    photoTileVol->SetLineWidth(1);
 
    auto* rotPhoto = new TGeoRotation(Form("photoTileRotation_%d_%d", photTileCount, rPosId));
    rotPhoto->RotateY(90.0 - thetaBDeg); // +90 compensates the X->Z swap of the tile's local axes
    rotPhoto->RotateZ(photTileCount * deltaPhiDeg);
    auto* rotTransPhoto = new TGeoCombiTrans(photR0 * TMath::Cos(photTileCount * TMath::Pi() / (nTilesPhi / 2)),
                                             photR0 * TMath::Sin(photTileCount * TMath::Pi() / (nTilesPhi / 2)),
                                             photR0 * TMath::Tan(thetaB),
                                             rotPhoto);
 
    motherVolume->AddNode(photoTileVol, 1, rotTransPhoto);
    photTileCount++;
  }
 
  // Argon sectors "connect" radiator and photosensor tiles, they are not really physical
  for (auto& argonSector : argonSectors) {
    float separation{(aerDetDistance - radThick - photThick)};
    auto* radiator = radiatorTiles[argSectorsCount];
    auto* photosensor = photoTiles[argSectorsCount];
    argonSector = new TGeoArb8(separation / 2);
 
    argonSector->SetVertex(0, -photZ / 2, -photYmin / 2);
    argonSector->SetVertex(1, -photZ / 2, photYmin / 2);
    argonSector->SetVertex(2, photZ / 2, photYmax / 2);
    argonSector->SetVertex(3, photZ / 2, -photYmax / 2);
    argonSector->SetVertex(4, -radZ / 2, -radYmin / 2);
    argonSector->SetVertex(5, -radZ / 2, radYmin / 2);
    argonSector->SetVertex(6, radZ / 2, radYmax / 2);
    argonSector->SetVertex(7, radZ / 2, -radYmax / 2);
 
    TGeoVolume* argonSectorVol = new TGeoVolume(Form("argonSector_%d_%d", rPosId, argSectorsCount), argonSector, medAr);
    argonSectorVol->SetVisibility(kTRUE);
    argonSectorVol->SetLineColor(kOrange - 8);
    argonSectorVol->SetLineWidth(1);
    auto* rotArgon = new TGeoRotation(Form("argonSectorRotation_%d_%d", argSectorsCount, rPosId));
    rotArgon->RotateY(-90 - thetaBDeg);
    rotArgon->RotateZ(argSectorsCount * deltaPhiDeg);
    auto* rotTransArgon = new TGeoCombiTrans((radRad0 + TMath::Cos(thetaB) * (separation + radThick) / 2) * TMath::Cos(argSectorsCount * TMath::Pi() / (nTilesPhi / 2)),
                                             (radRad0 + TMath::Cos(thetaB) * (separation + radThick) / 2) * TMath::Sin(argSectorsCount * TMath::Pi() / (nTilesPhi / 2)),
                                             radRad0 * TMath::Tan(thetaB) + TMath::Sin(thetaB) * (separation + radThick) / 2,
                                             rotArgon);
    motherVolume->AddNode(argonSectorVol, 1, rotTransArgon);
    argSectorsCount++;
  }
}
 
FWDRich::FWDRich(std::string name,
                 float rMin,
                 float rMax,
                 float zAerogelMin,
                 float dZAerogel,
                 float zArgonMin,
                 float dZArgon,
                 float zSiliconMin,
                 float dZSilicon) : mName{name},
                                    mRmin{rMin},
                                    mRmax{rMax},
                                    mZAerogelMin{zAerogelMin},
                                    mDZAerogel{dZAerogel},
                                    mZArgonMin{zArgonMin},
                                    mDZArgon{dZArgon},
                                    mZSiliconMin{zSiliconMin},
                                    mDZSilicon{dZSilicon}
{
}
 
BWDRich::BWDRich(std::string name,
                 float rMin,
                 float rMax,
                 float zAerogelMin,
                 float dZAerogel,
                 float zArgonMin,
                 float dZArgon,
                 float zSiliconMin,
                 float dZSilicon) : mName{name},
                                    mRmin{rMin},
                                    mRmax{rMax},
                                    mZAerogelMin{zAerogelMin},
                                    mDZAerogel{dZAerogel},
                                    mZArgonMin{zArgonMin},
                                    mDZArgon{dZArgon},
                                    mZSiliconMin{zSiliconMin},
                                    mDZSilicon{dZSilicon}
{
}
 
void FWDRich::createFWDRich(TGeoVolume* motherVolume)
{
  TGeoMedium* medAerogel = gGeoManager->GetMedium("RCH_AEROGEL$");
  if (!medAerogel) {
    LOGP(fatal, "RICH: Aerogel medium not found");
  }
  TGeoMedium* medSi = gGeoManager->GetMedium("RCH_SILICON$");
  if (!medSi) {
    LOGP(fatal, "RICH: Silicon medium not found");
  }
  TGeoMedium* medAr = gGeoManager->GetMedium("RCH_ARGON$");
  if (!medAr) {
    LOGP(fatal, "RICH: Argon medium not found");
  }
 
  // Create the aerogel volume
  TGeoTube* aerogel = new TGeoTube(mRmin, mRmax, mDZAerogel / 2);
  TGeoVolume* aerogelVol = new TGeoVolume(mName.c_str(), aerogel, medAerogel);
  aerogelVol->SetLineColor(kOrange - 8);
 
  TGeoTranslation* transAerogel = new TGeoTranslation(0, 0, mZAerogelMin + mDZAerogel / 2);
  motherVolume->AddNode(aerogelVol, 1, transAerogel);
 
  // Create the argon volume
  TGeoTube* argon = new TGeoTube(mRmin, mRmax, mDZArgon / 2);
  TGeoVolume* argonVol = new TGeoVolume(mName.c_str(), argon, medAr);
  argonVol->SetLineColor(kOrange - 9);
 
  TGeoTranslation* transArgon = new TGeoTranslation(0, 0, mZArgonMin + mDZArgon / 2);
  motherVolume->AddNode(argonVol, 1, transArgon);
 
  // Create the silicon volume
  TGeoTube* silicon = new TGeoTube(mRmin, mRmax, mDZSilicon / 2);
  TGeoVolume* siliconVol = new TGeoVolume(mName.c_str(), silicon, medSi);
  siliconVol->SetLineColor(kOrange - 8);
 
  TGeoTranslation* transSilicon = new TGeoTranslation(0, 0, mZSiliconMin + mDZSilicon / 2);
  motherVolume->AddNode(siliconVol, 1, transSilicon);
}
 
void BWDRich::createBWDRich(TGeoVolume* motherVolume)
{
  TGeoMedium* medAerogel = gGeoManager->GetMedium("RCH_AEROGEL$");
  if (!medAerogel) {
    LOGP(fatal, "RICH: Aerogel medium not found");
  }
  TGeoMedium* medSi = gGeoManager->GetMedium("RCH_SILICON$");
  if (!medSi) {
    LOGP(fatal, "RICH: Silicon medium not found");
  }
  TGeoMedium* medAr = gGeoManager->GetMedium("RCH_ARGON$");
  if (!medAr) {
    LOGP(fatal, "RICH: Argon medium not found");
  }
 
  // Create the aerogel volume
  TGeoTube* aerogel = new TGeoTube(mRmin, mRmax, mDZAerogel / 2);
  TGeoVolume* aerogelVol = new TGeoVolume(mName.c_str(), aerogel, medAerogel);
  aerogelVol->SetLineColor(kOrange - 8);
 
  TGeoTranslation* transAerogel = new TGeoTranslation(0, 0, -mZAerogelMin - mDZAerogel / 2);
  motherVolume->AddNode(aerogelVol, 1, transAerogel);
 
  // Create the argon volume
  TGeoTube* argon = new TGeoTube(mRmin, mRmax, mDZArgon / 2);
  TGeoVolume* argonVol = new TGeoVolume(mName.c_str(), argon, medAr);
  argonVol->SetLineColor(kOrange - 8);
 
  TGeoTranslation* transArgon = new TGeoTranslation(0, 0, -mZArgonMin - mDZArgon / 2);
  motherVolume->AddNode(argonVol, 1, transArgon);
 
  // Create the silicon volume
  TGeoTube* silicon = new TGeoTube(mRmin, mRmax, mDZSilicon / 2);
  TGeoVolume* siliconVol = new TGeoVolume(mName.c_str(), silicon, medSi);
  siliconVol->SetLineColor(kOrange - 8);
 
  TGeoTranslation* transSilicon = new TGeoTranslation(0, 0, -mZSiliconMin - mDZSilicon / 2);
  motherVolume->AddNode(siliconVol, 1, transSilicon);
}
 
} // namespace rich
} // namespace o2