Scifi Class Reference

#include <Scifi.h>

Inheritance diagram for Scifi:

Collaboration diagram for Scifi:

Public Member Functions
	Scifi (const char *name, Bool_t Active, const char *Title="Scifi")
	Scifi ()
virtual	~Scifi ()
void	ConstructGeometry ()
void	GetPosition (Int_t id, TVector3 &vLeft, TVector3 &vRight)
TVector3	GetLocalPos (Int_t id, TVector3 *glob)
void	GetSiPMPosition (Int_t SiPMChan, TVector3 &A, TVector3 &B)
Double_t	GetCorrectedTime (Int_t fDetectorID, Double_t rawTime, Double_t L)
Double_t	ycross (Double_t a, Double_t R, Double_t x)
Double_t	integralSqrt (Double_t ynorm)
Double_t	fraction (Double_t R, Double_t x, Double_t y)
Double_t	area (Double_t a, Double_t R, Double_t xL, Double_t xR)
void	SiPMmapping ()
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	GetSiPMmap ()
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	GetFibresMap ()
std::map< Int_t, float >	GetSiPMPos ()
virtual void	SiPMOverlap ()
void	SetConfPar (TString name, Float_t value)
void	SetConfPar (TString name, Int_t value)
void	SetConfPar (TString name, TString value)
void	SetConfPar (TString name, std::vector< float > values)
Float_t	GetConfParF (TString name)
Int_t	GetConfParI (TString name)
TString	GetConfParS (TString name)
std::vector< Float_t >	GetConfParVector (TString name)
void	InitEvent (SNDLHCEventHeader *e)
virtual void	Initialize ()
virtual Bool_t	ProcessHits (FairVolume *v=0)
virtual void	Register ()
virtual TClonesArray *	GetCollection (Int_t iColl) const
virtual void	Reset ()
ScifiPoint *	AddHit (Int_t trackID, Int_t detID, TVector3 pos, TVector3 mom, Double_t time, Double_t length, Double_t eLoss, Int_t pdgCode)
virtual void	CopyClones (TClonesArray *cl1, TClonesArray *cl2, Int_t offset)
virtual void	SetSpecialPhysicsCuts ()
virtual void	EndOfEvent ()
virtual void	FinishPrimary ()
virtual void	FinishRun ()
virtual void	BeginPrimary ()
virtual void	PostTrack ()
virtual void	PreTrack ()
virtual void	BeginEvent ()
	Scifi (const Scifi &)
Scifi &	operator= (const Scifi &)

Public Attributes
ClassDef(Scifi, 3) private Int_t	fVolumeID
	track index
TLorentzVector	fPos
	volume id
TLorentzVector	fMom
	position at entrance
Double32_t	fTime
	momentum at entrance
Double32_t	fLength
	time
Double32_t	fELoss
	length
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	fibresSiPM
	energy loss
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	siPMFibres
	mapping of fibres to SiPM channels
std::map< Int_t, float >	SiPMPos
	inverse mapping
TClonesArray *	fScifiPointCollection
	local SiPM channel position
std::map< TString, Float_t >	conf_floats
std::map< TString, Int_t >	conf_ints
std::map< TString, TString >	conf_strings
std::map< TString, std::vector< Float_t > >	conf_vectors
SNDLHCEventHeader *	eventHeader
std::vector< int >	covered_runs_time_alignment
std::vector< int >	covered_runs_position_alignment
int	last_run_time
int	last_run_pos
TString	last_time_alignment_tag
TString	last_position_alignment_tag
bool	alignment_init

Protected Member Functions
Int_t	InitMedium (const char *name)

Detailed Description

Definition at line 19 of file Scifi.h.

Constructor & Destructor Documentation

Scifi() [1/3]

Scifi::Scifi	(	const char *	name,
		Bool_t	Active,
		const char *	Title = "Scifi"
	)

Definition at line 65 of file Scifi.cxx.

: FairDetector(name, true, kLHCScifi),
fTrackID(-1),
fVolumeID(-1),
fPos(),
fMom(),
fTime(-1.),
fLength(-1.),
fELoss(-1),
eventHeader(0),
last_run_time(-1),
last_run_pos(-1),
last_time_alignment_tag(""),
last_position_alignment_tag(""),
alignment_init(false),
fScifiPointCollection(new TClonesArray("ScifiPoint"))
{
}

Scifi() [2/3]

Scifi::Scifi

(

)

Definition at line 46 of file Scifi.cxx.

: FairDetector("Scifi", "", kTRUE),
fTrackID(-1),
fVolumeID(-1),
fPos(),
fMom(),
fTime(-1.),
fLength(-1.),
fELoss(-1),
eventHeader(0),
last_run_time(-1),
last_run_pos(-1),
last_time_alignment_tag(""),
last_position_alignment_tag(""),
alignment_init(false),
fScifiPointCollection(new TClonesArray("ScifiPoint"))
{
}

~Scifi()

Scifi::~Scifi ( )

virtual

Definition at line 84 of file Scifi.cxx.

{
    if (fScifiPointCollection) {
        fScifiPointCollection->Delete();
        delete fScifiPointCollection;
    }
}

Scifi() [3/3]

Scifi::Scifi

(

const Scifi &

)

Member Function Documentation

AddHit()

ScifiPoint * Scifi::AddHit	(	Int_t	trackID,
		Int_t	detID,
		TVector3	pos,
		TVector3	mom,
		Double_t	time,
		Double_t	length,
		Double_t	eLoss,
		Int_t	pdgCode
	)

This method is an example of how to add your own point of type muonPoint to the clones array

Definition at line 962 of file Scifi.cxx.

{
    TClonesArray& clref = *fScifiPointCollection;
    Int_t size = clref.GetEntriesFast();
    return new(clref[size]) ScifiPoint(trackID, detID, pos, mom,
                                       time, length, eLoss, pdgCode);
}

area()

Double_t Scifi::area	(	Double_t	a,
		Double_t	R,
		Double_t	xL,
		Double_t	xR
	)

Definition at line 837 of file Scifi.cxx.

{
    Double_t fracL = -1;
    Double_t fracR = -1;
    if (xL<=a-R && xR>=a+R) {return 1;}
    Double_t leftC    = ycross(a,R,xL);
    Double_t rightC = ycross(a,R,xR);
    if (leftC<0 && rightC<0) {return -1;}
    if ( !(rightC<0) ){  fracR = fraction(R,abs(xR-a),rightC);}
    if ( !(leftC<0) )   {   fracL = fraction(R,abs(xL-a),leftC);}
    Double_t theAnswer = 0;
    if ( !(leftC<0) ) { 
        if(xL<a){theAnswer += 1-fracL;}
        else{      theAnswer += fracL;}
        if ( !(rightC<0) ) {theAnswer -=1;}
    }
    if ( !(rightC<0) ){
        if(xR>a){ theAnswer += 1-fracR;}
        else{      theAnswer +=  fracR;}
    }
    return theAnswer;
}

BeginEvent()

virtual void Scifi::BeginEvent ( )

inlinevirtual

Definition at line 94 of file Scifi.h.

{;}

BeginPrimary()

virtual void Scifi::BeginPrimary ( )

inlinevirtual

Definition at line 91 of file Scifi.h.

{;}

ConstructGeometry()

void Scifi::ConstructGeometry

(

)

Create the detector geometry

Definition at line 118 of file Scifi.cxx.

