Quick Links: ROOT Homepage Class Index Class Hierarchy

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

Sections: class description function members data members class charts

class AliHMPIDParam: public TNamed

  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
  *                                                                        *
  * Permission to use, copy, modify and distribute this software and its   *
  * documentation strictly for non-commercial purposes is hereby granted   *
  * without fee, provided that the above copyright notice appears in all   *
  * copies and that both the copyright notice and this permission notice   *
  * appear in the supporting documentation. The authors make no claims     *
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *

Function Members (Methods)

public:

virtual	~AliHMPIDParam()
static Int_t	A2C(Int_t pad)
static Int_t	A2P(Int_t pad)
static Int_t	A2X(Int_t pad)
static Int_t	A2Y(Int_t pad)
static Int_t	Abs(Int_t ch, Int_t pc, Int_t x, Int_t y)
void	TObject::AbstractMethod(const char* method) const
virtual void	TObject::AppendPad(Option_t* option = "")
virtual void	TObject::Browse(TBrowser* b)
Float_t	ChPhiMax(Int_t ch)
Float_t	ChPhiMin(Int_t ch)
Float_t	ChThMax(Int_t ch)
Float_t	ChThMin(Int_t ch)
static TClass*	Class()
virtual const char*	TObject::ClassName() const
virtual void	TNamed::Clear(Option_t* option = "")
virtual TObject*	TNamed::Clone(const char* newname = "") const
virtual Int_t	TNamed::Compare(const TObject* obj) const
virtual void	TNamed::Copy(TObject& named) const
static Int_t	DDL2C(Int_t ddl)
virtual void	TObject::Delete(Option_t* option = "")MENU
virtual Int_t	TObject::DistancetoPrimitive(Int_t px, Int_t py)
Float_t	DistCut() const
virtual void	TObject::Draw(Option_t* option = "")
virtual void	TObject::DrawClass() constMENU
virtual TObject*	TObject::DrawClone(Option_t* option = "") constMENU
virtual void	TObject::Dump() constMENU
static Double_t	EPhotMax()
static Double_t	EPhotMin()
virtual void	TObject::Error(const char* method, const char* msgfmt) const
virtual void	TObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual void	TObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual void	TObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual void	TObject::Fatal(const char* method, const char* msgfmt) const
virtual void	TNamed::FillBuffer(char*& buffer)
virtual TObject*	TObject::FindObject(const char* name) const
virtual TObject*	TObject::FindObject(const TObject* obj) const
static Double_t	FindTemp(Double_t tLow, Double_t tHigh, Double_t y)
Double_t	GapIdx() const
Double_t	GapThick() const
static Double_t	GausPar(Double_t x, Double_t a1, Double_t a2, Double_t a3)
virtual Option_t*	TObject::GetDrawOption() const
static Long_t	TObject::GetDtorOnly()
Double_t	GetEPhotMean() const
virtual const char*	TObject::GetIconName() const
Bool_t	GetInstType() const
virtual const char*	TNamed::GetName() const
virtual char*	TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_t	TObject::GetObjectStat()
virtual Option_t*	TObject::GetOption() const
Double_t	GetRefIdx() const
virtual const char*	TNamed::GetTitle() const
virtual UInt_t	TObject::GetUniqueID() const
virtual Bool_t	TObject::HandleTimer(TTimer* timer)
virtual ULong_t	TNamed::Hash() const
static Double_t	HinRad(Float_t y)
static void	IdealPosition(Int_t iCh, TGeoHMatrix* m)
virtual void	TObject::Info(const char* method, const char* msgfmt) const
virtual Bool_t	TObject::InheritsFrom(const char* classname) const
virtual Bool_t	TObject::InheritsFrom(const TClass* cl) const
static Int_t	InHVSector(Float_t y)
virtual void	TObject::Inspect() constMENU
static AliHMPIDParam*	Instance()
static AliHMPIDParam*	InstanceNoGeo()
void	TObject::InvertBit(UInt_t f)
virtual TClass*	IsA() const
static Bool_t	IsDeadPad(Int_t padx, Int_t pady, Int_t ch)
virtual Bool_t	TObject::IsEqual(const TObject* obj) const
virtual Bool_t	TObject::IsFolder() const
static Bool_t	IsInDead(Float_t x, Float_t y)
static Bool_t	IsInside(Float_t x, Float_t y, Float_t d = 0)
Bool_t	TObject::IsOnHeap() const
static Bool_t	IsOverTh(Float_t q)
virtual Bool_t	TNamed::IsSortable() const
Bool_t	TObject::IsZombie() const
static Double_t	K1x()
static Double_t	K1y()
static Double_t	K2x()
static Double_t	K2y()
static Double_t	K4x()
static Double_t	K4y()
static Double_t	LAbsGap(Double_t eV)
static Double_t	LAbsRad(Double_t eV)
static Double_t	LAbsWin(Double_t eV)
TVector3	Lors2Mars(Int_t c, Float_t x, Float_t y, Int_t pl = kPc) const
void	Lors2Mars(Int_t c, Float_t x, Float_t y, Double_t* m, Int_t pl = kPc) const
void	Lors2MarsVec(Int_t c, Double_t* m, Double_t* l) const
static void	Lors2Pad(Float_t x, Float_t y, Int_t& pc, Int_t& px, Int_t& py)
static Float_t	LorsX(Int_t pc, Int_t padx)
static Float_t	LorsY(Int_t pc, Int_t pady)
virtual void	TNamed::ls(Option_t* option = "") const
void	Mars2Lors(Int_t c, Double_t* m, Float_t& x, Float_t& y) const
void	Mars2LorsVec(Int_t c, Double_t* m, Float_t& th, Float_t& ph) const
static Float_t	MaxPcX(Int_t iPc)
static Float_t	MaxPcY(Int_t iPc)
void	TObject::MayNotUse(const char* method) const
Double_t	MeanIdxRad() const
Double_t	MeanIdxWin() const
static Float_t	MinPcX(Int_t iPc)
static Float_t	MinPcY(Int_t iPc)
Float_t	MultCut() const
static Double_t	NIdxGap(Double_t eV)
static Double_t	NIdxRad(Double_t eV, Double_t temp)
static Double_t	NIdxWin(Double_t eV)
static Double_t	NMgF2Idx(Double_t eV)
TVector3	Norm(Int_t c) const
void	Norm(Int_t c, Double_t* n) const
virtual Bool_t	TObject::Notify()
static Int_t	Nsig()
void	TObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static void	TObject::operator delete(void* ptr)
static void	TObject::operator delete(void* ptr, void* vp)
static void	TObject::operator delete[](void* ptr)
static void	TObject::operator delete[](void* ptr, void* vp)
void*	TObject::operator new(size_t sz)
void*	TObject::operator new(size_t sz, void* vp)
void*	TObject::operator new[](size_t sz)
void*	TObject::operator new[](size_t sz, void* vp)
virtual void	TObject::Paint(Option_t* option = "")
static Double_t	PitchAnodeCathode()
void	Point(Int_t c, Double_t* p, Int_t plane) const
virtual void	TObject::Pop()
virtual void	Print(Option_t* opt = "") const
void	PrintChStatus(Int_t ch)
Float_t	QCut() const
static Double_t	QEffCSI(Double_t eV)
static Float_t	r2d()
static Int_t	Radiator(Float_t y)
Double_t	RadThick() const
virtual Int_t	TObject::Read(const char* name)
virtual void	TObject::RecursiveRemove(TObject* obj)
void	TObject::ResetBit(UInt_t f)
virtual void	TObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual void	TObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
void	TObject::SetBit(UInt_t f)
void	TObject::SetBit(UInt_t f, Bool_t set)
void	SetChStatus(Int_t ch, Bool_t status = kTRUE)
virtual void	TObject::SetDrawOption(Option_t* option = "")MENU
static void	TObject::SetDtorOnly(void* obj)
void	SetEPhotMean(Double_t ePhotMean)
void	SetGeomAccept()
void	SetInstanceType(Bool_t inst)
virtual void	TNamed::SetName(const char* name)MENU
virtual void	TNamed::SetNameTitle(const char* name, const char* title)
void	SetNSigmas(Int_t sigmas)
static void	TObject::SetObjectStat(Bool_t stat)
void	SetPcStatus(Int_t ch, Int_t pc, Bool_t status)
void	SetRefIdx(Double_t refRadIdx)
void	SetSectStatus(Int_t ch, Int_t sect, Bool_t status)
void	SetTemp(Double_t temp)
void	SetThreshold(Int_t thres)
virtual void	TNamed::SetTitle(const char* title = "")MENU
virtual void	TObject::SetUniqueID(UInt_t uid)
virtual void	ShowMembers(TMemberInspector&)
Double_t	SigCrom(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh, Double_t beta)
Double_t	SigGeom(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh, Double_t beta)
Double_t	SigLoc(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh, Double_t beta)
Double_t	Sigma2(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh)
static Double_t	SigmaCorrFact(Int_t iPart, Double_t occupancy)
static Float_t	SizeAllX()
static Float_t	SizeAllY()
virtual Int_t	TNamed::Sizeof() const
static Float_t	SizePadX()
static Float_t	SizePadY()
static Float_t	SizePcX()
static Float_t	SizePcY()
static Double_t	SqrtK3x()
static Double_t	SqrtK3y()
static Int_t	Stack(Int_t evt = -1, Int_t tid = -1)
static Int_t	StackCount(Int_t pid, Int_t evt)
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual void	TObject::SysError(const char* method, const char* msgfmt) const
Bool_t	TObject::TestBit(UInt_t f) const
Int_t	TObject::TestBits(UInt_t f) const
virtual void	TObject::UseCurrentStyle()
virtual void	TObject::Warning(const char* method, const char* msgfmt) const
Double_t	WinIdx() const
Double_t	WinThick() const
virtual Int_t	TObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_t	TObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const

