MTCDetector Class Reference

#include <MTCDetector.h>

Inheritance diagram for MTCDetector:

Collaboration diagram for MTCDetector:

Public Member Functions
	MTCDetector (const char *name, Bool_t Active, const char *Title="", Int_t DetId=0)
	MTCDetector ()
void	SetMTCParameters (Double_t width, Double_t height, Double_t fiber_tilt_angle, Double_t iron_thickness, Double_t scifi_thickness, Int_t num_of_agg_channels, Double_t scint_cell_size, Double_t scint_thickness, Int_t number_of_layers, Double_t z_position, Double_t field_strength)
virtual void	CreateScintModule (const char *name, TGeoVolumeAssembly *modMotherVol, Double_t z_shift, Double_t width, Double_t height, Double_t thickness, Double_t cellSizeX, Double_t cellSizeY, TGeoMedium *material, Int_t color, Double_t transparency, Int_t LayerId)
virtual void	CreateSciFiModule (const char *name, TGeoVolumeAssembly *modMotherVol, Double_t width, Double_t height, Double_t thickness, Int_t LayerId)
void	ConstructGeometry () override
void	GetPosition (Int_t fDetectorID, TVector3 &vLeft, TVector3 &vRight)
TVector3	GetLocalPos (Int_t fDetectorID, TVector3 *glob)
void	GetSiPMPosition (Int_t SiPMChan, TVector3 &A, TVector3 &B)
void	SiPMmapping ()
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	GetSiPMmapU ()
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	GetFibresMapU ()
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	GetSiPMmapV ()
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	GetFibresMapV ()
std::map< Int_t, float >	GetSiPMPos_U ()
std::map< Int_t, float >	GetSiPMPos_V ()
Int_t	Get_NSiPMChan () const
Float_t	Get_SciFiActiveX () const
virtual void	SiPMOverlap ()
Bool_t	ProcessHits (FairVolume *vol=0) override
Public Member Functions inherited from SHiP::Detector< MTCDetPoint >
	Detector ()=default
	Detector (const char *Name, Bool_t Active, Int_t detID)
	Detector (const char *Name, Bool_t Active)
	~Detector () override=default
MTCDetPoint *	AddHit (Args &&... args)
void	ConstructGeometry () override=0
void	Initialize () override
void	Reset () override
void	EndOfEvent () override
void	Register () override
TClonesArray *	GetCollection (Int_t iColl) const override
void	UpdatePointTrackIndices (const std::map< Int_t, Int_t > &indexMap) override
	Update track indices in point collection after track filtering.
void	SetSpecialPhysicsCuts () override
void	FinishPrimary () override
void	FinishRun () override
void	BeginPrimary () override
void	PostTrack () override
void	PreTrack () override
void	BeginEvent () override
void	CopyClones (TClonesArray *cl1, TClonesArray *cl2, Int_t offset) override
Public Member Functions inherited from ISTLPointContainer
virtual void	UpdatePointTrackIndices (const std::map< Int_t, Int_t > &indexMap)=0
	Update track indices in point collection after track filtering.
virtual	~ISTLPointContainer ()=default

Private Member Functions
	MTCDetector (const MTCDetector &)=delete
	local SiPM channel position
MTCDetector &	operator= (const MTCDetector &)=delete

Private Attributes
Double_t	fWidth
Double_t	fHeight
Double_t	fSciFiActiveX
Double_t	fSciFiActiveY
Double_t	fSciFiBendingAngle
Double_t	fIronThick
Double_t	fSciFiThick
Double_t	fScintThick
Double_t	fScintCellSize
Int_t	fLayers
Double_t	fZCenter
Double_t	fFieldY
Double_t	fZEpoxyMat
Double_t	fiberMatThick = 0.135
Double_t	fFiberLength
Double_t	fFiberPitch = 0.025
Double_t	lowerIronThick = 0.3
Double_t	airGap = 0.1
Double_t	upperIronThick = 0.3
Double_t	zLowerIronInt = -3.5 / 10
Double_t	zFiberMat1 = -1.325 / 10
Double_t	zAirGap = -0.15 / 10
Double_t	zFiberMat2 = 1.025 / 10
Double_t	zUpperIronInt = 3.2 / 10
Double_t	fFiberRadius = 0.01125
Int_t	numFiberLayers = 6
Int_t	fNSiPMChan
Int_t	fChannelAggregated
Int_t	fNSiPMs = 1
Int_t	fNMats = 1
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	fibresSiPM_U
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	siPMFibres_U
	mapping of fibres to SiPM channels
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	fibresSiPM_V
	inverse mapping
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	siPMFibres_V
	mapping of fibres to SiPM channels
std::map< Int_t, float >	SiPMPos_U
	inverse mapping
std::map< Int_t, float >	SiPMPos_V

Static Private Attributes
static constexpr Int_t	kMaxChannelsPerSiPM = 1000

Additional Inherited Members
Protected Attributes inherited from SHiP::Detector< MTCDetPoint >
Int_t	fEventID
Int_t	fTrackID
	event index
Int_t	fVolumeID
	track index
TLorentzVector	fPos
	volume id
TLorentzVector	fMom
	position at entrance
Double_t	fTime
	momentum at entrance
Double_t	fLength
	time
Double_t	fELoss
	length
std::vector< MTCDetPoint > *	fDetPoints
	energy loss
TGeoVolume *	fDetector

Detailed Description

Definition at line 21 of file MTCDetector.h.

Constructor & Destructor Documentation

MTCDetector() [1/3]