{
  InitMedium("CarbonComposite");
  TGeoMedium *CarbonComposite = gGeoManager->GetMedium("CarbonComposite");
 
  InitMedium("rohacell");
  TGeoMedium *rohacell = gGeoManager->GetMedium("rohacell");
 
  InitMedium("air");
  TGeoMedium *air = gGeoManager->GetMedium("air");
 
  InitMedium("Polycarbonate");
  TGeoMedium *PlasticBase = gGeoManager->GetMedium("Polycarbonate");
  
  InitMedium("Polystyrene");
  TGeoMedium *Polystyrene = gGeoManager->GetMedium("Polystyrene");
 
  InitMedium("PMMA");
  TGeoMedium *PMMA = gGeoManager->GetMedium("PMMA");
 
  InitMedium("PMMA2");
  TGeoMedium *PMMA2 = gGeoManager->GetMedium("PMMA2");
  
  InitMedium("Epoxy");
  TGeoMedium *Epoxy = gGeoManager->GetMedium("Epoxy");
 
  TGeoVolume *volTarget = gGeoManager->GetVolume("volTarget");
  
  InitMedium("iron");
  TGeoMedium *Fe =gGeoManager->GetMedium("iron");
 
// external parameters
    Double_t fXDimension = conf_floats["Scifi/xdim"];
    Double_t fYDimension = conf_floats["Scifi/ydim"];
    Double_t fZDimension = conf_floats["Scifi/zdim"];
 
    Double_t fWidthScifiMat   = conf_floats["Scifi/scifimat_width"];
    Double_t fLengthScifiMat = conf_floats["Scifi/scifimat_length"];
    Double_t fZScifiMat              = conf_floats["Scifi/scifimat_z"];
    Double_t fZEpoxyMat          = conf_floats["Scifi/epoxymat_z"];
    Double_t fGapScifiMat        = conf_floats["Scifi/scifimat_gap"]; //dead zone between mats
 
    Double_t fFiberLength         = conf_floats["Scifi/fiber_length"];
    Double_t fScintCore_rmax  =  conf_floats["Scifi/scintcore_rmax"];
    Double_t fClad1_rmin  =  conf_floats["Scifi/clad1_rmin"];
    Double_t fClad1_rmax =  conf_floats["Scifi/clad1_rmax"];
    Double_t fClad2_rmin  =  conf_floats["Scifi/clad2_rmin"];
    Double_t fClad2_rmax =  conf_floats["Scifi/clad2_rmax"];
 
    Double_t fHorPitch         =  conf_floats["Scifi/horizontal_pitch"]; //Fiber position params
    Double_t fVertPitch        =  conf_floats["Scifi/vertical_pitch"];
    Double_t fOffsetRowS  =  conf_floats["Scifi/rowlong_offset"];
    Double_t fOffsetRowL  =  conf_floats["Scifi/rowshort_offset"];
 
    Double_t fZCarbonFiber = conf_floats["Scifi/carbonfiber_z"];
    Double_t fZHoneycomb = conf_floats["Scifi/honeycomb_z"];
    Double_t fZGlue = conf_floats["Scifi/glue_z"];
    Double_t fZAirgap = conf_floats["Scifi/airgap_z"];
 
    Double_t fXPlastBar = conf_floats["Scifi/plastbar_x"]; //Dimension of plastic bar
    Double_t fYPlastBar = conf_floats["Scifi/plastbar_y"]; 
    Double_t fZPlastBar = conf_floats["Scifi/plastbar_z"];
    
    // Air gaps in baby SciFi modules
    Double_t fZBabyPlaneGap = conf_floats["Scifi/plane_gap"];
    Double_t fZBabyTedlarToPlaneGap = conf_floats["Scifi/tedlar_to_plane"];
    // Offsets between the upstream tedlar sheet and the upstream passive block
    // It includes the air gap formed btw the baby module frame and the upstream tedlar sheet. 
    Double_t fStationOffset[4] = {0, conf_floats["Scifi/station_offset1"],
                         conf_floats["Scifi/station_offset2"],
                         conf_floats["Scifi/station_offset3"]};
 
    Int_t fNFibers_Srow = conf_ints["Scifi/nfibers_shortrow"]; 
    Int_t fNFibers_Lrow = conf_ints["Scifi/nfibers_longrow"]; 
    Int_t fNFibers_z = conf_ints["Scifi/nfibers_z"]; 
 
    Double_t fSeparationBrick = conf_floats["Scifi/scifi_separation"];  //Separation between successive SciFi volumes
    Double_t fZOffset = conf_floats["Scifi/offset_z"]; 
    Int_t fNMats   = conf_ints["Scifi/nmats"];             //Number of mats in one SciFi plane
    Int_t fNScifi    = conf_ints["Scifi/nscifi"];               //Number of Scifi walls
    Int_t fNSiPMs  = conf_ints["Scifi/nsipm_mat"]; //Number of SiPMs per SciFi mat
 
    Double_t fWidthChannel = conf_floats["Scifi/channel_width"]; //One channel width 
    Double_t fHeightChannel = conf_floats["Scifi/channel_height"]; //One channel height
    Double_t fCharr = conf_floats["Scifi/charr_width"]; //Width of an array of 64 channels without gaps
    Double_t fEdge = conf_floats["Scifi/sipm_edge"]; //Edge at the left and right sides of the SiPM
    Double_t fCharrGap = conf_floats["Scifi/charr_gap"]; //Gap between two charr
    Double_t fBigGap = conf_floats["Scifi/sipm_diegap"]; //Gap between two arrays
    Int_t fNSiPMChan = conf_ints["Scifi/nsipm_channels"]; //Number of channels in each SiPM
    Double_t firstChannelX = conf_floats["Scifi/firstChannelX"]; //local X Position of first channel in plane
    
    Int_t PassiveBlockNotCenterred = conf_ints["Scifi/PassiveBlocknotCenterred"]; // flag showing whether the passive material (FeBlocks) are to be centerred wrt the Scifi
 
//edge positions in TI18 survey system:
        std::map<int,TVector3> Vedges;
        Vedges[0]=TVector3(-conf_floats["Scifi/Xpos0"],conf_floats["Scifi/Zpos0"],conf_floats["Scifi/Ypos0"]);
        Vedges[1]=TVector3(-conf_floats["Scifi/Xpos1"],conf_floats["Scifi/Zpos1"],conf_floats["Scifi/Ypos1"]);
        Vedges[2]=TVector3(-conf_floats["Scifi/Xpos2"],conf_floats["Scifi/Zpos2"],conf_floats["Scifi/Ypos2"]);
        Vedges[3]=TVector3(-conf_floats["Scifi/Xpos3"],conf_floats["Scifi/Zpos3"],conf_floats["Scifi/Ypos3"]);
        Vedges[4]=TVector3(-conf_floats["Scifi/Xpos4"],conf_floats["Scifi/Zpos4"],conf_floats["Scifi/Ypos4"]);
 
//edge position in Scifi engineering drawing, y down, z towards IP1, pos X left.
//                                                         need y up, z away from IP1, pos X left:  y and z need to change sign.
 
        TVector3 Sedge = TVector3(conf_floats["Scifi/EdgeAX"],-conf_floats["Scifi/EdgeAY"],-conf_floats["Scifi/EdgeAZ"]);
//first channel position in Scifi engineering drawing:
        TVector3 SHfirst = TVector3(conf_floats["Scifi/FirstChannelHX"],-conf_floats["Scifi/FirstChannelHY"],-conf_floats["Scifi/FirstChannelHZ"]);
        TVector3 SVfirst = TVector3(conf_floats["Scifi/FirstChannelVX"],-conf_floats["Scifi/FirstChannelVY"],-conf_floats["Scifi/FirstChannelVZ"]);
 
//first channel position in sndsw local plane:
        TVector3 LHfirst = TVector3(conf_floats["Scifi/LfirstChannelHX"],conf_floats["Scifi/LfirstChannelHY"],conf_floats["Scifi/LfirstChannelHZ"]);
        TVector3 LVfirst = TVector3(conf_floats["Scifi/LfirstChannelVX"],conf_floats["Scifi/LfirstChannelVY"],conf_floats["Scifi/LfirstChannelVZ"]);
// moving plane to match edges:
        std::map<int,TVector3> DeltasH;
        std::map<int,TVector3> DeltasV;
        for (int i=0;i<5;i++){
            DeltasH[i]  = Vedges[i] - LHfirst + SHfirst - Sedge;
            DeltasV[i]  = Vedges[i] - LVfirst + SVfirst - Sedge;
        }
   Double_t totalThickness{};
 
  //Carbon Fiber Film
  TGeoVolume *CarbonFiberVolume = gGeoManager->MakeBox("CarbonFiber", CarbonComposite, fXDimension/2, fYDimension/2, fZCarbonFiber/2);
  CarbonFiberVolume->SetLineColor(kGray - 2);
  CarbonFiberVolume->SetVisibility(1);
 
  //Honeycomb Rohacell
  TGeoVolume *HoneycombVolume = gGeoManager->MakeBox("Honeycomb", rohacell, fXDimension/2, fYDimension/2, fZHoneycomb/2);
  HoneycombVolume->SetLineColor(kYellow);
  HoneycombVolume->SetVisibility(1);
 
  // Glue between Carbon Fiber and Honeycomb or Glue between Carbon Fiber and Scifi mat
  TGeoVolume *GlueVolume = gGeoManager->MakeBox("Glue", Epoxy, fXDimension/2, fYDimension/2, fZGlue/2);
  GlueVolume->SetLineColor(kYellow-1);
  GlueVolume->SetVisibility(1);
 
  // Air gap in the middle
  TGeoVolume *AirGapVolume = gGeoManager->MakeBox("Airgap", air, fXDimension/2, fYDimension/2, fZAirgap/2);
  AirGapVolume->SetLineColor(kGray-1);
  AirGapVolume->SetVisibility(1);
 
  //Plastic/Air
  //Definition of the box containing polycarbonate pieces and an air gap
  TGeoVolume *PlasticAirVolume = gGeoManager->MakeBox("PlasticAir", air, fXDimension/2, fYDimension/2, fZPlastBar/2); 
  PlasticAirVolume->SetLineColor(kGray-1);
  PlasticAirVolume->SetVisibility(1);
  PlasticAirVolume->SetVisDaughters(1);
  
  //Plastic bars
  TGeoVolume *PlasticBarVolume = gGeoManager->MakeBox("PlasticBar", PlasticBase, fXPlastBar/2, fYPlastBar/2, fZPlastBar/2); 
  PlasticBarVolume->SetLineColor(kGray-4);
  PlasticBarVolume->SetVisibility(1);
 
  PlasticAirVolume->AddNode(PlasticBarVolume, 0, new TGeoTranslation(- fXDimension/2 + fXPlastBar/2, 0, 0));  //bars are placed || to y
  PlasticAirVolume->AddNode(PlasticBarVolume, 1, new TGeoTranslation(+ fXDimension/2 - fXPlastBar/2, 0, 0));
 
  //Plastic Glue  Air
  //Definition of the box containing glue between plastic bar and scifi mat, and an air in the middel
  TGeoVolume *PlasticGlueAirVolume = gGeoManager->MakeBox("PlasticGlueAir", air, fXDimension/2, fYDimension/2, fZGlue/2); 
  PlasticGlueAirVolume->SetLineColor(kGray-1);
  PlasticGlueAirVolume->SetVisibility(1);
  PlasticGlueAirVolume->SetVisDaughters(1);
  
  //Plastic glue bars
  TGeoVolume *PlasticGlueBarVolume = gGeoManager->MakeBox("PlasticGlueBar", Epoxy, fXPlastBar/2, fYPlastBar/2, fZGlue/2); 
  PlasticGlueBarVolume->SetLineColor(kYellow-1);
  PlasticGlueBarVolume->SetVisibility(1);
 
  PlasticGlueAirVolume->AddNode(PlasticGlueBarVolume, 0, new TGeoTranslation(- fXDimension/2 + fXPlastBar/2, 0, 0));  //bars are placed || to y
  PlasticGlueAirVolume->AddNode(PlasticGlueBarVolume, 1, new TGeoTranslation(+ fXDimension/2 - fXPlastBar/2, 0, 0));
 
  //Definition of the two air gaps for baby SciFi
  TGeoVolume *PlaneGapVolume = gGeoManager->MakeBox("PlaneGap", air, fXDimension/2, fYDimension/2, fZBabyPlaneGap/2);
  PlaneGapVolume->SetLineColor(kOrange-4);
  PlaneGapVolume->SetTransparency(50);
  PlaneGapVolume->SetVisibility(1);
  TGeoVolume *TedlarToPlaneGapVolume = gGeoManager->MakeBox("TedlarToPlaneGap", air, fXDimension/2, fYDimension/2, fZBabyTedlarToPlaneGap/2);
  TedlarToPlaneGapVolume->SetLineColor(kOrange-4);
  TedlarToPlaneGapVolume->SetTransparency(50);
  TedlarToPlaneGapVolume->SetVisibility(1);
 
  //Fiber volume that contains the scintillating core and double cladding
  TGeoVolumeAssembly *FiberVolume = new TGeoVolumeAssembly("FiberVolume");
 
  TGeoVolume *ScintCoreVol = gGeoManager->MakeTube("ScintCoreVol", Polystyrene, 0, fScintCore_rmax, fFiberLength/2); 
  TGeoVolume *Clad1Vol = gGeoManager->MakeTube("Clad1Vol", PMMA, fClad1_rmin, fClad1_rmax, fFiberLength/2); 
  TGeoVolume *Clad2Vol = gGeoManager->MakeTube("Clad2Vol", PMMA2, fClad2_rmin, fClad2_rmax, fFiberLength/2); 
  
  FiberVolume->AddNode(ScintCoreVol, 0);
  FiberVolume->AddNode(Clad1Vol, 0);
  FiberVolume->AddNode(Clad2Vol, 0);
  FiberVolume->SetVisDaughters(kFALSE);
 
  //Add SciFi fiber as sensitive unit
  AddSensitiveVolume(ScintCoreVol);
 
  //Fiber and plane rotations
  TGeoRotation *rothorfiber = new TGeoRotation("rothorfiber", 90, 90, 0);
  TGeoRotation *rotvertfiber = new TGeoRotation("rotvertfiber", 0, 90, 0);
  TGeoRotation *rot = new TGeoRotation("rot", 90, 180, 0);
 
  //SciFi mats for X and Y fiber planes
  Double_t MatThickness{};
  TGeoMedium *MatMaterial;
  if (fNScifi==5){ //TI18 SciFi
     MatMaterial = Epoxy;  
     MatThickness = fZEpoxyMat;
  }
  if (fNScifi==4){ // no glue in baby SciFi planes
     MatMaterial = air;  
     MatThickness = fZScifiMat;
  }
  TGeoVolume *HorMatVolume  = gGeoManager->MakeBox("HorMatVolume", MatMaterial, fLengthScifiMat/2, fWidthScifiMat/2, MatThickness/2); 
  TGeoVolume *VertMatVolume = gGeoManager->MakeBox("VertMatVolume", MatMaterial, fWidthScifiMat/2, fLengthScifiMat/2, MatThickness/2); 
 
  Double_t zPosM;
  Double_t offsetS =  -fWidthScifiMat/2 + fOffsetRowS;
  Double_t offsetL =  -fWidthScifiMat/2 + fOffsetRowL;
 
  // All fibres will be assigned station number 1 and mat number 1, to keep compatibility with the STMRFFF format.
  int dummy_station = 1;
  int dummy_mat = 1;
  
  //Adding horizontal fibers
  for (int irow = 0; irow < fNFibers_z; irow++){
    zPosM =  -fZScifiMat/2 + fClad2_rmax + irow*fVertPitch;
    if (irow%2 == 0){
      for (int ifiber = 0; ifiber < fNFibers_Srow; ifiber++){
    HorMatVolume->AddNode(FiberVolume, 1e6*dummy_station + 1e5*0 + 1e4*dummy_mat + 1e3*(irow + 1) + ifiber + 1, new TGeoCombiTrans("rottranshor0", 0, offsetS + ifiber*fHorPitch, zPosM, rothorfiber));
      }
    }
    else{
      for (int ifiber = 0; ifiber < fNFibers_Lrow; ifiber++){
    HorMatVolume->AddNode(FiberVolume, 1e6*dummy_station + 1e5*0 + 1e4*dummy_mat + 1e3*(irow + 1) + ifiber + 1, new TGeoCombiTrans("rottranshor1", 0, offsetL + ifiber*fHorPitch, zPosM, rothorfiber));
      }
    }
  }
  
  //Adding vertical fibers
  for (int irow = 0; irow < fNFibers_z; irow++){
    zPosM =  -fZScifiMat/2 + fClad2_rmax + irow*fVertPitch;
    if (irow%2 == 0){
      for (int ifiber = 0; ifiber < fNFibers_Srow; ifiber++){
    VertMatVolume->AddNode(FiberVolume, 1e6*dummy_station + 1e5*1 + 1e4*dummy_mat +  1e3*(irow + 1) + ifiber + 1, new TGeoCombiTrans("rottransvert0", offsetS + ifiber*fHorPitch, 0, zPosM, rotvertfiber));
      }
    }
    else{
      for (int ifiber = 0; ifiber < fNFibers_Lrow; ifiber++){
    VertMatVolume->AddNode(FiberVolume, 1e6*dummy_station + 1e5*1 + 1e4*dummy_mat + 1e3*(irow + 1) + ifiber + 1, new TGeoCombiTrans("rottransvert1", offsetL + ifiber*fHorPitch, 0, zPosM, rotvertfiber));
      }
    }
  }
 
  // for testbeam 2023
  // for now the distinct feature of the testbeam could be the 4 SciFi planes
  std::map<int, TGeoVolume*> volFeTarget;
  std::map<int, float> fFeTargetX;
  std::map<int, float> fFeTargetY;
  std::map<int, float> fFeTargetZ;
  for ( int i = 0; i < fNScifi; i++){
      std::string station = std::to_string(i+1);
      fFeTargetX[i] = conf_floats[TString("Scifi/FeTargetX"+station)];
      fFeTargetY[i] = conf_floats[TString("Scifi/FeTargetZ"+station)];
      fFeTargetZ[i] = conf_floats[TString("Scifi/FeTargetY"+station)];
  }
 
  // DetID is of the form: 
  // first digit - station number
  // second digit - type of the plane: 0-horizontal fiber, 1-vertical fiber
  // third digit - mat number
  // fourth digit - row number (in Z direction)
  // last three digits - fiber number
  // e.g. DetID = 1021074 -> station 1, horizontal fiber plane, mat 2, row 1, fiber 74
  for (int istation = 0; istation < fNScifi; istation++){
    Int_t node = 1e6*(istation+1);
    std::string station = std::to_string(istation+1);
    TGeoVolumeAssembly *ScifiVolume        = new TGeoVolumeAssembly( TString("ScifiVolume"+station) );
    TGeoVolumeAssembly *ScifiHorPlaneVol = new TGeoVolumeAssembly( TString("ScifiHorPlaneVol"+station) );
    TGeoVolumeAssembly *ScifiVertPlaneVol = new TGeoVolumeAssembly( TString("ScifiVertPlaneVol"+station) );
 
    //TI18 SciFi
    if (fNScifi==5){
    //Adding the first half of the SciFi module that contains horizontal fibres
    ScifiVolume->AddNode(CarbonFiberVolume, 0, new TGeoTranslation(0, 0, fZCarbonFiber/2));
    ScifiVolume->AddNode(GlueVolume, 0, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue/2));
    ScifiVolume->AddNode(HoneycombVolume, 0, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb/2));
    ScifiVolume->AddNode(GlueVolume, 1, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue/2));
    ScifiVolume->AddNode(CarbonFiberVolume, 1, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber/2));
    ScifiVolume->AddNode(GlueVolume, 2, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber + fZGlue/2));
    ScifiVolume->AddNode(ScifiHorPlaneVol, node, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber + fZGlue + fZEpoxyMat/2));
    ScifiVolume->AddNode(PlasticGlueAirVolume, 0, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber + fZGlue + fZEpoxyMat + fZGlue/2));
    ScifiVolume->AddNode(PlasticAirVolume, 0, new TGeoTranslation(0, 0, fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber + fZGlue + fZEpoxyMat + fZGlue + fZPlastBar/2));
 
    Double_t first_half_z = fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber + fZGlue + fZEpoxyMat + fZGlue + fZPlastBar;
    ScifiVolume->AddNode(AirGapVolume, 0, new TGeoTranslation(0, 0, first_half_z + fZAirgap/2));
 
    //Adding the second half of the SciFi module that contains vertical fibres
    ScifiVolume->AddNode(PlasticAirVolume, 1, new TGeoCombiTrans("rottrans0", 0, 0, first_half_z + fZAirgap + fZPlastBar/2, rot));
    ScifiVolume->AddNode(PlasticGlueAirVolume, 1, new TGeoCombiTrans("rottrans0",0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue/2, rot));
    ScifiVolume->AddNode(ScifiVertPlaneVol, node, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat/2));
    ScifiVolume->AddNode(GlueVolume, 3, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue/2));
    ScifiVolume->AddNode(CarbonFiberVolume, 2, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber/2));
    ScifiVolume->AddNode(GlueVolume, 4, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber + fZGlue/2));
    ScifiVolume->AddNode(HoneycombVolume, 0, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber + fZGlue + fZHoneycomb/2));
    ScifiVolume->AddNode(GlueVolume, 5, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue/2));
    ScifiVolume->AddNode(CarbonFiberVolume, 3, new TGeoTranslation(0, 0, first_half_z + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber/2));
 
    // Double_t totalThickness = fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber + fZGlue + fZEpoxyMat + fZGlue + fZPlastBar + fZAirgap + fZPlastBar + fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber;
    totalThickness = fZCarbonFiber + fZGlue + fZHoneycomb + fZGlue + fZCarbonFiber +
                          fZGlue + fZEpoxyMat + fZGlue + fZPlastBar + fZAirgap + fZPlastBar +
                          fZGlue + fZEpoxyMat + fZGlue + fZCarbonFiber + fZGlue + fZHoneycomb +
                          fZGlue + fZCarbonFiber;
    }
 
    //Baby SciFi
    // No glue in this case and one uses fZScifiMat and not the fZEpoxyMat for the mat thickness
    if (fNScifi==4){
       //Adding the first half of the SciFi module that contains horizontal fibres
       ScifiVolume->AddNode(TedlarToPlaneGapVolume, 1, new TGeoTranslation(0, 0, fZBabyTedlarToPlaneGap/2));
       ScifiVolume->AddNode(ScifiHorPlaneVol, node, new TGeoTranslation(0, 0, fZBabyTedlarToPlaneGap + fZScifiMat/2));
 
       // Add the air gap between the X and Y plane
       ScifiVolume->AddNode(PlaneGapVolume, 0, new TGeoTranslation(0, 0, fZBabyTedlarToPlaneGap + fZScifiMat + fZBabyPlaneGap/2));
 
       //Adding the second half of the SciFi module that contains vertical fibres
       ScifiVolume->AddNode(ScifiVertPlaneVol, node, new TGeoTranslation(0, 0, fZBabyTedlarToPlaneGap + 3*fZScifiMat/2 + fZBabyPlaneGap));
       ScifiVolume->AddNode(TedlarToPlaneGapVolume, 2, new TGeoTranslation(0, 0, 3*fZBabyTedlarToPlaneGap/2 + 2*fZScifiMat + fZBabyPlaneGap));
       
       totalThickness = 2*fZBabyTedlarToPlaneGap + 2*fZScifiMat + fZBabyPlaneGap;
    }
 
    volTarget->AddNode(ScifiVolume, node, 
               new TGeoTranslation(DeltasV[istation][0], DeltasH[istation][1], DeltasH[istation][2]));
 
    // std::cout<<"deltas "<<DeltasV[istation][0]<<" "<< DeltasH[istation][1]<<" "<< DeltasH[istation][2]<<" "<<totalThickness<<std::endl;
    // for 2023 testbeam put iron blocks of variable length in between SciFi planes - the planes are dowstream of the blocks!
    // for the 2024 testbeam, the iron blocks are aligned to Brick 1 and laid on the concrete (same as SciFi 1)
    if (fNScifi==4 && istation != 0) {
       volFeTarget[istation] = gGeoManager->MakeBox(TString("volFeTarget"+station),Fe,fFeTargetX[istation]/2., fFeTargetY[istation]/2., fFeTargetZ[istation]/2.);
       volFeTarget[istation]->SetLineColor(kGreen-4);
       volTarget->AddNode(volFeTarget[istation],1,
                                         new TGeoTranslation(DeltasV[istation][0] - PassiveBlockNotCenterred*fabs(fXDimension-fFeTargetX[istation])/2.,
                                                             DeltasH[istation][1] + PassiveBlockNotCenterred*(DeltasH[0][1]-DeltasH[istation][1]
                                                                                                             +fabs(fYDimension-fFeTargetY[istation])/2.),
                                                             DeltasH[istation][2] - fStationOffset[istation] - fFeTargetZ[istation]/2.));
    }
 
    //Creating Scifi planes by appending fiber mats
    for (int imat = 0; imat < fNMats; imat++){
      int N = fNMats==1 ? imat : imat-1;
      
      //Placing mats along Y 
      ScifiHorPlaneVol->AddNode(HorMatVolume, 1e6*(istation+1) + 1e4*(imat + 1), new TGeoTranslation(0, N*(fWidthScifiMat+fGapScifiMat), 0));
        
      //Placing mats along X
      ScifiVertPlaneVol->AddNode(VertMatVolume, 1e6*(istation+1) + 1e5 + 1e4*(imat + 1), new TGeoTranslation(N*(fWidthScifiMat+fGapScifiMat), 0, 0)); 
    }
  }
 
}

