Upgrade/AliToyMCEventGenerator.cxx
Upgrade/AliToyMCEventGeneratorSimple.cxx
Upgrade/AliToyMCReconstruction.cxx
+ Upgrade/AliToyMCDrawer.cxx
)
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
virtual Bool_t Update(const AliCluster* c2, Double_t chi2, Int_t i);
AliTPCTrackerPoint * GetTrackPoint(Int_t i);
AliTPCclusterMI * GetClusterFast(Int_t irow){ return fClusterPointer[irow];}
+ AliTPCclusterMI * GetClusterFast(Int_t irow) const { return fClusterPointer[irow];}
void SetClusterPointer(Int_t irow, AliTPCclusterMI* cl) {fClusterPointer[irow]=cl;}
Double_t GetDensityFirst(Int_t n);
Double_t GetSigma2C() const {
#pragma link C++ class AliToyMCEventGenerator+;
#pragma link C++ class AliToyMCEventGeneratorSimple+;
#pragma link C++ class AliToyMCReconstruction+;
+#pragma link C++ class AliToyMCDrawer;
#endif
#include <iostream>
-#include <AliMagF.h>
+#include <TROOT.h>
#include <TChain.h>
#include <TMath.h>
#include <TTree.h>
#include <TAxis.h>
#include <TLegend.h>
#include <TPad.h>
+#include <TGeoGlobalMagField.h>
+
+#include <AliMagF.h>
+#include <AliCDBManager.h>
+#include <AliTPCParam.h>
+#include <AliGeomManager.h>
+#include <AliTPCcalibDB.h>
#include <AliTrackPointArray.h>
#include <AliCluster.h>
+#include <AliLog.h>
+#include <AliTPCLaserTrack.h>
+
+
#include "AliToyMCDrawer.h"
#include "AliToyMCEvent.h"
#include "AliToyMCTrack.h"
-#include <AliCDBManager.h>
-#include <AliTPCParam.h>
-#include <AliGeomManager.h>
-#include <TGeoGlobalMagField.h>
-#include <AliTPCcalibDB.h>
-#include <AliTPCROC.h>
// Visualization class. To use
ClassImp(AliToyMCDrawer);
AliToyMCDrawer::AliToyMCDrawer()
- : TObject()
- ,fInputTree(0x0)
- ,inFile(0x0)
- ,fFileName(0x0)
- ,fEvent(0x0)
- ,fEventArray(0x0)
- ,fDispHist(0x0)
- ,fCenterTime(-1.)
- ,fDriftVel(-1.)
-
- {
+ : TObject()
+ ,fInputTree(0x0)
+ ,fInFile(0x0)
+ ,fFileName()
+ ,fEvent(0x0)
+ ,fEventArray(0x0)
+ ,fDispHist(0x0)
+ ,fCenterTime(-1.)
+ ,fDriftVel(-1.)
+ ,fTPCParam(0x0)
+ ,fMaxZ0(0.)
+ ,fIFCRadius(83.5)
+ ,fOFCRadius(254.5)
+ ,fTimeRange(0)
+ ,fRoc(AliTPCROC::Instance())
+ ,fPoints(0x0)
+ ,fDistPoints(0x0)
+ {
fEventArray = new TClonesArray("AliToyMCEvent");
fTPCParam = AliTPCcalibDB::Instance()->GetParameters();
fTPCParam->ReadGeoMatrices();
- fDriftVel = fTPCParam->GetDriftV();///1000000;
- fMaxZ0=fTPCParam->GetZLength();
+ fDriftVel = fTPCParam->GetDriftV();
+ fMaxZ0 =fTPCParam->GetZLength();
fTimeRange = 2*fMaxZ0/fDriftVel;
- fIFCRadius= 83.5;
- fOFCRadius= 254.5;
- fRoc = AliTPCROC::Instance();
fPoints = new TClonesArray("TPolyMarker3D");
fDistPoints = new TClonesArray("TPolyMarker3D");
-
}
//________________________________________________________________
AliToyMCDrawer::AliToyMCDrawer(const AliToyMCDrawer &drawer)
: TObject(drawer)
,fInputTree(drawer.fInputTree)
- ,inFile(drawer.inFile)
+ ,fInFile(drawer.fInFile)
,fFileName(drawer.fFileName)
,fEvent(drawer.fEvent)
,fEventArray(drawer.fEventArray)
,fDriftVel(drawer.fDriftVel)
,fTPCParam(drawer.fTPCParam)
,fMaxZ0(drawer.fMaxZ0)
- ,fOFCRadius(drawer.fOFCRadius)
,fIFCRadius(drawer.fIFCRadius)
+ ,fOFCRadius(drawer.fOFCRadius)
,fTimeRange(drawer.fTimeRange)
,fRoc(drawer.fRoc)
,fPoints(drawer.fPoints)
//destructor
delete fEvent;
delete fEventArray;
- delete fDispHist;
delete fPoints;
delete fDistPoints;
+ delete fDispHist;
}
//________________________________________________________________
Int_t AliToyMCDrawer::FillEventArray(Double_t snapShotTime)
{
- if(!fFileName) {
+ if(fFileName.IsNull()) {
std::cout << "no input file provided, using default (toyMC.root)" << std::endl;
fFileName = "toyMC.root";
}
- inFile = new TFile(fFileName,"read");
- fInputTree = dynamic_cast<TTree*> (inFile->Get("toyMCtree"));
+ fInFile = new TFile(fFileName.Data(),"read");
+ gROOT->cd();
+ fInputTree = dynamic_cast<TTree*> (fInFile->Get("toyMCtree"));
fInputTree->SetBranchAddress("event",&fEvent);
fEventArray->Clear();
//________________________________________________________________
Int_t AliToyMCDrawer::FillEventArray(Int_t middleEventNbr, Double_t snapShotTime)
{
- if(!fFileName) {
+ if(fFileName.IsNull()) {
std::cout << "no input file provided, using default (toyMC.root)" << std::endl;
fFileName = "toyMC.root";
}
- if(!inFile) inFile = new TFile(fFileName,"read");
+ if(!fInFile) fInFile = new TFile(fFileName.Data(),"read");
+ gROOT->cd();
if(!fInputTree)
{
- fInputTree = dynamic_cast<TTree*> (inFile->Get("toyMCtree"));
+ fInputTree = dynamic_cast<TTree*> (fInFile->Get("toyMCtree"));
// fInputTree->Add(fileName);
fInputTree->SetBranchAddress("event",&fEvent);
}
+}
+
+//________________________________________________________________
+void AliToyMCDrawer::DrawLaserEvent(Int_t nLaserEvents, Int_t side, Int_t rod, Int_t bundle, Int_t beam)
+{
+ //
+ //
+ //
+
+ fPoints->Clear();
+ fDistPoints->Clear();
+ if (!ConnectInputTree()) return;
+
+ AliTPCLaserTrack::LoadTracks();
+ TObjArray *arr=AliTPCLaserTrack::GetTracks();
+
+ DrawGeometry();
+
+ Int_t laserEvents=0;
+ for (Int_t iev=0;iev<fInputTree->GetEntries();++iev) {
+ fInputTree->GetEntry(iev);
+ if (fEvent->GetEventType()!=AliToyMCEvent::kLaser) continue;
+ if (fEvent->GetNumberOfTracks()!=arr->GetEntriesFast()) {
+ AliError(Form("Wrong number of tracks in the laser event: %d!=%d",fEvent->GetNumberOfTracks(),arr->GetEntriesFast()));
+ continue;
+ }
+
+ for (Int_t iTrack=0; iTrack<fEvent->GetNumberOfTracks();++iTrack){
+ AliTPCLaserTrack *laserTrack = (AliTPCLaserTrack*)arr->UncheckedAt(iTrack);
+ if (side >-1 && laserTrack->GetSide() != side ) continue;
+ if (rod >-1 && laserTrack->GetRod() != rod ) continue;
+ if (bundle>-1 && laserTrack->GetBundle() != bundle ) continue;
+ if (beam >-1 && laserTrack->GetBeam() != beam ) continue;
+ const AliToyMCTrack *track = fEvent->GetTrack(iTrack);
+ DrawTrack(track,0,fEvent->GetT0(),kRed);
+ }
+
+ ++laserEvents;
+ if (laserEvents==nLaserEvents) break;
+ }
+
+
}
//________________________________________________________________
}
+//________________________________________________________________
+Bool_t AliToyMCDrawer::ConnectInputTree()
+{
+ //
+ //
+ //
+
+ if(fFileName.IsNull()) {
+ AliError("no input file provided, using default (toyMC.root)");
+ fFileName = "toyMC.root";
+ }
+ if (fInFile && fInFile->GetName()==fFileName) return kTRUE;
+ delete fInFile;
+ fInFile=0x0;
+ delete fInputTree;
+ fInputTree=0x0;
+
+ fInFile = new TFile(fFileName.Data(),"read");
+ if (!fInFile || !fInFile->IsOpen() || fInFile->IsZombie() ) {
+ delete fInFile;
+ return kFALSE;
+ }
+
+ gROOT->cd();
+
+ fInputTree = dynamic_cast<TTree*> (fInFile->Get("toyMCtree"));
+
+ if (!fInputTree){
+ AliError("Could not connect tree!\n");
+ delete fInFile;
+ fInFile=0x0;
+ return kFALSE;
+ }
+
+ fInputTree->SetBranchAddress("event",&fEvent);
+ return kTRUE;
+}
\ No newline at end of file
#include <TH3F.h>
#include <TTree.h>
#include <TFile.h>
-#include <TClonesArray.h>
+#include <TString.h>
+
#include <AliTPCParam.h>
+#include <AliTPCROC.h>
+
#include "AliToyMCEvent.h"
#include "AliToyMCTrack.h"
+
class TPolyMarker3D;
-class AliTPCROC;
+// class AliTPCROC;
class TClonesArray;
/* Visualization class. To use */
void SetFileName(const Char_t* filename) {fFileName = filename;}
void DrawEvent(AliToyMCEvent *currentEvent, Double_t centerTime, Int_t color);
void DrawTrack(const AliToyMCTrack *track, Double_t centerTime, Double_t currentEventTime, Int_t color);
+ void DrawLaserEvent(Int_t nLaserEvents=1, Int_t side=-1, Int_t rod=-1, Int_t bundle=-1, Int_t beam=-1);
void DrawGeometry();
void DrawEvents(Bool_t both = kFALSE, Bool_t before = kTRUE);
// void DrawEvents(Bool_t time = kTRUE, Bool_t both = kTRUE, Bool_t before = kTRUE);
const AliToyMCEvent* GetEvent(Int_t eventnr) const {return static_cast<const AliToyMCEvent*>(fEventArray->At(eventnr));}
- private:
+private:
TTree* fInputTree;
- TFile* inFile;
- const char* fFileName;
+ TFile* fInFile;
+ TString fFileName;
AliToyMCEvent* fEvent;
TClonesArray* fEventArray;
TH3F* fDispHist;
Double_t fDriftVel;
AliTPCParam *fTPCParam;
Double_t fMaxZ0;
- Double_t fOFCRadius;
Double_t fIFCRadius;
+ Double_t fOFCRadius;
Double_t fTimeRange;
AliTPCROC *fRoc;
TClonesArray *fPoints;
- TClonesArray *fDistPoints;
+ TClonesArray *fDistPoints;
+
+ Bool_t ConnectInputTree();
+
ClassDef(AliToyMCDrawer, 1);
};
AliToyMCEvent::AliToyMCEvent()
:TObject()
,fEventNumber(0)
+ ,fEventType(kPhysics)
,fT0(-1.)
,fX(-1000.)
,fY(-1000.)
AliToyMCEvent::AliToyMCEvent(const AliToyMCEvent &event)
: TObject(event)
,fEventNumber(event.fEventNumber)
+ ,fEventType(event.fEventType)
,fT0(event.fT0)
,fX(event.fX)
,fY(event.fY)
{
return new(fTracks[fTracks.GetEntriesFast()]) AliToyMCTrack(track);
}
+//____________________________________________________
+AliToyMCTrack* AliToyMCEvent::AddTrack(Double_t xyz[3],Double_t pxpypz[3],
+ Double_t cv[21],Short_t sign)
+{
+ return new(fTracks[fTracks.GetEntriesFast()]) AliToyMCTrack(xyz,pxpypz,cv,sign);
+}
virtual ~AliToyMCEvent() {}
AliToyMCEvent& operator = (const AliToyMCEvent &event);
+ enum EEventType {
+ kPhysics=0,
+ kLaser
+ };
+
static void SetInitialEventCounter(Int_t iev) { fgEvCounter=iev; }
AliToyMCTrack* AddTrack(const AliToyMCTrack &track);
-
+ AliToyMCTrack* AddTrack(Double_t xyz[3],Double_t pxpypz[3],
+ Double_t cv[21],Short_t sign);
+
Int_t GetNumberOfTracks() const { return fTracks.GetEntriesFast(); }
const AliToyMCTrack* GetTrack(Int_t track) const { return static_cast<const AliToyMCTrack*>(fTracks.At(track)); }
Float_t GetX() const {return fX; }
Float_t GetY() const {return fY; }
Float_t GetZ() const {return fZ; }
+
+ void SetEventType(EEventType type) { fEventType=type; }
+ EEventType GetEventType() const { return fEventType; }
private:
static Int_t fgEvCounter;
UInt_t fEventNumber;
+
+ EEventType fEventType;
Float_t fT0;
Float_t fX;
#include <TGeoGlobalMagField.h>
#include <TSpline.h>
#include <TObjString.h>
+#include <TROOT.h>
#include <AliLog.h>
#include <AliTPCROC.h>
#include <AliTPCclusterMI.h>
#include <AliTPCSpaceCharge3D.h>
#include <AliTPCROC.h>
+#include <AliExternalTrackParam.h>
#include "AliToyMCEvent.h"
#include "AliToyMCTrack.h"
,fOutTree(0x0)
,fUseStepCorrection(kFALSE)
,fUseMaterialBudget(kFALSE)
+ ,fIsLaser(kTRUE)
{
fTPCParam = AliTPCcalibDB::Instance()->GetParameters();
fTPCParam->ReadGeoMatrices();
,fOutTree(0x0)
,fUseStepCorrection(gen.fUseStepCorrection)
,fUseMaterialBudget(gen.fUseMaterialBudget)
+ ,fIsLaser(gen.fIsLaser)
{
//
gRandom->SetSeed();
MakeTPCClusters(trackIn, t0);
MakeTRDClusters(trackIn/*,t0*/);
- return 1;
+ return kTRUE;
}
//________________________________________________________________
void AliToyMCEventGenerator::MakeITSClusters(AliToyMCTrack &trackIn/*, Double_t t0*/)
const Double_t kMaxZ0 = fTPCParam->GetZLength();
const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
- AliToyMCTrack track(trackIn);
+ AliExternalTrackParam track(trackIn);
Double_t xyz[3] = {0.,0.,0.};
if (!AliTrackerBase::PropagateTrackTo(&track,ITSRadii[0],kMass,5,kTRUE,kMaxSnp,0,kFALSE,fUseMaterialBudget)) {
if (TMath::Abs(track.GetZ())>kMaxZ0) continue;
if (TMath::Abs(track.GetZ())>lengthITS[iLayer]/2) continue;
- AliCluster* tempCl = new AliCluster();
-
- tempCl->SetX(xyz[0]);
- tempCl->SetY(xyz[1]);
- tempCl->SetZ(xyz[2]);
-
- Double_t sigmaY = 0.0004;
- Double_t sigmaZ = 0.0004;
-
- tempCl->SetSigmaY2(sigmaY*sigmaY);
- tempCl->SetSigmaZ2(sigmaZ*sigmaZ);
-
- trackIn.AddITSPoint(*tempCl);
-
+ const Double_t sigmaY = 0.0004;
+ const Double_t sigmaZ = 0.0004;
+ AliCluster* tempCl = trackIn.AddITSPoint(AliCluster(1000,xyz[0],xyz[1],xyz[2],sigmaY*sigmaY,sigmaZ*sigmaZ,0));
+ tempCl->SetLabel(trackIn.GetUniqueID(), 0);
}
}
const Double_t kMaxZ0 = fTPCParam->GetZLength();
const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
- AliToyMCTrack track(trackIn);
+ AliExternalTrackParam track(trackIn);
Double_t xyz[3] = {0.,0.,0.};
if (!AliTrackerBase::PropagateTrackTo(&track,TRDRadii[0],kMass,5,kTRUE,kMaxSnp,0,kFALSE,fUseMaterialBudget)) {
if (TMath::Abs(track.GetZ())>kMaxZ0) continue;
if (TMath::Abs(track.GetZ())>lengthTRD[iLayer]/2) continue;
- AliCluster* tempCl = new AliCluster();
-
- tempCl->SetX(xyz[0]);
- tempCl->SetY(xyz[1]);
- tempCl->SetZ(xyz[2]);
-
- Double_t sigmaY = 0.06;
- Double_t sigmaZ = 0.2;
-
- tempCl->SetSigmaY2(sigmaY*sigmaY);
- tempCl->SetSigmaZ2(sigmaZ*sigmaZ);
-
- trackIn.AddTRDPoint(*tempCl);
-
+ const Double_t sigmaY = 0.06;
+ const Double_t sigmaZ = 0.2;
+ AliCluster* tempCl = trackIn.AddTRDPoint(AliCluster(1000,xyz[0],xyz[1],xyz[2],sigmaY*sigmaY,sigmaZ*sigmaZ,0));
+ tempCl->SetLabel(trackIn.GetUniqueID(), 0);
}
}
// make it big enough to hold all points
// store real number of generated points in the unique id
const Int_t nMaxPoints=3000;
- AliTrackPointArray pointArray0(nMaxPoints); //undistorted
- AliTrackPointArray pointArray1(nMaxPoints); //distorted
+ static AliTrackPointArray pointArray0(nMaxPoints); //undistorted
+ static AliTrackPointArray pointArray1(nMaxPoints); //distorted
//Create space point of undistorted and distorted clusters along the propagated track trajectory
CreateSpacePoints(trackIn,pointArray0,pointArray1);
// a graph is filled in local coordinates for later
//
- const Double_t kMaxSnp = 0.85;
+ Double_t kMaxSnp = 0.85;
+ if (fIsLaser) kMaxSnp=0.99;
const Double_t kMaxZ0 = fTPCParam->GetZLength();
const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
const Double_t iFCRadius = 83.5; //radius constants found in AliTPCCorrection.cxx
const Double_t oFCRadius = 254.5;
- AliToyMCTrack track(trackIn);
+ AliExternalTrackParam track(trackIn);
//!!! TODO: make this adjustable perhaps
const Double_t stepSize=0.1;
Double_t xyz[3] = {0.,0.,0.};
Float_t xyzf[3] = {0.,0.,0.};
//!!! when does the propagation not work, how often does it happen?
- if (!AliTrackerBase::PropagateTrackTo(&track,iFCRadius,kMass,5,kTRUE,kMaxSnp,0,kFALSE,fUseMaterialBudget)) {
+ if (!AliTrackerBase::PropagateTrackTo(&track,iFCRadius,kMass,5,kTRUE,kMaxSnp,0,kFALSE,fUseMaterialBudget) && !fIsLaser) {
AliError(Form("Propagation to IFC: %.2f failed\n",iFCRadius));
return;
}
Int_t npoints=0;
for (Double_t radius=iFCRadius; radius<oFCRadius; radius+=stepSize){
-
//!!! changed from return 0 to continue -> Please check
if (!AliTrackerBase::PropagateTrackTo(&track,radius,kMass,1,kTRUE,kMaxSnp,0,kFALSE,fUseMaterialBudget)) {
- AliError(Form("Propagation to %.2f failed\n",radius));
+ AliError(Form("Propagation to r=%.2f (snp=%.2f) failed\n",radius,track.GetSnp()));
continue;
}
track.GetXYZ(xyz);
//
//
-
const Int_t npoints=Int_t(arrPoints.GetUniqueID());
Int_t secOld=-1;
if (!SetupCluster(tempCl,xyz,sec,t0)) continue;
tempCl.SetLabel(tr.GetUniqueID(), 0);
-
+
if (type==0) tr.AddSpacePoint(tempCl);
else tr.AddDistortedSpacePoint(tempCl);
// printf("SetupCluster %3d: (%.2f, %.2f, %.2f), %d, %.2f\n",irow,xyz[0],xyz[1],xyz[2],sec,t0);
fOutTree = new TTree("toyMCtree","Tree with toyMC simulation");
fOutTree->Branch("event","AliToyMCEvent",&fEvent);
+ gROOT->cd();
+
return kTRUE;
}
void AliToyMCEventGenerator::FillTree()
{
// fill the tree
- if (fOutTree) fOutTree->Fill();
+ if (fOutTree&&fEvent) fOutTree->Fill();
}
//________________________________________________________________
void SetUseMaterialBudget(Bool_t use) { fUseMaterialBudget=use; }
Bool_t GetUseMaterialBudget() const { return fUseMaterialBudget; }
+
+ void SetIsLaser(Bool_t use) { fIsLaser=use; }
+ Bool_t GetIsLaser() const { return fIsLaser; }
protected:
AliTPCParam *fTPCParam;
Bool_t fUseStepCorrection;
Bool_t fUseMaterialBudget;
+ Bool_t fIsLaser;
ClassDef(AliToyMCEventGenerator, 1)
#include <TRandom.h>
#include <TF1.h>
#include <TStopwatch.h>
-#include <AliESDtrackCuts.h>
-#include <AliESDtrack.h>
#include <TFile.h>
#include <TTree.h>
#include <TRandom3.h>
+#include <AliESDtrackCuts.h>
+#include <AliESDtrack.h>
+#include <AliTPCLaserTrack.h>
+
#include "AliToyMCEvent.h"
#include "AliToyMCEventGeneratorSimple.h"
Double_t etaCuts=.9;
Double_t mass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
- TF1 fpt("fpt",Form("x*(1+(sqrt(x*x+%f^2)-%f)/([0]*[1]))^(-[0])",mass,mass),0.4,10);
- fpt.SetParameters(7.24,0.120);
- fpt.SetNpx(10000);
+ static TF1 fpt("fpt",Form("x*(1+(sqrt(x*x+%f^2)-%f)/([0]*[1]))^(-[0])",mass,mass),0.4,10);
+ if (fpt.GetParameter(0)<1){
+ printf("Set Parameters\n");
+ fpt.SetParameters(7.24,0.120);
+ fpt.SetNpx(200);
+ }
// Int_t nTracks = 400; //TODO: draw from experim dist
// Int_t nTracks = 20; //TODO: draw from experim dist
Int_t nTracksLocal = fNtracks;
pxyz[2]=pt*TMath::Tan(theta);
Double_t vertex[3]={0,0,retEvent->GetZ()};
Double_t cv[21]={0};
- AliToyMCTrack *tempTrack = new AliToyMCTrack(vertex,pxyz,cv,sign);
+ AliToyMCTrack *tempTrack = retEvent->AddTrack(vertex,pxyz,cv,sign);
// use unique ID for track number
// this will be used in DistortTrack track to set the cluster label
// in one simulation the track id should be unique for performance studies
tempTrack->SetUniqueID(fCurrentTrack++);
-
- Bool_t trackDist = DistortTrack(*tempTrack, time);
- if(trackDist) retEvent->AddTrack(*tempTrack);
- delete tempTrack;
+ DistortTrack(*tempTrack, time);
}
return retEvent;
CloseOutputFile();
}
+//________________________________________________________________
+void AliToyMCEventGeneratorSimple::RunSimulationLaser(const Int_t nevents/*=1*/)
+{
+ //
+ // run simple simulation with equal event spacing
+ //
+
+ if (!ConnectOutputFile()) return;
+ //initialise the space charge. Should be done after the tree was set up
+ InitSpaceCharge();
+
+ // within one simulation the track count should be unique for effeciency studies
+ fCurrentTrack=0;
+
+ Double_t eventTime=0.;
+ const Double_t eventSpacing=1./10.; //laser is running at 10Hz equally spaced
+ TStopwatch s;
+ for (Int_t ievent=0; ievent<nevents; ++ievent){
+ printf("Generating event %3d (%.3g)\n",ievent,eventTime);
+ fEvent = GenerateLaser(eventTime);
+ FillTree();
+ delete fEvent;
+ fEvent=0x0;
+ eventTime+=eventSpacing;
+ }
+ s.Stop();
+ s.Print();
+
+ CloseOutputFile();
+}
+
//________________________________________________________________
AliToyMCEvent* AliToyMCEventGeneratorSimple::GenerateESD(AliESDEvent &esdEvent, Double_t time) {
Double_t cv[21]={0};
Int_t sign = part->Charge();
- AliToyMCTrack *tempTrack = new AliToyMCTrack(vertex,pxyz,cv,sign);
+ AliToyMCTrack *tempTrack = retEvent->AddTrack(vertex,pxyz,cv,sign);
// use unique ID for track number
// this will be used in DistortTrack track to set the cluster label
// in one simulation the track id should be unique for performance studies
tempTrack->SetUniqueID(fCurrentTrack++);
-
-
- Bool_t trackDist = DistortTrack(*tempTrack, time);
- if(trackDist) {
- retEvent->AddTrack(*tempTrack);
-
- nUsedTracks++;
- }
- delete tempTrack;
+ DistortTrack(*tempTrack, time);
+ nUsedTracks++;
if(nUsedTracks >= fNtracks) break;
}
Double_t cv[21]={0};
Int_t sign = part->Charge();
- AliToyMCTrack *tempTrack = new AliToyMCTrack(vertex,pxyz,cv,sign);
+ AliToyMCTrack *tempTrack = retEvent->AddTrack(vertex,pxyz,cv,sign);
// use unique ID for track number
// this will be used in DistortTrack track to set the cluster label
// in one simulation the track id should be unique for performance studies
tempTrack->SetUniqueID(fCurrentTrack++);
-
-
- Bool_t trackDist = DistortTrack(*tempTrack, time);
- if(trackDist) {
- retEvent->AddTrack(*tempTrack);
-
- nUsedTracks++;
- }
- delete tempTrack;
+ DistortTrack(*tempTrack, time);
+
if(nUsedTracks >= fNtracks) break;
}
return retEvent;
}
+//________________________________________________________________
+AliToyMCEvent* AliToyMCEventGeneratorSimple::GenerateLaser(Double_t time)
+{
+ //
+ // Generate an Event with laser tracks
+ //
+
+ AliToyMCEvent *retEvent = new AliToyMCEvent();
+ retEvent->SetEventType(AliToyMCEvent::kLaser);
+
+ retEvent->SetT0(time);
+ retEvent->SetX(0);
+ retEvent->SetX(0);
+ retEvent->SetZ(0);
+
+ AliTPCLaserTrack::LoadTracks();
+ TObjArray *arr=AliTPCLaserTrack::GetTracks();
+
+ //since we have a laser track force no material budges
+ Bool_t materialBudget=GetUseMaterialBudget();
+ SetUseMaterialBudget(kFALSE);
+ SetIsLaser(kTRUE);
+
+ for (Int_t iTrack=0; iTrack<arr->GetEntriesFast(); ++iTrack){
+ AliExternalTrackParam *track=(AliExternalTrackParam*)arr->At(iTrack);
+ AliToyMCTrack *tempTrack = retEvent->AddTrack(AliToyMCTrack(*track));
+ // for laser only TPC clusters exist
+ tempTrack->SetUniqueID(fCurrentTrack++);
+ MakeTPCClusters(*tempTrack, time);
+ }
+
+ SetIsLaser(kFALSE);
+ SetUseMaterialBudget(materialBudget);
+ return retEvent;
+}
+
//________________________________________________________________
void AliToyMCEventGeneratorSimple::GetNGeneratedEventsAndSpacing(const Bool_t equalSpacing, Int_t &ngen, Double_t &spacing)
{
AliToyMCEvent* Generate(Double_t time);
AliToyMCEvent* GenerateESD(AliESDEvent& esdEvent, Double_t time);
AliToyMCEvent* GenerateESD2(Double_t time);
+ AliToyMCEvent* GenerateLaser(Double_t time);
- void SetParametersToyGen(const Char_t* parfilename="files/params.root", Double_t vertexMean = 0., Double_t vertexSigma = 7.);
+ void SetParametersToyGen(const Char_t* parfilename="$ALICE_ROOT/TPC/Upgrade/files/params.root", Double_t vertexMean = 0., Double_t vertexSigma = 7.);
void RunSimulation(const Int_t nevents=10, const Int_t ntracks=20);
void RunSimulationBunchTrain(const Int_t nevents=10, const Int_t ntracks=20);
void RunSimulationESD(const Int_t nevents=10, const Int_t ntracks=20);
+ void RunSimulationLaser(const Int_t nevents=1);
+
void SetInputESD(const Char_t* filename) {fInputFileNameESD = filename;}
Int_t OpenInputAndGetMaxEvents(const Int_t type, const Int_t nevents);
void RunSimulation2(const Bool_t equalspacing, const Int_t type, const Int_t nevents, const Int_t ntracks);
printf("============== Processing Event %6d =================\n",iev);
fTree->GetEvent(iev);
for (Int_t itr=0; itr<fEvent->GetNumberOfTracks(); ++itr){
- printf(" > ====== Processing Track %6d ======== \n",itr);
+// printf(" > ====== Processing Track %6d ======== \n",itr);
const AliToyMCTrack *tr=fEvent->GetTrack(itr);
tOrig = *tr;
// voluem ID to add later ....
// p.SetXYZ(xyz);
// p.SetCov(cov);
- AliTrackPoint *tp=const_cast<AliTPCclusterMI*>(cl)->MakePoint();
- p=*tp;
- delete tp;
+// AliTrackPoint *tp=const_cast<AliTPCclusterMI*>(cl)->MakePoint(p);
+// p=*tp;
+// delete tp;
+ const_cast<AliTPCclusterMI*>(cl)->MakePoint(p);
// cl->Print();
// p.Print();
p.SetVolumeID(cl->GetDetector());
return tFirst;
}
-//_____________________________________________________________________________
+//____________________________________________________________________________________
Int_t AliToyMCReconstruction::LoadOuterSectors() {
//-----------------------------------------------------------------
// This function fills outer TPC sectors with clusters.
}
-//_____________________________________________________________________________
+//____________________________________________________________________________________
Int_t AliToyMCReconstruction::LoadInnerSectors() {
//-----------------------------------------------------------------
// This function fills inner TPC sectors with clusters.
return 0;
}
-//_____________________________________________________________________________
+//____________________________________________________________________________________
Int_t AliToyMCReconstruction::GetSector(AliExternalTrackParam *track) {
//-----------------------------------------------------------------
// This function returns the sector number for a given track
return sector;
}
-//_____________________________________________________________________________
+//____________________________________________________________________________________
void AliToyMCReconstruction::FillSectorStructure(Int_t maxev) {
//-----------------------------------------------------------------
// This function fills the sector structure of AliToyMCReconstruction
Int_t sec = cl->GetDetector();
Int_t row = cl->GetRow();
+ // set Q of the cluster to 1, Q==0 does not work for the seeding
+ cl->SetQ(1);
+
// set cluster time to cluster Z (if not ideal tracking)
if ( !fIdealTracking ) {
- cl->SetZ(cl->GetTimeBin());
- }
+ // a 'valid' position in z is needed for the seeding procedure
+// cl->SetZ(cl->GetTimeBin()*GetVDrift());
+ cl->SetZ(cl->GetTimeBin());
+ }
//Printf("Fill clusters (sector %d row %d): %.2f %.2f %.2f %.2f",sec,row,cl->GetX(),cl->GetY(),cl->GetZ(),cl->GetTimeBin());
// fill arrays for inner and outer sectors (A/C side handled internally)
// }
// }
}
+
+//____________________________________________________________________________________
+AliToyMCTrack *AliToyMCReconstruction::ConvertTPCSeedToToyMCTrack(const AliTPCseed &seed)
+{
+ //
+ //
+ //
+
+
+ AliToyMCTrack *tToy = new AliToyMCTrack(seed);
+
+ for (Int_t icl=0; icl<159; ++icl){
+ const AliTPCclusterMI * const cl=seed.GetClusterFast(icl);
+ tToy->AddDistortedSpacePoint(*cl);
+ }
+
+ return tToy;
+}
+
+//____________________________________________________________________________________
+AliExternalTrackParam* AliToyMCReconstruction::GetRefittedTrack(const AliTPCseed &seed)
+{
+ //
+ //
+ //
+
+ AliExternalTrackParam *track=new AliExternalTrackParam;
+
+
+ return track;
+}
AliExternalTrackParam* GetSeedFromTrack(const AliToyMCTrack * const tr);
AliExternalTrackParam* GetFittedTrackFromSeed(const AliToyMCTrack *tr, const AliExternalTrackParam *seed);
AliExternalTrackParam* GetFittedTrackFromSeedAllClusters(const AliToyMCTrack *tr, const AliExternalTrackParam *seed, Int_t &nClus);
+
+ AliToyMCTrack *ConvertTPCSeedToToyMCTrack(const AliTPCseed &seed);
+ AliExternalTrackParam* GetRefittedTrack(const AliTPCseed &seed);
+
AliExternalTrackParam* ClusterToTrackAssociation(const AliTPCseed *seed, Int_t trackID, Int_t &nClus);
void InitSpaceCharge();
AliToyMCTrack::AliToyMCTrack()
:AliExternalTrackParam()
- ,fSpacePoints("AliTPCclusterMI")
- ,fDistortedSpacePoints("AliTPCclusterMI")
- ,fITSPoints("AliCluster")
- ,fTRDPoints("AliCluster")
+ ,fSpacePoints("AliTPCclusterMI",160)
+ ,fDistortedSpacePoints("AliTPCclusterMI",160)
+ ,fITSPoints("AliCluster",7)
+ ,fTRDPoints("AliCluster",6)
{
//default constructor
}
-//____________________________________________________
+//________________________________________________________________
AliToyMCTrack::AliToyMCTrack(const AliToyMCTrack &track)
: AliExternalTrackParam(track)
,fSpacePoints(track.fSpacePoints)
{
//copy constructor
}
-//_____________________________________________________
+
+//________________________________________________________________
+AliToyMCTrack::AliToyMCTrack(const AliExternalTrackParam ¶m)
+ :AliExternalTrackParam(param)
+ ,fSpacePoints("AliTPCclusterMI",160)
+ ,fDistortedSpacePoints("AliTPCclusterMI",160)
+ ,fITSPoints("AliCluster",7)
+ ,fTRDPoints("AliCluster",6)
+{
+ //
+ // initialise from external track param
+ //
+}
+//________________________________________________________________
AliToyMCTrack& AliToyMCTrack::operator = (const AliToyMCTrack &track)
{
//assignment operator
const Double_t param[5],
const Double_t covar[15])
:AliExternalTrackParam(x,alpha,param,covar)
- ,fSpacePoints("AliTPCclusterMI")
- ,fDistortedSpacePoints("AliTPCclusterMI")
- ,fITSPoints("AliCluster")
- ,fTRDPoints("AliCluster")
+ ,fSpacePoints("AliTPCclusterMI",160)
+ ,fDistortedSpacePoints("AliTPCclusterMI",160)
+ ,fITSPoints("AliCluster",7)
+ ,fTRDPoints("AliCluster",6)
{
//create external track parameters from given arguments
}
AliToyMCTrack::AliToyMCTrack(Double_t xyz[3],Double_t pxpypz[3],
Double_t cv[21],Short_t sign)
:AliExternalTrackParam(xyz,pxpypz,cv,sign)
- ,fSpacePoints("AliTPCclusterMI")
- ,fDistortedSpacePoints("AliTPCclusterMI")
- ,fITSPoints("AliCluster")
- ,fTRDPoints("AliCluster")
+ ,fSpacePoints("AliTPCclusterMI",160)
+ ,fDistortedSpacePoints("AliTPCclusterMI",160)
+ ,fITSPoints("AliCluster",7)
+ ,fTRDPoints("AliCluster",6)
{
}
//________________________________________________________________
const Double_t covar[15]);
AliToyMCTrack(Double_t xyz[3],Double_t pxpypz[3],
Double_t cv[21],Short_t sign);
+ AliToyMCTrack(const AliExternalTrackParam ¶m);
AliToyMCTrack(const AliToyMCTrack &track);
AliToyMCTrack& operator=(const AliToyMCTrack &track);
virtual ~AliToyMCTrack() {}
--- /dev/null
+void makeComparisonTree(TString filename, TString addToName)
+{
+ TFile fn(filename.Data());
+ gROOT->cd();
+ fTPCCorrection=(AliTPCCorrection*)fn.Get("map");
+ fn.Close();
+
+ TString outFile=addToName;
+ outFile.Append(".root");
+ TTreeSRedirector *sred=new TTreeSRedirector(outFile.Data());
+
+ Float_t dx[3]={0,0,0};
+
+ for (Float_t iz=-240; iz<=240; iz+=20) {
+ Short_t roc=(iz>=0)?0:18;
+ for (Float_t ir=86; ir<250; ir+=20) {
+ for (Float_t iphi=0; iphi<TMath::TwoPi(); iphi+=10*TMath::DegToRad()){
+ Float_t x=ir*(Float_t)TMath::Cos(iphi);
+ Float_t y=ir*(Float_t)TMath::Sin(iphi);
+ Float_t x3[3]={x,y,iz};
+ (*sred) << "t" <<
+ "r=" << ir <<
+ "phi=" << iphi <<
+ "x=" << x <<
+ "y=" << y <<
+ "z=" << iz;
+
+ //distortions
+ fTPCCorrection->GetDistortion(x3,roc,dx);
+ Float_t xd = x+dx[0];
+ Float_t yd = y+dx[1];
+ Float_t zd = iz+dx[2];
+ Float_t rd = TMath::Sqrt(xd*xd+yd*yd);
+ Float_t phid = TMath::ATan2(yd,xd);
+ if (phid<0) phid+=TMath::TwoPi();
+ (*sred) << "t" <<
+ "xd=" << xd <<
+ "yd=" << yd <<
+ "zd=" << zd <<
+ "rd=" << rd <<
+ "phid=" << phid;
+
+ // correct back distorted point
+ Float_t xd3[3]={xd,yd,zd};
+
+ fTPCCorrection->GetCorrection(xd3,roc,dx);
+ Float_t xdc = xd+dx[0];
+ Float_t ydc = yd+dx[1];
+ Float_t zdc = zd+dx[2];
+ Float_t rdc = TMath::Sqrt(xdc*xdc+ydc*ydc);
+ Float_t phidc = TMath::ATan2(ydc,xdc);
+ if (phidc<0) phidc+=TMath::TwoPi();
+
+ (*sred) << "t" <<
+ "xdc=" << xdc <<
+ "ydc=" << ydc <<
+ "zdc=" << zdc <<
+ "rdc=" << rdc <<
+ "phidc=" << phidc;
+
+ // write current point
+ (*sred) << "t" <<
+ "\n";
+
+ }
+ }
+ }
+
+ delete sred;
+}
+
+void makeAllComparisonTrees()
+{
+ makeComparisonTree("$ALICE_ROOT/TPC/Calib/maps/SC_NeCO2_eps5_50kHz_precal.lookup.root","LUT_05");
+ makeComparisonTree("$ALICE_ROOT/TPC/Calib/maps/SC_NeCO2_eps10_50kHz_precal.lookup.root","LUT_10");
+ makeComparisonTree("$ALICE_ROOT/TPC/Calib/maps/SC_NeCO2_eps20_50kHz_precal.lookup.root","LUT_20");
+}
+
+TCanvas *GetCanvas(TString addToName);
+
+void makeHistos(TString addToName) {
+ TString fileName; //("test_");
+ fileName.Append(addToName.Data());
+ fileName.Append(".root");
+ TFile f(fileName.Data());
+ gROOT->cd();
+ TTree *t=f.Get("t");
+ gStyle->SetTitleX(0.18);
+ gStyle->SetTitleW(1-.18-.1);
+
+ t->SetMarkerStyle(20);
+ t->SetMarkerSize(.8);
+
+ TCanvas *c=0x0;
+ c=GetCanvas(addToName+"_zRes");
+ t->Draw("zdc-z:z:r","","colz");
+ c->SaveAs(Form("%s_zRes.png",addToName.Data()));
+ //
+ c=GetCanvas(addToName+"_rRes");
+ t->Draw("rdc-r:z:r","","colz");
+ c->SaveAs(Form("%s_rRes.png",addToName.Data()));
+ //
+ c=GetCanvas(addToName+"_phiRes");
+ t->Draw("phidc-phi:z:r","abs(phidc-phi)<1","colz");
+ c->SaveAs(Form("%s_phiRes.png",addToName.Data()));
+ //
+ c=GetCanvas(addToName+"_rphiRes");
+ t->Draw("(phidc*rdc)-(phi*r):z+(r-84)/(254-84)*18:r","abs(phidc-phi)<1","colz");
+ c->SaveAs(Form("%s_rphiRes.png",addToName.Data()));
+
+ f.Close();
+}
+
+
+
+void makeAllHistos() {
+ makeHistos("LUT_05");
+ makeHistos("LUT_10");
+ makeHistos("LUT_20");
+
+}
+
+TCanvas *GetCanvas(TString addToName)
+{
+ TString cName(addToName);
+ cName.Prepend("c_");
+ TCanvas *c=gROOT->GetListOfCanvases()->FindObject(cName.Data());
+ if (!c) c=new TCanvas(cName.Data(),addToName.Data());
+ c->Clear();
+ c->cd();
+ return c;
+}
+
+
+
break;
}
- outputFile.Append(Form("_%04dev_%04dtr"));
+ outputFile.Append(Form("_%04dev_%04dtr",nevents,ntracks));
outputFile.Append(".root");
s.SetOutputFileName(outputFile.Data());
// plots
if(doPlots){
- TString outFileName = inFileName;
+ TString outFileName = gSystem->BaseName(inFileName.Data());
outFileName.ReplaceAll(".root","");
cT0->SaveAs(Form("%s_T0.eps",outFileName.Data()));
+ cZ0->SaveAs(Form("%s_Z0.eps",outFileName.Data()));
cT02D->SaveAs(Form("%s_T02D.eps",outFileName.Data()));
cTrackParams->SaveAs(Form("%s_TrackParams.eps",outFileName.Data()));
+ cT0->SaveAs(Form("%s_T0.png",outFileName.Data()));
+ cZ0->SaveAs(Form("%s_Z0.png",outFileName.Data()));
+ cT02D->SaveAs(Form("%s_T02D.png",outFileName.Data()));
+ cTrackParams->SaveAs(Form("%s_TrackParams.png",outFileName.Data()));
}
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff