// //
// Uniform/nonuniform field tracking switches (default: uniform field) //
// //
-// rec.SetUniformFieldTracking(); ( rec.SetNonuniformFieldTracking(); ) //
+// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
// //
// The filling of additional ESD information can be steered by //
// //
#include <TROOT.h>
#include <TPluginManager.h>
#include <TStopwatch.h>
+#include <TGeoManager.h>
+#include <TLorentzVector.h>
#include "AliReconstruction.h"
#include "AliReconstructor.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliESD.h"
+#include "AliESDfriend.h"
#include "AliESDVertex.h"
+#include "AliMultiplicity.h"
#include "AliTracker.h"
#include "AliVertexer.h"
+#include "AliVertexerTracks.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
#include "AliPID.h"
#include "AliESDpid.h"
-#include "AliMagF.h"
-
-
+#include "AliESDtrack.h"
#include "AliRunTag.h"
-#include "AliLHCTag.h"
#include "AliDetectorTag.h"
#include "AliEventTag.h"
+#include "AliTrackPointArray.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliAlignObj.h"
+#include "AliCentralTrigger.h"
+#include "AliCTPRawStream.h"
ClassImp(AliReconstruction)
const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename,
+AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri,
const char* name, const char* title) :
TNamed(name, title),
- fRunLocalReconstruction("ALL"),
fUniformField(kTRUE),
fRunVertexFinder(kTRUE),
fRunHLTTracking(kFALSE),
+ fStopOnError(kFALSE),
+ fWriteAlignmentData(kFALSE),
+ fWriteESDfriend(kFALSE),
+ fFillTriggerESD(kTRUE),
+
+ fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
fGAliceFileName(gAliceFilename),
fInput(""),
+ fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
- fStopOnError(kFALSE),
fCheckPointLevel(0),
fOptions(),
+ fLoadAlignFromCDB(kTRUE),
+ fLoadAlignData("ALL"),
fRunLoader(NULL),
fRawReader(NULL),
- fVertexer(NULL)
+ fVertexer(NULL),
+ fDiamondProfile(NULL),
+
+ fAlignObjArray(NULL),
+ fCDBUri(cdbUri),
+ fSpecCDBUri()
{
// create reconstruction object with default parameters
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
TNamed(rec),
- fRunLocalReconstruction(rec.fRunLocalReconstruction),
fUniformField(rec.fUniformField),
fRunVertexFinder(rec.fRunVertexFinder),
fRunHLTTracking(rec.fRunHLTTracking),
+ fStopOnError(rec.fStopOnError),
+ fWriteAlignmentData(rec.fWriteAlignmentData),
+ fWriteESDfriend(rec.fWriteESDfriend),
+ fFillTriggerESD(rec.fFillTriggerESD),
+
+ fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
fGAliceFileName(rec.fGAliceFileName),
fInput(rec.fInput),
+ fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
- fStopOnError(rec.fStopOnError),
fCheckPointLevel(0),
fOptions(),
+ fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
+ fLoadAlignData(rec.fLoadAlignData),
fRunLoader(NULL),
fRawReader(NULL),
- fVertexer(NULL)
+ fVertexer(NULL),
+ fDiamondProfile(NULL),
+
+ fAlignObjArray(rec.fAlignObjArray),
+ fCDBUri(rec.fCDBUri),
+ fSpecCDBUri()
{
// copy constructor
- for (Int_t i = 0; i < fOptions.GetEntriesFast(); i++) {
+ for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
}
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
+ for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
+ if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
+ }
}
//_____________________________________________________________________________
CleanUp();
fOptions.Delete();
+ fSpecCDBUri.Delete();
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::InitCDBStorage()
+{
+// activate a default CDB storage
+// First check if we have any CDB storage set, because it is used
+// to retrieve the calibration and alignment constants
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ if (man->IsDefaultStorageSet())
+ {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default CDB storage has been already set !");
+ AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ fCDBUri = "";
+ }
+ else {
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ man->SetDefaultStorage(fCDBUri);
+ }
+
+ // Now activate the detector specific CDB storage locations
+ for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
+ TObject* obj = fSpecCDBUri[i];
+ if (!obj) continue;
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
+ }
+ man->Print();
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetDefaultStorage(const char* uri) {
+// Store the desired default CDB storage location
+// Activate it later within the Run() method
+
+ fCDBUri = uri;
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
+// Store a detector-specific CDB storage location
+// Activate it later within the Run() method
+
+ AliCDBPath aPath(calibType);
+ if(!aPath.IsValid()){
+ // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if(!strcmp(calibType, fgkDetectorName[iDet])) {
+ aPath.SetPath(Form("%s/*", calibType));
+ AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
+ break;
+ }
+ }
+ if(!aPath.IsValid()){
+ AliError(Form("Not a valid path or detector: %s", calibType));
+ return;
+ }
+ }
+
+ // check that calibType refers to a "valid" detector name
+ Bool_t isDetector = kFALSE;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ TString detName = fgkDetectorName[iDet];
+ if(aPath.GetLevel0() == detName) {
+ isDetector = kTRUE;
+ break;
+ }
+ }
+
+ if(!isDetector) {
+ AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
+ return;
+ }
+
+ TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
+ if (obj) fSpecCDBUri.Remove(obj);
+ fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetRunNumber()
+{
+ // The method is called in Run() in order
+ // to set a correct run number.
+ // In case of raw data reconstruction the
+ // run number is taken from the raw data header
+
+ if(AliCDBManager::Instance()->GetRun() < 0) {
+ if (!fRunLoader) {
+ AliError("No run loader is found !");
+ return kFALSE;
+ }
+ // read run number from gAlice
+ if(fRunLoader->GetAliRun())
+ AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
+ else {
+ if(fRawReader) {
+ if(fRawReader->NextEvent()) {
+ AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
+ fRawReader->RewindEvents();
+ }
+ else {
+ AliError("No raw-data events found !");
+ return kFALSE;
+ }
+ }
+ else {
+ AliError("Neither gAlice nor RawReader objects are found !");
+ return kFALSE;
+ }
+ }
+ AliInfo(Form("CDB Run number: %d",AliCDBManager::Instance()->GetRun()));
+ }
+ return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::ApplyAlignObjsToGeom(TObjArray* alObjArray)
+{
+ // Read collection of alignment objects (AliAlignObj derived) saved
+ // in the TClonesArray ClArrayName and apply them to the geometry
+ // manager singleton.
+ //
+ alObjArray->Sort();
+ Int_t nvols = alObjArray->GetEntriesFast();
+
+ Bool_t flag = kTRUE;
+
+ for(Int_t j=0; j<nvols; j++)
+ {
+ AliAlignObj* alobj = (AliAlignObj*) alObjArray->UncheckedAt(j);
+ if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
+ }
+
+ if (AliDebugLevelClass() >= 1) {
+ gGeoManager->GetTopNode()->CheckOverlaps(20);
+ TObjArray* ovexlist = gGeoManager->GetListOfOverlaps();
+ if(ovexlist->GetEntriesFast()){
+ AliError("The application of alignment objects to the geometry caused huge overlaps/extrusions!");
+ }
+ }
+
+ return flag;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetAlignObjArraySingleDet(const char* detName)
+{
+ // Fills array of single detector's alignable objects from CDB
+
+ AliDebug(2, Form("Loading alignment data for detector: %s",detName));
+
+ AliCDBEntry *entry;
+
+ AliCDBPath path(detName,"Align","Data");
+
+ entry=AliCDBManager::Instance()->Get(path.GetPath());
+ if(!entry){
+ AliDebug(2,Form("Couldn't load alignment data for detector %s",detName));
+ return kFALSE;
+ }
+ entry->SetOwner(1);
+ TClonesArray *alignArray = (TClonesArray*) entry->GetObject();
+ alignArray->SetOwner(0);
+ AliDebug(2,Form("Found %d alignment objects for %s",
+ alignArray->GetEntries(),detName));
+
+ AliAlignObj *alignObj=0;
+ TIter iter(alignArray);
+
+ // loop over align objects in detector
+ while( ( alignObj=(AliAlignObj *) iter.Next() ) ){
+ fAlignObjArray->Add(alignObj);
+ }
+ // delete entry --- Don't delete, it is cached!
+
+ AliDebug(2, Form("fAlignObjArray entries: %d",fAlignObjArray->GetEntries() ));
+ return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
+{
+ // Read the alignment objects from CDB.
+ // Each detector is supposed to have the
+ // alignment objects in DET/Align/Data CDB path.
+ // All the detector objects are then collected,
+ // sorted by geometry level (starting from ALIC) and
+ // then applied to the TGeo geometry.
+ // Finally an overlaps check is performed.
+
+ // Load alignment data from CDB and fill fAlignObjArray
+ if(fLoadAlignFromCDB){
+ if(!fAlignObjArray) fAlignObjArray = new TObjArray();
+
+ //fAlignObjArray->RemoveAll();
+ fAlignObjArray->Clear();
+ fAlignObjArray->SetOwner(0);
+
+ TString detStr = detectors;
+ TString dataNotLoaded="";
+ TString dataLoaded="";
+
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if(!SetAlignObjArraySingleDet(fgkDetectorName[iDet])){
+ dataNotLoaded += fgkDetectorName[iDet];
+ dataNotLoaded += " ";
+ } else {
+ dataLoaded += fgkDetectorName[iDet];
+ dataLoaded += " ";
+ }
+ } // end loop over detectors
+
+ if ((detStr.CompareTo("ALL") == 0)) detStr = "";
+ dataNotLoaded += detStr;
+ if(!dataLoaded.IsNull()) AliInfo(Form("Alignment data loaded for: %s",
+ dataLoaded.Data()));
+ if(!dataNotLoaded.IsNull()) AliInfo(Form("Didn't/couldn't load alignment data for: %s",
+ dataNotLoaded.Data()));
+ } // fLoadAlignFromCDB flag
+
+ // Check if the array with alignment objects was
+ // provided by the user. If yes, apply the objects
+ // to the present TGeo geometry
+ if (fAlignObjArray) {
+ if (gGeoManager && gGeoManager->IsClosed()) {
+ if (ApplyAlignObjsToGeom(fAlignObjArray) == kFALSE) {
+ AliError("The misalignment of one or more volumes failed!"
+ "Compare the list of simulated detectors and the list of detector alignment data!");
+ return kFALSE;
+ }
+ }
+ else {
+ AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
+ return kFALSE;
+ }
+ }
+
+ return kTRUE;
+}
//_____________________________________________________________________________
void AliReconstruction::SetGAliceFile(const char* fileName)
fRawReader = new AliRawReaderDate(fileName);
fRawReader->SelectEvents(7);
}
+ if (!fEquipIdMap.IsNull() && fRawReader)
+ fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
+
// get the run loader
if (!InitRunLoader()) return kFALSE;
+ // Initialize the CDB storage
+ InitCDBStorage();
+
+ // Set run number in CDBManager (if it is not already set by the user)
+ if (!SetRunNumber()) if (fStopOnError) return kFALSE;
+
+ // Import ideal TGeo geometry and apply misalignment
+ if (!gGeoManager) {
+ TString geom(gSystem->DirName(fGAliceFileName));
+ geom += "/geometry.root";
+ TGeoManager::Import(geom.Data());
+ if (!gGeoManager) if (fStopOnError) return kFALSE;
+ }
+ if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
+
// local reconstruction
if (!fRunLocalReconstruction.IsNull()) {
if (!RunLocalReconstruction(fRunLocalReconstruction)) {
}
}
+
+ TStopwatch stopwatch;
+ stopwatch.Start();
+
// get the possibly already existing ESD file and tree
AliESD* esd = new AliESD; AliESD* hltesd = new AliESD;
TFile* fileOld = NULL;
hlttree->Branch("ESD", "AliESD", &hltesd);
delete esd; delete hltesd;
esd = NULL; hltesd = NULL;
+
+ // create the file and tree with ESD additions
+ TFile *filef=0; TTree *treef=0; AliESDfriend *esdf=0;
+ if (fWriteESDfriend) {
+ filef = TFile::Open("AliESDfriends.root", "RECREATE");
+ if (!filef->IsOpen()) {
+ AliError("opening AliESDfriends.root failed");
+ }
+ treef = new TTree("esdFriendTree", "Tree with ESD friends");
+ treef->Branch("ESDfriend", "AliESDfriend", &esdf);
+ }
+
gROOT->cd();
+ AliVertexerTracks tVertexer;
+ if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
+
// loop over events
if (fRawReader) fRawReader->RewindEvents();
hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
esd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
hltesd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
- if (gAlice) {
- esd->SetMagneticField(gAlice->Field()->SolenoidField());
- hltesd->SetMagneticField(gAlice->Field()->SolenoidField());
- } else {
- // ???
- }
+
+ // Set magnetic field from the tracker
+ esd->SetMagneticField(AliTracker::GetBz());
+ hltesd->SetMagneticField(AliTracker::GetBz());
// vertex finder
if (fRunVertexFinder) {
AliESDpid::MakePID(esd);
if (fCheckPointLevel > 1) WriteESD(esd, "PID");
+ if (fFillTriggerESD) {
+ if (!ReadESD(esd, "trigger")) {
+ if (!FillTriggerESD(esd)) {
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ }
+ if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
+ }
+ }
+
+ esd->SetPrimaryVertex(tVertexer.FindPrimaryVertex(esd));
+
// write ESD
tree->Fill();
// write HLT ESD
hlttree->Fill();
+ // write ESD friend
+ if (fWriteESDfriend) {
+ esdf=new AliESDfriend();
+ esd->GetESDfriend(esdf);
+ treef->Fill();
+ }
+
if (fCheckPointLevel > 0) WriteESD(esd, "final");
delete esd; delete hltesd;
esd = NULL; hltesd = NULL;
}
+ AliInfo(Form("Execution time for filling ESD : R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
+
file->cd();
tree->Write();
hlttree->Write();
+ if (fWriteESDfriend) {
+ filef->cd();
+ treef->Write(); delete treef; filef->Close(); delete filef;
+ }
+
// Create tags for the events in the ESD tree (the ESD tree is always present)
// In case of empty events the tags will contain dummy values
CreateTag(file);
if(!vertex){
AliWarning("Vertex not found");
vertex = new AliESDVertex();
+ vertex->SetName("default");
}
else {
vertex->SetTruePos(vtxPos); // store also the vertex from MC
+ vertex->SetName("reconstructed");
}
} else {
vertex = new AliESDVertex(vtxPos, vtxErr);
}
esd->SetVertex(vertex);
+ // if SPD multiplicity has been determined, it is stored in the ESD
+ AliMultiplicity *mult= fVertexer->GetMultiplicity();
+ if(mult)esd->SetMultiplicity(mult);
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
}
// load clusters
if (iDet > 1) { // all except ITS, TPC
TTree* tree = NULL;
- if (iDet == 3) { // TOF
- fLoader[iDet]->LoadDigits("read");
- tree = fLoader[iDet]->TreeD();
- } else {
- fLoader[iDet]->LoadRecPoints("read");
- tree = fLoader[iDet]->TreeR();
- }
+ fLoader[iDet]->LoadRecPoints("read");
+ tree = fLoader[iDet]->TreeR();
if (!tree) {
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
// unload clusters
if (iDet > 2) { // all except ITS, TPC, TRD
fTracker[iDet]->UnloadClusters();
- if (iDet == 3) { // TOF
- fLoader[iDet]->UnloadDigits();
- } else {
- fLoader[iDet]->UnloadRecPoints();
- }
+ fLoader[iDet]->UnloadRecPoints();
+ }
+ // updated PID in TPC needed by the ITS tracker -MI
+ if (iDet == 1) {
+ GetReconstructor(1)->FillESD(fRunLoader, esd);
+ GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
+ AliESDpid::MakePID(esd);
}
}
+ // write space-points to the ESD in case alignment data output
+ // is switched on
+ if (fWriteAlignmentData)
+ WriteAlignmentData(esd);
+
// pass 3: TRD + TPC + ITS refit inwards
for (Int_t iDet = 2; iDet >= 0; iDet--) {
if (!fTracker[iDet]) continue;
fTracker[iDet]->UnloadClusters();
fLoader[iDet]->UnloadRecPoints();
}
-
+ //
+ // Propagate track to the vertex - if not done by ITS
+ //
+ Int_t ntracks = esd->GetNumberOfTracks();
+ for (Int_t itrack=0; itrack<ntracks; itrack++){
+ const Double_t kRadius = 3; // beam pipe radius
+ const Double_t kMaxStep = 5; // max step
+ const Double_t kMaxD = 123456; // max distance to prim vertex
+ Double_t fieldZ = AliTracker::GetBz(); //
+ AliESDtrack * track = esd->GetTrack(itrack);
+ if (!track) continue;
+ if (track->IsOn(AliESDtrack::kITSrefit)) continue;
+ track->PropagateTo(kRadius, fieldZ, track->GetMass(),kMaxStep,kTRUE);
+ track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
+ }
+
AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillTriggerESD(AliESD*& esd)
+{
+ // Reads the trigger decision which is
+ // stored in Trigger.root file and fills
+ // the corresponding esd entries
+
+ AliInfo("Filling trigger information into the ESD");
+
+ if (fRawReader) {
+ AliCTPRawStream input(fRawReader);
+ if (!input.Next()) {
+ AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
+ return kFALSE;
+ }
+ esd->SetTriggerMask(input.GetClassMask());
+ esd->SetTriggerCluster(input.GetClusterMask());
+ }
+ else {
+ AliRunLoader *runloader = AliRunLoader::GetRunLoader();
+ if (runloader) {
+ if (!runloader->LoadTrigger()) {
+ AliCentralTrigger *aCTP = runloader->GetTrigger();
+ esd->SetTriggerMask(aCTP->GetClassMask());
+ esd->SetTriggerCluster(aCTP->GetClusterMask());
+ }
+ else {
+ AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
+ return kFALSE;
+ }
+ }
+ else {
+ AliError("No run loader is available! The trigger information is not stored in the ESD !");
+ return kFALSE;
+ }
+ }
+
+ return kTRUE;
+}
//_____________________________________________________________________________
Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
if (fRunLoader->LoadgAlice() == 0) {
gAlice = fRunLoader->GetAliRun();
AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
- AliExternalTrackParam::SetFieldMap(gAlice->Field());
- if(fUniformField)
- AliExternalTrackParam::SetUniformFieldTracking();
- else
- AliExternalTrackParam::SetNonuniformFieldTracking();
}
}
if (!gAlice && !fRawReader) {
}
delete fVertexer;
fVertexer = NULL;
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
delete fRunLoader;
fRunLoader = NULL;
//_____________________________________________________________________________
void AliReconstruction::CreateTag(TFile* file)
{
+ /////////////
+ //muon code//
+ ////////////
+ Double_t fMUONMASS = 0.105658369;
+ //Variables
+ Double_t fX,fY,fZ ;
+ Double_t fThetaX, fThetaY, fPyz, fChisquare;
+ Double_t fPxRec,fPyRec, fPzRec, fEnergy;
+ Int_t fCharge;
+ TLorentzVector fEPvector;
+
+ Float_t fZVertexCut = 10.0;
+ Float_t fRhoVertexCut = 2.0;
+
+ Float_t fLowPtCut = 1.0;
+ Float_t fHighPtCut = 3.0;
+ Float_t fVeryHighPtCut = 10.0;
+ ////////////
+
+ Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
+
+ // Creates the tags for all the events in a given ESD file
Int_t ntrack;
- Int_t NProtons, NKaons, NPions, NMuons, NElectrons;
- Int_t Npos, Nneg, Nneutr;
- Int_t NK0s, Nneutrons, Npi0s, Ngamas;
- Int_t Nch1GeV, Nch3GeV, Nch10GeV;
- Int_t Nmu1GeV, Nmu3GeV, Nmu10GeV;
- Int_t Nel1GeV, Nel3GeV, Nel10GeV;
- Float_t MaxPt = .0, MeanPt = .0, TotalP = .0;
+ Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
+ Int_t nPos, nNeg, nNeutr;
+ Int_t nK0s, nNeutrons, nPi0s, nGamas;
+ Int_t nCh1GeV, nCh3GeV, nCh10GeV;
+ Int_t nMu1GeV, nMu3GeV, nMu10GeV;
+ Int_t nEl1GeV, nEl3GeV, nEl10GeV;
+ Float_t maxPt = .0, meanPt = .0, totalP = .0;
+ Int_t fVertexflag;
+ Int_t iRunNumber = 0;
+ TString fVertexName("default");
AliRunTag *tag = new AliRunTag();
- AliDetectorTag *detTag = new AliDetectorTag();
AliEventTag *evTag = new AliEventTag();
TTree ttag("T","A Tree with event tags");
- TBranch * btag = ttag.Branch("AliTAG", "AliRunTag", &tag);
+ TBranch * btag = ttag.Branch("AliTAG", &tag);
btag->SetCompressionLevel(9);
-
+
AliInfo(Form("Creating the tags......."));
if (!file || !file->IsOpen()) {
AliError(Form("opening failed"));
delete file;
return ;
- }
-
+ }
+ Int_t firstEvent = 0,lastEvent = 0;
TTree *t = (TTree*) file->Get("esdTree");
TBranch * b = t->GetBranch("ESD");
AliESD *esd = 0;
b->SetAddress(&esd);
- tag->SetRunId(esd->GetRunNumber());
-
- Int_t firstEvent = 0,lastEvent = 0;
- Int_t i_NumberOfEvents = b->GetEntries();
- for (Int_t i_EventNumber = 0; i_EventNumber < i_NumberOfEvents; i_EventNumber++)
- {
- ntrack = 0;
- Npos = 0;
- Nneg = 0;
- Nneutr =0;
- NK0s = 0;
- Nneutrons = 0;
- Npi0s = 0;
- Ngamas = 0;
- NProtons = 0;
- NKaons = 0;
- NPions = 0;
- NMuons = 0;
- NElectrons = 0;
- Nch1GeV = 0;
- Nch3GeV = 0;
- Nch10GeV = 0;
- Nmu1GeV = 0;
- Nmu3GeV = 0;
- Nmu10GeV = 0;
- Nel1GeV = 0;
- Nel3GeV = 0;
- Nel10GeV = 0;
- MaxPt = .0;
- MeanPt = .0;
- TotalP = .0;
-
- b->GetEntry(i_EventNumber);
- const AliESDVertex * VertexIn = esd->GetVertex();
-
- for (Int_t i_TrackNumber = 0; i_TrackNumber < esd->GetNumberOfTracks(); i_TrackNumber++)
- {
- AliESDtrack * ESDTrack = esd->GetTrack(i_TrackNumber);
- UInt_t status = ESDTrack->GetStatus();
-
- //select only tracks with ITS refit
- if ((status&AliESDtrack::kITSrefit)==0) continue;
-
- //select only tracks with TPC refit-->remove extremely high Pt tracks
- if ((status&AliESDtrack::kTPCrefit)==0) continue;
-
- //select only tracks with the "combined PID"
- if ((status&AliESDtrack::kESDpid)==0) continue;
- Double_t p[3];
- ESDTrack->GetPxPyPz(p);
- Double_t P = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
- Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
- TotalP += P;
- MeanPt += fPt;
- if(fPt > MaxPt)
- MaxPt = fPt;
-
- if(ESDTrack->GetSign() > 0)
- {
- Npos++;
- if(fPt > 1.0)
- Nch1GeV++;
- if(fPt > 3.0)
- Nch3GeV++;
- if(fPt > 10.0)
- Nch10GeV++;
- }
- if(ESDTrack->GetSign() < 0)
- {
- Nneg++;
- if(fPt > 1.0)
- Nch1GeV++;
- if(fPt > 3.0)
- Nch3GeV++;
- if(fPt > 10.0)
- Nch10GeV++;
- }
- if(ESDTrack->GetSign() == 0)
- Nneutr++;
-
- //PID
- Double_t prob[10];
- ESDTrack->GetESDpid(prob);
-
- //K0s
- if ((prob[8]>prob[7])&&(prob[8]>prob[6])&&(prob[8]>prob[5])&&(prob[8]>prob[4])&&(prob[8]>prob[3])&&(prob[8]>prob[2])&&(prob[8]>prob[1])&&(prob[8]>prob[0]))
- NK0s++;
- //neutrons
- if ((prob[7]>prob[8])&&(prob[7]>prob[6])&&(prob[7]>prob[5])&&(prob[7]>prob[4])&&(prob[7]>prob[3])&&(prob[7]>prob[2])&&(prob[7]>prob[1])&&(prob[7]>prob[0]))
- Nneutrons++;
- //pi0s
- if ((prob[6]>prob[8])&&(prob[6]>prob[7])&&(prob[6]>prob[5])&&(prob[6]>prob[4])&&(prob[6]>prob[3])&&(prob[6]>prob[2])&&(prob[6]>prob[1])&&(prob[6]>prob[0]))
- Npi0s++;
- //gamas
- if ((prob[5]>prob[8])&&(prob[5]>prob[7])&&(prob[5]>prob[6])&&(prob[5]>prob[4])&&(prob[5]>prob[3])&&(prob[5]>prob[2])&&(prob[5]>prob[1])&&(prob[5]>prob[0]))
- Ngamas++;
- //protons
- if ((prob[4]>prob[8])&&(prob[4]>prob[7])&&(prob[4]>prob[6])&&(prob[4]>prob[5])&&(prob[4]>prob[3])&&(prob[4]>prob[2])&&(prob[4]>prob[1])&&(prob[4]>prob[0]))
- NProtons++;
- //kaons
- if ((prob[3]>prob[8])&&(prob[3]>prob[7])&&(prob[3]>prob[6])&&(prob[3]>prob[5])&&(prob[3]>prob[4])&&(prob[3]>prob[2])&&(prob[3]>prob[1])&&(prob[3]>prob[0]))
- NKaons++;
- //kaons
- if ((prob[2]>prob[8])&&(prob[2]>prob[7])&&(prob[2]>prob[6])&&(prob[2]>prob[5])&&(prob[2]>prob[4])&&(prob[2]>prob[3])&&(prob[2]>prob[1])&&(prob[2]>prob[0]))
- NPions++;
- //muons
- if ((prob[1]>prob[8])&&(prob[1]>prob[7])&&(prob[1]>prob[6])&&(prob[1]>prob[5])&&(prob[1]>prob[4])&&(prob[1]>prob[3])&&(prob[1]>prob[2])&&(prob[1]>prob[0]))
- {
- NMuons++;
- if(fPt > 1.0)
- Nmu1GeV++;
- if(fPt > 3.0)
- Nmu3GeV++;
- if(fPt > 10.0)
- Nmu10GeV++;
- }
- //electrons
- if ((prob[0]>prob[8])&&(prob[0]>prob[7])&&(prob[0]>prob[6])&&(prob[0]>prob[5])&&(prob[0]>prob[4])&&(prob[0]>prob[3])&&(prob[0]>prob[2])&&(prob[0]>prob[1]))
- {
- NElectrons++;
- if(fPt > 1.0)
- Nel1GeV++;
- if(fPt > 3.0)
- Nel3GeV++;
- if(fPt > 10.0)
- Nel10GeV++;
- }
-
-
-
- ntrack++;
- }//track loop
- // Fill the event tags
- MeanPt = MeanPt/ntrack;
+ b->GetEntry(0);
+ Int_t iInitRunNumber = esd->GetRunNumber();
+
+ Int_t iNumberOfEvents = b->GetEntries();
+ for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
+ ntrack = 0;
+ nPos = 0;
+ nNeg = 0;
+ nNeutr =0;
+ nK0s = 0;
+ nNeutrons = 0;
+ nPi0s = 0;
+ nGamas = 0;
+ nProtons = 0;
+ nKaons = 0;
+ nPions = 0;
+ nMuons = 0;
+ nElectrons = 0;
+ nCh1GeV = 0;
+ nCh3GeV = 0;
+ nCh10GeV = 0;
+ nMu1GeV = 0;
+ nMu3GeV = 0;
+ nMu10GeV = 0;
+ nEl1GeV = 0;
+ nEl3GeV = 0;
+ nEl10GeV = 0;
+ maxPt = .0;
+ meanPt = .0;
+ totalP = .0;
+ fVertexflag = 0;
+
+ b->GetEntry(iEventNumber);
+ iRunNumber = esd->GetRunNumber();
+ if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
+ const AliESDVertex * vertexIn = esd->GetVertex();
+ if (!vertexIn) AliError("ESD has not defined vertex.");
+ if (vertexIn) fVertexName = vertexIn->GetName();
+ if(fVertexName != "default") fVertexflag = 1;
+ for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
+ AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
+ UInt_t status = esdTrack->GetStatus();
- evTag->SetEventId(i_EventNumber+1);
- evTag->SetVertexX(VertexIn->GetXv());
- evTag->SetVertexY(VertexIn->GetYv());
- evTag->SetVertexZ(VertexIn->GetZv());
+ //select only tracks with ITS refit
+ if ((status&AliESDtrack::kITSrefit)==0) continue;
+ //select only tracks with TPC refit
+ if ((status&AliESDtrack::kTPCrefit)==0) continue;
- evTag->SetT0VertexZ(esd->GetT0zVertex());
+ //select only tracks with the "combined PID"
+ if ((status&AliESDtrack::kESDpid)==0) continue;
+ Double_t p[3];
+ esdTrack->GetPxPyPz(p);
+ Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
+ Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
+ totalP += momentum;
+ meanPt += fPt;
+ if(fPt > maxPt) maxPt = fPt;
- evTag->SetTrigger(esd->GetTrigger());
+ if(esdTrack->GetSign() > 0) {
+ nPos++;
+ if(fPt > fLowPtCut) nCh1GeV++;
+ if(fPt > fHighPtCut) nCh3GeV++;
+ if(fPt > fVeryHighPtCut) nCh10GeV++;
+ }
+ if(esdTrack->GetSign() < 0) {
+ nNeg++;
+ if(fPt > fLowPtCut) nCh1GeV++;
+ if(fPt > fHighPtCut) nCh3GeV++;
+ if(fPt > fVeryHighPtCut) nCh10GeV++;
+ }
+ if(esdTrack->GetSign() == 0) nNeutr++;
- evTag->SetZDCNeutronEnergy(esd->GetZDCNEnergy());
- evTag->SetZDCProtonEnergy(esd->GetZDCPEnergy());
- evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
- evTag->SetNumOfParticipants(esd->GetZDCParticipants());
+ //PID
+ Double_t prob[5];
+ esdTrack->GetESDpid(prob);
+ Double_t rcc = 0.0;
+ for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
+ if(rcc == 0.0) continue;
+ //Bayes' formula
+ Double_t w[5];
+ for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
- evTag->SetNumOfTracks(esd->GetNumberOfTracks());
- evTag->SetNumOfPosTracks(Npos);
- evTag->SetNumOfNegTracks(Nneg);
- evTag->SetNumOfNeutrTracks(Nneutr);
+ //protons
+ if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
+ //kaons
+ if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
+ //pions
+ if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
+ //electrons
+ if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
+ nElectrons++;
+ if(fPt > fLowPtCut) nEl1GeV++;
+ if(fPt > fHighPtCut) nEl3GeV++;
+ if(fPt > fVeryHighPtCut) nEl10GeV++;
+ }
+ ntrack++;
+ }//track loop
+
+ /////////////
+ //muon code//
+ ////////////
+ Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
+ // loop over all reconstructed tracks (also first track of combination)
+ for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
+ AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
+ if (muonTrack == 0x0) continue;
- evTag->SetNumOfV0s(esd->GetNumberOfV0s());
- evTag->SetNumOfCascades(esd->GetNumberOfCascades());
- evTag->SetNumOfKinks(esd->GetNumberOfKinks());
- evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
+ // Coordinates at vertex
+ fZ = muonTrack->GetZ();
+ fY = muonTrack->GetBendingCoor();
+ fX = muonTrack->GetNonBendingCoor();
- evTag->SetNumOfProtons(NProtons);
- evTag->SetNumOfKaons(NKaons);
- evTag->SetNumOfPions(NPions);
- evTag->SetNumOfMuons(NMuons);
- evTag->SetNumOfElectrons(NElectrons);
- evTag->SetNumOfPhotons(Ngamas);
- evTag->SetNumOfPi0s(Npi0s);
- evTag->SetNumOfNeutrons(Nneutrons);
- evTag->SetNumOfKaon0s(NK0s);
+ fThetaX = muonTrack->GetThetaX();
+ fThetaY = muonTrack->GetThetaY();
- evTag->SetNumOfChargedAbove1GeV(Nch1GeV);
- evTag->SetNumOfChargedAbove3GeV(Nch3GeV);
- evTag->SetNumOfChargedAbove10GeV(Nch10GeV);
- evTag->SetNumOfMuonsAbove1GeV(Nmu1GeV);
- evTag->SetNumOfMuonsAbove3GeV(Nmu3GeV);
- evTag->SetNumOfMuonsAbove10GeV(Nmu10GeV);
- evTag->SetNumOfElectronsAbove1GeV(Nel1GeV);
- evTag->SetNumOfElectronsAbove3GeV(Nel3GeV);
- evTag->SetNumOfElectronsAbove10GeV(Nel10GeV);
+ fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
+ fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
+ fPxRec = fPzRec * TMath::Tan(fThetaX);
+ fPyRec = fPzRec * TMath::Tan(fThetaY);
+ fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
- evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles());
- evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles());
+ //ChiSquare of the track if needed
+ fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
+ fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
+ fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
- evTag->SetTotalMomentum(TotalP);
- evTag->SetMeanPt(MeanPt);
- evTag->SetMaxPt(MaxPt);
-
- tag->AddEventTag(evTag);
- }
- lastEvent = i_NumberOfEvents;
+ // total number of muons inside a vertex cut
+ if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
+ nMuons++;
+ if(fEPvector.Pt() > fLowPtCut) {
+ nMu1GeV++;
+ if(fEPvector.Pt() > fHighPtCut) {
+ nMu3GeV++;
+ if (fEPvector.Pt() > fVeryHighPtCut) {
+ nMu10GeV++;
+ }
+ }
+ }
+ }
+ }//muon track loop
+
+ // Fill the event tags
+ if(ntrack != 0)
+ meanPt = meanPt/ntrack;
+
+ evTag->SetEventId(iEventNumber+1);
+ if (vertexIn) {
+ evTag->SetVertexX(vertexIn->GetXv());
+ evTag->SetVertexY(vertexIn->GetYv());
+ evTag->SetVertexZ(vertexIn->GetZv());
+ evTag->SetVertexZError(vertexIn->GetZRes());
+ }
+ evTag->SetVertexFlag(fVertexflag);
+
+ evTag->SetT0VertexZ(esd->GetT0zVertex());
+
+ evTag->SetTriggerMask(esd->GetTriggerMask());
+ evTag->SetTriggerCluster(esd->GetTriggerCluster());
+
+ evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
+ evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
+ evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
+ evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
+ evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
+ evTag->SetNumOfParticipants(esd->GetZDCParticipants());
+
+
+ evTag->SetNumOfTracks(esd->GetNumberOfTracks());
+ evTag->SetNumOfPosTracks(nPos);
+ evTag->SetNumOfNegTracks(nNeg);
+ evTag->SetNumOfNeutrTracks(nNeutr);
+
+ evTag->SetNumOfV0s(esd->GetNumberOfV0s());
+ evTag->SetNumOfCascades(esd->GetNumberOfCascades());
+ evTag->SetNumOfKinks(esd->GetNumberOfKinks());
+ evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
+
+ evTag->SetNumOfProtons(nProtons);
+ evTag->SetNumOfKaons(nKaons);
+ evTag->SetNumOfPions(nPions);
+ evTag->SetNumOfMuons(nMuons);
+ evTag->SetNumOfElectrons(nElectrons);
+ evTag->SetNumOfPhotons(nGamas);
+ evTag->SetNumOfPi0s(nPi0s);
+ evTag->SetNumOfNeutrons(nNeutrons);
+ evTag->SetNumOfKaon0s(nK0s);
+
+ evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
+ evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
+ evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
+ evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
+ evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
+ evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
+ evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
+ evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
+ evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
+
+ evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
+ evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
+
+ evTag->SetTotalMomentum(totalP);
+ evTag->SetMeanPt(meanPt);
+ evTag->SetMaxPt(maxPt);
+
+ tag->SetRunId(iInitRunNumber);
+ tag->AddEventTag(*evTag);
+ }
+ lastEvent = iNumberOfEvents;
ttag.Fill();
tag->Clear();
ftag->Close();
file->cd();
delete tag;
- delete detTag;
delete evTag;
}
+void AliReconstruction::WriteAlignmentData(AliESD* esd)
+{
+ // Write space-points which are then used in the alignment procedures
+ // For the moment only ITS, TRD and TPC
+
+ // Load TOF clusters
+ if (fTracker[3]){
+ fLoader[3]->LoadRecPoints("read");
+ TTree* tree = fLoader[3]->TreeR();
+ if (!tree) {
+ AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
+ return;
+ }
+ fTracker[3]->LoadClusters(tree);
+ }
+ Int_t ntracks = esd->GetNumberOfTracks();
+ for (Int_t itrack = 0; itrack < ntracks; itrack++)
+ {
+ AliESDtrack *track = esd->GetTrack(itrack);
+ Int_t nsp = 0;
+ Int_t idx[200];
+ for (Int_t iDet = 3; iDet >= 0; iDet--)
+ nsp += track->GetNcls(iDet);
+ if (nsp) {
+ AliTrackPointArray *sp = new AliTrackPointArray(nsp);
+ track->SetTrackPointArray(sp);
+ Int_t isptrack = 0;
+ for (Int_t iDet = 3; iDet >= 0; iDet--) {
+ AliTracker *tracker = fTracker[iDet];
+ if (!tracker) continue;
+ Int_t nspdet = track->GetNcls(iDet);
+ if (nspdet <= 0) continue;
+ track->GetClusters(iDet,idx);
+ AliTrackPoint p;
+ Int_t isp = 0;
+ Int_t isp2 = 0;
+ while (isp < nspdet) {
+ Bool_t isvalid = tracker->GetTrackPoint(idx[isp2],p); isp2++;
+ const Int_t kNTPCmax = 159;
+ if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
+ if (!isvalid) continue;
+ sp->AddPoint(isptrack,&p); isptrack++; isp++;
+ }
+ }
+ }
+ }
+ if (fTracker[3]){
+ fTracker[3]->UnloadClusters();
+ fLoader[3]->UnloadRecPoints();
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff