From e5e748262b4b9b31dfe8f6b9b79827dab74ab669 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= Date: Thu, 5 Mar 2026 09:27:41 +0100 Subject: [PATCH] [ALICE3] Update FT3 geometry - simplify geometry building - unify indices, variables --- .../FT3/base/include/FT3Base/FT3BaseParam.h | 3 - .../FT3/base/include/FT3Base/GeometryTGeo.h | 3 - .../include/FT3Simulation/Detector.h | 45 +- .../include/FT3Simulation/FT3Layer.h | 20 +- .../ALICE3/FT3/simulation/src/Detector.cxx | 452 ++++++------------ .../ALICE3/FT3/simulation/src/FT3Layer.cxx | 65 ++- .../ALICE3/FT3/simulation/src/FT3Module.cxx | 2 +- 7 files changed, 221 insertions(+), 369 deletions(-) diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h index b286aa068611c..7160067f075f7 100644 --- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h +++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h @@ -42,9 +42,6 @@ struct FT3BaseParam : public o2::conf::ConfigurableParamHelper { Float_t etaOut = 1.5; Float_t Layerx2X0 = 0.01; - // FT3Geometry::External file - std::string configFile = ""; // Overrides geoModel parameter when provided - O2ParamDef(FT3BaseParam, "FT3Base"); }; diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h index bb22af7ad7f9d..3c78850dffb55 100644 --- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h +++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h @@ -101,9 +101,6 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo static const char* composeSymNameSensor(Int_t d, Int_t lr); protected: - static constexpr int MAXLAYERS = 15; ///< max number of active layers - - Int_t mNumberOfLayers; ///< number of layers static std::string sInnerVolumeName; ///< Mother inner volume name static std::string sVolumeName; ///< Mother volume name static std::string sLayerName; ///< Layer name diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h index a68f8cf7788b6..8bc4b7f634d7c 100644 --- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h +++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h @@ -25,7 +25,6 @@ #include "TGeoManager.h" // for gGeoManager, TGeoManager (ptr only) #include "TLorentzVector.h" // for TLorentzVector #include "TVector3.h" // for TVector3 -#include "FT3Base/FT3BaseParam.h" class FairVolume; class TGeoVolume; @@ -34,25 +33,10 @@ class TParticle; class TString; -namespace o2 -{ -namespace ft3 +namespace o2::ft3 { class GeometryTGeo; -} -} // namespace o2 -namespace o2 -{ -namespace ft3 -{ -class FT3Layer; -} -} // namespace o2 - -namespace o2 -{ -namespace ft3 -{ +class FT3BaseParam; class FT3Layer; class Detector : public o2::base::DetImpl @@ -108,8 +92,16 @@ class Detector : public o2::base::DetImpl void PostTrack() override { ; } void PreTrack() override { ; } + static constexpr int IdxForwardDisks = 0; + static constexpr int IdxBackwardDisks = 1; /// Returns the number of layers - Int_t getNumberOfLayers() const { return mNumberOfLayers; } + size_t getNumberOfLayers() const + { + if (mLayerName[IdxBackwardDisks].size() != mLayerName[IdxForwardDisks].size()) { + LOG(fatal) << "Number of layers in the two directions are different! Returning 0."; + } + return mLayerName[IdxBackwardDisks].size(); + } void buildBasicFT3(const FT3BaseParam& param); void buildFT3V1(); @@ -117,16 +109,10 @@ class Detector : public o2::base::DetImpl void buildFT3Scoping(); void buildFT3NewVacuumVessel(); void buildFT3ScopingV3(); - void buildFT3FromFile(std::string); - - GeometryTGeo* mGeometryTGeo; //! access to geometry details - - void exportLayout(); protected: std::vector mLayerID; - std::vector> mLayerName; - Int_t mNumberOfLayers; + std::array, 2> mLayerName; // Two sets of layer names, one per direction (forward/backward) private: /// this is transient data about track passing the sensor @@ -154,16 +140,15 @@ class Detector : public o2::base::DetImpl Detector& operator=(const Detector&); - std::vector> mLayers; - bool mIsPipeActivated = true; //! If Alice 3 pipe is present append inner disks to vacuum volume to avoid overlaps + std::array, 2> mLayers; // Two sets of layers, one per direction (forward/backward) + bool mIsPipeActivated = true; //! If Alice 3 pipe is present append inner disks to vacuum volume to avoid overlaps template friend class o2::base::DetImpl; ClassDefOverride(Detector, 1); }; -} // namespace ft3 -} // namespace o2 +} // namespace o2::ft3 #ifdef USESHM namespace o2 diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h index 44a0ef0f7d8bc..44fd8eb08e444 100644 --- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h +++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h @@ -36,7 +36,7 @@ class FT3Layer : public TObject FT3Layer() = default; // Sample layer constructor - FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0); + FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0, bool partOfMiddleLayers); /// Copy constructor FT3Layer(const FT3Layer&) = default; @@ -51,6 +51,7 @@ class FT3Layer : public TObject auto getInnerRadius() const { return mInnerRadius; } auto getOuterRadius() const { return mOuterRadius; } auto getDirection() const { return mDirection; } + bool getIsInMiddleLayer() const { return mIsMiddleLayer; } auto getZ() const { return mZ; } auto getx2X0() const { return mx2X0; } @@ -77,14 +78,15 @@ class FT3Layer : public TObject static TGeoMedium* medFoam; private: - Int_t mLayerNumber = -1; ///< Current layer number - Int_t mDirection; ///< Layer direction 0=Forward 1 = Backward - std::string mLayerName; ///< Current layer name - Double_t mInnerRadius; ///< Inner radius of this layer - Double_t mOuterRadius; ///< Outer radius of this layer - Double_t mZ; ///< Z position of the layer - Double_t mChipThickness; ///< Chip thickness - Double_t mx2X0; ///< Layer material budget x/X0 + Int_t mLayerNumber = -1; ///< Current layer number + Int_t mDirection; ///< Layer direction 0=Forward 1 = Backward + bool mIsMiddleLayer = true; ///< Wether this layer is part of the middle layers + std::string mLayerName; ///< Current layer name + Double_t mInnerRadius; ///< Inner radius of this layer + Double_t mOuterRadius; ///< Outer radius of this layer + Double_t mZ; ///< Z position of the layer + Double_t mChipThickness; ///< Chip thickness + Double_t mx2X0; ///< Layer material budget x/X0 ClassDefOverride(FT3Layer, 0); // ALICE 3 EndCaps geometry }; diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx index 4b139272834f1..0a93a4061ae44 100644 --- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx +++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx @@ -59,97 +59,6 @@ Detector::Detector() { } -//_________________________________________________________________________________________________ -void Detector::buildFT3FromFile(std::string configFileName) -{ - // Geometry description from file. One line per disk - // z_layer r_in r_out Layerx2X0 - // This simple file reader is not failproof. Do not add empty lines! - - /* - # Sample FT3 configuration - # z_layer r_in r_out Layerx2X0 - -45.3 2.5 9.26 0.0042 - -46.7 2.5 9.26 0.0042 - -48.6 2.5 9.8 0.0042 - -50.0 2.5 9.8 0.0042 - -52.4 2.5 10.43 0.0042 - -53.8 2.5 10.43 0.0042 - -67.7 3.82 13.01 0.0042 - -69.1 3.82 13.01 0.0042 - -76.1 3.92 14.35 0.0042 - -77.5 3.92 14.35 0.0042 - */ - - mLayerName.clear(); - mLayers.clear(); - mLayerID.clear(); - mLayerName.resize(1); - mLayers.resize(1); - - LOG(info) << "Building FT3 Detector: From file"; - LOG(info) << " FT3 detector configuration: " << configFileName; - std::ifstream ifs(configFileName.c_str()); - if (!ifs.good()) { - LOG(fatal) << " Invalid FT3Base.configFile!"; - } - std::string tempstr; - float z_layer, r_in, r_out, Layerx2X0; - char delimiter; - int layerNumber = 0; - while (std::getline(ifs, tempstr)) { - if (tempstr[0] == '#') { - LOG(info) << " Comment: " << tempstr; - continue; - } - std::istringstream iss(tempstr); - iss >> z_layer; - iss >> r_in; - iss >> r_out; - iss >> Layerx2X0; - - int direction = 1; // Forwards - if (z_layer < 0) { - // Backwards - direction = 0; - } - - std::string directionName = std::to_string(direction); - std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); - mLayerName[0].push_back(layerName); - LOG(info) << "Adding Layer " << layerName << " at z = " << z_layer << " ; direction = " << direction << " ; r_in = " << r_in << " ; r_out = " << r_out << " x/X0 = " << Layerx2X0; - auto& thisLayer = mLayers[0].emplace_back(direction, layerNumber, layerName, z_layer, r_in, r_out, Layerx2X0); - layerNumber++; - } - - mNumberOfLayers = layerNumber; - LOG(info) << " Loaded FT3 Detector with " << mNumberOfLayers << " layers"; -} - -//_________________________________________________________________________________________________ -void Detector::exportLayout() -{ - // Export FT3 Layout description to file. - // One line per disk: - // z_layer r_in r_out Layerx2X0 - - std::string configFileName = "FT3_layout.cfg"; - - LOG(info) << "Exporting FT3 Detector layout to " << configFileName; - - std::ofstream fOut(configFileName.c_str(), std::ios::out); - if (!fOut) { - printf("Cannot open file\n"); - return; - } - fOut << "# z_layer r_in r_out Layerx2X0" << std::endl; - for (auto layers_dir : mLayers) { - for (auto layer : layers_dir) { - fOut << layer.getZ() << " " << layer.getInnerRadius() << " " << layer.getOuterRadius() << " " << layer.getx2X0() << std::endl; - } - } -} - //_________________________________________________________________________________________________ void Detector::buildBasicFT3(const FT3BaseParam& param) { @@ -158,28 +67,27 @@ void Detector::buildBasicFT3(const FT3BaseParam& param) LOG(info) << "Building FT3 Detector: Conical Telescope"; - auto z_first = param.z0; - auto z_length = param.zLength; - auto etaIn = param.etaIn; - auto etaOut = param.etaOut; - auto Layerx2X0 = param.Layerx2X0; - mNumberOfLayers = param.nLayers; - mLayerName.resize(2); - mLayerName[0].resize(mNumberOfLayers); - mLayerName[1].resize(mNumberOfLayers); + const int numberOfLayers = param.nLayers; + const auto z_first = param.z0; + const auto z_length = param.zLength; + const auto etaIn = param.etaIn; + const auto etaOut = param.etaOut; + const auto Layerx2X0 = param.Layerx2X0; + mLayerName[IdxBackwardDisks].resize(numberOfLayers); + mLayerName[IdxForwardDisks].resize(numberOfLayers); mLayerID.clear(); - mLayers.resize(2); - for (int direction : {0, 1}) { - for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) { - std::string layerName = GeometryTGeo::getFT3LayerPattern() + std::to_string(layerNumber + mNumberOfLayers * direction); + for (int direction : {IdxBackwardDisks, IdxForwardDisks}) { + for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) { + std::string layerName = GeometryTGeo::getFT3LayerPattern() + std::to_string(layerNumber + numberOfLayers * direction); mLayerName[direction][layerNumber] = layerName; // Adds evenly spaced layers - float layerZ = z_first + (layerNumber * z_length / (mNumberOfLayers - 1)) * std::copysign(1, z_first); - float rIn = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaIn)))); - float rOut = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaOut)))); - auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, layerZ, rIn, rOut, Layerx2X0); + const float layerZ = z_first + (layerNumber * z_length / numberOfLayers) * std::copysign(1, z_first); + const float rIn = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaIn)))); + const float rOut = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaOut)))); + const bool isMiddleLayer = layerNumber < 3; + auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, layerZ, rIn, rOut, Layerx2X0, isMiddleLayer); } } } @@ -192,10 +100,10 @@ void Detector::buildFT3V1() LOG(info) << "Building FT3 Detector: V1"; - mNumberOfLayers = 10; - float sensorThickness = 30.e-4; - float layersx2X0 = 1.e-2; - std::vector> layersConfig{ + const int numberOfLayers = 10; + const float sensorThickness = 30.e-4; + const float layersx2X0 = 1.e-2; + const std::vector> layersConfig{ {26., .5, 3., 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} {30., .5, 3., 0.1f * layersx2X0}, {34., .5, 3., 0.1f * layersx2X0}, @@ -207,14 +115,12 @@ void Detector::buildFT3V1() {220., 3.5, 80.f, layersx2X0}, {279., 3.5, 80.f, layersx2X0}}; - mLayerName.resize(2); - mLayerName[0].resize(mNumberOfLayers); - mLayerName[1].resize(mNumberOfLayers); + mLayerName[IdxBackwardDisks].resize(numberOfLayers); + mLayerName[IdxForwardDisks].resize(numberOfLayers); mLayerID.clear(); - mLayers.resize(2); - for (auto direction : {0, 1}) { - for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) { + for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) { + for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) { std::string directionName = std::to_string(direction); std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); mLayerName[direction][layerNumber] = layerName; @@ -226,7 +132,8 @@ void Detector::buildFT3V1() LOG(info) << "Adding Layer " << layerName << " at z = " << z; // Add layers - auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0); + const bool isMiddleLayer = layerNumber < 3; + auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer); } } } @@ -239,10 +146,10 @@ void Detector::buildFT3V3b() LOG(info) << "Building FT3 Detector: V3b"; - mNumberOfLayers = 12; + const int numberOfLayers = 12; float sensorThickness = 30.e-4; float layersx2X0 = 1.e-2; - std::vector> layersConfig{ + std::vector> layersConfig{ {26., .5, 3., 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} {30., .5, 3., 0.1f * layersx2X0}, {34., .5, 3., 0.1f * layersx2X0}, @@ -256,14 +163,12 @@ void Detector::buildFT3V3b() {340., 12.5, 80.f, layersx2X0}, {400., 14.7, 80.f, layersx2X0}}; - mLayerName.resize(2); - mLayerName[0].resize(mNumberOfLayers); - mLayerName[1].resize(mNumberOfLayers); + mLayerName[IdxBackwardDisks].resize(numberOfLayers); + mLayerName[IdxForwardDisks].resize(numberOfLayers); mLayerID.clear(); - mLayers.resize(2); - for (auto direction : {0, 1}) { - for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) { + for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) { + for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) { std::string directionName = std::to_string(direction); std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); mLayerName[direction][layerNumber] = layerName; @@ -275,7 +180,8 @@ void Detector::buildFT3V3b() LOG(info) << "Adding Layer " << layerName << " at z = " << z; // Add layers - auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0); + const bool isMiddleLayer = layerNumber < 3; + auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer); } } } @@ -291,10 +197,10 @@ void Detector::buildFT3NewVacuumVessel() LOG(info) << "Building FT3 Detector: After Upgrade Days March 2024 version"; - mNumberOfLayers = 9; - float sensorThickness = 30.e-4; - float layersx2X0 = 1.e-2; - std::vector> layersConfigCSide{ + const int numberOfLayers = 9; + const float sensorThickness = 30.e-4; + const float layersx2X0 = 1.e-2; + const std::vector> layersConfigCSide{ {77., 7.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} {100., 7.0, 35., layersx2X0}, {122., 7.0, 35., layersx2X0}, @@ -305,7 +211,7 @@ void Detector::buildFT3NewVacuumVessel() {300., 7.0, 68.f, layersx2X0}, {350., 7.0, 68.f, layersx2X0}}; - std::vector> layersConfigASide{ + const std::vector> layersConfigASide{ {77., 5.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} {100., 5.0, 35., layersx2X0}, {122., 5.0, 35., layersx2X0}, @@ -316,14 +222,12 @@ void Detector::buildFT3NewVacuumVessel() {300., 5.0, 68.f, layersx2X0}, {350., 5.0, 68.f, layersx2X0}}; - mLayerName.resize(2); - mLayerName[0].resize(mNumberOfLayers); - mLayerName[1].resize(mNumberOfLayers); + mLayerName[IdxBackwardDisks].resize(numberOfLayers); + mLayerName[IdxForwardDisks].resize(numberOfLayers); mLayerID.clear(); - mLayers.resize(2); - for (auto direction : {0, 1}) { - for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) { + for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) { + for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) { std::string directionName = std::to_string(direction); std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); mLayerName[direction][layerNumber] = layerName; @@ -342,7 +246,8 @@ void Detector::buildFT3NewVacuumVessel() LOG(info) << "Adding Layer " << layerName << " at z = " << z; // Add layers - auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0); + const bool isMiddleLayer = layerNumber < 3; + auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer); } } } @@ -356,52 +261,45 @@ void Detector::buildFT3ScopingV3() LOG(info) << "Building FT3 Detector: v3 scoping version"; - mNumberOfLayers = 6; - float sensorThickness = 30.e-4; - float layersx2X0 = 1.e-2; - std::vector> layersConfigCSide{ - {77., 10.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} - {100., 10.0, 35., layersx2X0}, - {122., 10.0, 35., layersx2X0}, - {150., 20.0, 68.f, layersx2X0}, - {180., 20.0, 68.f, layersx2X0}, - {220., 20.0, 68.f, layersx2X0}}; - - std::vector> layersConfigASide{ - {77., 10.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} - {100., 10.0, 35., layersx2X0}, - {122., 10.0, 35., layersx2X0}, - {150., 20.0, 68.f, layersx2X0}, - {180., 20.0, 68.f, layersx2X0}, - {220., 20.0, 68.f, layersx2X0}}; - - mLayerName.resize(2); - mLayerName[0].resize(mNumberOfLayers); - mLayerName[1].resize(mNumberOfLayers); + const int numberOfLayers = 6; + const float sensorThickness = 30.e-4; + const float layersx2X0 = 1.e-2; + using LayerConfig = std::array; // {z_layer, r_in, r_out, Layerx2X0} + const std::array layersConfigCSide{LayerConfig{77., 10.0, 35., layersx2X0}, + LayerConfig{100., 10.0, 35., layersx2X0}, + LayerConfig{122., 10.0, 35., layersx2X0}, + LayerConfig{150., 20.0, 68.f, layersx2X0}, + LayerConfig{180., 20.0, 68.f, layersx2X0}, + LayerConfig{220., 20.0, 68.f, layersx2X0}}; + + const std::array layersConfigASide{LayerConfig{77., 10.0, 35., layersx2X0}, + LayerConfig{100., 10.0, 35., layersx2X0}, + LayerConfig{122., 10.0, 35., layersx2X0}, + LayerConfig{150., 20.0, 68.f, layersx2X0}, + LayerConfig{180., 20.0, 68.f, layersx2X0}, + LayerConfig{220., 20.0, 68.f, layersx2X0}}; + const std::array enabled{true, true, true, true, true, true}; // To enable or disable layers for debug purpose + mLayerID.clear(); - mLayers.resize(2); - for (auto direction : {0, 1}) { - for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) { - std::string directionName = std::to_string(direction); - std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); - mLayerName[direction][layerNumber] = layerName; - float z, rIn, rOut, x0; - if (direction == 0) { // C-Side - z = layersConfigCSide[layerNumber][0]; - rIn = layersConfigCSide[layerNumber][1]; - rOut = layersConfigCSide[layerNumber][2]; - x0 = layersConfigCSide[layerNumber][3]; - } else if (direction == 1) { // A-Side - z = layersConfigASide[layerNumber][0]; - rIn = layersConfigASide[layerNumber][1]; - rOut = layersConfigASide[layerNumber][2]; - x0 = layersConfigASide[layerNumber][3]; + for (int direction : {IdxBackwardDisks, IdxForwardDisks}) { + mLayerName[direction].clear(); + const std::array& layerConfig = (direction == IdxBackwardDisks) ? layersConfigCSide : layersConfigASide; + for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) { + if (!enabled[layerNumber]) { + continue; } - - LOG(info) << "Adding Layer " << layerName << " at z = " << z; + const std::string directionName = std::to_string(direction); + const std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); + mLayerName[direction].push_back(layerName.c_str()); + const float z = layerConfig[layerNumber][0]; + const float rIn = layerConfig[layerNumber][1]; + const float rOut = layerConfig[layerNumber][2]; + const float x0 = layerConfig[layerNumber][3]; + LOG(info) << "buildFT3ScopingV3 -> Adding Layer " << layerNumber << "/" << numberOfLayers << " " << layerName << " at z = " << z; // Add layers - auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0); + const bool isMiddleLayer = layerNumber < 3; + auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer); } } } @@ -413,10 +311,10 @@ void Detector::buildFT3Scoping() LOG(info) << "Building FT3 Detector: Scoping document version"; - mNumberOfLayers = 12; - float sensorThickness = 30.e-4; - float layersx2X0 = 1.e-2; - std::vector> layersConfig{ + const int numberOfLayers = 12; + const float sensorThickness = 30.e-4; + const float layersx2X0 = 1.e-2; + const std::vector> layersConfig{ {26., .5, 2.5, 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0} {30., .5, 2.5, 0.1f * layersx2X0}, {34., .5, 2.5, 0.1f * layersx2X0}, @@ -430,26 +328,24 @@ void Detector::buildFT3Scoping() {300., 5.0, 68.f, layersx2X0}, {350., 5.0, 68.f, layersx2X0}}; - mLayerName.resize(2); - mLayerName[0].resize(mNumberOfLayers); - mLayerName[1].resize(mNumberOfLayers); + mLayerName[IdxBackwardDisks].resize(numberOfLayers); + mLayerName[IdxForwardDisks].resize(numberOfLayers); mLayerID.clear(); - mLayers.resize(2); - for (auto direction : {0, 1}) { - for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) { + for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) { + for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) { std::string directionName = std::to_string(direction); std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber); mLayerName[direction][layerNumber] = layerName; auto& z = layersConfig[layerNumber][0]; - auto& rIn = layersConfig[layerNumber][1]; auto& rOut = layersConfig[layerNumber][2]; auto& x0 = layersConfig[layerNumber][3]; LOG(info) << "Adding Layer " << layerName << " at z = " << z; // Add layers - auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0); + const bool isMiddleLayer = layerNumber < 3; + auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer); } } } @@ -464,24 +360,17 @@ Detector::Detector(bool active) // FT3 Base configuration parameters auto& ft3BaseParam = FT3BaseParam::Instance(); - if (ft3BaseParam.configFile != "") { - LOG(info) << "FT3 Geometry configuration file provided. Overriding FT3Base.geoModel configuration."; - buildFT3FromFile(ft3BaseParam.configFile); - - } else { - switch (ft3BaseParam.geoModel) { - case Default: - buildFT3ScopingV3(); // v3 Dec 25 - break; - case Telescope: - buildBasicFT3(ft3BaseParam); // BasicFT3 = Parametrized telescopic detector (equidistant layers) - break; - default: - LOG(fatal) << "Invalid Geometry.\n"; - break; - } + switch (ft3BaseParam.geoModel) { + case Default: + buildFT3ScopingV3(); // v3 Dec 25 + break; + case Telescope: + buildBasicFT3(ft3BaseParam); // BasicFT3 = Parametrized telescopic detector (equidistant layers) + break; + default: + LOG(fatal) << "Invalid Geometry.\n"; + break; } - exportLayout(); } //_________________________________________________________________________________________________ @@ -494,7 +383,6 @@ Detector::Detector(const Detector& rhs) { mLayerID = rhs.mLayerID; mLayerName = rhs.mLayerName; - mNumberOfLayers = rhs.mNumberOfLayers; } //_________________________________________________________________________________________________ @@ -527,7 +415,6 @@ Detector& Detector::operator=(const Detector& rhs) mLayerID = rhs.mLayerID; mLayerName = rhs.mLayerName; - mNumberOfLayers = rhs.mNumberOfLayers; mLayers = rhs.mLayers; mTrackData = rhs.mTrackData; @@ -543,8 +430,6 @@ void Detector::InitializeO2Detector() // Define the list of sensitive volumes LOG(info) << "Initialize FT3 O2Detector"; - mGeometryTGeo = GeometryTGeo::Instance(); - defineSensitiveVolumes(); } @@ -693,12 +578,10 @@ void Detector::ConstructGeometry() void Detector::createGeometry() { - mGeometryTGeo = GeometryTGeo::Instance(); - TGeoVolume* volFT3 = new TGeoVolumeAssembly(GeometryTGeo::getFT3VolPattern()); TGeoVolume* volIFT3 = new TGeoVolumeAssembly(GeometryTGeo::getFT3InnerVolPattern()); - LOG(info) << "GeometryBuilder::buildGeometry volume name = " << GeometryTGeo::getFT3VolPattern(); + LOG(info) << "FT3: createGeometry volume name = " << GeometryTGeo::getFT3VolPattern(); TGeoVolume* vALIC = gGeoManager->GetVolume("barrel"); if (!vALIC) { @@ -710,69 +593,40 @@ void Detector::createGeometry() LOG(info) << "Running simulation with no beam pipe."; } - LOG(debug) << "FT3 createGeometry: " - << Form("gGeoManager name is %s title is %s", gGeoManager->GetName(), gGeoManager->GetTitle()); - - if (mLayers.size() == 2) { // V1 and telescope - if (!A3IPvac) { - for (int direction : {0, 1}) { // Backward layers at mLayers[0]; Forward layers at mLayers[1] - std::string directionString = direction ? "Forward" : "Backward"; - LOG(info) << "Creating FT3 " << directionString << " layers:"; - for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) { - mLayers[direction][iLayer].createLayer(volFT3); - } - } - vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.)); - } else { // If beampipe is enabled append inner disks to beampipe filling volume, this should be temporary. - for (int direction : {0, 1}) { - std::string directionString = direction ? "Forward" : "Backward"; - LOG(info) << "Creating FT3 " << directionString << " layers:"; - for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) { - if (iLayer < 3) { - mLayers[direction][iLayer].createLayer(volIFT3); - } else { - mLayers[direction][iLayer].createLayer(volFT3); - } - } - } - A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.)); - vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.)); - } - - for (auto direction : {0, 1}) { - std::string directionString = direction ? "Forward" : "Backward"; - LOG(info) << "Registering FT3 " << directionString << " LayerIDs:"; + // This will need to adapt to the new scheme + if (!A3IPvac) { + for (int direction : {IdxBackwardDisks, IdxForwardDisks}) { // Backward layers at mLayers[0]; Forward layers at mLayers[1] + const std::string directionString = direction ? "Forward" : "Backward"; + LOG(info) << " Creating FT3 without beampipe " << directionString << " layers:"; for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) { - auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer)) : 0; - mLayerID.push_back(layerID); - LOG(info) << " " << directionString << " layer " << iLayer << " LayerID " << layerID; + mLayers[direction][iLayer].createLayer(volFT3); } } - } - - if (mLayers.size() == 1) { // All layers registered at mLayers[0], used when building from file - LOG(info) << "Creating FT3 layers:"; - if (A3IPvac) { - for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) { - if (std::abs(mLayers[0][iLayer].getZ()) < 25) { - mLayers[0][iLayer].createLayer(volIFT3); + vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.)); + } else { // If beampipe is enabled append inner disks to beampipe filling volume, this should be temporary. + for (int direction : {IdxBackwardDisks, IdxForwardDisks}) { + const std::string directionString = direction ? "Forward" : "Backward"; + LOG(info) << " Creating FT3 " << directionString << " layers:"; + for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) { + LOG(info) << " Creating " << directionString << " layer " << iLayer; + if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks + mLayers[direction][iLayer].createLayer(volIFT3); } else { - mLayers[0][iLayer].createLayer(volFT3); + mLayers[direction][iLayer].createLayer(volFT3); } } - A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.)); - vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.)); - } else { - for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) { - mLayers[0][iLayer].createLayer(volFT3); - } - vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.)); } - LOG(info) << "Registering FT3 LayerIDs:"; - for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) { - auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), 0, iLayer)) : 0; + A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.)); + vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.)); + } + + for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) { + std::string directionString = direction ? "Forward" : "Backward"; + LOG(info) << " Registering FT3 " << directionString << " LayerIDs for " << mLayers[direction].size() << " layers:"; + for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) { + auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer)) : 0; mLayerID.push_back(layerID); - LOG(info) << " mLayerID[" << iLayer << "] = " << layerID; + LOG(info) << " " << directionString << " layer " << iLayer << " LayerID " << layerID; } } } @@ -786,40 +640,34 @@ void Detector::defineSensitiveVolumes() TString volumeName; LOG(info) << "Adding FT3 Sensitive Volumes"; - // The names of the FT3 sensitive volumes have the format: FT3Sensor_(0,1)_(0...sNumberLayers-1) - if (mLayers.size() == 2) { - for (int direction : {0, 1}) { - for (int iLayer = 0; iLayer < mNumberOfLayers; iLayer++) { - volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer); - if (iLayer < 3) { // ML disks - v = geoManager->GetVolume(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer)); - AddSensitiveVolume(v); - } else { // OT disks - for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) { - std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count); - std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count); - v = geoManager->GetVolume(sensor_name_front.c_str()); - if (v) { - AddSensitiveVolume(v); - } - v = geoManager->GetVolume(sensor_name_back.c_str()); - if (v) { - AddSensitiveVolume(v); - } + for (int direction : {IdxBackwardDisks, IdxForwardDisks}) { + for (int iLayer = 0; iLayer < getNumberOfLayers(); iLayer++) { + LOG(info) << "Adding FT3 Sensitive Volume for direction " << direction << " layer " << iLayer << "/" << getNumberOfLayers(); + volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer); + if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks + const std::string sensorName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer); + v = geoManager->GetVolume(sensorName.c_str()); + if (!v) { + geoManager->GetListOfVolumes()->ls(); + LOG(fatal) << "Could not find volume " << sensorName << " for direction " << direction << " layer " << iLayer; + } + AddSensitiveVolume(v); + } else { // OT disks + for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) { + std::string sensor_name_front = "FT3sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count); + std::string sensor_name_back = "FT3sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count); + v = geoManager->GetVolume(sensor_name_front.c_str()); + if (v) { + AddSensitiveVolume(v); + } + v = geoManager->GetVolume(sensor_name_back.c_str()); + if (v) { + AddSensitiveVolume(v); } } } } } - - if (mLayers.size() == 1) { - for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) { - volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer); - v = geoManager->GetVolume(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mLayers[0][iLayer].getDirection(), iLayer)); - LOG(info) << "Adding FT3 Sensitive Volume => " << v->GetName(); - AddSensitiveVolume(v); - } - } } //_________________________________________________________________________________________________ diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx index 97f42eca6143f..1ad4d1aad1eeb 100644 --- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx +++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx @@ -16,7 +16,6 @@ #include "FT3Simulation/FT3Layer.h" #include "FT3Base/GeometryTGeo.h" -#include "FT3Simulation/Detector.h" #include // for LOG @@ -55,20 +54,29 @@ TGeoMedium* FT3Layer::waterMed = nullptr; TGeoMaterial* FT3Layer::foamMat = nullptr; TGeoMedium* FT3Layer::medFoam = nullptr; -FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0) +FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0, bool partOfMiddleLayers) { // Creates a simple parametrized EndCap layer covering the given // pseudorapidity range at the z layer position mDirection = layerDirection; mLayerNumber = layerNumber; + mIsMiddleLayer = partOfMiddleLayers; mLayerName = layerName; mZ = layerDirection ? std::abs(z) : -std::abs(z); mx2X0 = Layerx2X0; mInnerRadius = rIn; mOuterRadius = rOut; - auto Si_X0 = 9.5; + const double Si_X0 = 9.5; mChipThickness = Layerx2X0 * Si_X0; + // Sanity checks + if (std::isnan(mZ)) { + LOG(fatal) << "FT3 Layer " << mLayerNumber << " has z = NaN, which is not a valid number."; + } + if (mZ < 0.001 && mZ > -0.001) { + LOG(fatal) << "FT3 Layer " << mLayerNumber << " has z = " << mZ << " cm, which is very close to 0."; + } + LOG(info) << "Creating FT3 Layer " << mLayerNumber << " ; direction " << mDirection; LOG(info) << " Using silicon X0 = " << Si_X0 << " to emulate layer radiation length."; LOG(info) << " Layer z = " << mZ << " ; R_in = " << mInnerRadius << " ; R_out = " << mOuterRadius << " ; x2X0 = " << mx2X0 << " ; ChipThickness = " << mChipThickness; @@ -110,8 +118,8 @@ void FT3Layer::createSeparationLayer_waterCooling(TGeoVolume* motherVolume, cons FT3Layer::initialize_mat(); - double carbonFiberThickness = 0.01; - double foamSpacingThickness = 0.5; + const double carbonFiberThickness = 0.01; // cm + const double foamSpacingThickness = 0.5; // cm TGeoTube* carbonFiberLayer = new TGeoTube(mInnerRadius, mOuterRadius, carbonFiberThickness / 2); @@ -122,15 +130,15 @@ void FT3Layer::createSeparationLayer_waterCooling(TGeoVolume* motherVolume, cons carbonFiberLayerVol1->SetLineColor(kGray + 2); carbonFiberLayerVol2->SetLineColor(kGray + 2); - double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0; + const double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0; motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, mZ - zSeparation)); motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, mZ + zSeparation)); - double pipeOuterRadius = 0.20; - double kaptonThickness = 0.0025; - double pipeInnerRadius = pipeOuterRadius - kaptonThickness; - double pipeMaxLength = mOuterRadius * 2.0; + const double pipeOuterRadius = 0.20; + const double kaptonThickness = 0.0025; + const double pipeInnerRadius = pipeOuterRadius - kaptonThickness; + const double pipeMaxLength = mOuterRadius * 2.0; int name_it = 0; @@ -199,8 +207,8 @@ void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string FT3Layer::initialize_mat(); - double carbonFiberThickness = 0.01; - double foamSpacingThickness = 1.0; + constexpr double carbonFiberThickness = 0.01; // cm + constexpr double foamSpacingThickness = 1.0; // cm TGeoTube* carbonFiberLayer = new TGeoTube(mInnerRadius, mOuterRadius, carbonFiberThickness / 2); TGeoTube* foamLayer = new TGeoTube(mInnerRadius, mOuterRadius, foamSpacingThickness / 2); @@ -215,16 +223,19 @@ void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string foamLayerVol->SetFillColorAlpha(kBlack, 1.0); carbonFiberLayerVol2->SetLineColor(kGray + 2); - double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0; + const double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0; - motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, mZ - zSeparation)); - motherVolume->AddNode(foamLayerVol, 1, new TGeoTranslation(0, 0, mZ)); - motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, mZ + zSeparation)); + motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, 0 - zSeparation)); + motherVolume->AddNode(foamLayerVol, 1, new TGeoTranslation(0, 0, 0)); + motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, 0 + zSeparation)); } void FT3Layer::createLayer(TGeoVolume* motherVolume) { - if (mLayerNumber >= 0 && mLayerNumber < 3) { + if (mLayerNumber < 0) { + LOG(fatal) << "Invalid layer number " << mLayerNumber << " for FT3 layer."; + } + if (mIsMiddleLayer) { // ML disks std::string chipName = o2::ft3::GeometryTGeo::getFT3ChipPattern() + std::to_string(mLayerNumber), sensName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mDirection, mLayerNumber); @@ -255,7 +266,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume) LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName(); motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans); - } else if (mLayerNumber >= 3) { + } else { // OT disks FT3Module module; @@ -264,11 +275,23 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume) std::string backLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Back"; std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber); + TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$"); + TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, 10 * mChipThickness / 2); + TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir); + layerVol->SetLineColor(kYellow + 2); + // createSeparationLayer_waterCooling(motherVolume, separationLayerName); - createSeparationLayer(motherVolume, separationLayerName); + createSeparationLayer(layerVol, separationLayerName); // create disk faces - module.createModule(mZ, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", motherVolume); - module.createModule(mZ, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", motherVolume); + module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", layerVol); + module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", layerVol); + + // Finally put everything in the mother volume + auto* FwdDiskRotation = new TGeoRotation("FwdDiskRotation", 0, 0, 180); + auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ, FwdDiskRotation); + + LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName(); + motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans); } } diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx index 9318554837706..20a481cb36046 100644 --- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx +++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx @@ -199,7 +199,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double bottom_y_pos_value = 3.5; bottom_y_neg_value = -3.5; } else { - std::cout << "Different config - to determine offsets needed." << std::endl; + LOG(warning) << "Different config - to determine offsets needed for " << "Rin = " << Rin << " ; sensor_height = " << sensor_height << " ; sensor_width = " << sensor_width << " layer " << layerNumber; x_condition_min = -Rin; x_condition_max = Rin; adjust_bottom_y_pos = false;