protected:

	AliHMPIDParam(Bool_t noGeo)
virtual void	TObject::DoError(int level, const char* location, const char* fmt, va_list va) const
void	TObject::MakeZombie()

private:

	AliHMPIDParam(const AliHMPIDParam& r)
AliHMPIDParam&	operator=(const AliHMPIDParam& r)

Data Members

public:

enum EChamberData {	kMinCh
	kMaxCh
	kMinPc
	kMaxPc
};
enum EPadxData {	kPadPcX
	kMinPx
	kMaxPx
	kMaxPcx
};
enum EPadyData {	kPadPcY
	kMinPy
	kMaxPy
	kMaxPcy
};
enum EPedestalData {	kPadMeanZeroCharge
	kPadSigmaZeroCharge
	kPadMeanMasked
	kPadSigmaMasked
};
enum EPlaneId {	kPc
	kRad
	kAnod
};
enum ETrackingFlags {	kMipDistCut
	kMipQdcCut
	kNoPhotAccept
};
enum TObject::EStatusBits {	kCanDelete
	kMustCleanup
	kObjInCanvas
	kIsReferenced
	kHasUUID
	kCannotPick
	kNoContextMenu
	kInvalidObject
};
enum TObject::[unnamed] {	kIsOnHeap
	kNotDeleted
	kZombie
	kBitMask
	kSingleKey
	kOverwrite
	kWriteDelete
};