CopyClones()

virtual void Scifi::CopyClones ( TClonesArray *  cl1, TClonesArray *  cl2, Int_t  offset  )

inlinevirtual

The following methods can be implemented if you need to make any optional action in your detector during the transport.

Definition at line 85 of file Scifi.h.

                                            {;}

EndOfEvent()

void Scifi::EndOfEvent ( )

virtual

Definition at line 931 of file Scifi.cxx.

{
    fScifiPointCollection->Clear();
}

FinishPrimary()

virtual void Scifi::FinishPrimary ( )

inlinevirtual

Definition at line 89 of file Scifi.h.

{;}

FinishRun()

virtual void Scifi::FinishRun ( )

inlinevirtual

Definition at line 90 of file Scifi.h.

{;}

fraction()

Double_t Scifi::fraction	(	Double_t	R,
		Double_t	x,
		Double_t	y
	)

Definition at line 830 of file Scifi.cxx.

{
    Double_t F= 2*R*R*(integralSqrt(y/R) );
    F-=(2*x*y);
    Double_t result = F/(R*R*TMath::Pi());
       return  result;
}

GetCollection()

TClonesArray * Scifi::GetCollection ( Int_t  iColl ) const

virtual

Gets the produced collections

Definition at line 950 of file Scifi.cxx.