MTCDetector::MTCDetector	(	const char *	name,
		Bool_t	Active,
		const char *	Title = "",
		Int_t	DetId = 0
	)

Definition at line 144 of file MTCDetector.cxx.

    : Detector(name, Active, kMTC) {}

MTCDetector() [2/3]

MTCDetector::MTCDetector

(

)

Definition at line 142 of file MTCDetector.cxx.

: Detector("MTC", kTRUE, kMTC) {}

MTCDetector() [3/3]

MTCDetector::MTCDetector ( const MTCDetector &  )

privatedelete

local SiPM channel position

Member Function Documentation

ConstructGeometry()

void MTCDetector::ConstructGeometry ( )

overridevirtual

Create the detector geometry

Implements SHiP::Detector< MTCDetPoint >.

Definition at line 316 of file MTCDetector.cxx.

                                    {
  // Initialize media (using FairROOT's interface)
  ShipGeo::InitMedium("SciFiMat");
  ShipGeo::InitMedium("Epoxy");
  ShipGeo::InitMedium("air");
  TGeoMedium* air = gGeoManager->GetMedium("air");
  TGeoMedium* ironMed = gGeoManager->GetMedium("iron");
  // For the scintillator, you may use the same medium as SciFiMat or another if
  // defined.
  TGeoMedium* scintMed = gGeoManager->GetMedium("SciFiMat");
  ShipGeo::InitMedium("silicon");
 
  // Define the module spacing based on three sublayers:
  //   fIronThick (outer iron), fSciFiThick (SciFi module/fiber module),
  //   fScintThick (scintillator)
  Double_t moduleSpacing = fIronThick + fSciFiThick + fScintThick;
  Double_t totalLength = fLayers * moduleSpacing;
 
  // --- Create an envelope volume for the detector (green, semi-transparent)
  // ---
  auto envBox =
      new TGeoBBox("MTC_env", fWidth / 2, fHeight / 2, totalLength / 2);
  auto envVol = new TGeoVolume("MTC", envBox, air);
  envVol->SetLineColor(kGreen);
  envVol->SetTransparency(50);
 
  // --- Outer Iron Layer (gray) ---
  auto ironBox =
      new TGeoBBox("MTC_iron", fWidth / 2, fHeight / 2, fIronThick / 2);
  auto ironVol = new TGeoVolume("MTC_iron", ironBox, ironMed);
  ironVol->SetLineColor(kGray + 1);
  ironVol->SetTransparency(20);
  // Enable the field in the iron volume
  if (fFieldY != 0) ironVol->SetField(new TGeoUniformMagField(0, fFieldY, 0));
 
  // --- Assemble the layers into the envelope ---
  TGeoVolumeAssembly* sensitiveModule = new TGeoVolumeAssembly("MTC_layer");
  // Define a layer for the SciFi module
  CreateSciFiModule("MTC", sensitiveModule, fWidth, fHeight, fSciFiThick, 1);
  CreateScintModule("MTC", sensitiveModule, fSciFiThick / 2 + fScintThick / 2,
                    fWidth, fHeight, fScintThick, fScintCellSize,
                    fScintCellSize, scintMed, kAzure + 7, 30, 1);
 
  for (Int_t i = 0; i < fLayers; i++) {
    // Compute the center position (z) for the current module
    Double_t zPos = -totalLength / 2 + i * moduleSpacing;
 
    // Place the Outer Iron layer (shifted down by half the SciFi+scint
    // thickness)
    envVol->AddNode(ironVol, i,
                    new TGeoTranslation(0, 0, zPos + fIronThick / 2));
    // Place the sensitive module (SciFi + Scintillator) at the correct z
    // position
    envVol->AddNode(
        sensitiveModule, i,
        new TGeoTranslation(0, 0, zPos + fIronThick + fSciFiThick / 2));
  }
 
  // Finally, add the envelope to the top volume with the global z offset
  // fZCenter
  gGeoManager->GetTopVolume()->AddNode(envVol, 1,
                                       new TGeoTranslation(0, 0, fZCenter));
}

CreateSciFiModule()

void MTCDetector::CreateSciFiModule ( const char *  name, TGeoVolumeAssembly *  modMotherVol, Double_t  width, Double_t  height, Double_t  thickness, Int_t  LayerId  )

virtual