protected:

TGeoHMatrix*	fM[7]	pointers to matrices defining HMPID chambers rotations-translations
TString	TNamed::fName	object identifier
Double_t	fPhotEMean	mean energy of photon
Double_t	fRefIdx	running refractive index of C6F14
Double_t	fTemp	actual temparature of C6F14
TString	TNamed::fTitle	object title
Float_t	fX	x shift of LORS with respect to rotated MARS
Float_t	fY	y shift of LORS with respect to rotated MARS
static Float_t	fgAllX
static Float_t	fgAllY	definition of HMPID geometric parameters
static Float_t	fgCellX
static Float_t	fgCellY
static AliHMPIDParam*	fgInstance	static pointer to instance of AliHMPIDParam singleton
static Bool_t	fgInstanceType	kTRUE if from geomatry kFALSE if from ideal geometry
static Bool_t	fgMapPad[160][144][7]	map of pads to evaluate if they are active or dead (160,144) pads for 7 chambers
static Int_t	fgNSigmas	sigma Cut
static Float_t	fgPcX
static Float_t	fgPcY
static Int_t	fgThreshold	sigma Cut
static const Double_t	fgkD	ANODE-CATHODE distance 0.445/2
static const Double_t	fgkK1x
static const Double_t	fgkK1y
static const Double_t	fgkK2x
static const Double_t	fgkK2y
static const Double_t	fgkK4x
static const Double_t	fgkK4y
static Float_t	fgkMaxPcX[6]	limits PC
static Float_t	fgkMaxPcY[6]
static Float_t	fgkMinPcX[6]	limits PC
static Float_t	fgkMinPcY[6]	limits PC
static const Double_t	fgkSqrtK3x
static const Double_t	fgkSqrtK3y

