//////////////////////////////////////////////////////////////////////////
-#include <TTask.h>
+#include <TTask.h> //base class
class AliRICHHelix;
-
+class AliRICHParam;
+class TClonesArray;
class AliRICHRecon : public TTask
{
public :
- AliRICHRecon(AliRICHHelix *pHelix,TClonesArray *pClusters,Int_t iMipId);
- virtual ~AliRICHRecon(){;}
+ AliRICHRecon();
+ virtual ~AliRICHRecon() {}
- Double_t ThetaCerenkov(); // it returns reconstructed Theta Cerenkov
+ Double_t ThetaCerenkov(AliRICHHelix *pHelix,TClonesArray *pCluLst,Int_t &iMipId); // it returns reconstructed Theta Cerenkov
void FindThetaPhotonCerenkov(); //
void FindAreaAndPortionOfRing(); //
- void FindEmissionPoint(); //
void FindPhotonAnglesInDRS(); //
void FindPhiPoint(); //
void FindThetaAtQuartz(Float_t ThetaCer); //
- void HoughResponse(); //
- void HoughFiltering(float HCS[]); //
- void FlagPhotons(); //
- void FindWeightThetaCerenkov(); //
+ Double_t HoughResponse ( ); //most probable track theta ckov out of all photon candidate thetas
+ Int_t FlagPhotons (Double_t theta); //n. of photon candidates which thetas are inside a window around most probable track theta ckov
+ void FindThetaCerenkov(Int_t iNclus); //
void FindIntersectionWithDetector(); //
Float_t Cerenkovangle(Float_t n, Float_t b);//
Int_t PhotonInBand(); //
Int_t CheckDetectorAcceptance() const; //
Int_t GetFittedHoughPhotons() const{ return fFittedHoughPhotons;} //
Int_t GetPhotonFlag() const{ return fPhotonFlag[fPhotonIndex];} //
- Int_t GetTrackCharge() const{ return fTrackCharge;} //
Int_t GetPhotonsNumber() const{ return fPhotonsNumber;} //
Int_t GetPhotonIndex() const{ return fPhotonIndex;} //
- Int_t GetMipIndex() const{ return fMipIndex;} //
- Int_t GetTrackIndex() const{ return fTrackIndex;} //
- Int_t GetCandidatePhotonsNumber() const{ return fCandidatePhotonsNumber;} //
- Int_t GetHoughPhotons() const{ return fHoughPhotons;} //
- Float_t GetPhotonEnergy() const{ return fPhotonEnergy;} //
- Float_t GetFreonRefractiveIndex() const{ return fFreonRefractiveIndex;} //
- Float_t GetQuartzRefractiveIndex() const{ return fQuartzRefractiveIndex;} //
- Float_t GetGasRefractiveIndex() const{ return fGasRefractiveIndex;} //
+ Float_t GetPhotonEnergy() const{ return fEphot;} //
Float_t GetEmissionPoint() const{ return fLengthEmissionPoint;} //
Float_t GetMassHypotesis() const{ return fMassHypotesis;} //
Float_t GetBetaOfParticle() const{ return fTrackBeta;} //
Float_t GetThetaPhotonInTRS() const{ return fThetaPhotonInTRS;} //
Float_t GetPhiPhotonInTRS() const{ return fPhiPhotonInTRS;} //
Float_t GetThetaAtQuartz() const{ return fThetaAtQuartz;} //
- Float_t GetPhiPoint() const{ return fPhiPoint;} //
+ Float_t GetPhiPoint() const{ return fPhiPoint[fPhotonIndex];} //
Float_t GetXCoordOfEmission() const{ return fXEmiss;} //
Float_t GetYCoordOfEmission() const{ return fYEmiss;} //
Float_t GetXInnerRing() const{ return fXInner;} //
Float_t GetPhotonEta() const{ return fPhotonEta[fPhotonIndex];} //
Float_t GetPhotonWeight() const{ return fPhotonWeight[fPhotonIndex];} //
Float_t GetHoughRMS() const{ return fHoughRMS;} //
+ Double_t GetPhotBKG() const{ return fnPhotBKG;} //
Float_t GetFittedTrackTheta() const{ return fFittedTrackTheta;} //
Float_t GetFittedTrackPhi() const{ return fFittedTrackPhi;} //
Float_t GetFittedThetaCerenkov() const{ return fFittedThetaCerenkov;} //
- void SetPhotonEnergy(Float_t PhotonEnergy) { fPhotonEnergy = PhotonEnergy;} //
- void SetFreonRefractiveIndex() {fFreonRefractiveIndex = fFreonScaleFactor*(1.177+0.0172*fPhotonEnergy);}//
- void SetQuartzRefractiveIndex() {fQuartzRefractiveIndex = sqrt(1+(46.411/(113.763556-TMath::Power(fPhotonEnergy,2)))+(228.71/(328.51563-TMath::Power(fPhotonEnergy,2))));}//
- void SetGasRefractiveIndex() { fGasRefractiveIndex = 1.;} //
- void SetFreonScaleFactor(Float_t FreonScaleFactor) {fFreonScaleFactor = FreonScaleFactor;} //
+ Float_t GetRingSigma2() const{ return fRingSigma2;} //
+ void SetPhotonEnergy(Float_t e) { fEphot = e;} //
void SetEmissionPoint(Float_t LengthEmissionPoint) { fLengthEmissionPoint = LengthEmissionPoint;} //
void SetEntranceX(Float_t Xtoentr) { fXtoentr = Xtoentr;} //
void SetEntranceY(Float_t Ytoentr) { fYtoentr = Ytoentr;} //
void SetThetaPhotonInDRS(Float_t Theta) {fThetaPhotonInDRS = Theta;} //
void SetPhiPhotonInDRS(Float_t Phi) {fPhiPhotonInDRS = Phi;} //
void SetThetaAtQuartz(Float_t ThetaAtQuartz) {fThetaAtQuartz = ThetaAtQuartz;} //
- void SetPhiPoint(Float_t PhiPoint){ fPhiPoint = PhiPoint;} //
+ void SetPhiPoint(Float_t PhiPoint){ fPhiPoint[fPhotonIndex] = PhiPoint;} //
void SetXCoordOfEmission(Float_t XEmiss) {fXEmiss = XEmiss;} //
void SetYCoordOfEmission(Float_t YEmiss) {fYEmiss = YEmiss;} //
void SetXPointOnCathode(Float_t PhotonLimitX) { fPhotonLimitX = PhotonLimitX;} //
void SetThetaPhotonCerenkov(Float_t ThetaPhotCer) {fThetaPhotonCerenkov = ThetaPhotCer;} //
void SetTrackTheta(Float_t TrackTheta) { fTrackTheta = TrackTheta;} //
void SetTrackPhi(Float_t TrackPhi) { fTrackPhi = TrackPhi;} //
- void SetTrackCharge(Int_t TrackCharge) { fTrackCharge = TrackCharge;} //
void SetShiftX(Float_t ShiftX) { fShiftX = ShiftX;} //
void SetShiftY(Float_t ShiftY) { fShiftY = ShiftY;} //
void SetDetectorWhereX(Float_t Xcoord) { fXcoord = Xcoord;} //
void SetPhotonEta(Float_t PhotonEta) { fPhotonEta[fPhotonIndex] = PhotonEta;} //
void SetPhotonFlag(Int_t PhotonFlag) { fPhotonFlag[fPhotonIndex] = PhotonFlag;} //
void SetPhotonWeight(Float_t PhotonWeight) { fPhotonWeight[fPhotonIndex] = PhotonWeight;} //
+ void SetPhotBKG(Double_t nPhotBKG) {fnPhotBKG=nPhotBKG;} //
void SetHoughRMS(Float_t HoughRMS) { fHoughRMS = HoughRMS;} //
- void SetMipIndex(Int_t MipIndex) { fMipIndex = MipIndex;} //
- void SetTrackIndex(Int_t TrackIndex) { fTrackIndex = TrackIndex;} //
- void SetHoughPhotons(Int_t HoughPhotons) { fHoughPhotons = HoughPhotons;} //
- void SetHoughPhotonsNorm(Float_t HoughPhotonsNorm) { fHoughPhotonsNorm = HoughPhotonsNorm;} //
void SetFittedTrackTheta(Float_t FittedTrackTheta) { fFittedTrackTheta = FittedTrackTheta;} //
void SetFittedTrackPhi(Float_t FittedTrackPhi) { fFittedTrackPhi = FittedTrackPhi;} //
void SetFittedThetaCerenkov(Float_t FittedThetaCerenkov) { fFittedThetaCerenkov = FittedThetaCerenkov;}//
void SetFittedHoughPhotons(Int_t FittedHoughPhotons) { fFittedHoughPhotons = FittedHoughPhotons;} //
- void FindBetaFromTheta(Float_t ThetaCerenkov) {fTrackBeta = 1/(fFreonRefractiveIndex*cos(ThetaCerenkov));}//
+ void SetRingSigma2(Float_t RingSigma2) { fRingSigma2 = RingSigma2;} //
Float_t SnellAngle(Float_t n1, Float_t n2, Float_t theta1); //
Float_t FromEmissionToCathode(); //
protected:
- TClonesArray *fpClusters; // poiter to clusters
- Int_t fTrackCharge; // charge track
- Int_t fMipIndex; // index for Mip
- Int_t fTrackIndex; // index for track
Int_t fPhotonsNumber; // Number of photons candidate
Int_t fPhotonIndex; // index of photons
Int_t fPhotonFlag[3000]; // flag for photons
- Int_t fCandidatePhotonsNumber; // number of candidate photons
- Int_t fHoughPhotons; // n. photons after Hough
Int_t fFittedHoughPhotons; // n. photons after Hough and after minimization
+ Int_t fMinNumPhots; // minimum number of photons for a given ring
Float_t fTrackTheta; // Theta of track at RICH
Float_t fTrackPhi; // Phi of track at RICH
Float_t fThetaPhotonInDRS; // Theta of photon in Detector Reference System (DRS)
Float_t fPhiPhotonInDRS; // Phi of photon in DRS
Float_t fThetaAtQuartz; // Theta at the quartz entrance
- Float_t fPhiPoint; // phi of ring point
+ Float_t fPhiPoint[3000]; // array of phi of ring photons
Float_t fXEmiss; // x emission
Float_t fYEmiss; // y emission
Float_t fXInner; // X inner ring
Float_t fYOuter; // Y outer ring
Float_t fInnerRadius; // inner radius
Float_t fOuterRadius; // outer radius
- Float_t fPhotonEnergy; // photon energy
- Float_t fFreonRefractiveIndex; // n freon
- Float_t fQuartzRefractiveIndex; // n quartz
- Float_t fGasRefractiveIndex; // n gas
- Float_t fFreonScaleFactor; // scale factor for n freon
+ Float_t fEphot; // photon energy
Float_t fLengthEmissionPoint; // lenght of emmission point
Float_t fPhotonLimitX; // X phys limit for photon
Float_t fPhotonLimitY; // Y phys limit for photon
Float_t fPhotonEta[3000]; // theta cerenkov of photon candidates
Float_t fPhotonWeight[3000]; // weigth
Float_t fHoughRMS; // rms Hough
- Float_t* fCandidatePhotonX; // x photon candidates
- Float_t* fCandidatePhotonY; // y photon candidates
- Float_t fHoughPhotonsNorm; // n. photons norm.
Float_t fFittedTrackTheta; // theta track after minim.
Float_t fFittedTrackPhi; // phi track after minim.
Float_t fFittedThetaCerenkov; // thetacerenkov after minim.
- Int_t fThetaBin; // bin in theta
Float_t fThetaMin,fThetaMax; // min max
- Float_t fXmin,fXmax,fYmin,fYmax; // xy min max
- Int_t fNrings; //current number of reconstructed rings
Bool_t fIsWEIGHT; // flag to consider weight procedure
Bool_t fIsBACKGROUND; // flag to simulate bkg
- Float_t fRadiatorWidth; // radiator width
- Float_t fQuartzWidth; // quartz width
- Float_t fGapWidth; // gap width
Float_t fDTheta; // Step for sliding window
Float_t fWindowWidth; // Hough width of sliding window
Int_t fEtaFlag[3000]; // flag for good photons
Float_t fEtaPhotons[3000]; // Cerenkov angle each photon
Float_t fWeightPhotons[3000]; // weight for each photon
+ Double_t fnPhotBKG; // # estimated BKG photons in the ring
Float_t fThetaCerenkov; // Theta angle for Hough
Float_t fWeightThetaCerenkov; // Theta Cerenkov angle weighted
Float_t fThetaPeakPos; // Peak position
-
-
+ Float_t fRingSigma2; // sigma2 of the reconstructed ring
ClassDef(AliRICHRecon,0)
};