Definition at line 202 of file MTCDetector.cxx.

                                                                       {
  // --- Lower Internal Iron ---
  TGeoBBox* lowerIronBox = new TGeoBBox(Form("%s_lowerIron", name), width / 2,
                                        height / 2, lowerIronThick / 2);
  TGeoVolume* lowerIronVol = new TGeoVolume(
      Form("%s_lowerIron", name), lowerIronBox, gGeoManager->GetMedium("iron"));
  lowerIronVol->SetLineColor(kGray + 1);
  lowerIronVol->SetTransparency(20);
  modMotherVol->AddNode(lowerIronVol, 0,
                        new TGeoTranslation(0, 0, zLowerIronInt));
 
  // --- Lower Epoxy matrix (replaces SciFiMat layer) ---
  TGeoVolumeAssembly* ScifiVolU =
      new TGeoVolumeAssembly(Form("%s_scifi_U", name));
  modMotherVol->AddNode(ScifiVolU, 0, new TGeoTranslation(0, 0, 0));
  TGeoBBox* epoxyMatBoxU = new TGeoBBox(Form("%s_epoxyMat", name), width / 2,
                                        height / 2, fiberMatThick / 2);
  TGeoVolume* ScifiMatVolU = new TGeoVolume(
      Form("%s_epoxyMat", name), epoxyMatBoxU, gGeoManager->GetMedium("Epoxy"));
  ScifiMatVolU->SetLineColor(kYellow - 2);
  ScifiMatVolU->SetTransparency(30);
  ScifiMatVolU->SetVisibility(kFALSE);
  ScifiMatVolU->SetVisDaughters(kFALSE);
  ScifiVolU->AddNode(ScifiMatVolU, 0, new TGeoTranslation(0, 0, zFiberMat1));
 
  // --- Upper Epoxy matrix (replaces SciFiMat layer) ---
  TGeoVolumeAssembly* ScifiVolV =
      new TGeoVolumeAssembly(Form("%s_scifi_V", name));
  modMotherVol->AddNode(ScifiVolV, 0, new TGeoTranslation(0, 0, 0));
  TGeoBBox* epoxyMatBoxV = new TGeoBBox(Form("%s_epoxyMat", name), width / 2,
                                        height / 2, fiberMatThick / 2);
  TGeoVolume* ScifiMatVolV = new TGeoVolume(
      Form("%s_epoxyMat", name), epoxyMatBoxV, gGeoManager->GetMedium("Epoxy"));
  ScifiMatVolV->SetLineColor(kYellow - 2);
  ScifiMatVolV->SetTransparency(30);
  ScifiMatVolV->SetVisibility(kFALSE);
  ScifiMatVolV->SetVisDaughters(kFALSE);
  ScifiVolV->AddNode(ScifiMatVolV, 0, new TGeoTranslation(0, 0, zFiberMat2));
 
  // --- Upper Internal Iron ---
  TGeoBBox* upperIronBox = new TGeoBBox(Form("%s_upperIron", name), width / 2,
                                        height / 2, upperIronThick / 2);
  TGeoVolume* upperIronVol = new TGeoVolume(
      Form("%s_upperIron", name), upperIronBox, gGeoManager->GetMedium("iron"));
  upperIronVol->SetLineColor(kGray + 1);
  upperIronVol->SetTransparency(20);
  modMotherVol->AddNode(upperIronVol, 0,
                        new TGeoTranslation(0, 0, zUpperIronInt));
 
  // -----------------------------
  // Now build the fibers inside each Epoxy block:
  // Common fiber parameters (cm)
  Double_t layerThick = fiberMatThick / numFiberLayers;
  fFiberLength = fSciFiActiveY / cos(fSciFiBendingAngle * TMath::DegToRad()) -
                 2 * fFiberRadius * sin(fSciFiBendingAngle * TMath::DegToRad());
  LOG(info) << "Fiber length set to " << fFiberLength << " cm";
  Int_t fNumFibers = static_cast<Int_t>(fSciFiActiveX / fFiberPitch);
 
  // --- Define the SciFi fiber volume ---
  TGeoTube* fiberTube =
      new TGeoTube("FiberTube", 0, fFiberRadius, fFiberLength / 2);
  TGeoVolume* fiberVol =
      new TGeoVolume("FiberVol", fiberTube, gGeoManager->GetMedium("SciFiMat"));
  AddSensitiveVolume(fiberVol);
  fiberVol->SetLineColor(kMagenta);
  fiberVol->SetTransparency(15);
  fiberVol->SetVisibility(kFALSE);
 
  // --- Rotations for U/V fibers ---
  TGeoRotation* rotU = new TGeoRotation();
  rotU->RotateY(fSciFiBendingAngle);
  rotU->RotateX(90.);
  TGeoRotation* rotV = new TGeoRotation();
  rotV->RotateY(-fSciFiBendingAngle);
  rotV->RotateX(90.);
 
  // --- Place U-fibers inside lower Epoxy ---
  for (int layer = 0; layer < numFiberLayers; ++layer) {
    Double_t z0 = -fiberMatThick / 2 + (layer + 0.5) * (layerThick);
    for (int j = 0; j < fNumFibers; ++j) {
      Double_t x0 = -fSciFiActiveX / 2 + (j + 0.5) * fFiberPitch;
      if (layer % 2 == 1) {
        if (j == fNumFibers - 1) {
          continue;  // Skip the last layer for odd layers
        }
        x0 += fFiberPitch / 2;
      }
      TGeoCombiTrans* ct = new TGeoCombiTrans("", x0, 0, z0, rotU);
      Int_t copyNo = 100000000 + 1000000 + 0 * 100000 + layer * 10000 + j;
      ScifiMatVolU->AddNode(fiberVol, copyNo, ct);
    }
  }
 
  // --- Place V-fibers inside upper Epoxy ---
  for (int layer = 0; layer < numFiberLayers; ++layer) {
    Double_t z0 = -fiberMatThick / 2 + (layer + 0.5) * (layerThick);
    for (int j = 0; j < fNumFibers; ++j) {
      Double_t x0 = -fSciFiActiveX / 2 + (j + 0.5) * fFiberPitch;
      if (layer % 2 == 1) {
        if (j == fNumFibers - 1) {
          continue;  // Skip the last layer for odd layers
        }
        x0 += fFiberPitch / 2;
      }
      TGeoCombiTrans* ct = new TGeoCombiTrans("", x0, 0, z0, rotV);
      Int_t copyNo = 100000000 + 1000000 + 1 * 100000 + layer * 10000 + j;
      ScifiMatVolV->AddNode(fiberVol, copyNo, ct);
    }
  }
}

CreateScintModule()

void MTCDetector::CreateScintModule ( const char *  name, TGeoVolumeAssembly *  modMotherVol, Double_t  z_shift, Double_t  width, Double_t  height, Double_t  thickness, Double_t  cellSizeX, Double_t  cellSizeY, TGeoMedium *  material, Int_t  color, Double_t  transparency, Int_t  LayerId  )