{
    if (iColl == 0) { return fScifiPointCollection; }
    else { return NULL; }
}

GetConfParF()

Float_t Scifi::GetConfParF ( TString  name )

inline

Definition at line 50 of file Scifi.h.

{return conf_floats[name];} 

GetConfParI()

Int_t Scifi::GetConfParI ( TString  name )

inline

Definition at line 51 of file Scifi.h.

{return conf_ints[name];}

GetConfParS()

TString Scifi::GetConfParS ( TString  name )

inline

Definition at line 52 of file Scifi.h.

{return conf_strings[name];}

GetConfParVector()

std::vector< Float_t > Scifi::GetConfParVector ( TString  name )

inline

Definition at line 53 of file Scifi.h.

{return conf_vectors[name];}

GetCorrectedTime()

Double_t Scifi::GetCorrectedTime	(	Int_t	fDetectorID,
		Double_t	rawTime,
		Double_t	L
	)

Definition at line 614 of file Scifi.cxx.

                                                                               {
/* expect time in u.ns  and  path length to sipm u.cm */
    TString tag = "t";
    TString sID;
 
    if (eventHeader){
        Int_t fRunNumber = eventHeader->GetRunId();
        if (fRunNumber != last_run_time){
          last_run_time = fRunNumber;
          if (fRunNumber<1) {
            LOG(ERROR) << "Scifi::GetCorrectedTime: non valid run number "<<fRunNumber;
            return rawTime;
          }
          
          if (covered_runs_time_alignment.size()!=0){
              tag = "t_"+std::to_string(covered_runs_time_alignment[covered_runs_time_alignment.size()-1]);
              for (int i=1; i<covered_runs_time_alignment.size(); i++){
                   if (fRunNumber>=covered_runs_time_alignment[i-1] && fRunNumber<covered_runs_time_alignment[i]){
                       tag = "t_"+std::to_string(covered_runs_time_alignment[i-1]);
                   }
              }
              // special case
              if (fRunNumber<5193 && fRunNumber>5174) tag = "t_"+std::to_string(covered_runs_time_alignment[0]);
          }
          else{     
               // allow reading older geo files with letter tags i.e. A, B, C
              tag = "tA";
              if (fRunNumber>5116 && !(fRunNumber<5193 && fRunNumber>5174) ) {tag = "tB";}
          }
          // 2023 and 2024 testbeam data don't have custom tags
          if (fRunNumber>=1e5) {tag = "t";}
          last_time_alignment_tag = tag;
        }
    }
    sID.Form("%i",fDetectorID);
    Double_t cor = conf_floats["Scifi/station"+TString(sID(0,1))+last_time_alignment_tag];
    if (sID(1,1)=="0"){
            // In the teatbeam 2024, SciFi 2H needs internal time corrections per channel
        if (conf_ints["Scifi/channelTimeAlignment"]==1 &&  floor(fDetectorID/100000)==20) {
           cor+=conf_vectors["Scifi/station"+TString(sID(0,4))+"XXX"+last_time_alignment_tag][fDetectorID%1000];
        }
        cor+=conf_floats["Scifi/station"+TString(sID(0,1))+"H"+TString(sID(2,1))+last_time_alignment_tag];
    }
    else{
        cor+=conf_floats["Scifi/station"+TString(sID(0,1))+"V"+TString(sID(2,1))+last_time_alignment_tag];
    }
    cor += L/conf_floats["Scifi/signalSpeed"];
    return rawTime-cor;
}

