Quick Links: KDetSim ROOT Homepage Class Index Class Hierarchy

Source: header file source file inheritance tree (.pdf)

Sections: class description function members data members class charts

class KDetector: public KGeometry, public KMaterial


KDetector

The base class for all detectors. It incorporates the calculation of
electric and weithing field as well as simulation of drift.

Calculation of the drift:

Function Members (Methods)

public:

	KDetector()
	KDetector(const KDetector&)
	~KDetector()
void	CalField(Int_t)
void	CalM(KStruct* seg, Double_t* data, Int_t = -1)
void	CalPhyField()
void	CalRamoField()
static TClass*	Class()
void	Declaration(Int_t)
static Double_t	KMaterial::dEdx(Double_t)
static Float_t	KMaterial::dEX(Double_t, Double_t, Double_t, Double_t)
TH2F*	Draw(Char_t*, Float_t = 1)
TH1F*	Draw1D(Char_t*, Float_t, Int_t, Float_t)
void	Drift(Double_t, Double_t, Double_t, Float_t, KStruct*, Double_t = 0)
void	KGeometry::ElCylinder(Float_t* Pos, Float_t R, Float_t L, Int_t O, Int_t Wei, Int_t Mat)
void	KGeometry::ElLine(Float_t* r0, Float_t* r1, Float_t* W, Int_t Wei, Int_t Mat)
void	KGeometry::ElRectangle(Float_t* Pos, Float_t* Size, Int_t Wei, Int_t Mat)
void	KGeometry::ElRectangle(Float_t* Pos, Float_t* Size, TH3F*, Float_t)
void	GaussBeam(Int_t, Float_t, Float_t, Float_t, Float_t, Float_t)
TH3F*	KGeometry::GetGeom()
void	KGeometry::GetGrid(TH3I*, Short_t = 0)
Float_t	KGeometry::GetLowEdge(Int_t)
Double_t	GetPrecision()
Double_t	KGeometry::GetStepSize(Int_t, Int_t)
Double_t	KGeometry::GetStepSize(Int_t, Float_t)
Float_t	KGeometry::GetUpEdge(Int_t)
virtual TClass*	IsA() const
Double_t	kappa(int, int, int, int)
TH3F*	KGeometry::MapToGeometry(Double_t*, Double_t = 1)
void	MipIR(Int_t = 20, Float_t = 0)
static Int_t	KMaterial::MobMod()
KDetector&	operator=(const KDetector&)
static Float_t	KMaterial::Perm(Int_t = 1)
TFile*	Read(Char_t, Char_t)
void	KGeometry::Reset(Int_t = 0, Int_t = 0)
void	ResetRnd(Int_t seed)
static Float_t	KMaterial::Rho()
void	Save(Char_t, Char_t)
Int_t	KGeometry::SetBoundaryConditions()
void	SetCalculationParameters(Double_t x, Int_t y)
void	SetDebug(Short_t x)
void	SetDriftHisto(Float_t x, Int_t = 200)
int	KGeometry::SetElecVolt(int i)
void	SetEntryPoint(Float_t x, Float_t y, Float_t z)
void	SetExitPoint(Float_t x, Float_t y, Float_t z)
void	SetNeff(TF3* neff, Int_t calnow = 1)
void	SetNeff(TH3F* neff, Int_t calnow = 1)
void	SetPrecision(Double_t x)
void	SetVoltage(Float_t x, Int_t calnow = 1)
void	ShowGaussBeam(Int_t, Float_t, Float_t, Float_t, Int_t, Int_t)
virtual void	ShowMembers(TMemberInspector&)
void	ShowMipIR(Int_t, Int_t = 14, Int_t = 1)
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
Double_t	V(int, int)

Data Members

public:

Float_t	B[3]	magnetic field
Float_t	BDTresh	hole multiplication - break down treshold
Int_t	BreakDown	if break down occurs it goes to 1 otherwise is 0
TH3I*	KGeometry::DM	detector material
TH3I*	KGeometry::EG	electrode geometry
static Int_t	KMaterial::ImpactIonization	impact ionization model
Float_t	MTresh	treshold for taking multiplication into account
static Int_t	KMaterial::Mat	Material index
static Int_t	KMaterial::Mobility	mobility model for each material
TF3*	NeffF	effective dopping concentration function
TH3F*	NeffH	effective dopping concentration histogram
KField*	Ramo	ramo field
KField*	Real	electric field
Float_t	SStep	Simulation step size;
static Float_t	KMaterial::Temperature	Temperature
Float_t	Voltage	Voltage
Float_t	Voltage2	Voltage2
TArrayF	Voltages	Array of voltages
Int_t	average	Average (over how many events)
Int_t	diff	Diffusion simulation (yes=1, no=0)
Float_t	enp[3]	entry point for the charge drift
Float_t	exp[3]	exit point for the cahrge drift
TH1F*	neg	contribution of the electrons to the total drift current
Int_t	KGeometry::nx	x-divisions
Int_t	KGeometry::ny	y-divisions
Int_t	KGeometry::nz	z-divisions
TH1F*	pos	contribution of the holes to the total drift current
TH1F*	sum	total drift current
Float_t	taue	effective trapping time constants - used if Multiplication is ON
Float_t	tauh	effective trapping time constants - used if Multiplication is ON