virtual

Definition at line 170 of file MTCDetector.cxx.

                                                                          {
  modMotherVol->SetLineColor(color);
  modMotherVol->SetTransparency(transparency);
  auto scint_volume = new TGeoVolumeAssembly(Form("%s_scint", name));
  modMotherVol->AddNode(scint_volume, 0, new TGeoTranslation(0, 0, z_shift));
  auto scint_mat = new TGeoVolumeAssembly(Form("%s_scint_mat", name));
  scint_volume->AddNode(scint_mat, 0, new TGeoTranslation(0, 0, 0));
  auto cell = new TGeoBBox(Form("%s_cell", name), cellSizeX / 2, cellSizeY / 2,
                           thickness / 2);
  auto cellVol = new TGeoVolume(Form("%s_cell", name), cell, material);
  cellVol->SetLineColor(color);
  cellVol->SetTransparency(transparency);
  AddSensitiveVolume(cellVol);
  Int_t nX = Int_t(width / cellSizeX);
  Int_t nY = Int_t(height / cellSizeY);
 
  for (Int_t i = 0; i < nX; i++) {
    for (Int_t j = 0; j < nY; j++) {
      Double_t x = -width / 2 + cellSizeX * (i + 0.5);
      Double_t y = -height / 2 + cellSizeY * (j + 0.5);
      scint_mat->AddNode(cellVol, 1e8 + 1e6 + 2e5 + 0e4 + i * nY + j,
                         new TGeoTranslation(x, y, 0));
    }
  }
}

Get_NSiPMChan()

Int_t MTCDetector::Get_NSiPMChan ( ) const

inline

Definition at line 67 of file MTCDetector.h.

{ return fNSiPMChan; }

Get_SciFiActiveX()

Float_t MTCDetector::Get_SciFiActiveX ( ) const

inline

Definition at line 68 of file MTCDetector.h.

{ return fSciFiActiveX; }

GetFibresMapU()

std::map< Int_t, std::map< Int_t, std::array< float, 2 > > > MTCDetector::GetFibresMapU ( )

inline

Definition at line 56 of file MTCDetector.h.

                                                                   {
    return siPMFibres_U;
  }

GetFibresMapV()

std::map< Int_t, std::map< Int_t, std::array< float, 2 > > > MTCDetector::GetFibresMapV ( )

inline

Definition at line 62 of file MTCDetector.h.

                                                                   {
    return siPMFibres_V;
  }

GetLocalPos()

TVector3 MTCDetector::GetLocalPos	(	Int_t	fDetectorID,
		TVector3 *	glob
	)

Transform global position to local position in plane

Definition at line 565 of file MTCDetector.cxx.

                                                                   {
  Int_t station_number = static_cast<int>(fDetectorID / 1e6) % 100;
  Int_t plane_type = static_cast<int>(fDetectorID / 1e5) %
                     10;  // 0 for horizontal, 1 for vertical
 
  TString sID, stationID;
  sID.Form("%i", fDetectorID);
  stationID.Form("%i", station_number);
  // Basic hierarchy:
  // /cave/MTC_1/MTC_layer_1/MTC_sciFi_mother_1/MTC_sciFi_epoxyMat_U_1/FiberVol_101010187
  TString path = "/cave/MTC_1/MTC_layer_" + stationID +
                 ((plane_type == 0) ? "/MTC_scifi_U_0" : "/MTC_scifi_V_0");
  TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
  nav->cd(path);
  Double_t aglob[3];
  Double_t aloc[3];
  glob->GetXYZ(aglob);
  nav->MasterToLocal(aglob, aloc);
  return TVector3(aloc[0], aloc[1], aloc[2]);
}

GetPosition()

void MTCDetector::GetPosition	(	Int_t	fDetectorID,
		TVector3 &	vLeft,
		TVector3 &	vRight
	)

Get position of single fibre in global coordinate system

Definition at line 517 of file MTCDetector.cxx.

                                                                         {
  /*
    Example of fiberID: 123051820, where:
      - 1: MTC unique ID
      - 23: layer number
      - 0: station type (0 for +5 degrees, 1 for -5 degrees, 2 for scint plane)
      - 5: z-layer number (0-5)
      - 1820: local fibre ID within the station
    Example of SiPM global channel (what is seen in the output file): 123001123,
    where:
      - 1: MTC unique ID
      - 23: layer number
      - 0: station type (0 for +5 degrees, 1 for -5 degrees)
      - 0: mat number (only 0 by June 2025)
      - 1: SiPM number (automatically assigned based on fibre aggregation
    settings)
      - 123: number of the SiPM channel (0-N). The channel number depends on the
    fibre aggregation setting.
  */
 
  Int_t station_number = static_cast<int>(fDetectorID / 1e6) % 100;
  Int_t plane_type = static_cast<int>(fDetectorID / 1e5) %
                     10;  // 0 for horizontal, 1 for vertical
 
  TString sID, stationID;
  sID.Form("%i", fDetectorID);
  stationID.Form("%i", station_number);
  // Basic hierarchy:
  // /cave/MTC_1/MTC_layer_1/MTC_sciFi_mother_1/MTC_sciFi_epoxyMat_U_1/FiberVol_101010187
  TString path =
      "/cave/MTC_1/MTC_layer_" + stationID +
      ((plane_type == 0) ? "/MTC_scifi_U_0/MTC_epoxyMat_0/FiberVol_1010"
                         : "/MTC_scifi_V_0/MTC_epoxyMat_0/FiberVol_1011");
  path += sID(4, 5);
  TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
  nav->cd(path);
  TGeoNode* W = nav->GetCurrentNode();
  TGeoBBox* S = dynamic_cast<TGeoBBox*>(W->GetVolume()->GetShape());
 
  Double_t top[3] = {0, 0, (S->GetDZ())};
  Double_t bot[3] = {0, 0, -(S->GetDZ())};
  Double_t Gtop[3], Gbot[3];
  nav->LocalToMaster(top, Gtop);
  nav->LocalToMaster(bot, Gbot);
  A.SetXYZ(Gtop[0], Gtop[1], Gtop[2]);
  B.SetXYZ(Gbot[0], Gbot[1], Gbot[2]);
}