GetFibresMap()

std::map< Int_t, std::map< Int_t, std::array< float, 2 > > > Scifi::GetFibresMap ( )

inline

Definition at line 43 of file Scifi.h.

{return siPMFibres;}

GetLocalPos()

TVector3 Scifi::GetLocalPos	(	Int_t	id,
		TVector3 *	glob
	)

Transform global position to local position in plane

Definition at line 709 of file Scifi.cxx.

                                                   {
    TString sID;
    sID.Form("%i",id);
    TString path = "/cave_1/Detector_0/volTarget_1/ScifiVolume"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000/";
    if (sID(1,1)=="0"){
        path+="ScifiHorPlaneVol"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000";
    }else{
        path+="ScifiVertPlaneVol"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000";
    }
    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 Scifi::GetPosition	(	Int_t	id,
		TVector3 &	vLeft,
		TVector3 &	vRight
	)

Get position of single fibre in global coordinate system

Definition at line 664 of file Scifi.cxx.

{
//  TGeoVolumeAssembly *SiPMmapVol = gGeoManager->FindVolumeFast("SiPMmapVol");
//  if(!SiPMmapVol ){SiPMmapVol=SiPMOverlap();}
 
/* STMRFFF
 First digit S:             station # within the sub-detector
 Second digit T:        type of the plane: 0-horizontal fiber plane, 1-vertical fiber plane
 Third digit M:             determines the mat number
 Fourth digit R:        row number (in Z direction)
 Last three digits F:   fiber number
*/
 
    Int_t station_number = int(fDetectorID/1e6);
    Int_t mat_number = int(fDetectorID/1e4)%int(fDetectorID/1e5);
 
    Int_t local_fibre_id = fDetectorID - (station_number-1)*1e6 - (mat_number-1)*1e4;
    TString sLocalID;
    sLocalID.Form("%i", local_fibre_id);
 
    TString sID;
    sID.Form("%i",fDetectorID);
    TString path = "/cave_1/Detector_0/volTarget_1/ScifiVolume"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000/";
    if (sID(1,1)=="0"){
        path+="ScifiHorPlaneVol"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000/";
        path+="HorMatVolume_"+TString(sID(0,3))+"0000/";
    }else{
        path+="ScifiVertPlaneVol"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000/";
        path+="VertMatVolume_"+TString(sID(0,3))+"0000/";
    }
    path+="FiberVolume_"+sLocalID;
    TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
    nav->cd(path);
    LOG(DEBUG) <<path<<" "<<fDetectorID;
    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]);
 
}

