//
//
//
-// This function is used for fitting
-void fcn1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
+
ClassImp(AliMUONClusterFinderAZ)
-AliMUONClusterFinderAZ* AliMUONClusterFinderAZ::fgClusterFinder = NULL;
-TMinuit* AliMUONClusterFinderAZ::fgMinuit = NULL;
//_____________________________________________________________________________
AliMUONClusterFinderAZ::AliMUONClusterFinderAZ(Bool_t draw=0, Int_t iReco=0)
fNextCathode = kFALSE;
fColPad = 0;
*/
+ fgClusterFinder = NULL;
+ fgMinuit = NULL;
}
//_____________________________________________________________________________
}
//_____________________________________________________________________________
-void fcn1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
+void AliMUONClusterFinderAZ::fcn1(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
{
// Fit for one track
AliMUONClusterFinderAZ& c = *(AliMUONClusterFinderAZ::fgClusterFinder);
cnew.SetY(cath, y);
cnew.SetZ(cath, fZpad);
cnew.SetCharge(cath, 100);
- cnew.fPeakSignal[cath] = 20;
- cnew.fMultiplicity[cath] = 5;
+ cnew.SetPeakSignal(cath,20);
+ cnew.SetMultiplicity(cath, 5);
cnew.fNcluster[cath] = 1;
cnew.fChi2[cath] = fmin; //0.1;
/*
AliMUONClusterFinderAZ(Bool_t draw, Int_t iReco);// Constructor
virtual ~AliMUONClusterFinderAZ(); // Destructor
- void FindRawClusters(); // the same interface as for old cluster finder
- void EventLoop(Int_t nev, Int_t ch); // first event
- Bool_t TestTrack(Int_t t); // test if track was selected
+ void FindRawClusters(); // the same interface as for old cluster finder
+ void EventLoop(Int_t nev, Int_t ch); // first event
+ Bool_t TestTrack(Int_t t); // test if track was selected
- static AliMUONClusterFinderAZ* fgClusterFinder;
-
- Int_t fnPads[2]; // ! number of pads in the cluster on 2 cathodes
- Float_t fXyq[6][kDim]; // ! pad information
- Int_t fPadIJ[2][kDim]; // ! pad information
- AliSegmentation *fSegmentation[2]; // ! segmentation
- AliMUONResponse *fResponse; // ! response
- Float_t fZpad; // ! z-coordinate of the hit
- Int_t fNpar; // ! number of fit parameters
- Double_t fQtot; // ! total cluster charge
- Int_t fReco; // ! =1 if run reco with writing to TreeR
+ static AliMUONClusterFinderAZ* fgClusterFinder;
+
+protected:
- protected:
+
+
private:
-
- static TMinuit* fgMinuit; // ! Fitter
- Bool_t fUsed[2][kDim]; // ! flags for used pads
- TH2F *fHist[4]; // ! histograms
+
+ Int_t fnPads[2]; // ! number of pads in the cluster on 2 cathodes
+ Float_t fXyq[6][kDim]; // ! pad information
+ Int_t fPadIJ[2][kDim]; // ! pad information
+ AliSegmentation *fSegmentation[2]; // ! segmentation
+ AliMUONResponse *fResponse;// ! response
+ Float_t fZpad; // ! z-coordinate of the hit
+ Int_t fNpar; // ! number of fit parameters
+ Double_t fQtot; // ! total cluster charge
+ Int_t fReco; // ! =1 if run reco with writing to TreeR
+
+ static TMinuit* fgMinuit; // ! Fitter
+ Bool_t fUsed[2][kDim]; // ! flags for used pads
+ TH2F* fHist[4]; // ! histograms
TClonesArray *fMuonDigits; // ! pointer to digits
- Bool_t fDraw; // ! draw flag
- Int_t fnMu; // number of muons passing thru the selected area
- Double_t fxyMu[2][7]; // ! muon information
- TObjArray *fPixArray; // collection of pixels
+ Bool_t fDraw; // ! draw flag
+ Int_t fnMu; // number of muons passing thru the selected area
+ Double_t fxyMu[2][7]; // ! muon information
+ TObjArray* fPixArray; // collection of pixels
// Functions
- void ModifyHistos(void); // modify histograms
- void AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
+ void ModifyHistos(void); // modify histograms
+ void AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
Bool_t Overlap(Int_t cath, TObject *dig); // check if the pad from one cathode overlaps with a pad in the cluster on the other cathode
Bool_t Overlap(Float_t *xy1, Int_t iPad, Float_t *xy12, Int_t iSkip); // check if pads xy1 and iPad overlap and return overlap area
Bool_t CheckPrecluster(Int_t *nShown); // check precluster to simplify it (if possible)
- void BuildPixArray(); // build array of pixels
- void AjustPixel(Float_t width, Int_t ixy); // ajust size of small pixels
- void AjustPixel(Float_t wxmin, Float_t wymin); // ajust size of large pixels
+ void BuildPixArray(); // build array of pixels
+ void AjustPixel(Float_t width, Int_t ixy); // ajust size of small pixels
+ void AjustPixel(Float_t wxmin, Float_t wymin); // ajust size of large pixels
Bool_t MainLoop(); // repeat MLEM algorithm until pixels become sufficiently small
- void Mlem(Double_t *coef, Double_t *probi); // use MLEM for cluster finding
- void FindCOG(TH2D *mlem, Double_t *xyc); // find COG position around maximum bin
- Int_t FindNearest(AliMUONPixel *pixPtr0); // find nearest neighbouring pixel to the given one
- void Split(TH2D *mlem, Double_t *coef); // steering function for pixels
- void AddBin(TH2D *mlem, Int_t ic, Int_t jc, Int_t mode, Bool_t* used, TObjArray *pix); // add a bin to the cluster
+ void Mlem(Double_t *coef, Double_t *probi); // use MLEM for cluster finding
+ void FindCOG(TH2D *mlem, Double_t *xyc); // find COG position around maximum bin
+ Int_t FindNearest(AliMUONPixel *pixPtr0); // find nearest neighbouring pixel to the given one
+ void Split(TH2D *mlem, Double_t *coef); // steering function for pixels
+ void AddBin(TH2D *mlem, Int_t ic, Int_t jc, Int_t mode, Bool_t* used, TObjArray *pix); // add a bin to the cluster
TObject* BinToPix(TH2D *mlem, Int_t jc, Int_t ic); // hist. bin-to-pixel
- void AddCluster(Int_t ic, Int_t nclust, TMatrixD *aijcluclu, Bool_t *used, Int_t *clustNumb, Int_t &nCoupled); // add a cluster to the group of coupled clusters
+ void AddCluster(Int_t ic, Int_t nclust, TMatrixD *aijcluclu, Bool_t *used, Int_t *clustNumb, Int_t &nCoupled); // add a cluster to the group of coupled clusters
Double_t MinGroupCoupl(Int_t nCoupled, Int_t *clustNumb, TMatrixD *aijcluclu, Int_t *minGroup); // find group of cluster with min. coupling to others
- Int_t SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *clustNumb, Int_t *clustFit, TMatrixD *aijcluclu); //select pads for fit
- void Merge(Int_t nForFit, Int_t nCoupled, Int_t *clustNumb, Int_t *clustFit, TObjArray **clusters, TMatrixD *aijcluclu, TMatrixD *aijclupad); // merge clusters
- Int_t Fit(Int_t nfit, Int_t *clustFit, TObjArray **clusters, Double_t *parOk); // do the fitting
- void UpdatePads(Int_t nfit, Double_t *par); // subtract fitted charges from pads
- void AddRawCluster(Double_t x, Double_t y, Double_t fmin); // add new raw cluster
+ Int_t SelectPad(Int_t nCoupled, Int_t nForFit, Int_t *clustNumb, Int_t *clustFit, TMatrixD *aijcluclu); //select pads for fit
+ void Merge(Int_t nForFit, Int_t nCoupled, Int_t *clustNumb, Int_t *clustFit, TObjArray **clusters, TMatrixD *aijcluclu, TMatrixD *aijclupad); // merge clusters
+ Int_t Fit(Int_t nfit, Int_t *clustFit, TObjArray **clusters, Double_t *parOk); // do the fitting
+ void UpdatePads(Int_t nfit, Double_t *par); // subtract fitted charges from pads
+ void AddRawCluster(Double_t x, Double_t y, Double_t fmin); // add new raw cluster
Int_t FindLocalMaxima(Int_t *localMax, Double_t *maxVal); // find local maxima
- void FlagLocalMax(TH2D *hist, Int_t i, Int_t j, Int_t *isLocalMax); // flag local max
- void FindCluster(Int_t *localMax, Int_t iMax); // find cluster around local max
+ void FlagLocalMax(TH2D *hist, Int_t i, Int_t j, Int_t *isLocalMax); // flag local max
+ void FindCluster(Int_t *localMax, Int_t iMax); // find cluster around local max
+ // This function is used for fitting
+ void fcn1(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag);
ClassDef(AliMUONClusterFinderAZ,0) // cluster finder in MUON arm of ALICE
};
fInput->SetCluster(c);
- fMul[0]=c->fMultiplicity[0];
- fMul[1]=c->fMultiplicity[1];
+ fMul[0]=c->GetMultiplicity(0);
+ fMul[1]=c->GetMultiplicity(1);
//
// dump digit information into arrays
cnew.SetY(cath, Float_t(ym[ico][0]));
cnew.SetZ(cath, fZPlane);
- cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+ cnew.SetMultiplicity(cath,c->GetMultiplicity(cath));
for (i=0; i<fMul[cath]; i++) {
cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
}
fprintf(stderr,"\nRawCluster %d cath %d\n",ico,cath);
- fprintf(stderr,"mult_av %d\n",c->fMultiplicity[cath]);
+ fprintf(stderr,"mult_av %d\n",c->GetMultiplicity(cath));
FillCluster(&cnew,cath);
}
- cnew.fClusterType=cnew.PhysicsContribution();
+ cnew.SetClusterType(cnew.PhysicsContribution());
AddRawCluster(cnew);
fNPeaks++;
}
cnew.SetX(cath, Float_t(xm[ico][1]));
cnew.SetY(cath, Float_t(ym[ico][0]));
cnew.SetZ(cath, fZPlane);
- cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+ cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
for (i=0; i<fMul[cath]; i++) {
cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
}
fprintf(stderr,"\nRawCluster %d cath %d\n",ico,cath);
- fprintf(stderr,"mult_av %d\n",c->fMultiplicity[cath]);
+ fprintf(stderr,"mult_av %d\n",c->GetMultiplicity(cath));
FillCluster(&cnew,cath);
}
- cnew.fClusterType=cnew.PhysicsContribution();
+ cnew.SetClusterType(cnew.PhysicsContribution());
AddRawCluster(cnew);
fNPeaks++;
}
cnew.SetX(cath, Float_t(xm[ico][1]));
cnew.SetY(cath, Float_t(ym[ico][0]));
cnew.SetZ(cath, fZPlane);
- cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+ cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
for (i=0; i<fMul[cath]; i++) {
cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
}
fprintf(stderr,"\nRawCluster %d cath %d\n",ico,cath);
- fprintf(stderr,"mult_av %d\n",c->fMultiplicity[cath]);
+ fprintf(stderr,"mult_av %d\n",c->GetMultiplicity(cath));
FillCluster(&cnew,cath);
}
- cnew.fClusterType=cnew.PhysicsContribution();
+ cnew.SetClusterType(cnew.PhysicsContribution());
AddRawCluster(cnew);
fNPeaks++;
}
cnew.SetX(cath, Float_t(xm[ico][1]));
cnew.SetY(cath, Float_t(ym[ico][0]));
cnew.SetZ(cath, fZPlane);
- cnew.fMultiplicity[cath]=c->fMultiplicity[cath];
+ cnew.SetMultiplicity(cath, c->GetMultiplicity(cath));
for (i=0; i<fMul[cath]; i++) {
cnew.fIndexMap[i][cath]=c->fIndexMap[i][cath];
fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
}
FillCluster(&cnew,cath);
}
- cnew.fClusterType=cnew.PhysicsContribution();
+ cnew.SetClusterType(cnew.PhysicsContribution());
AddRawCluster(cnew);
fNPeaks++;
}
Int_t ix, iy;
if (cath==1) {
- c->fPeakSignal[cath]=c->fPeakSignal[0];
+ c->SetPeakSignal(cath,c->GetPeakSignal(0));
} else {
- c->fPeakSignal[cath]=0;
+ c->SetPeakSignal(cath,0);
}
}
if (fDebugLevel)
- fprintf(stderr,"\n fPeakSignal %d\n",c->fPeakSignal[cath]);
- for (Int_t i=0; i<c->fMultiplicity[cath]; i++)
+ fprintf(stderr,"\n fPeakSignal %d\n",c->GetPeakSignal(cath));
+ for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
{
dig= fInput->Digit(cath,c->fIndexMap[i][cath]);
ix=dig->PadX()+c->fOffsetMap[i][cath];
//
//
if (fDebugLevel>1)
- fprintf(stderr,"q %d c->fPeakSignal[cath] %d\n",q,c->fPeakSignal[cath]);
+ fprintf(stderr,"q %d c->fPeakSignal[cath] %d\n",q,c->GetPeakSignal(cath));
// peak signal and track list
- if (q>c->fPeakSignal[cath]) {
- c->fPeakSignal[cath]=q;
- c->fTracks[0]=dig->Hit();
- c->fTracks[1]=dig->Track(0);
- c->fTracks[2]=dig->Track(1);
+ if (q>c->GetPeakSignal(cath)) {
+ c->SetPeakSignal(cath, q);
+ c->SetTrack(0,dig->Hit());
+ c->SetTrack(1,dig->Track(0));
+ c->SetTrack(2,dig->Track(1));
// fprintf(stderr," c->fTracks[0] %d c->fTracks[1] %d\n",dig->fHit,dig->fTracks[0]);
}
//
Float_t xpad, ypad, zpad;
Float_t dx, dy, dr;
- for (Int_t i=0; i<c->fMultiplicity[cath]; i++)
+ for (Int_t i=0; i<c->GetMultiplicity(cath); i++)
{
dig = fInput->Digit(cath,c->fIndexMap[i][cath]);
fSeg[cath]->
} else if (dig->Physics() == 0) {
c->fPhysicsMap[i]=0;
} else c->fPhysicsMap[i]=1;
- c->fPeakSignal[cath]=q;
- c->fTracks[0]=dig->Hit();
- c->fTracks[1]=dig->Track(0);
- c->fTracks[2]=dig->Track(1);
+ c->SetPeakSignal(cath,q);
+ c->SetTrack(0,dig->Hit());
+ c->SetTrack(1,dig->Track(0));
+ c->SetTrack(2,dig->Track(1));
if (fDebugLevel)
fprintf(stderr," c->fTracks[0] %d c->fTracks[1] %d\n",dig->Hit(),
dig->Track(0));
Int_t theX=dig->PadX();
Int_t theY=dig->PadY();
- if (q > TMath::Abs(c.fPeakSignal[0]) && q > TMath::Abs(c.fPeakSignal[1])) {
- c.fPeakSignal[cath]=q;
- c.fTracks[0]=dig->Hit();
- c.fTracks[1]=dig->Track(0);
- c.fTracks[2]=dig->Track(1);
+ if (q > TMath::Abs(c.GetPeakSignal(0)) && q > TMath::Abs(c.GetPeakSignal(1))) {
+ c.SetPeakSignal(cath,q);
+ c.SetTrack(0,dig->Hit());
+ c.SetTrack(1,dig->Track(0));
+ c.SetTrack(2,dig->Track(1));
}
//
// Make sure that list of digits is ordered
//
- Int_t mu=c.fMultiplicity[cath];
+ Int_t mu=c.GetMultiplicity(cath);
c.fIndexMap[mu][cath]=idx;
if (dig->Physics() >= dig->Signal()) {
}
}
- c.fMultiplicity[cath]++;
- if (c.fMultiplicity[cath] >= 50 ) {
- printf("FindCluster - multiplicity >50 %d \n",c.fMultiplicity[0]);
- c.fMultiplicity[cath]=49;
+ c.SetMultiplicity(cath, c.GetMultiplicity(cath)+1);
+ if (c.GetMultiplicity(cath) >= 50 ) {
+ printf("FindCluster - multiplicity >50 %d \n",c.GetMultiplicity(0));
+ c.SetMultiplicity(cath, 49);
}
// Prepare center of gravity calculation
if (fDebugLevel)
fprintf(stderr,"\n CATHODE %d CLUSTER %d\n",cath,ncls);
AliMUONRawCluster c;
- c.fMultiplicity[0]=0;
- c.fMultiplicity[1]=0;
- c.fPeakSignal[cath]=dig->Signal();
- c.fTracks[0]=dig->Hit();
- c.fTracks[1]=dig->Track(0);
- c.fTracks[2]=dig->Track(1);
+ c.SetMultiplicity(0, 0);
+ c.SetMultiplicity(1, 0);
+ c.SetPeakSignal(cath,dig->Signal());
+ c.SetTrack(0, dig->Hit());
+ c.SetTrack(1, dig->Track(0));
+ c.SetTrack(2, dig->Track(1));
// tag the beginning of cluster list in a raw cluster
c.fNcluster[0]=-1;
Float_t xcu, ycu;
if (fDebugLevel) {
fprintf(stderr,"\n Cathode 1 multiplicite %d X(CG) %f Y(CG) %f\n",
- c.fMultiplicity[0],c.GetX(0),c.GetY(0));
+ c.GetMultiplicity(0),c.GetX(0),c.GetY(0));
fprintf(stderr," Cathode 2 multiplicite %d X(CG) %f Y(CG) %f\n",
- c.fMultiplicity[1],c.GetX(1),c.GetY(1));
+ c.GetMultiplicity(1),c.GetX(1),c.GetY(1));
}
// Analyse cluster and decluster if necessary
//
ncls++;
c.fNcluster[1]=fNRawClusters;
- c.fClusterType=c.PhysicsContribution();
+ c.SetClusterType(c.PhysicsContribution());
fNPeaks=0;
//
//
// reset Cluster object
{ // begin local scope
- for (int k=0;k<c.fMultiplicity[0];k++) c.fIndexMap[k][0]=0;
+ for (int k=0;k<c.GetMultiplicity(0);k++) c.fIndexMap[k][0]=0;
} // end local scope
{ // begin local scope
- for (int k=0;k<c.fMultiplicity[1];k++) c.fIndexMap[k][1]=0;
+ for (int k=0;k<c.GetMultiplicity(1);k++) c.fIndexMap[k][1]=0;
} // end local scope
- c.fMultiplicity[0]=c.fMultiplicity[0]=0;
+ c.SetMultiplicity(0,0);
+ c.SetMultiplicity(1,0);
} // end loop ndig
cnew.fNcluster[0]=fNPeaks;
cnew.fNcluster[1]=0;
}
- cnew.fMultiplicity[cath]=0;
+ cnew.SetMultiplicity(cath,0);
cnew.SetX(cath, Float_t(fXFit[j]));
cnew.SetY(cath, Float_t(fYFit[j]));
cnew.SetZ(cath, fZPlane);
}
fSeg[cath]->SetHit(fXFit[j],fYFit[j],fZPlane);
for (i=0; i<fMul[cath]; i++) {
- cnew.fIndexMap[cnew.fMultiplicity[cath]][cath]=
+ cnew.fIndexMap[cnew.GetMultiplicity(cath)][cath]=
c->fIndexMap[i][cath];
fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
Float_t q1=fInput->Response()->IntXY(fSeg[cath]);
cnew.fContMap[i][cath]
=(q1*Float_t(cnew.GetCharge(cath)))/Float_t(fQ[i][cath]);
- cnew.fMultiplicity[cath]++;
+ cnew.SetMultiplicity(cath, cnew.GetMultiplicity(cath)+1 );
}
FillCluster(&cnew,0,cath);
} // cathode loop
- cnew.fClusterType=cnew.PhysicsContribution();
+ cnew.SetClusterType(cnew.PhysicsContribution());
if (cnew.GetCharge(0)>0 && cnew.GetCharge(1)>0) AddRawCluster(cnew);
fNPeaks++;
}
Float_t qtot;
Int_t i, cath, ix, iy;
AliMUONDigit* digit;
- fNmul[0]=cluster->fMultiplicity[0];
- fNmul[1]=cluster->fMultiplicity[1];
+ fNmul[0]=cluster->GetMultiplicity(0);
+ fNmul[1]=cluster->GetMultiplicity(1);
//PH printf("\n %p %p ", fDigits[0], fDigits[1]);
for (cath=0; cath<2; cath++) {
if (i==0 || i==1) return fZ[i];
else return 99999.;
}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetTrack(Int_t i) const
+{
+ if (i==0 || i==1 || i==2) return fTracks[i];
+ else return 99999;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetPeakSignal(Int_t i) const
+{
+ if (i==0 || i==1 ) return fPeakSignal[i];
+ else return 99999;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetMultiplicity(Int_t i) const
+{
+ if (i==0 || i==1 ) return fMultiplicity[i];
+ else return 99999;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::GetClusterType() const
+{
+ return fClusterType;
+}
+
//____________________________________________________
Int_t AliMUONRawCluster::SetCharge(Int_t i, Int_t Q)
{
}
else return 0;
}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetTrack(Int_t i, Int_t track)
+{
+ if (i==0 || i==1 || i==2) {
+ fTracks[i]=track;
+ return 1;
+ }
+ else return 0;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetPeakSignal(Int_t i, Int_t peaksignal)
+{
+ if (i==0 || i==1 ) {
+ fPeakSignal[i]=peaksignal;
+ return 1;
+ }
+ else return 0;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetMultiplicity(Int_t i, Int_t mul)
+{
+ if (i==0 || i==1 ) {
+ fMultiplicity[i]=mul;
+ return 1;
+ }
+ else return 0;
+}
+//____________________________________________________
+Int_t AliMUONRawCluster::SetClusterType(Int_t type)
+{
+ fClusterType=type;
+ return 1;
+}
Float_t GetX(Int_t i) const;
Float_t GetY(Int_t i) const;
Float_t GetZ(Int_t i) const;
+ Int_t GetTrack(Int_t i) const;
+ Int_t GetPeakSignal(Int_t i) const;
+ Int_t GetMultiplicity(Int_t i) const;
+ Int_t GetClusterType() const;
Int_t SetCharge(Int_t i,Int_t Q);
Int_t SetX(Int_t i, Float_t X);
Int_t SetY(Int_t i, Float_t Y);
Int_t SetZ(Int_t i, Float_t Z);
+ Int_t SetTrack(Int_t i, Int_t track);
+ Int_t SetPeakSignal(Int_t i, Int_t peaksignal);
+ Int_t SetMultiplicity(Int_t i, Int_t mul);
+ Int_t SetClusterType(Int_t type);
-private:
- Int_t fQ[2] ; // Q of cluster (in ADC counts)
- Float_t fX[2] ; // X of cluster
- Float_t fY[2] ; // Y of cluster
- Float_t fZ[2] ; // Z of cluster
-
-public:
- Int_t fTracks[3]; //labels of overlapped tracks
- Int_t fPeakSignal[2]; // Peak signal
Int_t fIndexMap[50][2]; // indeces of digits
Int_t fOffsetMap[50][2]; // Emmanuel special
Float_t fContMap[50][2]; // Contribution from digit
Int_t fPhysicsMap[50]; // Distinguish signal and background contr.
- Int_t fMultiplicity[2]; // Cluster multiplicity
Int_t fNcluster[2]; // Number of clusters
- Int_t fClusterType; // Cluster type
+
Float_t fChi2[2]; // Chi**2 of fit
Int_t fGhost; // 0 if not a ghost or ghost problem solved
// >0 if ghost problem remains because
// 1 both (true and ghost) satify
// charge chi2 compatibility
// 2 none give satisfactory chi2
-
+private:
+ Int_t fQ[2] ; // Q of cluster (in ADC counts)
+ Float_t fX[2] ; // X of cluster
+ Float_t fY[2] ; // Y of cluster
+ Float_t fZ[2] ; // Z of cluster
+ Int_t fTracks[3]; //labels of overlapped tracks
+ Int_t fPeakSignal[2]; // Peak signal
+ Int_t fMultiplicity[2]; // Cluster multiplicity
+ Int_t fClusterType; // Cluster type
ClassDef(AliMUONRawCluster,1) //Cluster class for MUON
};
hit1 = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i]);
rawclusters = fgMUON->GetMUONData()->RawClusters(hit1->GetChamberNumber());
clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit1->GetHitNumber());
- cout << clus->fTracks[1]-1;
- if (clus->fTracks[2] != 0) cout << " " << clus->fTracks[2]-1;
+ cout << clus->GetTrack(1)-1;
+ if (clus->GetTrack(2) != 0) cout << " " << clus->GetTrack(2)-1;
if (i == 0) cout << " <--> ";
}
cout << endl;
hit = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
- printf ("%4d", clus->fTracks[1] - 1);
+ printf ("%4d", clus->GetTrack(1) - 1);
//cout << clus->fTracks[1] - 1 << " ";
}
cout << endl;
hit = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
- if (clus->fTracks[2] != 0) printf ("%4d", clus->fTracks[2] - 1);
+ if (clus->GetTrack(2) != 0) printf ("%4d", clus->GetTrack(2) - 1);
else printf ("%4s", " ");
//if (clus->fTracks[2] != 0) cout << clus->fTracks[2] - 1 << " ";
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff