* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.18 2001/11/20 15:46:17 barbera
-Point coordinated are calculated in cylindrical reference frame once and for all at the beginning of tracking V1
-
-Revision 1.10.2.1 2001/10/24 07:26:04 hristov
-All the changes from the head are merged with the release
-
-Revision 1.14 2001/10/24 07:19:57 hristov
-Some pointer correctly initialised in one of the constructors
-
-Revision 1.13 2001/10/21 19:17:12 hristov
-Several pointers were set to zero in the default constructors to avoid memory management problems
+/* $Id$ */
-Revision 1.12 2001/10/19 21:32:35 nilsen
-Minor changes to remove compliation warning on gcc 2.92.2 compiler, and
-cleanded up a little bit of code.
-
-*/
-// The purpose of this class is to permorm the ITS tracking. The
+// The purpose of this class is to permorm the ITS tracking. The
// constructor has the task to inizialize some private members. The method
// DoTracking is written to be called by a macro. It gets the event number,
// the minimum and maximum order number of TPC tracks that are to be tracked
// imposition respectively. The authors thank Mariana Bondila to have help
// them to resolve some problems. July-2000
-#include <fstream.h>
+#include <Riostream.h>
#include <TMath.h>
#include <TBranch.h>
#include <TVector.h>
#include <TFile.h>
+#include <TRandom.h>
#include <TTree.h>
-#include <TStopwatch.h>
#include "TParticle.h"
#include "AliRun.h"
-#include "AliITS.h"
-#include "AliITSsegmentationSSD.h"
+#include "AliITSDetTypeRec.h"
#include "AliITSgeomSPD.h"
#include "AliITSgeomSDD.h"
#include "AliITSgeomSSD.h"
#include "AliITSgeom.h"
#include "AliITSRecPoint.h"
-#include "stdlib.h"
#include "AliKalmanTrack.h"
#include "AliMagF.h"
#include "AliITSTrackV1.h"
#include "AliITSIOTrack.h"
#include "AliITSRad.h"
-#include "../TPC/AliTPCtracker.h"
+#include "AliTPCtracker.h"
#include "AliITSTrackerV1.h"
-#include "AliITSVertex.h"
+#include "AliITSPid.h"
+#include "AliMC.h"
ClassImp(AliITSTrackerV1)
//______________________________________________________________________
AliITSTrackerV1::AliITSTrackerV1() {
//Default constructor
- fITS = 0;
+ //fITS = 0;
fresult = 0;
fPtref=0.;
fChi2max=0.;
fRecCylPhi=0;
fRecCylZ=0;
fFieldFactor=0;
+ fDetTypeRec = 0;
}
//______________________________________________________________________
-AliITSTrackerV1::AliITSTrackerV1(AliITS* IITTSS, Int_t evnumber, Bool_t flag) {
+AliITSTrackerV1::AliITSTrackerV1(Int_t evnumber, Bool_t flag) {
//Origin A. Badala' and G.S. Pappalardo:
// e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
// Class constructor. It does some initializations.
//PH Initialisation taken from the default constructor
- fITS = IITTSS;
- fresult = 0;
- fPtref = 0.;
- fChi2max =0.;
- frecPoints = 0;
- fvettid = 0;
- fflagvert = flag;
- frl = 0;
- fzmin = 0;
- fzmax = 0;
- fphimin = 0;
- fphimax = 0;
- fphidet = 0;
+ //fITS = IITTSS;
+ fresult = 0;
+ fPtref = 0.;
+ fChi2max =0.;
+ frecPoints = 0;
+ fvettid = 0;
+ fflagvert = flag;
+ frl = 0;
+ fzmin = 0;
+ fzmax = 0;
+ fphimin = 0;
+ fphimax = 0;
+ fphidet = 0;
- Int_t imax = 200,jmax = 450;
- frl = new AliITSRad(imax,jmax);
-
- ////////// gets information on geometry /////////////////////////////
- AliITSgeom *g1 = fITS->GetITSgeom();
- Int_t ll=1, dd=1;
- TVector det(9);
-
- Int_t ia;
- for(ia=0; ia<6; ia++) {
- fNlad[ia]=g1->GetNladders(ia+1);
- fNdet[ia]=g1->GetNdetectors(ia+1);
- //cout<<fNlad[i]<<" "<<fNdet[i]<<"\n";
- } // end for ia
+ Int_t imax = 200,jmax = 450;
+ frl = new AliITSRad(imax,jmax);
+
+ ////////// gets information on geometry /////////////////////////////
+ AliRunLoader* rl = AliRunLoader::Open("galice.root");
+ AliITSLoader* loader = (AliITSLoader*)runLoader->GetLoader("ITSLoader");
+ if (!loader) {
+ Error("AliITSTrackerV1", "ITS loader not found");
+ return;
+ }
+ fDetTypeRec = new AliITSDetTypeRec(loader);
+ AliITSgeom* g1 = loader->GetITSgeom();
+ Int_t ll=1, dd=1;
+ TVector det(9);
+
+ Int_t ia;
+ for(ia=0; ia<6; ia++) {
+ fNlad[ia]=g1->GetNladders(ia+1);
+ fNdet[ia]=g1->GetNdetectors(ia+1);
+ //cout<<fNlad[i]<<" "<<fNdet[i]<<"\n";
+ } // end for ia
+
//cout<<" mean radius = ";
- Int_t ib;
- for(ib=0; ib<6; ib++) {
- g1->GetCenterThetaPhi(ib+1,ll,dd,det);
- Double_t r1=TMath::Sqrt(det(0)*det(0)+det(1)*det(1));
- g1->GetCenterThetaPhi(ib+1,ll,dd+1,det);
- Double_t r2=TMath::Sqrt(det(0)*det(0)+det(1)*det(1));
- fAvrad[ib]=(r1+r2)/2.;
- //cout<<fAvrad[ib]<<" ";
- } // end for ib
+ Int_t ib;
+ for(ib=0; ib<6; ib++) {
+ g1->GetCenterThetaPhi(ib+1,ll,dd,det);
+ Double_t r1=TMath::Sqrt(det(0)*det(0)+det(1)*det(1));
+ g1->GetCenterThetaPhi(ib+1,ll,dd+1,det);
+ Double_t r2=TMath::Sqrt(det(0)*det(0)+det(1)*det(1));
+ fAvrad[ib]=(r1+r2)/2.;
+ //cout<<fAvrad[ib]<<" ";
+ } // end for ib
//cout<<"\n"; getchar();
-
- fDetx[0] = ((AliITSgeomSPD*)(g1->GetShape(1, ll, dd)))->GetDx();
- fDetz[0] = ((AliITSgeomSPD*)(g1->GetShape(1, ll, dd)))->GetDz();
-
- fDetx[1] = ((AliITSgeomSPD*)(g1->GetShape(2, ll, dd)))->GetDx();
- fDetz[1] = ((AliITSgeomSPD*)(g1->GetShape(2, ll, dd)))->GetDz();
+
+ fDetx[0] = ((AliITSgeomSPD*)(g1->GetShape(1, ll, dd)))->GetDx();
+ fDetz[0] = ((AliITSgeomSPD*)(g1->GetShape(1, ll, dd)))->GetDz();
+
+ fDetx[1] = ((AliITSgeomSPD*)(g1->GetShape(2, ll, dd)))->GetDx();
+ fDetz[1] = ((AliITSgeomSPD*)(g1->GetShape(2, ll, dd)))->GetDz();
fDetx[2] = ((AliITSgeomSDD*)(g1->GetShape(3, ll, dd)))->GetDx();
fDetz[2] = ((AliITSgeomSDD*)(g1->GetShape(3, ll, dd)))->GetDz();
fphidet[im1] = new Double_t[im2max];
} // end for im1
- //Float_t global[3],local[3];
- Double_t global[3],local[3];
+ Double_t global[3],local[3];
Double_t pigre=TMath::Pi();
Double_t xmin,ymin,xmax,ymax;
//////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////// allocate memory and define vector fNRecPoints and matrices fRecCylR, fRecCylPhi, fRecCylZ /////////////
gAlice->GetEvent(evnumber);
- Int_t NumOfModules = g1->GetIndexMax();
- //fRecCylR = new Float_t *[NumOfModules];
- fRecCylR = new Double_t *[NumOfModules];
- //fRecCylPhi = new Float_t *[NumOfModules];
- fRecCylPhi = new Double_t *[NumOfModules];
- //fRecCylZ = new Float_t *[NumOfModules];
- fRecCylZ = new Double_t *[NumOfModules];
+ Int_t numOfModules = g1->GetIndexMax();
+ fRecCylR = new Double_t *[numOfModules];
+ fRecCylPhi = new Double_t *[numOfModules];
+ fRecCylZ = new Double_t *[numOfModules];
AliITSRecPoint *recp;
- fNRecPoints = new Int_t[NumOfModules];
+ fNRecPoints = new Int_t[numOfModules];
- for(Int_t module=0; module<NumOfModules; module++) {
- fITS->ResetRecPoints();
- gAlice->TreeR()->GetEvent(module);
- frecPoints=fITS->RecPoints();
+ for(Int_t module=0; module<numOfModules; module++) {
+ fDetTypeRec->ResetRecPoints();
+ gAlice->TreeR()->GetEvent(module);
+ frecPoints=fDetTypeRec->RecPoints();
Int_t nRecPoints=fNRecPoints[module]=frecPoints->GetEntries();
- /*
- fRecCylR[module] = new Float_t[nRecPoints];
- fRecCylPhi[module] = new Float_t[nRecPoints];
- fRecCylZ[module] = new Float_t[nRecPoints];
- */
fRecCylR[module] = new Double_t[nRecPoints];
fRecCylPhi[module] = new Double_t[nRecPoints];
fRecCylZ[module] = new Double_t[nRecPoints];
local[1]=0.;
local[2]= recp->GetZ();
g1->LtoG(module,local,global);
- /*
- Float_t r = TMath::Sqrt(global[0]*global[0]+global[1]*global[1]); // r hit
- Float_t phi = TMath::ATan2(global[1],global[0]); if(phi<0.) phi+=2.*TMath::Pi(); // phi hit
- Float_t z = global[2]; // z hit
- */
Double_t r = TMath::Sqrt(global[0]*global[0]+global[1]*global[1]); // r hit
Double_t phi = TMath::ATan2(global[1],global[0]); if(phi<0.) phi+=2.*TMath::Pi(); // phi hit
- Double_t z = global[2]; // z hit
+ Double_t z = global[2]; // z hit
fRecCylR[module][ind]=r;
fRecCylPhi[module][ind]=phi;
////////// gets magnetic field factor //////////////////////////////
AliMagF * fieldPointer = gAlice->Field();
- fFieldFactor = (Double_t)fieldPointer->Factor();
- //cout<< " field factor = "<<fFieldFactor<<"\n"; getchar();
+ // fFieldFactor = (Double_t)fieldPointer->Factor();
+ fFieldFactor =(Double_t)fieldPointer-> SolenoidField()/10/.2;
+ // cout<< " field factor = "<<fFieldFactor<<"\n"; getchar();
+ delete rl;
+
}
//______________________________________________________________________
-AliITSTrackerV1::AliITSTrackerV1(const AliITSTrackerV1 &cobj) {
+AliITSTrackerV1::AliITSTrackerV1(const AliITSTrackerV1 &cobj) : TObject(cobj) {
// Origin A. Badala' and G.S. Pappalardo:
// e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
// copy constructor
- *fITS = *cobj.fITS;
+ // *fITS = *cobj.fITS;
*fresult = *cobj.fresult;
fPtref = cobj.fPtref;
fChi2max = cobj.fChi2max;
} // end for im2
- AliITSgeom *g1 = fITS->GetITSgeom();
- Int_t NumOfModules = g1->GetIndexMax();
+ AliRunLoader* rl = AliRunLoader::Open("galice.root");
+ rl->CdGAFile();
+ AliITSgeom* g1 = (AliITSgeom*)gDirectory->Get("AliITSgeom");
+
+ Int_t numOfModules = g1->GetIndexMax();
/*
- fRecCylR = new Float_t *[NumOfModules];
- fRecCylPhi = new Float_t *[NumOfModules];
- fRecCylZ = new Float_t *[NumOfModules];
+ fRecCylR = new Float_t *[numOfModules];
+ fRecCylPhi = new Float_t *[numOfModules];
+ fRecCylZ = new Float_t *[numOfModules];
*/
- fRecCylR = new Double_t *[NumOfModules];
- fRecCylPhi = new Double_t *[NumOfModules];
- fRecCylZ = new Double_t *[NumOfModules];
- fNRecPoints = new Int_t[NumOfModules];
- for(Int_t module=0; module<NumOfModules; module++) {
+ fRecCylR = new Double_t *[numOfModules];
+ fRecCylPhi = new Double_t *[numOfModules];
+ fRecCylZ = new Double_t *[numOfModules];
+ fNRecPoints = new Int_t[numOfModules];
+ for(Int_t module=0; module<numOfModules; module++) {
Int_t nRecPoints=fNRecPoints[module]=cobj.fNRecPoints[module];
/*
fRecCylR[module] = new Float_t[nRecPoints];
fRecCylZ[module][ind]=cobj.fRecCylZ[module][ind];
}
}
+ delete rl;
}
-void AliITSTrackerV1::DelMatrix(Int_t NumOfModules) {
- for(Int_t mod=0; mod<NumOfModules; mod++) {
+/*
+//______________________________________________________________________
+void AliITSTrackerV1::DelMatrix(Int_t numOfModules) {
+ // cleanup of some data members
+ for(Int_t mod=0; mod<numOfModules; mod++) {
delete fRecCylR[mod];
delete fRecCylPhi[mod];
delete fRecCylZ[mod];
delete fRecCylPhi;
delete fRecCylZ;
}
+*/
//______________________________________________________________________
AliITSTrackerV1::~AliITSTrackerV1(){
// Origin A. Badala' and G.S. Pappalardo:
}
//______________________________________________________________________
-AliITSTrackerV1 &AliITSTrackerV1::operator=(AliITSTrackerV1 obj) {
+AliITSTrackerV1 &AliITSTrackerV1::operator=(const AliITSTrackerV1 &obj) {
// Origin A. Badala' and G.S. Pappalardo:
// e-mail Angela.Badala@ct.infn.it, Giuseppe.S.Pappalardo@ct.infn.it
// assignement operator
- *fITS = *obj.fITS;
+ // *fITS = *obj.fITS;
*fresult = *obj.fresult;
fPtref = obj.fPtref;
fChi2max = obj.fChi2max;
} // end for im2
} // end for im1
- AliITSgeom *g1 = fITS->GetITSgeom();
- Int_t NumOfModules = g1->GetIndexMax();
- /*
- fRecCylR = new Float_t *[NumOfModules];
- fRecCylPhi = new Float_t *[NumOfModules];
- fRecCylZ = new Float_t *[NumOfModules];
- */
- fRecCylR = new Double_t *[NumOfModules];
- fRecCylPhi = new Double_t *[NumOfModules];
- fRecCylZ = new Double_t *[NumOfModules];
- fNRecPoints = new Int_t[NumOfModules];
- for(Int_t module=0; module<NumOfModules; module++) {
+ AliRunLoader* rl = AliRunLoader::Open("galice.root");
+ rl->CdGAFile();
+ AliITSgeom* g1 = (AliITSgeom*)gDirectory->Get("AliITSgeom");
+ // AliITSgeom *g1 = fITS->GetITSgeom();
+ Int_t numOfModules = g1->GetIndexMax();
+ fRecCylR = new Double_t *[numOfModules];
+ fRecCylPhi = new Double_t *[numOfModules];
+ fRecCylZ = new Double_t *[numOfModules];
+ fNRecPoints = new Int_t[numOfModules];
+ for(Int_t module=0; module<numOfModules; module++) {
Int_t nRecPoints=fNRecPoints[module]=obj.fNRecPoints[module];
- /*
- fRecCylR[module] = new Float_t[nRecPoints];
- fRecCylPhi[module] = new Float_t[nRecPoints];
- fRecCylZ[module] = new Float_t[nRecPoints];
- */
fRecCylR[module] = new Double_t[nRecPoints];
fRecCylPhi[module] = new Double_t[nRecPoints];
fRecCylZ[module] = new Double_t[nRecPoints];
}
+ delete rl;
return *this;
}
//______________________________________________________________________
// The method can be called by a macro. It preforms the tracking for
// all good TPC tracks
- printf("begin DoTracking - file %p\n",file);
+ printf("begin DoTracking - file %p\n",(void*)file);
gAlice->GetEvent(evNumber); //modificato per gestire hbt
- AliKalmanTrack *kkprov;
- kkprov->SetConvConst(100/0.299792458/0.2/fFieldFactor);
+ AliKalmanTrack::SetFieldMap(gAlice->Field());
+ // cout<<" field = "<<gAlice->Field()->SolenoidField()<<endl;
+
TFile *cf=TFile::Open("AliTPCclusters.root");
- AliTPCParam *digp= (AliTPCParam*)cf->Get("75x40_100x60");
+ AliTPCParam *digp= (AliTPCParam*)cf->Get("75x40_100x60_150x60");
if (!digp) { cerr<<"TPC parameters have not been found !\n"; getchar();}
cf->cd();
- AliTPCtracker *tracker = new AliTPCtracker(digp,evNumber);
+ AliRunLoader* rl = AliRunLoader::Open("galice.root");
+ AliITSLoader* itsl = (AliITSLoader*)rl->GetLoader("ITSLoader");
+ TString foldname(itsl->GetEventFolder()->GetName());
+ //TString foldname(fITS->GetLoader()->GetEventFolder()->GetName());
+ delete rl;
+ printf("This method is not converted to the NewIO !\n"); //I.B.
+ return; //I.B.
+ AliTPCtracker *tracker = new AliTPCtracker(digp); //I.B.
+ //PH tracker->SetEventNumber(evNumber); //I.B.
// Load clusters
- tracker->LoadInnerSectors();
- tracker->LoadOuterSectors();
+ printf("This method is not converted to the NewIO !\n"); //I.B.
+ return; //I.B.
+ tracker->LoadClusters(0); //I.B.
// Load tracks
TFile *tf=TFile::Open("AliTPCtracksSorted.root");
Int_t nentr=(Int_t)tracktree->GetEntries();
Int_t kk;
- AliTPCtrack *ioTrackTPC=0;
+ AliITSRecPoint *recp; // oggi
+ AliTPCtrack *ioTrackTPC=0;
for (kk=0; kk<nentr; kk++) {
ioTrackTPC=new AliTPCtrack;
tbranch->SetAddress(&ioTrackTPC);
TVector vec(5);
TTree *tr=gAlice->TreeR();
Int_t nent=(Int_t)tr->GetEntries();
- frecPoints = fITS->RecPoints();
+ frecPoints = fDetTypeRec->RecPoints();
Int_t numbpoints;
Int_t totalpoints=0;
for (mod=0; mod<nent; mod++) {
fvettid[mod]=0;
- fITS->ResetRecPoints();
+ fDetTypeRec->ResetRecPoints();
gAlice->TreeR()->GetEvent(mod);
numbpoints = frecPoints->GetEntries();
totalpoints+=numbpoints;
TTree tracktree1("TreeT","Tree with ITS tracks");
AliITSIOTrack *ioTrack=0;
+ AliITSPid *pid=new AliITSPid(1000); // oggi
+
tracktree1.Branch("ITStracks","AliITSIOTrack",&ioTrack,32000,0);
- TDatabasePDG * db = new TDatabasePDG;
+ TDatabasePDG * db = new TDatabasePDG;
Int_t j;
for (j=minTr; j<=maxTr; j++) {
/// mass definition ////////////////////////
Double_t mass=0.13956995;
Int_t pcode=211; // a pion by default
+
if(realmass) {
- Int_t TPClabel=TMath::Abs( track->GetLabel() );
- TParticle *p = (TParticle*)gAlice->Particle(TPClabel);
- pcode=p->GetPdgCode();
- // Int_t mothercode=p->GetFirstMother();
- //if(mothercode>0 ) numofsecondaries++; else numofprimaries++;
+ if(TMath::Abs(pcode)<20443) mass=db->GetParticle(pcode)->Mass();
+ }
+ else {
+ mass = track->GetMass();
+// cout << "Mass = " << mass << endl;
}
- //if(!pcode) pcode=211;
- if(TMath::Abs(pcode)<20443) mass=db->GetParticle(pcode)->Mass();
+
- ///////////////////////////////////////////////
- /*
- ////// propagation to the end of TPC //////////////
- Double_t xk=77.415;
- track->PropagateTo(xk, 28.94, 1.204e-3,mass); //Ne
- xk -=0.01;
- track->PropagateTo(xk, 44.77, 1.71,mass); //Tedlar
- xk -=0.04;
- track->PropagateTo(xk, 44.86, 1.45,mass); //kevlar
- xk -=2.0;
- track->PropagateTo(xk, 41.28, 0.029,mass); //Nomex
- xk-=16;
- track->PropagateTo(xk,36.2,1.98e-3,mass); //C02
- xk -=0.01;
- track->PropagateTo(xk, 24.01, 2.7,mass); //Al
- xk -=0.01;
- track->PropagateTo(xk, 44.77, 1.71,mass); //Tedlar
- xk -=0.04;
- track->PropagateTo(xk, 44.86, 1.45,mass); //kevlar
- xk -=0.5;
- track->PropagateTo(xk, 41.28, 0.029,mass); //Nomex
- ////////////////////////////////////////////////////////////////////
- */
// new propagation to the end of TPC
Double_t xk=80.;
// track->PropagateTo(xk,0.,0.); //Ne if it's still there //attenzione funziona solo se modifica in TPC
track->PropagateTo(xk, 44.77, 1.71); //Tedlar
xk -=0.005;
track->PropagateTo(xk, 24.01, 2.7); //Al
+
////////////////////////////////////////////////////////////////////////////////////////////////////////
- AliITSTrackV1 trackITS(*track);
+ //AliITSTrackV1 trackITS(*track);
+ AliITSTrackV1 trackITS(*track, fFieldFactor);
+ //cout<<" fFieldFactor = "<<fFieldFactor<<"\n";
trackITS.PutMass(mass); //new to add mass to track
if(fresult){ delete fresult; fresult=0;}
fresult = new AliITSTrackV1(trackITS);
primaryTrack.SetZv(zv);
primaryTrack.SetsigmaDv(sigmaDv);
primaryTrack.SetsigmaZv(sigmaZv);
- primaryTrack.PrimaryTrack(frl);
+ primaryTrack.PrimaryTrack();
TVector d2=primaryTrack.Getd2();
TVector tgl2=primaryTrack.Gettgl2();
TVector dtgl=primaryTrack.Getdtgl();
list->AddLast(&trackITS);
fPtref=TMath::Abs( (trackITS).GetPt() );
+ //cout<<" fPtref = " <<fPtref<<"\n";
if(fPtref>1.0) fChi2max=40.;
if(fPtref<=1.0) fChi2max=20.;
if(fPtref<0.4 ) fChi2max=100.;
// if(fPtref<0.2 ) fChi2max=20.;
//if(fPtref<0.2 ) fChi2max=10.;
//if(fPtref<0.1 ) fChi2max=5.;
- cout << "\n Pt = " << fPtref <<"\n"; //stampa
+ //cout << "\n Pt = " << fPtref <<"\n"; //stampa
RecursiveTracking(list);
list->Delete();
delete list;
for(k=0; k<3; k++){
Int_t lpp=(Int_t)vecLabRef(k);
if(lpp>=0) {
- TParticle *p=(TParticle*) gAlice->Particle(lpp);
+ TParticle *p=(TParticle*) gAlice->GetMCApp()->Particle(lpp);
Int_t pcode=p->GetPdgCode();
if(pcode==11) vecLabRef(k)=p->GetFirstMother();
} // end if
// cout<<" progressive track number = "<<j<<"\r";
// cout<<j<<"\r";
Int_t numOfCluster=(*fresult).GetNumClust();
- cout<<" progressive track number = "<<j<<"\n"; // stampa
+ //cout<<" progressive track number = "<<j<<"\n"; // stampa
Long_t labITS=(*fresult).GetLabel();
- cout << " ITS track label = " << labITS << "\n"; // stampa
+ //cout << " ITS track label = " << labITS << "\n"; // stampa
Int_t lab=track->GetLabel();
- cout << " TPC track label = " << lab <<"\n"; // stampa
+ //cout << " TPC track label = " << lab <<"\n"; // stampa
//propagation to vertex
Double_t rbeam=3.;
- if((*fresult).DoNotCross(rbeam)) continue; //no intersection with beampipe
+ if((*fresult).DoNotCross(rbeam)) continue; //no intersection with beampipe
(*fresult).Propagation(rbeam);
Double_t c00,c10,c11,c20,c21,c22,c30,c31,c32,c33,c40,c41,c42,c43,c44;
(*fresult).GetCElements(c00,
Int_t charge;
if(c>0.) charge=-1; else charge=1;
ioTrack->SetCharge(charge);
+ Double_t trackmass=(*fresult).GetMass(); // oggi
+ ioTrack->SetMass(trackmass); // oggi
ioTrack->SetCovMatrix(c00,
c10,c11,
c20,c21,c22,
ioTrack->SetTPCLabel(lab);
ioTrack->SetDz(dz);
Int_t il;
- for(il=0;il<6; il++){
+ /*
+ for(il=0;il<6; il++){
ioTrack->SetIdPoint(il,(*fresult).GetIdPoint(il));
ioTrack->SetIdModule(il,(*fresult).GetIdModule(il));
} // end for il
- tracktree1.Fill();
+ */
+ //tracktree1.Fill();
+ Float_t q[4]={-1.,-1.,-1.,-1.};
+ Float_t globaldedx=0.;
for (il=0;il<6;il++) {
idpoint=(*fresult).GetIdPoint(il);
idmodule=(*fresult).GetIdModule(il);
ioTrack->SetIdPoint(il,idpoint);
ioTrack->SetIdModule(il,idmodule);
- } // end for il
+ //// for q definition
+ if(il>1){
+ if(idmodule>0.){
+ fDetTypeRec->ResetRecPoints();
+ gAlice->TreeR()->GetEvent(idmodule);
+ recp=(AliITSRecPoint*)frecPoints->UncheckedAt(idpoint);
+ q[il-2]=recp->GetQ()*(*fresult).Getfcor(il-2);
+ }
+ }
+ } // end for il
+ q[0]/=280.; q[1]/=280.;
+ q[2]/=38.; q[3]/=38.;
+
+ // cout<<" q prima = "<<q[0]<<" "<<q[1]<<" "<<q[2]<<" "<<q[3]<<"\n"; getchar();
+
+ Int_t swap;
+ do{
+ swap=0;
+ for (il=0; il<3; il++) {
+ if (q[il]<=q[il+1]) continue;
+ Float_t tmp=q[il];
+ q[il]=q[il+1]; q[il+1]=tmp;
+ swap++;
+ }
+ } while(swap);
+
+
+ // cout<<" q dopo = "<<q[0]<<" "<<q[1]<<" "<<q[2]<<" "<<q[3]<<"\n"; getchar();
+
+ if(q[0]<0.) {
+ q[0]=q[1];
+ q[1]=q[2];
+ q[2]=q[3];
+ q[3]=-1.;
+ }
+
+ // cout<<" q dopo if = "<<q[0]<<" "<<q[1]<<" "<<q[2]<<" "<<q[3]<<"\n"; getchar();
+
+ globaldedx=(q[0]+q[1])/2.;
+
+ // if(q[3]> 0.) globaldedx=(q[0]+q[1]+q[2]+q[3])/4.;
+ // else globaldedx=(q[0]+q[1]+q[2])/3.;
+
+ ioTrack->SetdEdx(globaldedx);
+ ioTrack->SetPid(pid->GetPcode(ioTrack));
+
+ tracktree1.Fill();
} // end if on numOfCluster
//gObjectTable->Print(); // stampa memoria
} // end for (int j=minTr; j<=maxTr; j++)
tfile->ls();
char hname[30];
sprintf(hname,"TreeT%d",evNumber);
+ cout << "Number of saved ITS tracks " << tracktree1.GetEntries() << endl;
tracktree1.Write(hname);
TTree *fAli=gAlice->TreeK();
sigmazl[5]=0.6889;
///////////////////////////////////////////////////////////
Int_t index;
- AliITSgeom *g1 = fITS->GetITSgeom();
+ AliRunLoader* rl = AliRunLoader::Open("galice.root");
+ rl->CdGAFile();
+ AliITSgeom* g1 = (AliITSgeom*)gDirectory->Get("AliITSgeom");
+
AliITSRecPoint *recp;
for(index =0; index<trackITSlist->GetSize(); index++) {
AliITSTrackV1 *trackITS = (AliITSTrackV1 *) trackITSlist->At(index);
// << " "<<(*trackITS)(1)<<"\n"; getchar();
if(outinters==-1) continue;
Int_t flaghit=0;
+ (*trackITS).SetLayer(layerfin); // oggi
+ (*trackITS).Setfcor(); // oggi
if(outinters==0){
TVector toucLad(9), toucDet(9);
Int_t lycur=layerfin;
Int_t indexmod;
indexmod = g1->GetModuleIndex(lycur,(Int_t)toucLad(iriv),
(Int_t)toucDet(iriv));
- fITS->ResetRecPoints();
+ fDetTypeRec->ResetRecPoints();
gAlice->TreeR()->GetEvent(indexmod);
Int_t npoints=frecPoints->GetEntries();
continue;
// cout<<" supero sigmaphi \n";
AliITSTrackV1 *newTrack = new AliITSTrackV1((*trackITS));
- (*newTrack).SetLayer((*trackITS).GetLayer()-1);
+ //(*newTrack).SetLayer((*trackITS).GetLayer()-1);
if (TMath::Abs(rTrack-cluster(0))/rTrack>1e-6)
(*newTrack).Correct(Double_t(cluster(0)));
//cout<<" cluster(2) e(*newTrack).GetZ()="<<cluster(2)<<" "
// cout<<" chi2pred = "<<chi2pred<<"\n";
// if(chi2pred>fChi2max) continue; //aggiunto il 30-7-2001
if(iriv == 0) flaghit=1;
- (*newTrack).AddMS(frl); // add the multiple scattering
+ (*newTrack).AddMS(); // add the multiple scattering
//matrix to the covariance matrix
- (*newTrack).AddEL(frl,1.,0);
+ (*newTrack).AddEL(1.,0);
if(fflagvert){
KalmanFilterVert(newTrack,cluster,sigmanew);
if(flaghit==0 || outinters==-2) {
AliITSTrackV1 *newTrack = new AliITSTrackV1(*trackITS);
(*newTrack).Setfnoclust();
- (*newTrack).SetLayer((*trackITS).GetLayer()-1);
- (*newTrack).AddMS(frl); // add the multiple scattering matrix
+ //(*newTrack).SetLayer((*trackITS).GetLayer()-1);
+ (*newTrack).AddMS(); // add the multiple scattering matrix
// to the covariance matrix
- (*newTrack).AddEL(frl,1.,0);
+ (*newTrack).AddEL(1.,0);
listoftrack.AddLast(newTrack);
} // end if
} // end of for on tracks (index)
//gObjectTable->Print(); // stampa memoria
+ delete rl;
+
}
//______________________________________________________________________
Int_t AliITSTrackerV1::Intersection(AliITSTrackV1 &track,Int_t layer,
newTrack->SetChi2(newTrack->GetChi2()+chi2);
// newTrack->SetChi2(newTrack->GetChi2()+chi2pred);
}
+