GetSiPMmap()

std::map< Int_t, std::map< Int_t, std::array< float, 2 > > > Scifi::GetSiPMmap ( )

inline

Definition at line 42 of file Scifi.h.

{return fibresSiPM;}

GetSiPMPos()

std::map< Int_t, float > Scifi::GetSiPMPos ( )

inline

Definition at line 44 of file Scifi.h.

{return SiPMPos;}

GetSiPMPosition()

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

mean position of fibre2 associated with SiPM channel

Definition at line 727 of file Scifi.cxx.

{
/* STMRFFF
 First digit S:         station # within the sub-detector
 Second digit T:        type of the plane: 0-horizontal fiber plane, 1-vertical fiber plane
 Third digit M:         determines the mat number 0-2
 Fourth digit S:        SiPM number  0-3
 Last three digits F:   local SiPM channel number in one mat  0-127
*/
    Int_t locNumber            = SiPMChan%100000;
    Int_t globNumber         = int(SiPMChan/100000)*100000;
    Float_t locPosition        = SiPMPos[locNumber]; // local position in plane of reference plane.
    Double_t fFiberLength  = conf_floats["Scifi/fiber_length"];
    Int_t fNMats   = conf_ints["Scifi/nmats"]; 
    
    TString tag = "";
 
    // in case of old data with FairEventHeader, user will be responsible to use the correct geofile.
    if (eventHeader){
        Int_t fRunNumber = eventHeader->GetRunId();
        if (fRunNumber != last_run_pos){
          last_run_pos = fRunNumber;
 
          if (fRunNumber<1) {
          LOG(ERROR) << "Scifi::GetSiPMPosition: non valid run number "<<fRunNumber;
          return;
          }
          
          if (covered_runs_position_alignment.size()!=0){
              tag = "t_"+std::to_string(covered_runs_position_alignment[covered_runs_position_alignment.size()-1]);
              for (int i=1; i<covered_runs_position_alignment.size(); i++){
                   if (fRunNumber>=covered_runs_position_alignment[i-1] && fRunNumber<covered_runs_position_alignment[i]){
                       tag = "t_"+std::to_string(covered_runs_position_alignment[i-1]);
                   }
              }
          }
          else{
              // allow reading older geo files with letter tags i.e. A, B, C
              tag = "E";
              if (fRunNumber<4575) {tag = "A";}
              else if (fRunNumber<4855) {tag = "B";}
              else if (fRunNumber<5172) {tag = "C";}
              else if (fRunNumber<5431) {tag = "D";}
          }
          // 2023 testbeam data doesn't have a custom tag
          if (fRunNumber>=1e5) {tag = "";}
          last_position_alignment_tag = tag;
        }
    }
    TString sID;
    sID.Form("%i",SiPMChan);
    Int_t digits = fNMats==1 ? 2 : 1; 
    locPosition += conf_floats["Scifi/LocM"+TString(sID(0,3))+last_position_alignment_tag];
    Float_t rotPhi = conf_floats["Scifi/RotPhiS"+TString(sID(0,digits))+last_position_alignment_tag];
    Float_t rotPsi = conf_floats["Scifi/RotPsiS"+TString(sID(0,digits))+last_position_alignment_tag];
    Float_t rotTheta = conf_floats["Scifi/RotThetaS"+TString(sID(0,digits))+last_position_alignment_tag];
 
    Double_t loc[3] = {0,0,0};
    TString path = "/cave_1/Detector_0/volTarget_1/ScifiVolume"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000/";
    TGeoNavigator* nav = gGeoManager->GetCurrentNavigator();
    Double_t glob[3] = {0,0,0};
 
    if (sID(1,1)=="0"){
        path+="ScifiHorPlaneVol"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000";
        loc[0] = -fFiberLength/2 - (rotPhi + rotPsi)*locPosition ;
        loc[1] = locPosition - fFiberLength/2 * (rotPhi + rotPsi) ;
        loc[2] = rotTheta*locPosition;
        nav->cd(path);
        nav->LocalToMaster(loc, glob);
        A.SetXYZ( glob[0], glob[1],glob[2] );
        loc[0] = fFiberLength/2 - (rotPhi + rotPsi)*locPosition ;
        loc[1] = locPosition + fFiberLength/2 * (rotPhi + rotPsi) ;
        loc[2] = - rotTheta*locPosition;
        nav->LocalToMaster(loc, glob);
        B.SetXYZ( glob[0], glob[1],glob[2] );
    }else{
        path+="ScifiVertPlaneVol"+TString(sID(0,1))+"_"+TString(sID(0,1))+"000000";
        loc[0] = locPosition + fFiberLength/2*(rotPhi + rotPsi);
        loc[1] = -fFiberLength/2 + locPosition*(rotPhi + rotPsi);
        loc[2] = -fFiberLength/2*rotTheta;
        nav->cd(path);
        nav->LocalToMaster(loc, glob);
        A.SetXYZ( glob[0], glob[1],glob[2] );
        loc[0] = locPosition - fFiberLength/2*(rotPhi + rotPsi);
        loc[1] = fFiberLength/2 + locPosition*(rotPhi + rotPsi);
        loc[2] = -fFiberLength/2*rotTheta;
        nav->LocalToMaster(loc, glob);
        B.SetXYZ( glob[0], glob[1],glob[2] );
    }
}

InitEvent()

void Scifi::InitEvent

(

SNDLHCEventHeader *

e

)