GetSiPMmapU()

std::map< Int_t, std::map< Int_t, std::array< float, 2 > > > MTCDetector::GetSiPMmapU ( )

inline

Definition at line 53 of file MTCDetector.h.

                                                                 {
    return fibresSiPM_U;
  }

GetSiPMmapV()

std::map< Int_t, std::map< Int_t, std::array< float, 2 > > > MTCDetector::GetSiPMmapV ( )

inline

Definition at line 59 of file MTCDetector.h.

                                                                 {
    return fibresSiPM_V;
  }

GetSiPMPos_U()

std::map< Int_t, float > MTCDetector::GetSiPMPos_U ( )

inline

Definition at line 65 of file MTCDetector.h.

{ return SiPMPos_U; }

GetSiPMPos_V()

std::map< Int_t, float > MTCDetector::GetSiPMPos_V ( )

inline

Definition at line 66 of file MTCDetector.h.

{ return SiPMPos_V; }

GetSiPMPosition()

void MTCDetector::GetSiPMPosition	(	Int_t	SiPMChan,
		TVector3 &	A,
		TVector3 &	B
	)

mean position of fibre2 associated with SiPM channel

Definition at line 586 of file MTCDetector.cxx.

                                                                          {
  /* STMRFFF
      Example of fiberID: 123051820, where:
        - 1: MTC unique ID
        - 23: layer number
        - 0: station type (0 for +5 degrees, 1 for -5 degrees, 2 for scint
     plane)
        - 5: z-layer number (0-5)
        - 1820: local fibre ID within the station
      Example of SiPM global channel (what is seen in the output file):
     123001123, where:
        - 1: MTC unique ID
        - 23: layer number
        - 0: station type (0 for +5 degrees, 1 for -5 degrees)
        - 0: mat number (only 0 by June 2025)
        - 1: SiPM number (automatically assigned based on fibre aggregation
     settings)
        - 123: number of the SiPM channel (0-N). The channel number depends on
     the fibre aggregation setting.
  */
  Int_t locNumber = SiPMChan % 1000000;
  Int_t station_number = static_cast<int>(SiPMChan / 1e6) % 100;
  Int_t plane_type = static_cast<int>(SiPMChan / 1e5) %
                     10;  // 0 for horizontal, 1 for vertical
  Float_t locPosition;
  locPosition =
      (plane_type == 0 ? SiPMPos_U
                       : SiPMPos_V)[locNumber];  // local position in U/V plane
  TString stationID;
  stationID.Form("%i", station_number);
 
  Double_t loc[3] = {0, 0, 0};
  TString path = "/cave/MTC_1/MTC_layer_" + stationID +
                 ((plane_type == 0) ? "/MTC_scifi_U_0/MTC_epoxyMat_0"
                                    : "/MTC_scifi_V_0/MTC_epoxyMat_0");
  TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
  Double_t glob[3] = {0, 0, 0};
  loc[0] = locPosition;
  loc[1] = -fFiberLength / 2;
  loc[2] = 7.47;
  nav->cd(path);
  nav->LocalToMaster(loc, glob);
  A.SetXYZ(glob[0], glob[1], glob[2]);
  loc[0] = locPosition;
  loc[1] = fFiberLength / 2;
  loc[2] = 7.47;  // hardcoded for now, for some reason required to get the
                  // correct local position
  nav->LocalToMaster(loc, glob);
  B.SetXYZ(glob[0], glob[1], glob[2]);
}

operator=()

MTCDetector & MTCDetector::operator= ( const MTCDetector &  )

privatedelete

ProcessHits()

Bool_t MTCDetector::ProcessHits ( FairVolume *  vol = 0 )

override

This method is called from the MC stepping

Definition at line 380 of file MTCDetector.cxx.

                                               {
  // Set parameters at entrance of volume. Reset ELoss.
  if (gMC->IsTrackEntering()) {
    fELoss = 0.;
    fTime = gMC->TrackTime() * 1.0e09;
    fLength = gMC->TrackLength();
    gMC->TrackPosition(fPos);
    gMC->TrackMomentum(fMom);
    TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
    Int_t vol_local_id = nav->GetCurrentNode()->GetNumber() %
                         1000000;  // Local ID within the mat or scint.
    Int_t layer_id = nav->GetMother(3)->GetNumber();  // Get layer ID.
    fVolumeID = 100000000 + layer_id * 1000000 +
                vol_local_id;  // 1e8 + layer_id * 1e6 + fibre_local_id;
  }
  // Sum energy loss for all steps in the active volume
  fELoss += gMC->Edep();
 
  // Create vetoPoint when exiting active volume
  if (gMC->IsTrackExiting() || gMC->IsTrackStop() ||
      gMC->IsTrackDisappeared()) {
    if (fELoss == 0.) {
      return kFALSE;
    }  // if you do not want hits with zero eloss
 
    TParticle* p = gMC->GetStack()->GetCurrentTrack();
    fTrackID = gMC->GetStack()->GetCurrentTrackNumber();
    Int_t pdgCode = p->GetPdgCode();
    TLorentzVector Pos;
    gMC->TrackPosition(Pos);
    TLorentzVector Mom;
    gMC->TrackMomentum(Mom);
    Double_t x, y, z;
    if (fVolumeID / 100000 == 3) {
      x = (fPos.X() + Pos.X()) / 2.;
      y = (fPos.Y() + Pos.Y()) / 2.;
      z = (fPos.Z() + Pos.Z()) / 2.;
    } else {
      x = fPos.X();
      y = fPos.Y();
      z = (fPos.Z() + Pos.Z()) / 2.;
    }
 
    AddHit(fTrackID, fVolumeID, TVector3(x, y, z),
           TVector3(fMom.Px(), fMom.Py(), fMom.Pz()),  // entrance momentum
           fTime, fLength, fELoss, pdgCode);
    // hit->Print();
    ShipStack* stack = dynamic_cast<ShipStack*>(gMC->GetStack());
    stack->AddPoint(kMTC);
  }
  return kTRUE;
}

SetMTCParameters()

void MTCDetector::SetMTCParameters	(	Double_t	width,
		Double_t	height,
		Double_t	fiber_tilt_angle,
		Double_t	iron_thickness,
		Double_t	scifi_thickness,
		Int_t	num_of_agg_channels,
		Double_t	scint_cell_size,
		Double_t	scint_thickness,
		Int_t	number_of_layers,
		Double_t	z_position,
		Double_t	field_strength
	)

Definition at line 148 of file MTCDetector.cxx.

                             {
  fWidth = width;
  fHeight = height;
  fSciFiBendingAngle = fiber_tilt_angle;
  fIronThick = iron_thickness;
  fSciFiThick = scifi_thickness;
  fChannelAggregated = num_of_agg_channels;
  fScintCellSize = scint_cell_size;
  fScintThick = scint_thickness;
  fLayers = number_of_layers;
  fZCenter = z_position;
  fFieldY = field_strength;
  fSciFiActiveX = fWidth - fWidth * tan(fSciFiBendingAngle * TMath::DegToRad());
  fSciFiActiveY = fHeight;
}

SiPMmapping()

void MTCDetector::SiPMmapping

(

)

Definition at line 637 of file MTCDetector.cxx.

                              {
  // check if containers are already filled
  if (!fibresSiPM_U.empty() || !fibresSiPM_V.empty() || !SiPMPos_U.empty() ||
      !SiPMPos_V.empty()) {
    LOG(warning) << "SiPM mapping already done, skipping.";
    return;
  }
  Float_t fibresRadius = -1;
  Float_t dSiPM = -1;
  TGeoNode* vol;
  TGeoNode* fibre;
  SiPMOverlap();
  // Loop over both U and V planes
  std::vector<std::pair<const char*, const char*>> sipm_planes = {
      {"SiPMmapVolU", "MTC_scifi_U"}, {"SiPMmapVolV", "MTC_scifi_V"}};
  for (const auto& [sipm_vol, scifi_vol] : sipm_planes) {
    auto sipm = gGeoManager->FindVolumeFast(sipm_vol);
    if (!sipm) continue;
    TObjArray* Nodes = sipm->GetNodes();
    auto plane = gGeoManager->FindVolumeFast(scifi_vol);
    if (!plane) continue;
    for (int imat = 0; imat < plane->GetNodes()->GetEntries(); imat++) {
      auto mat = static_cast<TGeoNode*>(plane->GetNodes()->At(imat));
      auto vmat = mat->GetVolume();
      for (int ifibre = 0; ifibre < vmat->GetNodes()->GetEntriesFast();
           ifibre++) {
        fibre = static_cast<TGeoNode*>(vmat->GetNodes()->At(ifibre));
        if (fibresRadius < 0) {
          auto tmp = fibre->GetVolume()->GetShape();
          auto S = dynamic_cast<TGeoBBox*>(tmp);
          fibresRadius = S->GetDX();
        }
        Int_t fID =
            fibre->GetNumber() % 1000000 +
            imat * 1e4;  // local fibre number, global fibre number = SO+fID
        TVector3 Atop, Bbot;
        GetPosition(fibre->GetNumber(), Atop, Bbot);
        Float_t a = Bbot[0];
 
        //  check for overlap with any of the SiPM channels in the same mat
        for (Int_t nChan = 0; nChan < Nodes->GetEntriesFast();
             nChan++) {  // 7 SiPMs total times 128 channels
          vol = static_cast<TGeoNode*>(Nodes->At(nChan));
          Int_t N = vol->GetNumber();
          Float_t xcentre = vol->GetMatrix()->GetTranslation()[0];
          if (dSiPM < 0) {
            TGeoBBox* B = dynamic_cast<TGeoBBox*>(vol->GetVolume()->GetShape());
            dSiPM = B->GetDX();
          }
 
          if (TMath::Abs(xcentre - a) > 3 * dSiPM / 2) {
            continue;
          }  // no need to check further
          Float_t W = area(a, fibresRadius, xcentre - dSiPM, xcentre + dSiPM);
          if (W < 0) {
            continue;
          }
          std::array<float, 2> Wa;
          Wa[0] = W;
          Wa[1] = a;
 
          if (sipm_vol == std::string("SiPMmapVolU")) {
            fibresSiPM_U[N][fID] = Wa;
          } else {
            fibresSiPM_V[N][fID] = Wa;
          }
        }
      }
    }
    // calculate also local SiPM positions based on fibre positions and their
    // fraction probably an overkill, maximum difference between weighted
    // average and central position < 6 micron.
    if (sipm_vol == std::string("SiPMmapVolU")) {
      for (auto [N, it] : fibresSiPM_U) {
        Float_t m = 0;
        Float_t w = 0;
        for (auto [current_fibre, Wa] : it) {
          m += Wa[0] * Wa[1];
          w += Wa[0];
        }
        SiPMPos_U[N] = m / w;
      }
      // make inverse mapping, which fibre is associated to which SiPMs
      for (auto [N, it] : fibresSiPM_U) {
        for (auto [nfibre, Wa] : it) {
          siPMFibres_U[nfibre][N] = Wa;
        }
      }
    } else if (sipm_vol == std::string("SiPMmapVolV")) {
      for (auto [N, it] : fibresSiPM_V) {
        Float_t m = 0;
        Float_t w = 0;
        for (auto [current_fibre, Wa] : it) {
          m += Wa[0] * Wa[1];
          w += Wa[0];
        }
        SiPMPos_V[N] = m / w;
      }
      // make inverse mapping, which fibre is associated to which SiPMs
      for (auto [N, it] : fibresSiPM_V) {
        for (auto [nfibre, Wa] : it) {
          siPMFibres_V[nfibre][N] = Wa;
        }
      }
    }
  }
}