Class Charts

Inheritance Chart:

TNamed

←

AliHMPIDParam

Function documentation

AliHMPIDParam(Bool_t noGeo)

 Here all the intitializition is taken place when AliHMPIDParam::Instance() is invoked for the first time.
 In particular, matrices to be used for LORS<->MARS trasnformations are initialized from TGeo structure.
 Note that TGeoManager should be already initialized from geometry.root file

void Print(Option_t* opt = "") const

 print some usefull (hopefully) info on some internal guts of HMPID parametrisation

void IdealPosition(Int_t iCh, TGeoHMatrix* m)

 Construct ideal position matrix for a given chamber
 Arguments: iCh- chamber ID; pMatrix- pointer to precreated unity matrix where to store the results
   Returns: none

Int_t Stack(Int_t evt = -1, Int_t tid = -1)

 Prints some useful info from stack
 Arguments: evt - event number. if not -1 print info only for that event
            tid - track id. if not -1 then print it and all it's mothers if any
   Returns: mother tid of the given tid if any

Int_t StackCount(Int_t pid, Int_t evt)

 Counts total number of particles of given sort (including secondary) for a given event

Double_t Sigma2(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh)

 Analithical calculation of total error (as a sum of localization, geometrical and chromatic errors) on Cerenkov angle for a given Cerenkov photon
 created by a given MIP. Fromulae according to CERN-EP-2000-058
 Arguments: Cerenkov and azimuthal angles for Cerenkov photon, [radians]
            dip and azimuthal angles for MIP taken at the entrance to radiator, [radians]
            MIP beta
   Returns: absolute error on Cerenkov angle, [radians]

Double_t SigLoc(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh, Double_t beta)

 Analitical calculation of localization error (due to finite segmentation of PC) on Cerenkov angle for a given Cerenkov photon
 created by a given MIP. Fromulae according to CERN-EP-2000-058
 Arguments: Cerenkov and azimuthal angles for Cerenkov photon, [radians]
            dip and azimuthal angles for MIP taken at the entrance to radiator, [radians]
            MIP beta
   Returns: absolute error on Cerenkov angle, [radians]

Double_t SigCrom(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh, Double_t beta)

 Analitical calculation of chromatic error (due to lack of knowledge of Cerenkov photon energy) on Cerenkov angle for a given Cerenkov photon
 created by a given MIP. Fromulae according to CERN-EP-2000-058
 Arguments: Cerenkov and azimuthal angles for Cerenkov photon, [radians]
            dip and azimuthal angles for MIP taken at the entrance to radiator, [radians]
            MIP beta
   Returns: absolute error on Cerenkov angle, [radians]

Double_t SigGeom(Double_t trkTheta, Double_t trkPhi, Double_t ckovTh, Double_t ckovPh, Double_t beta)

 Analitical calculation of geometric error (due to lack of knowledge of creation point in radiator) on Cerenkov angle for a given Cerenkov photon
 created by a given MIP. Formulae according to CERN-EP-2000-058
 Arguments: Cerenkov and azimuthal angles for Cerenkov photon, [radians]
            dip and azimuthal angles for MIP taken at the entrance to radiator, [radians]
            MIP beta
   Returns: absolute error on Cerenkov angle, [radians]

Double_t SigmaCorrFact(Int_t iPart, Double_t occupancy)

AliHMPIDParam* Instance()

AliHMPIDParam* InstanceNoGeo()

Bool_t IsInDead(Float_t x, Float_t y)

Bool_t IsDeadPad(Int_t padx, Int_t pady, Int_t ch)

void Lors2Pad(Float_t x, Float_t y, Int_t& pc, Int_t& px, Int_t& py)

Int_t InHVSector(Float_t y)

Double_t FindTemp(Double_t tLow, Double_t tHigh, Double_t y)

