32#include "TGeoManager.h"
35#include "TGeoVolume.h"
37#include "TVirtualMC.h"
38#include "TVirtualMCStack.h"
40#include <fairlogger/Logger.h>
45#define MAX_SENSORS 2000
70 LOG(info) <<
"Building FT3 Detector: Conical Telescope";
72 const int numberOfLayers =
param.nLayers;
73 const auto z_first =
param.z0;
74 const auto z_length =
param.zLength;
75 const auto etaIn =
param.etaIn;
76 const auto etaOut =
param.etaOut;
77 const auto Layerx2X0 =
param.Layerx2X0;
82 for (
int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
84 mLayerName[direction][layerNumber] = layerName;
87 const float layerZ = z_first + (layerNumber * z_length / numberOfLayers) * std::copysign(1, z_first);
88 const float rIn = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaIn))));
89 const float rOut = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaOut))));
90 const bool isMiddleLayer = layerNumber < 3;
91 auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, layerZ, rIn, rOut, Layerx2X0, isMiddleLayer);
102 LOG(info) <<
"Building FT3 Detector: V1";
104 const int numberOfLayers = 10;
105 const float sensorThickness = 30.e-4;
106 const float layersx2X0 = 1.e-2;
107 const std::vector<std::array<float, 4>> layersConfig{
108 {26., .5, 3., 0.1f * layersx2X0},
109 {30., .5, 3., 0.1f * layersx2X0},
110 {34., .5, 3., 0.1f * layersx2X0},
111 {77., 3.5, 35., layersx2X0},
112 {100., 3.5, 35., layersx2X0},
113 {122., 3.5, 35., layersx2X0},
114 {150., 3.5, 80.f, layersx2X0},
115 {180., 3.5, 80.f, layersx2X0},
116 {220., 3.5, 80.f, layersx2X0},
117 {279., 3.5, 80.f, layersx2X0}};
123 for (
int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
126 mLayerName[direction][layerNumber] = layerName;
127 auto&
z = layersConfig[layerNumber][0];
129 auto& rIn = layersConfig[layerNumber][1];
130 auto& rOut = layersConfig[layerNumber][2];
131 auto&
x0 = layersConfig[layerNumber][3];
133 LOG(info) <<
"Adding Layer " << layerName <<
" at z = " <<
z;
135 const bool isMiddleLayer = layerNumber < 3;
136 auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName,
z, rIn, rOut,
x0, isMiddleLayer);
147 LOG(info) <<
"Building FT3 Detector: V3b";
149 const int numberOfLayers = 12;
150 float sensorThickness = 30.e-4;
151 float layersx2X0 = 1.e-2;
152 std::vector<std::array<float, 4>> layersConfig{
153 {26., .5, 3., 0.1f * layersx2X0},
154 {30., .5, 3., 0.1f * layersx2X0},
155 {34., .5, 3., 0.1f * layersx2X0},
156 {77., 5.0, 35., layersx2X0},
157 {100., 5.0, 35., layersx2X0},
158 {122., 5.0, 35., layersx2X0},
159 {150., 5.5, 80.f, layersx2X0},
160 {180., 6.6, 80.f, layersx2X0},
161 {220., 8.1, 80.f, layersx2X0},
162 {279., 10.2, 80.f, layersx2X0},
163 {340., 12.5, 80.f, layersx2X0},
164 {400., 14.7, 80.f, layersx2X0}};
170 for (
int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
173 mLayerName[direction][layerNumber] = layerName;
174 auto&
z = layersConfig[layerNumber][0];
176 auto& rIn = layersConfig[layerNumber][1];
177 auto& rOut = layersConfig[layerNumber][2];
178 auto&
x0 = layersConfig[layerNumber][3];
180 LOG(info) <<
"Adding Layer " << layerName <<
" at z = " <<
z;
182 const bool isMiddleLayer = layerNumber < 3;
183 auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName,
z, rIn, rOut,
x0, isMiddleLayer);
197 LOG(info) <<
"Building FT3 Detector: After Upgrade Days March 2024 version";
199 const int numberOfLayers = 9;
200 const float sensorThickness = 30.e-4;
201 const float layersx2X0 = 1.e-2;
202 const std::vector<std::array<float, 4>> layersConfigCSide{
203 {77., 7.0, 35., layersx2X0},
204 {100., 7.0, 35., layersx2X0},
205 {122., 7.0, 35., layersx2X0},
206 {150., 7.0, 68.f, layersx2X0},
207 {180., 7.0, 68.f, layersx2X0},
208 {220., 7.0, 68.f, layersx2X0},
209 {260., 7.0, 68.f, layersx2X0},
210 {300., 7.0, 68.f, layersx2X0},
211 {350., 7.0, 68.f, layersx2X0}};
213 const std::vector<std::array<float, 4>> layersConfigASide{
214 {77., 5.0, 35., layersx2X0},
215 {100., 5.0, 35., layersx2X0},
216 {122., 5.0, 35., layersx2X0},
217 {150., 5.0, 68.f, layersx2X0},
218 {180., 5.0, 68.f, layersx2X0},
219 {220., 5.0, 68.f, layersx2X0},
220 {260., 5.0, 68.f, layersx2X0},
221 {300., 5.0, 68.f, layersx2X0},
222 {350., 5.0, 68.f, layersx2X0}};
228 for (
int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
231 mLayerName[direction][layerNumber] = layerName;
232 float z, rIn, rOut,
x0;
233 if (direction == 0) {
234 z = layersConfigCSide[layerNumber][0];
235 rIn = layersConfigCSide[layerNumber][1];
236 rOut = layersConfigCSide[layerNumber][2];
237 x0 = layersConfigCSide[layerNumber][3];
238 }
else if (direction == 1) {
239 z = layersConfigASide[layerNumber][0];
240 rIn = layersConfigASide[layerNumber][1];
241 rOut = layersConfigASide[layerNumber][2];
242 x0 = layersConfigASide[layerNumber][3];
245 LOG(info) <<
"Adding Layer " << layerName <<
" at z = " <<
z;
247 const bool isMiddleLayer = layerNumber < 3;
248 auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName,
z, rIn, rOut,
x0, isMiddleLayer);
260 LOG(info) <<
"Building FT3 Detector: v3 scoping version";
262 const int numberOfLayers = 6;
263 const float sensorThickness = 30.e-4;
264 const float layersx2X0 = 1.e-2;
265 using LayerConfig = std::array<float, 4>;
266 const std::array<LayerConfig, numberOfLayers> layersConfigCSide{LayerConfig{77., 10.0, 35., layersx2X0},
267 LayerConfig{100., 10.0, 35., layersx2X0},
268 LayerConfig{122., 10.0, 35., layersx2X0},
269 LayerConfig{150., 20.0, 68.f, layersx2X0},
270 LayerConfig{180., 20.0, 68.f, layersx2X0},
271 LayerConfig{220., 20.0, 68.f, layersx2X0}};
273 const std::array<LayerConfig, numberOfLayers> layersConfigASide{LayerConfig{77., 10.0, 35., layersx2X0},
274 LayerConfig{100., 10.0, 35., layersx2X0},
275 LayerConfig{122., 10.0, 35., layersx2X0},
276 LayerConfig{150., 20.0, 68.f, layersx2X0},
277 LayerConfig{180., 20.0, 68.f, layersx2X0},
278 LayerConfig{220., 20.0, 68.f, layersx2X0}};
279 const std::array<bool, numberOfLayers>
enabled{
true,
true,
true,
true,
true,
true};
283 const std::array<LayerConfig, numberOfLayers>& layerConfig = (direction ==
IdxBackwardDisks) ? layersConfigCSide : layersConfigASide;
284 for (
int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
290 mLayerName[direction].push_back(layerName.c_str());
291 const float z = layerConfig[layerNumber][0];
292 const float rIn = layerConfig[layerNumber][1];
293 const float rOut = layerConfig[layerNumber][2];
294 const float x0 = layerConfig[layerNumber][3];
295 LOG(info) <<
"buildFT3ScopingV3 -> Adding Layer " << layerNumber <<
"/" << numberOfLayers <<
" " << layerName <<
" at z = " <<
z;
297 const bool isMiddleLayer = layerNumber < 3;
298 auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName,
z, rIn, rOut,
x0, isMiddleLayer);
308 LOG(info) <<
"Building FT3 Detector: Scoping document version";
310 const int numberOfLayers = 12;
311 const float sensorThickness = 30.e-4;
312 const float layersx2X0 = 1.e-2;
313 const std::vector<std::array<float, 4>> layersConfig{
314 {26., .5, 2.5, 0.1f * layersx2X0},
315 {30., .5, 2.5, 0.1f * layersx2X0},
316 {34., .5, 2.5, 0.1f * layersx2X0},
317 {77., 5.0, 35., layersx2X0},
318 {100., 5.0, 35., layersx2X0},
319 {122., 5.0, 35., layersx2X0},
320 {150., 5.0, 68.f, layersx2X0},
321 {180., 5.0, 68.f, layersx2X0},
322 {220., 5.0, 68.f, layersx2X0},
323 {260., 5.0, 68.f, layersx2X0},
324 {300., 5.0, 68.f, layersx2X0},
325 {350., 5.0, 68.f, layersx2X0}};
331 for (
int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
334 mLayerName[direction][layerNumber] = layerName;
335 auto&
z = layersConfig[layerNumber][0];
336 auto& rIn = layersConfig[layerNumber][1];
337 auto& rOut = layersConfig[layerNumber][2];
338 auto&
x0 = layersConfig[layerNumber][3];
340 LOG(info) <<
"Adding Layer " << layerName <<
" at z = " <<
z;
342 const bool isMiddleLayer = layerNumber < 3;
343 auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName,
z, rIn, rOut,
x0, isMiddleLayer);
364 mLayerName = rhs.mLayerName;
395 mLayerName = rhs.mLayerName;
396 mLayers = rhs.mLayers;
397 mTrackData = rhs.mTrackData;
409 LOG(info) <<
"Initialize FT3 O2Detector";
411 defineSensitiveVolumes();
418 if (!(
fMC->TrackCharge())) {
426 bool startHit =
false, stopHit =
false;
427 unsigned char status = 0;
428 if (
fMC->IsTrackEntering()) {
429 status |= Hit::kTrackEntering;
431 if (
fMC->IsTrackInside()) {
432 status |= Hit::kTrackInside;
434 if (
fMC->IsTrackExiting()) {
435 status |= Hit::kTrackExiting;
437 if (
fMC->IsTrackOut()) {
438 status |= Hit::kTrackOut;
440 if (
fMC->IsTrackStop()) {
441 status |= Hit::kTrackStopped;
443 if (
fMC->IsTrackAlive()) {
444 status |= Hit::kTrackAlive;
448 if ((status & Hit::kTrackEntering) || (status & Hit::kTrackInside && !mTrackData.mHitStarted)) {
450 }
else if ((status & (Hit::kTrackExiting | Hit::kTrackOut | Hit::kTrackStopped))) {
456 mTrackData.mEnergyLoss +=
fMC->Edep();
458 if (!(startHit | stopHit)) {
462 mTrackData.mEnergyLoss = 0.;
463 fMC->TrackMomentum(mTrackData.mMomentumStart);
464 fMC->TrackPosition(mTrackData.mPositionStart);
465 mTrackData.mTrkStatusStart = status;
466 mTrackData.mHitStarted =
true;
470 TLorentzVector positionStop;
471 fMC->TrackPosition(positionStop);
474 std::string volName =
fMC->CurrentVolName();
475 int direction = -1,
layer = -1, stave = -1, chip = -1;
476 geom->extractChipIds(volName, direction,
layer, stave, chip);
477 chipindex = geom->getChipIndex(direction,
layer, stave, chip);
479 Hit* p =
addHit(
stack->GetCurrentTrackNumber(), chipindex, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
480 mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
481 mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
503 for (
const auto& [materialID, material] :
Materials::materials) {
504 const int id =
static_cast<int>(materialID);
505 if (material.nComponents == 0) {
507 material.radl, material.absl);
515 const auto& tracking = material.tracking;
517 tracking.deemax, tracking.epsil, tracking.stmin);
563 TGeoVolume* vALIC = gGeoManager->GetVolume(
"barrel");
565 LOG(fatal) <<
"Could not find the top volume";
568 TGeoVolume* A3IPvac = gGeoManager->GetVolume(
"OUT_PIPEVACUUM");
570 LOG(info) <<
"Running simulation with no beam pipe.";
575 for (
int direction : {IdxBackwardDisks, IdxForwardDisks}) {
576 const std::string directionString =
direction ?
"Forward" :
"Backward";
577 LOG(info) <<
" Creating FT3 without beampipe " << directionString <<
" layers:";
578 for (
int iLayer = 0; iLayer < mLayers[
direction].size(); iLayer++) {
579 mLayers[
direction][iLayer].createLayer(volFT3);
582 vALIC->AddNode(volFT3, 2,
new TGeoTranslation(0., 30., 0.));
584 for (
int direction : {IdxBackwardDisks, IdxForwardDisks}) {
585 const std::string directionString =
direction ?
"Forward" :
"Backward";
586 LOG(info) <<
" Creating FT3 " << directionString <<
" layers:";
587 for (
int iLayer = 0; iLayer < mLayers[
direction].size(); iLayer++) {
588 LOG(info) <<
" Creating " << directionString <<
" layer " << iLayer;
589 if (mLayers[direction][iLayer].getIsInMiddleLayer()) {
590 mLayers[
direction][iLayer].createLayer(volIFT3);
592 mLayers[
direction][iLayer].createLayer(volFT3);
596 A3IPvac->AddNode(volIFT3, 2,
new TGeoTranslation(0., 0., 0.));
597 vALIC->AddNode(volFT3, 2,
new TGeoTranslation(0., 30., 0.));
602void Detector::defineSensitiveVolumes()
604 TGeoManager* geoManager = gGeoManager;
607 TObjArray* allVolumes = geoManager->GetListOfVolumes();
608 int nVolumes = allVolumes->GetEntriesFast();
610 LOG(info) <<
"Adding FT3 Sensitive Volumes by iterating over all geometry volumes...";
613 for (
int direction : {IdxBackwardDisks, IdxForwardDisks}) {
631 for (
int i = 0;
i < nVolumes; ++
i) {
632 TGeoVolume*
v = (TGeoVolume*)allVolumes->At(
i);
633 std::string vName =
v->GetName();
636 if (vName.find(
"Inactive") != std::string::npos || vName.find(
"inactive") != std::string::npos) {
641 bool isMatch =
false;
644 }
else if (vName.find(sig2) == 0 || vName.find(sig3) == 0 || vName.find(sig4) == 0) {
655 LOG(
error) <<
"NO sensitive volume found for direction " <<
direction <<
", layer " << iLayer;
657 LOG(info) << iSens <<
" sensitive volume(s) added for direction " <<
direction <<
" layer " << iLayer;
665 const TVector3& startMom,
double startE,
double endTime,
double eLoss,
unsigned char startStatus,
666 unsigned char endStatus)
668 mHits->emplace_back(trackID, detID, startPos, endPos, startMom, startE, endTime, eLoss, startStatus, endStatus);
669 return &(mHits->back());
Definition of the Stack class.
Definition of the FT3Layer class.
Materials of the FT3 detector, and access to the media made from them.
char error[CURL_ERROR_SIZE]
Definition of the GeometryTGeo class.
Definition of the Detector class.
FairDetector & operator=(const FairDetector &)
void AddSensitiveVolume(TGeoVolume *v)
TVirtualMC * fMC
flag for initialisation
void RegisterAny(const char *name, T *&obj, Bool_t toFile)
static FairRootManager * Instance()
Detector & operator=(const Detector &)
void Mixture(Int_t imat, const char *name, Float_t *a, Float_t *z, Float_t dens, Int_t nlmat, Float_t *wmat)
void Medium(Int_t numed, const char *name, Int_t nmat, Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd, Float_t stemax, Float_t deemax, Float_t epsil, Float_t stmin, Float_t *ubuf=nullptr, Int_t nbuf=0)
static void initFieldTrackingParams(int &mode, float &maxfield)
void Material(Int_t imat, const char *name, Float_t a, Float_t z, Float_t dens, Float_t radl, Float_t absl, Float_t *buf=nullptr, Int_t nwbuf=0)
std::string addNameTo(const char *ext) const
std::array< std::vector< TString >, 2 > mLayerName
static constexpr int IdxBackwardDisks
static constexpr int IdxForwardDisks
Detector()
Default constructor.
void buildBasicFT3(const FT3BaseParam ¶m)
void buildFT3NewVacuumVessel()
static const char * getFT3SensorPattern()
static const char * getFT3LayerPattern()
static const char * getFT3VolPattern()
static const char * getFT3InnerVolPattern()
void ConstructGeometry() override
void InitializeO2Detector() override
o2::trkft3::Hit * addHit(int trackID, unsigned short detID, const TVector3 &startPos, const TVector3 &endPos, const TVector3 &startMom, double startE, double endTime, double eLoss, unsigned char startStatus, unsigned char endStatus)
void EndOfEvent() override
int getNumberOfLayers() const
Number of VD petals.
bool ProcessHits(FairVolume *v=nullptr) override
static GeometryTGeo * Instance()
static ShmManager & Instance()
GLenum GLenum GLsizei const GLuint GLboolean enabled
GLenum GLuint GLint GLint layer
GLboolean GLboolean GLboolean GLboolean a
GLubyte GLubyte GLubyte GLubyte w
GLdouble GLdouble GLdouble z
std::array< float, maxMaterialComponents > ComponentArray
const float const float const float const float std::array< float, 3 > std::array< float, 3 > & direction
void freeSimVector(std::vector< T > *ptr)
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
std::string to_string(gsl::span< T, Size > span)
Common utility functions.
LOG(info)<< "Compressed in "<< sw.CpuTime()<< " s"