TargetTracker Class Reference

#include <TargetTracker.h>

Inheritance diagram for TargetTracker:

Collaboration diagram for TargetTracker:

Public Member Functions
	TargetTracker (const char *name, Double_t TTX, Double_t TTY, Double_t TTZ, Bool_t Active, const char *Title="TargetTrackers")
	TargetTracker ()
void	ConstructGeometry () override
void	SetSciFiParam (Double_t scifimat_width_, Double_t scifimat_hor_, Double_t scifimat_vert_, Double_t scifimat_z_, Double_t support_z_, Double_t honeycomb_z_)
void	SetNumberSciFi (Int_t n_hor_planes_, Int_t n_vert_planes_)
void	SetTargetTrackerParam (Double_t TTX, Double_t TTY, Double_t TTZ)
void	SetBrickParam (Double_t CellW)
void	SetTotZDimension (Double_t Zdim)
void	DecodeTTID (Int_t detID, Int_t &NTT, int &nplane, Bool_t &ishor)
void	SetNumberTT (Int_t n)
void	SetDesign (Int_t Design)
Bool_t	ProcessHits (FairVolume *v=0) override
	TargetTracker (const TargetTracker &)=delete
TargetTracker &	operator= (const TargetTracker &)=delete
	ClassDefOverride (TargetTracker, 4)
Public Member Functions inherited from SHiP::Detector< TTPoint >
	Detector ()=default
	Detector (const char *Name, Bool_t Active, Int_t detID)
	Detector (const char *Name, Bool_t Active)
	~Detector () override=default
TTPoint *	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

Protected Attributes
Double_t	TTrackerX
Double_t	TTrackerY
Double_t	TTrackerZ
Double_t	scifimat_width
Double_t	scifimat_hor
Double_t	scifimat_vert
Double_t	scifimat_z
Double_t	support_z
Double_t	honeycomb_z
Int_t	n_hor_planes
Int_t	n_vert_planes
Double_t	CellWidth
Double_t	ZDimension
Int_t	fNTT
Int_t	fDesign
Protected Attributes inherited from SHiP::Detector< TTPoint >
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< TTPoint > *	fDetPoints
	energy loss
TGeoVolume *	fDetector

Detailed Description

Definition at line 21 of file TargetTracker.h.

Constructor & Destructor Documentation

TargetTracker() [1/3]

TargetTracker::TargetTracker	(	const char *	name,
		Double_t	TTX,
		Double_t	TTY,
		Double_t	TTZ,
		Bool_t	Active,
		const char *	Title = "TargetTrackers"
	)

Definition at line 60 of file TargetTracker.cxx.

    : Detector(name, Active, ktauTT) {
  TTrackerX = TTX;
  TTrackerY = TTY;
  TTrackerZ = TTZ;
}

TargetTracker() [2/3]

TargetTracker::TargetTracker

(

)

Definition at line 58 of file TargetTracker.cxx.

: Detector("TargetTracker", kTRUE, ktauTT) {}

TargetTracker() [3/3]

TargetTracker::TargetTracker ( const TargetTracker &  )

delete

Member Function Documentation

ClassDefOverride()

TargetTracker::ClassDefOverride	(	TargetTracker	,
		4
	)

ConstructGeometry()

void TargetTracker::ConstructGeometry ( )

overridevirtual

Create the detector geometry

Implements SHiP::Detector< TTPoint >.