Definition at line 522 of file Scifi.cxx.

                                         {
  // get mapping to eventHeader
  eventHeader = e;
 
  // Initialize
  if (not alignment_init) {
    alignment_init = true;
    // Get available tags from the geometry file
    std::string tag_string;
    
    // Time alignment tags
    for (auto key : conf_floats){
      tag_string = key.first.Data();
      if (tag_string.find("Scifi/station1t_") != std::string::npos){
    covered_runs_time_alignment.push_back(stoi(tag_string.substr(tag_string.find("t_")+2)));
      }
    }
    std::sort(covered_runs_time_alignment.begin(),covered_runs_time_alignment.end());
    // Position alignment tags
    for (auto key : conf_floats){
      tag_string = key.first.Data();
      if (tag_string.find("Scifi/LocM100t_") != std::string::npos){
    covered_runs_position_alignment.push_back(stoi(tag_string.substr(tag_string.find("t_")+2)));
      }
    }
    std::sort(covered_runs_position_alignment.begin(),covered_runs_position_alignment.end());
  }
};

Initialize()

void Scifi::Initialize ( )

virtual

Initialization of the detector is done here

Definition at line 92 of file Scifi.cxx.

{
    FairDetector::Initialize();
}

InitMedium()

Int_t Scifi::InitMedium ( const char *  name )

protected

Definition at line 98 of file Scifi.cxx.

{
    static FairGeoLoader *geoLoad=FairGeoLoader::Instance();
    static FairGeoInterface *geoFace=geoLoad->getGeoInterface();
    static FairGeoMedia *media=geoFace->getMedia();
    static FairGeoBuilder *geoBuild=geoLoad->getGeoBuilder();
    
    FairGeoMedium *ShipMedium=media->getMedium(name);
    
    if (!ShipMedium)
    {
        Fatal("InitMedium","Material %s not defined in media file.", name);
        return -1111;
    }
    TGeoMedium* medium=gGeoManager->GetMedium(name);
    if (medium!=NULL)
        return ShipMedium->getMediumIndex();
    return geoBuild->createMedium(ShipMedium);
}

integralSqrt()

Double_t Scifi::integralSqrt

(

Double_t

ynorm

)

Definition at line 825 of file Scifi.cxx.

{
    Double_t y = 1./2.*(ynorm*TMath::Sqrt(1-ynorm*ynorm)+TMath::ASin(ynorm));
    return y;
}

operator=()

Scifi & Scifi::operator=

(

const Scifi &

)

PostTrack()

virtual void Scifi::PostTrack ( )

inlinevirtual

Definition at line 92 of file Scifi.h.

{;}

PreTrack()

virtual void Scifi::PreTrack ( )

inlinevirtual

Definition at line 93 of file Scifi.h.

{;}

ProcessHits()

Bool_t Scifi::ProcessHits ( FairVolume *  v = 0 )

virtual

this method is called for each step during simulation (see FairMCApplication::Stepping())

This method is called from the MC stepping

Definition at line 551 of file Scifi.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 fibre_local_id = nav->GetMother()->GetNumber() - 1e6 - 1e4; // Local ID within the mat.
        int fibre_mat_id = nav->GetMother(2)->GetNumber(); // Get mat ID.
 
        int fibre_station_number = int( fibre_mat_id / 1e6); // Get the station number from the mat
 
        int fibre_mat_id_station_removed = fibre_mat_id - fibre_station_number*1e6;
        int fibre_mat_number = int((fibre_mat_id_station_removed - int(fibre_mat_id_station_removed/1e5)*1e5)/1e4);
 
        fVolumeID = fibre_local_id + fibre_station_number*1e6 + fibre_mat_number*1e4;
 
        if (fVolumeID==0){std::cout<<"fiber vol id "<<nav->GetMother()->GetName()<<std::endl;}
 
    }
    // Sum energy loss for all steps in the active volume
    fELoss += gMC->Edep();
 
    // Create ScifiPoint at exit of active volume
    if ( gMC->IsTrackExiting()    ||
            gMC->IsTrackStop()       || 
            gMC->IsTrackDisappeared()   ) {
        if (fELoss == 0. ) { return kFALSE; }
        fTrackID  = gMC->GetStack()->GetCurrentTrackNumber();
/* STMRFFF
First digit S: station # within the sub-detector
Second digit T: type of the plane: 0-horizontal fiber plane, 1-vertical fiber plane
Third digit M: determines the mat number
Fourth digit R: row number (in Z direction)
Last three digits F: fiber number
*/
        TParticle* p=gMC->GetStack()->GetCurrentTrack();
        Int_t pdgCode = p->GetPdgCode();
 
        TLorentzVector Pos; 
        gMC->TrackPosition(Pos); 
        Double_t xmean = (fPos.X()+Pos.X())/2. ;
        Double_t ymean = (fPos.Y()+Pos.Y())/2. ;
        Double_t zmean = (fPos.Z()+Pos.Z())/2. ;
 
        AddHit(fTrackID,fVolumeID, TVector3(xmean, ymean,  zmean),
                TVector3(fMom.Px(), fMom.Py(), fMom.Pz()), fTime, fLength,
                fELoss, pdgCode);
 
        // Increment number of det points in TParticle
        ShipStack* stack = (ShipStack*) gMC->GetStack();
        stack->AddPoint(kLHCScifi);
    }   
 
    return kTRUE;
}

Register()

void Scifi::Register ( )

virtual

Registers the produced collections in FAIRRootManager.

This will create a branch in the output tree called ScifiPoint, setting the last parameter to kFALSE means: this collection will not be written to the file, it will exist only during the simulation.

Definition at line 937 of file Scifi.cxx.

{
    
    FairRootManager::Instance()->Register("ScifiPoint", "Scifi",
                                          fScifiPointCollection, kTRUE);
}

Reset()

void Scifi::Reset ( )

virtual

has to be called after each event to reset the containers

Definition at line 956 of file Scifi.cxx.

{
    fScifiPointCollection->Clear();
}

SetConfPar() [1/4]

void Scifi::SetConfPar ( TString  name, Float_t  value  )

inline

Definition at line 46 of file Scifi.h.

{conf_floats[name]=value;}

SetConfPar() [2/4]

void Scifi::SetConfPar ( TString  name, Int_t  value  )

inline

Definition at line 47 of file Scifi.h.

{conf_ints[name]=value;}

SetConfPar() [3/4]

void Scifi::SetConfPar ( TString  name, std::vector< float >  values  )

inline

Definition at line 49 of file Scifi.h.

{conf_vectors[name]=values;}

SetConfPar() [4/4]

void Scifi::SetConfPar ( TString  name, TString  value  )

inline

Definition at line 48 of file Scifi.h.

{conf_strings[name]=value;}

SetSpecialPhysicsCuts()

virtual void Scifi::SetSpecialPhysicsCuts ( )

inlinevirtual

Definition at line 87 of file Scifi.h.

{;}

SiPMmapping()

void Scifi::SiPMmapping

(

)