void SetChStatus(Int_t ch, Bool_t status = kTRUE)

void SetSectStatus(Int_t ch, Int_t sect, Bool_t status)

void SetPcStatus(Int_t ch, Int_t pc, Bool_t status)

void PrintChStatus(Int_t ch)

void SetGeomAccept()

#include <TVector3.h> // Lors2Mars()

Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
 See cxx source for full Copyright notice                               
Id

virtual ~AliHMPIDParam()

 Class providing all the needed parametrised information
 to construct the geometry, to define segmentation and to provide response model
 In future will also provide all the staff needed for alignment and calibration
ctor&dtor

Float_t r2d()

{return 57.2957795; }

Float_t SizePadX()

{return fgCellX; }

Float_t SizePadY()

{return fgCellY; }

Float_t SizePcX()

{return fgPcX; }

Float_t SizePcY()

{return fgPcY; }

Float_t MaxPcX(Int_t iPc)

{return fgkMaxPcX[iPc]; }

Float_t MaxPcY(Int_t iPc)

{return fgkMaxPcY[iPc]; }

Float_t MinPcX(Int_t iPc)

{return fgkMinPcX[iPc]; }

Float_t MinPcY(Int_t iPc)

{return fgkMinPcY[iPc]; }

Int_t Nsig()

{return fgNSigmas; }

Float_t SizeAllX()

{return fgAllX; }

Float_t SizeAllY()

{return fgAllY; }

Float_t LorsX(Int_t pc, Int_t padx)

{return (padx +0.5)*SizePadX()+fgkMinPcX[pc]; }

Float_t LorsY(Int_t pc, Int_t pady)

{return (pady +0.5)*SizePadY()+fgkMinPcY[pc]; }

Float_t ChPhiMin(Int_t ch)

{return Lors2Mars(ch,LorsX(ch,kMinPx)-fX,LorsY(ch,kMinPy)-fY).Phi()*r2d();}

Float_t ChThMin(Int_t ch)

{return Lors2Mars(ch,LorsX(ch,kMinPx)-fX,LorsY(ch,kMinPy)-fY).Theta()*r2d();}

Float_t ChPhiMax(Int_t ch)

{return Lors2Mars(ch,LorsX(ch,kMaxPcx)-fX,LorsY(ch,kMaxPcy)-fY).Phi()*r2d();}

Float_t ChThMax(Int_t ch)

{return Lors2Mars(ch,LorsX(ch,kMaxPcx)-fX,LorsY(ch,kMaxPcy)-fY).Theta()*r2d();}

Int_t Abs(Int_t ch, Int_t pc, Int_t x, Int_t y)

{return ch*100000000+pc*1000000+x*1000+y; }

Int_t DDL2C(Int_t ddl)

{return ddl/2; }

Int_t A2C(Int_t pad)

{return pad/100000000; }

Int_t A2P(Int_t pad)

{return pad%100000000/1000000; }

Int_t A2X(Int_t pad)

{return pad%1000000/1000; }

Int_t A2Y(Int_t pad)

{return pad%1000; }

Bool_t IsOverTh(Float_t q)

{return q >= fgThreshold; }

Bool_t GetInstType() const

{return fgInstanceType; }

Int_t Radiator(Float_t y)

{if (InHVSector(y)<0) return -1; return InHVSector(y)/2;}

Double_t HinRad(Float_t y)

{if (Radiator(y)<0) return -1;return y-Radiator(y)*fgkMinPcY[Radiator(y)];}

Bool_t IsInside(Float_t x, Float_t y, Float_t d = 0)

{return x>-d&&y>-d&&x<fgkMaxPcX[kMaxPc]+d&&y<fgkMaxPcY[kMaxPc]+d; }

Double_t EPhotMin()

For optical properties

{return 5.5;}

Double_t EPhotMax()

{return 8.5;}

Double_t NIdxRad(Double_t eV, Double_t temp)

{return TMath::Sqrt(1+0.554*(1239.84/eV)*(1239.84/eV)/((1239.84/eV)*(1239.84/eV)-5769))-0.0005*(temp-20);}

Double_t NIdxWin(Double_t eV)

{return TMath::Sqrt(1+46.411/(10.666*10.666-eV*eV)+228.71/(18.125*18.125-eV*eV));}