Definition at line 100 of file TargetTracker.cxx.

                                      {
  ShipGeo::InitMedium("vacuum");
  TGeoMedium* vacuum = gGeoManager->GetMedium("vacuum");
 
  ShipGeo::InitMedium("CarbonComposite");
  TGeoMedium* CarbonComposite = gGeoManager->GetMedium("CarbonComposite");
 
  ShipGeo::InitMedium("SciFiMat");
  TGeoMedium* SciFiMat = gGeoManager->GetMedium("SciFiMat");
 
  ShipGeo::InitMedium("Airex");
  TGeoMedium* Airex = gGeoManager->GetMedium("Airex");
 
  // Target Tracker
  TGeoVolume* volTarget = gGeoManager->GetVolume("volTarget");
 
  TGeoBBox* TT_box =
      new TGeoBBox("TT_box", TTrackerX / 2, TTrackerY / 2, TTrackerZ / 2);
  TGeoVolume* TT_volume = new TGeoVolume("TT", TT_box, vacuum);
  TT_volume->SetLineColor(kBlue - 1);
  // TT_volume->SetTransparency(1);
  TT_volume->SetVisibility(1);
  TT_volume->SetVisDaughters(1);
 
  // Support Carbon Composite
  TGeoBBox* TT_support_box = new TGeoBBox("TT_support_box", TTrackerX / 2,
                                          TTrackerY / 2, support_z / 2);
  TGeoVolume* TT_support_volume =
      new TGeoVolume("TT_support", TT_support_box, CarbonComposite);
  TT_support_volume->SetLineColor(kGray - 2);
  TT_support_volume->SetVisibility(1);
 
  // Honeycomb Airex (or Nomex)
  TGeoBBox* TT_honeycomb_box = new TGeoBBox("TT_honeycomb_box", TTrackerX / 2,
                                            TTrackerY / 2, honeycomb_z / 2);
  TGeoVolume* TT_honeycomb_volume =
      new TGeoVolume("TT_honeycomb", TT_honeycomb_box, Airex);
  TT_honeycomb_volume->SetLineColor(kYellow);
  TT_honeycomb_volume->SetVisibility(1);
 
  // SciFi planes
  TGeoBBox* TT_scifi_plane_hor_box = new TGeoBBox(
      "TT_scifi_plane_hor_box", TTrackerX / 2, TTrackerY / 2, scifimat_z / 2);
  TGeoVolume* TT_scifi_plane_hor_volume =
      new TGeoVolume("TT_scifi_plane_hor", TT_scifi_plane_hor_box, SciFiMat);
  TT_scifi_plane_hor_volume->SetVisibility(1);
 
  TGeoBBox* TT_scifi_plane_vert_box = new TGeoBBox(
      "TT_scifi_plane_vert_box", TTrackerX / 2, TTrackerY / 2, scifimat_z / 2);
  TGeoVolume* TT_scifi_plane_vert_volume =
      new TGeoVolume("TT_scifi_plane_vert", TT_scifi_plane_vert_box, SciFiMat);
  TT_scifi_plane_vert_volume->SetVisibility(1);
 
  // SciFi mats for X and Y
  TGeoBBox* TT_scifimat_hor_box =
      new TGeoBBox("TT_scifimat_hor_box", scifimat_hor / 2, scifimat_width / 2,
                   scifimat_z / 2);
  TGeoVolume* TT_scifimat_hor_volume =
      new TGeoVolume("TT_scifimat_hor", TT_scifimat_hor_box, SciFiMat);
  TT_scifimat_hor_volume->SetLineColor(kCyan - 9);
 
  TGeoBBox* TT_scifimat_vert_box =
      new TGeoBBox("TT_scifimat_vert_box", scifimat_width / 2,
                   scifimat_vert / 2, scifimat_z / 2);
  TGeoVolume* TT_scifimat_vert_volume =
      new TGeoVolume("TT_scifimat_vert", TT_scifimat_vert_box, SciFiMat);
  TT_scifimat_vert_volume->SetLineColor(kGreen - 7);
 
  // Add SciFi mat as sensitive unit
  AddSensitiveVolume(TT_scifimat_hor_volume);
  AddSensitiveVolume(TT_scifimat_vert_volume);
 
  // Creating physical volumes and multiply
  for (int i = 0; i < n_hor_planes; i++) {
    TT_scifi_plane_hor_volume->AddNode(
        TT_scifimat_hor_volume, i + 1,
        new TGeoTranslation(0, (-(n_hor_planes - 1) / 2.0 + i) * scifimat_width,
                            0));
  }
  for (int i = 0; i < n_vert_planes; i++) {
    TT_scifi_plane_vert_volume->AddNode(
        TT_scifimat_vert_volume, 100 + i + 1,
        new TGeoTranslation((-(n_vert_planes - 1) / 2.0 + i) * scifimat_width,
                            0, 0));
  }
 
  TT_volume->AddNode(TT_support_volume, 0,
                     new TGeoTranslation(0, 0, -TTrackerZ / 2 + support_z / 2));
  TT_volume->AddNode(
      TT_scifi_plane_hor_volume, 0,
      new TGeoTranslation(0, 0, -TTrackerZ / 2 + support_z + scifimat_z / 2));
  TT_volume->AddNode(
      TT_scifi_plane_vert_volume, 0,
      new TGeoTranslation(
          0, 0, -TTrackerZ / 2 + support_z + scifimat_z + scifimat_z / 2));
  TT_volume->AddNode(
      TT_honeycomb_volume, 0,
      new TGeoTranslation(
          0, 0, -TTrackerZ / 2 + support_z + 2 * scifimat_z + honeycomb_z / 2));
  TT_volume->AddNode(
      TT_support_volume, 1,
      new TGeoTranslation(0, 0,
                          -TTrackerZ / 2 + support_z + 2 * scifimat_z +
                              honeycomb_z + support_z / 2));
 
  Double_t first_tt_position = -ZDimension / 2 + TTrackerZ / 2;
 
  // fNTT - number of TT walls
  for (int l = 0; l < fNTT; ++l) {
    volTarget->AddNode(
        TT_volume, 1000 * (l + 1),
        new TGeoTranslation(0, 0,
                            first_tt_position + l * (TTrackerZ + CellWidth)));
  }
}

DecodeTTID()

void TargetTracker::DecodeTTID	(	Int_t	detID,
		Int_t &	NTT,
		int &	nplane,
		Bool_t &	ishor
	)

Definition at line 263 of file TargetTracker.cxx.

                                              {
  NTT = detID / 1000;
  int idir = (detID - NTT * 1000) / 100;
 
  if (idir == 1)
    ishor = kFALSE;
  else if (idir == 0)
    ishor = kTRUE;
 
  nplane = (detID - NTT * 1000 - idir * 100);
}

operator=()

TargetTracker & TargetTracker::operator= ( const TargetTracker &  )