SiPMOverlap()

void MTCDetector::SiPMOverlap ( )

virtual

Definition at line 434 of file MTCDetector.cxx.

                              {
  if (gGeoManager->FindVolumeFast("SiPMmapVolU") ||
      gGeoManager->FindVolumeFast("SiPMmapVolV")) {
    return;
  }
  Double_t fLengthScifiMat = fSciFiActiveY;
  Double_t fWidthChannel = fFiberPitch * fChannelAggregated;
  fNSiPMChan = std::ceil(fWidth / fWidthChannel);
  if (fNSiPMChan > kMaxChannelsPerSiPM) {
    LOG(warn) << "Number of SiPM channels (" << fNSiPMChan
              << ") exceeds maximum per SiPM (" << kMaxChannelsPerSiPM
              << "), redistributing across multiple SiPMs";
 
    fNSiPMs = static_cast<int>(
        std::ceil(static_cast<double>(fNSiPMChan) / kMaxChannelsPerSiPM));
 
    LOG(info) << "Increasing number of SiPMs up to " << fNSiPMs;
 
    // define redistribution of channels among SiPMs
    fNSiPMChan =
        static_cast<int>(std::ceil(fNSiPMChan / static_cast<float>(fNSiPMs)));
 
    LOG(info) << "New fNSiPMChan = " << fNSiPMChan;
  }
  Double_t fEdge = (fWidth - fNSiPMs * fNSiPMChan * fWidthChannel) / 2;
  Double_t firstChannelX = -fWidth / 2;
 
  LOG(info) << "SiPM Overlap parameters:\n"
            << "  fLengthScifiMat = " << fLengthScifiMat << " cm\n"
            << "  fWidthChannel = " << fWidthChannel << " cm\n"
            << "  fFiberPitch = " << fFiberPitch << " cm\n"
            << "  fChannelAggregated = " << fChannelAggregated << "\n"
            << "  fNSiPMChan = " << fNSiPMChan << "\n"
            << "  fNSiPMs = " << fNSiPMs << "\n"
            << "  fNMats = " << fNMats << "\n"
            << "  fEdge = " << fEdge << " cm\n"
            << "  firstChannelX = " << firstChannelX << " cm";
  // Contains all plane SiPMs, defined for horizontal fiber plane
  // To obtain SiPM map for vertical fiber plane rotate by 90 degrees around Z
  TGeoVolumeAssembly* SiPMmapVolU = new TGeoVolumeAssembly("SiPMmapVolU");
  TGeoVolumeAssembly* SiPMmapVolV = new TGeoVolumeAssembly("SiPMmapVolV");
 
  TGeoBBox* ChannelVol_box = new TGeoBBox(
      "ChannelVol", fWidthChannel / 2, fLengthScifiMat / 2, fiberMatThick / 2);
  TGeoVolume* ChannelVol = new TGeoVolume("ChannelVol", ChannelVol_box,
                                          gGeoManager->GetMedium("silicon"));
  /*
    Example of fiberID: 123051820, where:
      - 1: MTC unique ID
      - 23: layer number
      - 0: station type (0 for +5 degrees, 1 for -5 degrees, 2 for scint plane)
      - 5: z-layer number (0-5)
      - 1820: local fibre ID within the station
    Example of SiPM global channel (what is seen in the output file): 123001123,
    where:
      - 1: MTC unique ID
      - 23: layer number
      - 0: station type (0 for +5 degrees, 1 for -5 degrees)
      - 0: mat number (only 0 by June 2025)
      - 1: SiPM number (automatically assigned based on fibre aggregation
    settings)
      - 123: number of the SiPM channel (0-N). The channel number depends on the
    fibre aggregation setting.
  */
 
  Double_t pos = fEdge + firstChannelX;
  for (int imat = 0; imat < fNMats; imat++) {
    for (int isipms = 0; isipms < fNSiPMs; isipms++) {
      for (int ichannel = 0; ichannel < fNSiPMChan; ichannel++) {
        // +5 degrees
        SiPMmapVolU->AddNode(
            ChannelVol, 100000 * 0 + imat * 10000 + isipms * 1000 + ichannel,
            new TGeoTranslation(pos, 0, 0));
        // -5 degrees
        SiPMmapVolV->AddNode(
            ChannelVol, 100000 * 1 + imat * 10000 + isipms * 1000 + ichannel,
            new TGeoTranslation(-pos, 0, 0));
        pos += fWidthChannel;
      }
    }
  }
}