private:

Double_t	CalErr	Error of the solver
Short_t	Debug	Print information of drift calculation etc.
Double_t	Deps
Int_t	MaxIter	Maximum number of iterations in eq solver
TRandom*	ran	random number generator

Class Charts

Inheritance Chart:

KGeometry

KMaterial

←

KDetector

←

K3D

KPad

KPixel

KStrip

Function documentation

double V(int , int )

Double_t kappa(int , int , int , int )

Sets the effective space charge values for given point in the mesh!

void Declaration(Int_t )

 New declaration for a general detector class

void CalField(Int_t )

void Drift(Double_t , Double_t , Double_t , Float_t , KStruct* , Double_t = 0)

Drift simulation for a point charge (Float_t charg;)
starting from ( sx,sy, sz)
KStruct *seg is the structure where the  the drift paths, drift times and induced cahrges are stored

TH1F * Draw1D(Char_t* , Float_t , Int_t , Float_t )

 Draws the 1D projection of the Field
 Char_t option;  see ::Draw()
 Char_t proj;    see ::Draw()
 Int_t axis;     0=x, 1=y, 2=z;
 Float_t pos;    position along the missing coordinate if 2D z=0.5;

TH2F * Draw(Char_t* , Float_t = 1)

The function draws weighting and electric field and also the event display
 Float_t proj; position along the axis of projection
 Char_t *option:
           Which field do you want to plot?
		  W -weighting
 		  E -electric
              G -geometry
              M -material
              N -Neff = space charge
           What do do want to plot?
		  P - potential
 		  F - |field|
              X - x component of the field
              Y - y component of the field
              Z - z component of the field
          In case of 3D which plane?
              yz - the cross section is along the x value of proj
              xz - the cross section is along the y value of proj
              xy - the cross section is along the z value of proj

void MipIR(Int_t = 20, Float_t = 0)

 The simulation of the drift for the laser induced carriers - attenuation of the light.
 A track is devided into Int_ div buckets. Each bucket is drifted in the field. The
 induced currents for each carrier is calculated as the sum  all buckets.
	Int_t MobMod; mobility model
	Float_t B; magnetic field

void ShowMipIR(Int_t , Int_t = 14, Int_t = 1)

 The simulation of the drift for the minimum ionizing particles.
 A track is devided into Int_ div buckets. Each bucket is drifted in the field. The
 induced currents for each carrier is calculated as the sum  all buckets.

KDetector()

Author: Gregor Kramberger
Default constructor for KDetector class
Default = no space charge -> default space charge is function

~KDetector()

Destructor of the detector class

void CalM(KStruct* seg, Double_t* data, Int_t = -1)

void SetDriftHisto(Float_t x, Int_t = 200)

void Save(Char_t* , Char_t* )

TFile * Read(Char_t* , Char_t* )

void GaussBeam(Int_t , Float_t , Float_t , Float_t , Float_t , Float_t )

The simulation of the drift for Gaussian Beam.
A track is divided into Int_ div buckets. Each bucket is drifted in the field.
The induced currents for each carrier is calculated as the sum all buckets.

	- Int_t MobMod; mobility model                                                  
	- Float_t B; magnetic field                                                     

- Lambda [um]
- w0 [um]

void ShowGaussBeam(Int_t , Float_t , Float_t , Float_t , Int_t , Int_t )

Gaussian Beam for strip detector

A track is divided into Int_ div buckets. Each bucket is drifted in the field.
The induced currents for each carrier is calculated as the sum all buckets.

- Lambda [um]
- w0 [um]

KDetector()

 Constructors and destructor

void ResetRnd(Int_t seed)

Configuration functions

{delete ran; ran=new TRandom(seed);}

void SetCalculationParameters(Double_t x, Int_t y)

{CalErr=x; MaxIter=y;}

void CalPhyField()

{CalField(0);}

void CalRamoField()

{CalField(1);}

void SetVoltage(Float_t x, Int_t calnow = 1)

 Calculation in case of any changes

{Voltage=x; if(calnow) CalPhyField(); }

void SetNeff(TF3* neff, Int_t calnow = 1)

{NeffF=neff; if(calnow) CalPhyField(); }

void SetNeff(TH3F* neff, Int_t calnow = 1)

{NeffH=neff; if(calnow) CalPhyField(); }

void SetEntryPoint(Float_t x, Float_t y, Float_t z)

 Simulation of drift

{enp[0]=x; enp[1]=y; enp[2]=z;}

void SetExitPoint(Float_t x, Float_t y, Float_t z)

{exp[0]=x; exp[1]=y; exp[2]=z;}

void SetDebug(Short_t x)

 precision of drift

{Debug=x;}

void SetPrecision(Double_t x)

{Deps=x;}

Double_t GetPrecision()

The main detector class = the basis for simulation

{return Deps;}