delete

ProcessHits()

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

override

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

This method is called from the MC stepping

Definition at line 216 of file TargetTracker.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);
  }
  // Sum energy loss for all steps in the active volume
  fELoss += gMC->Edep();
 
  // Create TTPoint at exit of active volume
  if (gMC->IsTrackExiting() || gMC->IsTrackStop() ||
      gMC->IsTrackDisappeared()) {
    if (fELoss == 0.) {
      return kFALSE;
    }
    TParticle* p = gMC->GetStack()->GetCurrentTrack();
    Int_t pdgCode = p->GetPdgCode();
    fTrackID = gMC->GetStack()->GetCurrentTrackNumber();
 
    gMC->CurrentVolID(fVolumeID);
    Int_t detID = fVolumeID;
    Int_t TTstationID;
    gMC->CurrentVolOffID(2, TTstationID);
    fVolumeID = TTstationID + detID;
 
    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 muon det points in TParticle
    ShipStack* stack = dynamic_cast<ShipStack*>(gMC->GetStack());
    stack->AddPoint(ktauTT);
  }
 
  return kTRUE;
}

SetBrickParam()

void TargetTracker::SetBrickParam

(

Double_t

CellW

)

Definition at line 92 of file TargetTracker.cxx.

{ CellWidth = CellW; }

SetDesign()

void TargetTracker::SetDesign

(

Int_t

Design

)

Definition at line 98 of file TargetTracker.cxx.

{ fDesign = Design; }

SetNumberSciFi()

void TargetTracker::SetNumberSciFi	(	Int_t	n_hor_planes_,
		Int_t	n_vert_planes_
	)

Definition at line 80 of file TargetTracker.cxx.

                                                                            {
  n_hor_planes = n_hor_planes_;
  n_vert_planes = n_vert_planes_;
}

SetNumberTT()

void TargetTracker::SetNumberTT

(

Int_t

n

)

Definition at line 96 of file TargetTracker.cxx.

{ fNTT = n; }

SetSciFiParam()

void TargetTracker::SetSciFiParam	(	Double_t	scifimat_width_,
		Double_t	scifimat_hor_,
		Double_t	scifimat_vert_,
		Double_t	scifimat_z_,
		Double_t	support_z_,
		Double_t	honeycomb_z_
	)

Definition at line 68 of file TargetTracker.cxx.

                                                                              {
  scifimat_width = scifimat_width_;
  scifimat_hor = scifimat_hor_;
  scifimat_vert = scifimat_vert_;
  scifimat_z = scifimat_z_;
  support_z = support_z_;
  honeycomb_z = honeycomb_z_;
}

SetTargetTrackerParam()

void TargetTracker::SetTargetTrackerParam	(	Double_t	TTX,
		Double_t	TTY,
		Double_t	TTZ
	)

Definition at line 85 of file TargetTracker.cxx.

                                                        {
  TTrackerX = TTX;
  TTrackerY = TTY;
  TTrackerZ = TTZ;
}

SetTotZDimension()

void TargetTracker::SetTotZDimension

(

Double_t

Zdim

)

Definition at line 94 of file TargetTracker.cxx.

{ ZDimension = Zdim; }

Member Data Documentation

CellWidth

Double_t TargetTracker::CellWidth

protected

Definition at line 64 of file TargetTracker.h.

fDesign

Int_t TargetTracker::fDesign

protected

Definition at line 69 of file TargetTracker.h.

fNTT

Int_t TargetTracker::fNTT

protected

Definition at line 67 of file TargetTracker.h.

honeycomb_z

Double_t TargetTracker::honeycomb_z

protected

Definition at line 60 of file TargetTracker.h.

n_hor_planes

Int_t TargetTracker::n_hor_planes

protected

Definition at line 61 of file TargetTracker.h.

n_vert_planes

Int_t TargetTracker::n_vert_planes

protected

Definition at line 62 of file TargetTracker.h.

scifimat_hor

Double_t TargetTracker::scifimat_hor

protected

Definition at line 56 of file TargetTracker.h.

scifimat_vert

Double_t TargetTracker::scifimat_vert

protected

Definition at line 57 of file TargetTracker.h.

scifimat_width

Double_t TargetTracker::scifimat_width

protected

Definition at line 55 of file TargetTracker.h.

scifimat_z

Double_t TargetTracker::scifimat_z

protected

Definition at line 58 of file TargetTracker.h.

support_z

Double_t TargetTracker::support_z

protected

Definition at line 59 of file TargetTracker.h.

TTrackerX

Double_t TargetTracker::TTrackerX

protected

Definition at line 51 of file TargetTracker.h.

TTrackerY

Double_t TargetTracker::TTrackerY

protected

Definition at line 52 of file TargetTracker.h.

TTrackerZ

Double_t TargetTracker::TTrackerZ

protected

Definition at line 53 of file TargetTracker.h.

ZDimension

Double_t TargetTracker::ZDimension

protected

Definition at line 65 of file TargetTracker.h.

---

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

• SND/EmulsionTarget/TargetTracker.h
• SND/EmulsionTarget/TargetTracker.cxx