Double_t NMgF2Idx(Double_t eV)

{return 1.7744 - 2.866e-3*(1239.842609/eV) + 5.5564e-6*(1239.842609/eV)*(1239.842609/eV);}

Double_t NIdxGap(Double_t eV)

{return 1+0.12489e-6/(2.62e-4 - eV*eV/1239.84/1239.84);}

Double_t LAbsRad(Double_t eV)

{return (eV<7.8)*(GausPar(eV,3.20491e16,-0.00917890,0.742402)+GausPar(eV,3035.37,4.81171,0.626309))+(eV>=7.8)*0.0001;}

Double_t LAbsWin(Double_t eV)

{return (eV<8.2)*(818.8638-301.0436*eV+36.89642*eV*eV-1.507555*eV*eV*eV)+(eV>=8.2)*0.0001;}

Double_t LAbsGap(Double_t eV)

{return (eV<7.75)*6512.399+(eV>=7.75)*3.90743e-2/(-1.655279e-1+6.307392e-2*eV-8.011441e-3*eV*eV+3.392126e-4*eV*eV*eV);}

Double_t QEffCSI(Double_t eV)

{return (eV>6.07267)*0.344811*(1-exp(-1.29730*(eV-6.07267)));}

Double_t GausPar(Double_t x, Double_t a1, Double_t a2, Double_t a3)

{return a1*TMath::Exp(-0.5*((x-a2)/a3)*((x-a2)/a3));}

Double_t GetEPhotMean() const

{return fPhotEMean;}

Double_t GetRefIdx() const

{return fRefIdx;}

Double_t MeanIdxRad() const

{return NIdxRad(fPhotEMean,fTemp);}

Double_t MeanIdxWin() const

{return NIdxWin(fPhotEMean);}

Float_t DistCut() const

{return 1.0;}

Float_t QCut() const

{return 100;}

Float_t MultCut() const

{return 30;}

Double_t RadThick() const

{return 1.5;}

Double_t WinThick() const

{return 0.5;}

Double_t GapThick() const

{return 8.0;}

Double_t WinIdx() const

{return 1.5787;}

Double_t GapIdx() const

{return 1.0005;}

void Lors2Mars(Int_t c, Float_t x, Float_t y, Double_t* m, Int_t pl = kPc) const

trasformation methodes

void Mars2Lors(Int_t c, Double_t* m, Float_t& x, Float_t& y) const

{Double_t l[3];fM[c]->MasterToLocal(m,l);x=l[0]+fX;y=l[1]+fY;}

void Mars2LorsVec(Int_t c, Double_t* m, Float_t& th, Float_t& ph) const

void Lors2MarsVec(Int_t c, Double_t* m, Double_t* l) const

{fM[c]->LocalToMasterVect(m,l); }

TVector3 Norm(Int_t c) const

{Double_t n[3]; Norm(c,n); return TVector3(n); }

void Norm(Int_t c, Double_t* n) const

void Point(Int_t c, Double_t* p, Int_t plane) const

{Lors2Mars(c,0,0,p,plane);}

void SetTemp(Double_t temp)

{fTemp = temp;}

void SetEPhotMean(Double_t ePhotMean)

{fPhotEMean = ePhotMean;}

void SetRefIdx(Double_t refRadIdx)

{fRefIdx = refRadIdx;}

void SetNSigmas(Int_t sigmas)

{fgNSigmas = sigmas;}

void SetThreshold(Int_t thres)

{fgThreshold = thres;}

void SetInstanceType(Bool_t inst)

For PID

{fgInstanceType = inst;}

Double_t PitchAnodeCathode()

Mathieson Getters

{return fgkD;}

Double_t SqrtK3x()

{return fgkSqrtK3x;}

Double_t K2x()

{return fgkK2x;}

Double_t K1x()

{return fgkK1x;}

Double_t K4x()

{return fgkK4x;}

Double_t SqrtK3y()

{return fgkSqrtK3y;}

Double_t K2y()

{return fgkK2y;}

Double_t K1y()

{return fgkK1y;}

Double_t K4y()

{return fgkK4y;}

AliHMPIDParam(Bool_t noGeo)

AliHMPIDParam & operator=(const AliHMPIDParam& r)