Definition at line 860 of file Scifi.cxx.

                       {
    Float_t fibresRadius = -1;
    Float_t dSiPM = -1;
    TGeoNode* vol;
    TGeoNode* fibre;
    SiPMOverlap();           // 12 SiPMs per mat, made for horizontal mats, fibres staggered along y-axis.
    auto sipm    = gGeoManager->FindVolumeFast("SiPMmapVol");
    TObjArray* Nodes = sipm->GetNodes();
    auto plane  = gGeoManager->FindVolumeFast("ScifiHorPlaneVol1");
    for (int imat = 0; imat < plane->GetNodes()->GetEntriesFast(); imat++){
        auto mat =  static_cast<TGeoNode*>(plane->GetNodes()->At(imat));
        Float_t t1 = mat->GetMatrix()->GetTranslation()[1];
        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();
            }
            Float_t t2 = fibre->GetMatrix()->GetTranslation()[1];
            Int_t fID = fibre->GetNumber()%100000 + imat*1e4;     // local fibre number, global fibre number = SO+fID
            Float_t a = t1+t2;
 
    //  check for overlap with any of the SiPM channels in the same mat
            for(Int_t nChan = 0; nChan< Nodes->GetEntriesFast();nChan++){        // 12 SiPMs total and 4 SiPMs per mat times 128 channels
                vol = static_cast<TGeoNode*>(Nodes->At(nChan));
                Int_t N = vol->GetNumber()%100000;
                if (imat!=int(N/10000)){continue;}
                Float_t xcentre = vol->GetMatrix()->GetTranslation()[1];
                if  (dSiPM<0){
                    TGeoBBox* B = dynamic_cast<TGeoBBox*>(vol->GetVolume()->GetShape());
                    dSiPM = B->GetDY();
                }
                if (TMath::Abs(xcentre-a)>4*fibresRadius){ 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;
                fibresSiPM[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.
    std::map<Int_t,std::map<Int_t,std::array<float, 2>>>::iterator it;
    std::map<Int_t,std::array<float, 2>>::iterator itx;
    for (it = fibresSiPM.begin(); it != fibresSiPM.end(); it++)
    {
        Int_t N = it->first;
        Float_t m = 0;
        Float_t w = 0;
        for (itx = it->second.begin(); itx != it->second.end(); itx++)
        {
            m+=(itx->second)[0]*(itx->second)[1];
            w+=(itx->second)[0];
        }
        SiPMPos[N]=m/w;
    }
// make inverse mapping, which fibre is associated to which SiPMs
    for (it = fibresSiPM.begin(); it != fibresSiPM.end(); it++)
    {
        Int_t N = it->first;
        for (itx = it->second.begin(); itx != it->second.end(); itx++)
        {
            Int_t nfibre = itx->first;
            siPMFibres[nfibre][N]=itx->second;
        }
    }
}

SiPMOverlap()

void Scifi::SiPMOverlap ( )

virtual

Definition at line 479 of file Scifi.cxx.

{   
    if (gGeoManager->FindVolumeFast("SiPMmapVol")){return;}
    Double_t fLengthScifiMat = conf_floats["Scifi/scifimat_length"];
    Double_t fWidthChannel = conf_floats["Scifi/channel_width"];
    Double_t fHeightChannel = conf_floats["Scifi/channel_height"]; 
    Int_t fNSiPMChan = conf_ints["Scifi/nsipm_channels"];
    Int_t fNSiPMs  = conf_ints["Scifi/nsipm_mat"];
    Int_t fNMats   = conf_ints["Scifi/nmats"]; 
    Double_t fEdge = conf_floats["Scifi/sipm_edge"];
    Double_t fCharr = conf_floats["Scifi/charr_width"];
    Double_t fCharrGap = conf_floats["Scifi/charr_gap"];
    Double_t fBigGap = conf_floats["Scifi/sipm_diegap"];
    Double_t firstChannelX = conf_floats["Scifi/firstChannelX"];
 
    //Contains all plane SiPMs, defined for horizontal fiber plane
    //To obtain SiPM map for vertical fiber plane rotate by 90 degrees around Z
    TGeoVolumeAssembly *SiPMmapVol = new TGeoVolumeAssembly("SiPMmapVol");
 
    TGeoVolume*ChannelVol = gGeoManager->MakeBox("ChannelVol", 0, fLengthScifiMat/2, fWidthChannel/2, fHeightChannel/2);
 
    //DetID for each channel:
    //first digit: mat number (0-2)
    //second digit: SiPM number (0-3)
    //last three digits: channel number (0-127)
 
    Double_t SiPMArray_fullwidth = fEdge+fCharr+fCharrGap+fCharr+fEdge;
    TGeoVolumeAssembly *SiPMArrayVol;
    int N = fNMats == 1 ? 1 : 0;
    Double_t pos = -fEdge+firstChannelX + N*fLengthScifiMat;
    for (int imat = 0; imat < fNMats; imat++){
      for (int isipms = 0; isipms < fNSiPMs; isipms++){
        pos+= fEdge;
        for (int ichannel = 0; ichannel < fNSiPMChan; ichannel++){
            SiPMmapVol->AddNode(ChannelVol, imat*10000+isipms *1000 + ichannel, new TGeoTranslation(0, pos, 0));
            pos += fWidthChannel;
            if (ichannel==(fNSiPMChan/2-1)){pos += fCharrGap;}
        }
        pos+=fEdge+fBigGap;
    }
   }
}

ycross()

Double_t Scifi::ycross	(	Double_t	a,
		Double_t	R,
		Double_t	x
	)

Definition at line 818 of file Scifi.cxx.

{
    Double_t y = -1;
    Double_t A = R*R - (x-a)*(x-a);
    if ( !(A<0) ){y = TMath::Sqrt(A);}
    return y;
}

Member Data Documentation

alignment_init

bool Scifi::alignment_init

Definition at line 132 of file Scifi.h.

conf_floats

std::map<TString,Float_t> Scifi::conf_floats

configuration parameters

Definition at line 120 of file Scifi.h.

conf_ints

std::map<TString,Int_t> Scifi::conf_ints

Definition at line 121 of file Scifi.h.

conf_strings

std::map<TString,TString> Scifi::conf_strings

Definition at line 122 of file Scifi.h.

conf_vectors

std::map<TString,std::vector<Float_t> > Scifi::conf_vectors

Definition at line 123 of file Scifi.h.

covered_runs_position_alignment

std::vector<int> Scifi::covered_runs_position_alignment

Definition at line 128 of file Scifi.h.

covered_runs_time_alignment

std::vector<int> Scifi::covered_runs_time_alignment

Definition at line 127 of file Scifi.h.

eventHeader

SNDLHCEventHeader* Scifi::eventHeader

Definition at line 124 of file Scifi.h.

fELoss

Double32_t Scifi::fELoss

length

Definition at line 113 of file Scifi.h.

fibresSiPM

std::map<Int_t,std::map<Int_t,std::array<float, 2> > > Scifi::fibresSiPM

energy loss

Definition at line 114 of file Scifi.h.

fLength

Double32_t Scifi::fLength

time

Definition at line 112 of file Scifi.h.

fMom

TLorentzVector Scifi::fMom

position at entrance

Definition at line 110 of file Scifi.h.

fPos

TLorentzVector Scifi::fPos

volume id

Definition at line 109 of file Scifi.h.

fScifiPointCollection

TClonesArray* Scifi::fScifiPointCollection

local SiPM channel position

container for data points

Definition at line 118 of file Scifi.h.

fTime

Double32_t Scifi::fTime

momentum at entrance

Definition at line 111 of file Scifi.h.

fVolumeID

ClassDef (Scifi,3) private Int_t Scifi::fVolumeID

track index

Track information to be stored until the track leaves the active volume.

Definition at line 108 of file Scifi.h.

last_position_alignment_tag

TString Scifi::last_position_alignment_tag

Definition at line 131 of file Scifi.h.

last_run_pos

int Scifi::last_run_pos

Definition at line 129 of file Scifi.h.

last_run_time

int Scifi::last_run_time

Definition at line 129 of file Scifi.h.

last_time_alignment_tag

TString Scifi::last_time_alignment_tag

Definition at line 130 of file Scifi.h.

siPMFibres

std::map<Int_t,std::map<Int_t,std::array<float, 2> > > Scifi::siPMFibres

mapping of fibres to SiPM channels

Definition at line 115 of file Scifi.h.

SiPMPos

std::map<Int_t,float> Scifi::SiPMPos

inverse mapping

Definition at line 116 of file Scifi.h.

---

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

• shipLHC/Scifi.h
• shipLHC/Scifi.cxx