Member Data Documentation

airGap

Double_t MTCDetector::airGap = 0.1

private

Definition at line 92 of file MTCDetector.h.

fChannelAggregated

Int_t MTCDetector::fChannelAggregated

private

Definition at line 102 of file MTCDetector.h.

fFiberLength

Double_t MTCDetector::fFiberLength

private

Definition at line 87 of file MTCDetector.h.

fFiberPitch

Double_t MTCDetector::fFiberPitch = 0.025

private

Definition at line 88 of file MTCDetector.h.

fFiberRadius

Double_t MTCDetector::fFiberRadius = 0.01125

private

Definition at line 99 of file MTCDetector.h.

fFieldY

Double_t MTCDetector::fFieldY

private

Definition at line 84 of file MTCDetector.h.

fHeight

Double_t MTCDetector::fHeight

private

Definition at line 74 of file MTCDetector.h.

fiberMatThick

Double_t MTCDetector::fiberMatThick = 0.135

private

Definition at line 86 of file MTCDetector.h.

fibresSiPM_U

std::map<Int_t, std::map<Int_t, std::array<float, 2> > > MTCDetector::fibresSiPM_U

private

Definition at line 108 of file MTCDetector.h.

fibresSiPM_V

std::map<Int_t, std::map<Int_t, std::array<float, 2> > > MTCDetector::fibresSiPM_V

private

inverse mapping

Definition at line 112 of file MTCDetector.h.

fIronThick

Double_t MTCDetector::fIronThick

private

Definition at line 78 of file MTCDetector.h.

fLayers

Int_t MTCDetector::fLayers

private

Definition at line 82 of file MTCDetector.h.

fNMats

Int_t MTCDetector::fNMats = 1

private

Definition at line 106 of file MTCDetector.h.

fNSiPMChan

Int_t MTCDetector::fNSiPMChan

private

Definition at line 101 of file MTCDetector.h.

fNSiPMs

Int_t MTCDetector::fNSiPMs = 1

private

Definition at line 103 of file MTCDetector.h.

fSciFiActiveX

Double_t MTCDetector::fSciFiActiveX

private

Definition at line 75 of file MTCDetector.h.

fSciFiActiveY

Double_t MTCDetector::fSciFiActiveY

private

Definition at line 76 of file MTCDetector.h.

fSciFiBendingAngle

Double_t MTCDetector::fSciFiBendingAngle

private

Definition at line 77 of file MTCDetector.h.

fSciFiThick

Double_t MTCDetector::fSciFiThick

private

Definition at line 79 of file MTCDetector.h.

fScintCellSize

Double_t MTCDetector::fScintCellSize

private

Definition at line 81 of file MTCDetector.h.

fScintThick

Double_t MTCDetector::fScintThick

private

Definition at line 80 of file MTCDetector.h.

fWidth

Double_t MTCDetector::fWidth

private

Definition at line 73 of file MTCDetector.h.

fZCenter

Double_t MTCDetector::fZCenter

private

Definition at line 83 of file MTCDetector.h.

fZEpoxyMat

Double_t MTCDetector::fZEpoxyMat

private

Definition at line 85 of file MTCDetector.h.

kMaxChannelsPerSiPM

constexpr Int_t MTCDetector::kMaxChannelsPerSiPM = 1000

staticconstexprprivate

Definition at line 104 of file MTCDetector.h.

lowerIronThick

Double_t MTCDetector::lowerIronThick = 0.3

private

Definition at line 91 of file MTCDetector.h.

numFiberLayers

Int_t MTCDetector::numFiberLayers = 6

private

Definition at line 100 of file MTCDetector.h.

siPMFibres_U

std::map<Int_t, std::map<Int_t, std::array<float, 2> > > MTCDetector::siPMFibres_U

private

mapping of fibres to SiPM channels

Definition at line 110 of file MTCDetector.h.

siPMFibres_V

std::map<Int_t, std::map<Int_t, std::array<float, 2> > > MTCDetector::siPMFibres_V

private

mapping of fibres to SiPM channels

Definition at line 114 of file MTCDetector.h.

SiPMPos_U

std::map<Int_t, float> MTCDetector::SiPMPos_U

private

inverse mapping

Definition at line 115 of file MTCDetector.h.

SiPMPos_V

std::map<Int_t, float> MTCDetector::SiPMPos_V

private

Definition at line 115 of file MTCDetector.h.

upperIronThick

Double_t MTCDetector::upperIronThick = 0.3

private

Definition at line 93 of file MTCDetector.h.

zAirGap

Double_t MTCDetector::zAirGap = -0.15 / 10

private

Definition at line 96 of file MTCDetector.h.

zFiberMat1

Double_t MTCDetector::zFiberMat1 = -1.325 / 10

private

Definition at line 95 of file MTCDetector.h.

zFiberMat2

Double_t MTCDetector::zFiberMat2 = 1.025 / 10

private

Definition at line 97 of file MTCDetector.h.

zLowerIronInt

Double_t MTCDetector::zLowerIronInt = -3.5 / 10

private

Definition at line 94 of file MTCDetector.h.

zUpperIronInt

Double_t MTCDetector::zUpperIronInt = 3.2 / 10

private

Definition at line 98 of file MTCDetector.h.

---

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

• SND/MTC/MTCDetector.h
• SND/MTC/MTCDetector.cxx