X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliReconstruction.cxx;h=6c9c329408756478e0290d92264757218122099b;hb=86ee89e6a8f3b6a0cd5b84a8615847f971bcde12;hp=3d2fac036a45b48a7fa8f2da87d1f1120f53a98e;hpb=c3a7b59ad78b88072feaab8b40e071ae84bad21d;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index 3d2fac036a4..6c9c3294087 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -47,6 +47,15 @@ // The index -1 (default) can be used for the last event to indicate no // // upper limit of the event range. // // // +// In case of raw-data reconstruction the user can modify the default // +// number of events per digits/clusters/tracks file. In case the option // +// is not used the number is set 1. In case the user provides 0, than // +// the number of events is equal to the number of events inside the // +// raw-data file (i.e. one digits/clusters/tracks file): // +// // +// rec.SetNumberOfEventsPerFile(...); // +// // +// // // The name of the galice file can be changed from the default // // "galice.root" by passing it as argument to the AliReconstruction // // constructor or by // @@ -122,6 +131,7 @@ #include "AliRawReaderFile.h" #include "AliRawReaderDate.h" #include "AliRawReaderRoot.h" +#include "AliRawEventHeaderBase.h" #include "AliESD.h" #include "AliESDfriend.h" #include "AliESDVertex.h" @@ -129,6 +139,8 @@ #include "AliTracker.h" #include "AliVertexer.h" #include "AliVertexerTracks.h" +#include "AliV0vertexer.h" +#include "AliCascadeVertexer.h" #include "AliHeader.h" #include "AliGenEventHeader.h" #include "AliPID.h" @@ -139,6 +151,7 @@ #include "AliDetectorTag.h" #include "AliEventTag.h" +#include "AliGeomManager.h" #include "AliTrackPointArray.h" #include "AliCDBManager.h" #include "AliCDBEntry.h" @@ -147,11 +160,18 @@ #include "AliCentralTrigger.h" #include "AliCTPRawStream.h" +#include "AliAODEvent.h" +#include "AliAODHeader.h" +#include "AliAODTrack.h" +#include "AliAODVertex.h" +#include "AliAODCluster.h" + + ClassImp(AliReconstruction) //_____________________________________________________________________________ -const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"}; +const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"}; //_____________________________________________________________________________ AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri, @@ -161,9 +181,11 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdb fUniformField(kTRUE), fRunVertexFinder(kTRUE), fRunHLTTracking(kFALSE), + fRunMuonTracking(kFALSE), fStopOnError(kFALSE), fWriteAlignmentData(kFALSE), fWriteESDfriend(kFALSE), + fWriteAOD(kFALSE), fFillTriggerESD(kTRUE), fRunLocalReconstruction("ALL"), @@ -174,15 +196,18 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdb fEquipIdMap(""), fFirstEvent(0), fLastEvent(-1), + fNumberOfEventsPerFile(1), fCheckPointLevel(0), fOptions(), fLoadAlignFromCDB(kTRUE), fLoadAlignData("ALL"), + fESDPar(""), fRunLoader(NULL), fRawReader(NULL), fVertexer(NULL), + fDiamondProfile(NULL), fAlignObjArray(NULL), fCDBUri(cdbUri), @@ -205,9 +230,11 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fUniformField(rec.fUniformField), fRunVertexFinder(rec.fRunVertexFinder), fRunHLTTracking(rec.fRunHLTTracking), + fRunMuonTracking(rec.fRunMuonTracking), fStopOnError(rec.fStopOnError), fWriteAlignmentData(rec.fWriteAlignmentData), fWriteESDfriend(rec.fWriteESDfriend), + fWriteAOD(rec.fWriteAOD), fFillTriggerESD(rec.fFillTriggerESD), fRunLocalReconstruction(rec.fRunLocalReconstruction), @@ -218,15 +245,18 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fEquipIdMap(rec.fEquipIdMap), fFirstEvent(rec.fFirstEvent), fLastEvent(rec.fLastEvent), + fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile), fCheckPointLevel(0), fOptions(), fLoadAlignFromCDB(rec.fLoadAlignFromCDB), fLoadAlignData(rec.fLoadAlignData), + fESDPar(rec.fESDPar), fRunLoader(NULL), fRawReader(NULL), fVertexer(NULL), + fDiamondProfile(NULL), fAlignObjArray(rec.fAlignObjArray), fCDBUri(rec.fCDBUri), @@ -284,9 +314,9 @@ void AliReconstruction::InitCDBStorage() fCDBUri = ""; } else { - AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); - AliWarning(Form("Default CDB storage is set to: %s",fCDBUri.Data())); - AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data())); + AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); man->SetDefaultStorage(fCDBUri); } @@ -294,9 +324,9 @@ void AliReconstruction::InitCDBStorage() for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) { TObject* obj = fSpecCDBUri[i]; if (!obj) continue; - AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); - AliWarning(Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle())); - AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + 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(); @@ -353,6 +383,9 @@ void AliReconstruction::SetSpecificStorage(const char* calibType, const char* ur } + + + //_____________________________________________________________________________ Bool_t AliReconstruction::SetRunNumber() { @@ -390,72 +423,6 @@ Bool_t AliReconstruction::SetRunNumber() 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; jUncheckedAt(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) { @@ -469,51 +436,39 @@ Bool_t AliReconstruction::MisalignGeometry(const TString& detectors) // 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; - AliInfo(Form("Alignment data loaded for: %s", - dataLoaded.Data())); - 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!"); + TString detStr = detectors; + TString loadAlObjsListOfDets = ""; + + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + loadAlObjsListOfDets += fgkDetectorName[iDet]; + loadAlObjsListOfDets += " "; + } // end loop over detectors + (AliGeomManager::Instance())->ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data()); + }else{ + // 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 ((AliGeomManager::Instance())->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; } } - else { - AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!"); - return kFALSE; - } } + + delete fAlignObjArray; fAlignObjArray=0; + + // Update the TGeoPhysicalNodes + gGeoManager->RefreshPhysicalNodes(); return kTRUE; } @@ -538,8 +493,7 @@ void AliReconstruction::SetOption(const char* detector, const char* option) //_____________________________________________________________________________ -Bool_t AliReconstruction::Run(const char* input, - Int_t firstEvent, Int_t lastEvent) +Bool_t AliReconstruction::Run(const char* input) { // run the reconstruction @@ -574,6 +528,8 @@ Bool_t AliReconstruction::Run(const char* input, TGeoManager::Import(geom.Data()); if (!gGeoManager) if (fStopOnError) return kFALSE; } + + AliCDBManager* man = AliCDBManager::Instance(); if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE; // local reconstruction @@ -606,7 +562,7 @@ Bool_t AliReconstruction::Run(const char* input, stopwatch.Start(); // get the possibly already existing ESD file and tree - AliESD* esd = new AliESD; AliESD* hltesd = new AliESD; + AliESD* esd = new AliESD(); AliESD* hltesd = new AliESD(); TFile* fileOld = NULL; TTree* treeOld = NULL; TTree *hlttreeOld = NULL; if (!gSystem->AccessPathName("AliESDs.root")){ @@ -614,68 +570,84 @@ Bool_t AliReconstruction::Run(const char* input, fileOld = TFile::Open("AliESDs.old.root"); if (fileOld && fileOld->IsOpen()) { treeOld = (TTree*) fileOld->Get("esdTree"); - if (treeOld) treeOld->SetBranchAddress("ESD", &esd); + if (treeOld)esd->ReadFromTree(treeOld); hlttreeOld = (TTree*) fileOld->Get("HLTesdTree"); - if (hlttreeOld) hlttreeOld->SetBranchAddress("ESD", &hltesd); + if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld); } } // create the ESD output file and tree TFile* file = TFile::Open("AliESDs.root", "RECREATE"); + file->SetCompressionLevel(2); if (!file->IsOpen()) { AliError("opening AliESDs.root failed"); if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;} } + TTree* tree = new TTree("esdTree", "Tree with ESD objects"); - tree->Branch("ESD", "AliESD", &esd); + esd = new AliESD(); + esd->CreateStdContent(); + esd->WriteToTree(tree); + TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects"); - hlttree->Branch("ESD", "AliESD", &hltesd); + hltesd = new AliESD(); + hltesd->CreateStdContent(); + hltesd->WriteToTree(hlttree); + + /* CKB Why? 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; + */ + // create the branch with ESD additions + 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); + esdf = new AliESDfriend(); + TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf); + br->SetFile("AliESDfriends.root"); + esd->AddObject(esdf); + } + + // Get the diamond profile from OCDB + AliCDBEntry* entry = AliCDBManager::Instance() + ->Get("GRP/Calib/MeanVertex"); + + if(entry) { + fDiamondProfile = dynamic_cast (entry->GetObject()); + } else { + AliError("No diamond profile found in OCDB!"); } - gROOT->cd(); - - AliVertexerTracks tVertexer; + AliVertexerTracks tVertexer(AliTracker::GetBz()); + if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile); // loop over events if (fRawReader) fRawReader->RewindEvents(); for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) { if (fRawReader) fRawReader->NextEvent(); - if ((iEvent < firstEvent) || ((lastEvent >= 0) && (iEvent > lastEvent))) { + if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) { // copy old ESD to the new one if (treeOld) { - treeOld->SetBranchAddress("ESD", &esd); + esd->ReadFromTree(treeOld); treeOld->GetEntry(iEvent); } tree->Fill(); if (hlttreeOld) { - hlttreeOld->SetBranchAddress("ESD", &hltesd); + esd->ReadFromTree(hlttreeOld); hlttreeOld->GetEntry(iEvent); } hlttree->Fill(); continue; } - + AliInfo(Form("processing event %d", iEvent)); fRunLoader->GetEvent(iEvent); - char fileName[256]; - sprintf(fileName, "ESD_%d.%d_final.root", + char aFileName[256]; + sprintf(aFileName, "ESD_%d.%d_final.root", fRunLoader->GetHeader()->GetRun(), fRunLoader->GetHeader()->GetEventNrInRun()); - if (!gSystem->AccessPathName(fileName)) continue; + if (!gSystem->AccessPathName(aFileName)) continue; // local reconstruction if (!fRunLocalReconstruction.IsNull()) { @@ -684,16 +656,21 @@ Bool_t AliReconstruction::Run(const char* input, } } - esd = new AliESD; hltesd = new AliESD; + esd->SetRunNumber(fRunLoader->GetHeader()->GetRun()); hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun()); - esd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun()); - hltesd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun()); - + esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun()); + hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun()); + // Set magnetic field from the tracker esd->SetMagneticField(AliTracker::GetBz()); hltesd->SetMagneticField(AliTracker::GetBz()); + + + // Fill raw-data error log into the ESD + if (fRawReader) FillRawDataErrorLog(iEvent,esd); + // vertex finder if (fRunVertexFinder) { if (!ReadESD(esd, "vertex")) { @@ -714,6 +691,15 @@ Bool_t AliReconstruction::Run(const char* input, } } + // Muon tracking + if (!fRunTracking.IsNull()) { + if (fRunMuonTracking) { + if (!RunMuonTracking()) { + if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;} + } + } + } + // barrel tracking if (!fRunTracking.IsNull()) { if (!ReadESD(esd, "tracking")) { @@ -730,6 +716,8 @@ Bool_t AliReconstruction::Run(const char* input, if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;} } } + // fill Event header information from the RawEventHeader + if (fRawReader){FillRawEventHeaderESD(esd);} // combined PID AliESDpid::MakePID(esd); @@ -744,42 +732,93 @@ Bool_t AliReconstruction::Run(const char* input, } } - esd->SetPrimaryVertex(tVertexer.FindPrimaryVertex(esd)); + //Try to improve the reconstructed primary vertex position using the tracks + AliESDVertex *pvtx=0; + Bool_t dovertex=kTRUE; + TObject* obj = fOptions.FindObject("ITS"); + if (obj) { + TString optITS = obj->GetTitle(); + if (optITS.Contains("cosmics") || optITS.Contains("COSMICS")) + dovertex=kFALSE; + } + if(dovertex) pvtx=tVertexer.FindPrimaryVertex(esd); + if(fDiamondProfile) esd->SetDiamond(fDiamondProfile); + + if (pvtx) + if (pvtx->GetStatus()) { + // Store the improved primary vertex + esd->SetPrimaryVertex(pvtx); + // Propagate the tracks to the DCA to the improved primary vertex + Double_t somethingbig = 777.; + Double_t bz = esd->GetMagneticField(); + Int_t nt=esd->GetNumberOfTracks(); + while (nt--) { + AliESDtrack *t = esd->GetTrack(nt); + t->RelateToVertex(pvtx, bz, somethingbig); + } + } + { + // V0 finding + AliV0vertexer vtxer; + vtxer.Tracks2V0vertices(esd); + + // Cascade finding + AliCascadeVertexer cvtxer; + cvtxer.V0sTracks2CascadeVertices(esd); + } + // write ESD + if (fWriteESDfriend) { + new (esdf) AliESDfriend(); // Reset... + esd->GetESDfriend(esdf); + } 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; + esd->Reset(); + hltesd->Reset(); + // esdf->Reset(); + // delete esdf; esdf = 0; + } + + + tree->GetUserInfo()->Add(esd); + hlttree->GetUserInfo()->Add(hltesd); + + + + if(fESDPar.Contains("ESD.par")){ + AliInfo("Attaching ESD.par to Tree"); + TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par"); + tree->GetUserInfo()->Add(fn); } + AliInfo(Form("Execution time for filling ESD : R:%.2fs C:%.2fs", stopwatch.RealTime(),stopwatch.CpuTime())); file->cd(); + if (fWriteESDfriend) + tree->SetBranchStatus("ESDfriend*",0); tree->Write(); hlttree->Write(); - if (fWriteESDfriend) { - filef->cd(); - treef->Write(); delete treef; filef->Close(); delete filef; + if (fWriteAOD) { + TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE"); + ESDFile2AODFile(file, aodFile); + aodFile->Close(); } + gROOT->cd(); // 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); - CleanUp(file, fileOld); + + CleanUp(file, fileOld); return kTRUE; } @@ -793,6 +832,9 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors) TStopwatch stopwatch; stopwatch.Start(); + AliCDBManager* man = AliCDBManager::Instance(); + Bool_t origCache = man->GetCacheFlag(); + TString detStr = detectors; for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; @@ -803,6 +845,13 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors) AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); TStopwatch stopwatchDet; stopwatchDet.Start(); + + AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet])); + + man->SetCacheFlag(kTRUE); + TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]); + man->GetAll(calibPath); // entries are cached! + if (fRawReader) { fRawReader->RewindEvents(); reconstructor->Reconstruct(fRunLoader, fRawReader); @@ -812,8 +861,13 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors) AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs", fgkDetectorName[iDet], stopwatchDet.RealTime(),stopwatchDet.CpuTime())); + + // unload calibration data + man->ClearCache(); } + man->SetCacheFlag(origCache); + if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { AliError(Form("the following detectors were not found: %s", detStr.Data())); @@ -883,9 +937,9 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) } loader->WriteRecPoints("OVERWRITE"); loader->UnloadRecPoints(); - AliDebug(1,Form("Execution time for %s: R:%.2fs C:%.2fs", - fgkDetectorName[iDet], - stopwatchDet.RealTime(),stopwatchDet.CpuTime())); + AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs", + fgkDetectorName[iDet], + stopwatchDet.RealTime(),stopwatchDet.CpuTime())); } if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) { @@ -918,6 +972,7 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd) } if (fVertexer) { + if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile); AliInfo("running the ITS vertex finder"); if (fLoader[0]) fLoader[0]->LoadRecPoints(); vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber()); @@ -928,7 +983,6 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd) vertex->SetName("default"); } else { - vertex->SetTruePos(vtxPos); // store also the vertex from MC vertex->SetName("reconstructed"); } @@ -946,7 +1000,7 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd) } esd->SetVertex(vertex); // if SPD multiplicity has been determined, it is stored in the ESD - AliMultiplicity *mult= fVertexer->GetMultiplicity(); + AliMultiplicity *mult = fVertexer->GetMultiplicity(); if(mult)esd->SetMultiplicity(mult); for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { @@ -1020,6 +1074,62 @@ Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd) return kTRUE; } +//_____________________________________________________________________________ +Bool_t AliReconstruction::RunMuonTracking() +{ +// run the muon spectrometer tracking + + TStopwatch stopwatch; + stopwatch.Start(); + + if (!fRunLoader) { + AliError("Missing runLoader!"); + return kFALSE; + } + Int_t iDet = 7; // for MUON + + AliInfo("is running..."); + + // Get a pointer to the MUON reconstructor + AliReconstructor *reconstructor = GetReconstructor(iDet); + if (!reconstructor) return kFALSE; + + + TString detName = fgkDetectorName[iDet]; + AliDebug(1, Form("%s tracking", detName.Data())); + AliTracker *tracker = reconstructor->CreateTracker(fRunLoader); + if (!tracker) { + AliWarning(Form("couldn't create a tracker for %s", detName.Data())); + return kFALSE; + } + + // create Tracks + fLoader[iDet]->LoadTracks("update"); + fLoader[iDet]->CleanTracks(); + fLoader[iDet]->MakeTracksContainer(); + + // read RecPoints + fLoader[iDet]->LoadRecPoints("read"); + + if (!tracker->Clusters2Tracks(0x0)) { + AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet])); + return kFALSE; + } + fLoader[iDet]->UnloadRecPoints(); + + fLoader[iDet]->WriteTracks("OVERWRITE"); + fLoader[iDet]->UnloadTracks(); + + delete tracker; + + + AliInfo(Form("Execution time: R:%.2fs C:%.2fs", + stopwatch.RealTime(),stopwatch.CpuTime())); + + return kTRUE; +} + + //_____________________________________________________________________________ Bool_t AliReconstruction::RunTracking(AliESD*& esd) { @@ -1030,6 +1140,10 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd) AliInfo("running tracking"); + //Fill the ESD with the T0 info (will be used by the TOF) + if (fReconstructor[11]) + GetReconstructor(11)->FillESD(fRunLoader, esd); + // pass 1: TPC + ITS inwards for (Int_t iDet = 1; iDet >= 0; iDet--) { if (!fTracker[iDet]) continue; @@ -1080,7 +1194,7 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd) // run tracking if (fTracker[iDet]->PropagateBack(esd) != 0) { AliError(Form("%s backward propagation failed", fgkDetectorName[iDet])); - return kFALSE; + // return kFALSE; } if (fCheckPointLevel > 1) { WriteESD(esd, Form("%s.back", fgkDetectorName[iDet])); @@ -1112,7 +1226,7 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd) // run tracking if (fTracker[iDet]->RefitInward(esd) != 0) { AliError(Form("%s inward refit failed", fgkDetectorName[iDet])); - return kFALSE; + // return kFALSE; } if (fCheckPointLevel > 1) { WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet])); @@ -1252,6 +1366,39 @@ Bool_t AliReconstruction::FillTriggerESD(AliESD*& esd) return kTRUE; } + + + + +//_____________________________________________________________________________ +Bool_t AliReconstruction::FillRawEventHeaderESD(AliESD*& esd) +{ + // + // Filling information from RawReader Header + // + + AliInfo("Filling information from RawReader Header"); + esd->SetBunchCrossNumber(0); + esd->SetOrbitNumber(0); + esd->SetPeriodNumber(0); + esd->SetTimeStamp(0); + esd->SetEventType(0); + const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader(); + if (eventHeader){ + + const UInt_t *id = eventHeader->GetP("Id"); + esd->SetBunchCrossNumber((id)[1]&0x00000fff); + esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff)); + esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff); + + esd->SetTimeStamp((eventHeader->Get("Timestamp"))); + esd->SetEventType((eventHeader->Get("Type"))); + } + + return kTRUE; +} + + //_____________________________________________________________________________ Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const { @@ -1348,6 +1495,10 @@ Bool_t AliReconstruction::InitRunLoader() iEvent++; } fRawReader->RewindEvents(); + if (fNumberOfEventsPerFile > 0) + fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile); + else + fRunLoader->SetNumberOfEventsPerFile(iEvent); fRunLoader->WriteHeader("OVERWRITE"); fRunLoader->CdGAFile(); fRunLoader->Write(0, TObject::kOverwrite); @@ -1372,10 +1523,10 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet) if (detName == "HLT") { if (!gROOT->GetClass("AliLevel3")) { - gSystem->Load("libAliL3Src.so"); - gSystem->Load("libAliL3Misc.so"); - gSystem->Load("libAliL3Hough.so"); - gSystem->Load("libAliL3Comp.so"); + gSystem->Load("libAliHLTSrc.so"); + gSystem->Load("libAliHLTMisc.so"); + gSystem->Load("libAliHLTHough.so"); + gSystem->Load("libAliHLTComp.so"); } } @@ -1415,7 +1566,7 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet) ->CreateDetectorFolders(fRunLoader->GetEventFolder(), detName, detName); // first check if a plugin is defined for the loader - TPluginHandler* pluginHandler = + pluginHandler = pluginManager->FindHandler("AliLoader", detName); // if not, add a plugin for it if (!pluginHandler) { @@ -1482,6 +1633,11 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors) fRunHLTTracking = kTRUE; continue; } + if (detName == "MUON") { + fRunMuonTracking = kTRUE; + continue; + } + fTracker[iDet] = reconstructor->CreateTracker(fRunLoader); if (!fTracker[iDet] && (iDet < 7)) { @@ -1507,6 +1663,8 @@ void AliReconstruction::CleanUp(TFile* file, TFile* fileOld) } delete fVertexer; fVertexer = NULL; + delete fDiamondProfile; + fDiamondProfile = NULL; delete fRunLoader; fRunLoader = NULL; @@ -1534,7 +1692,7 @@ Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const if (!esd) return kFALSE; char fileName[256]; sprintf(fileName, "ESD_%d.%d_%s.root", - esd->GetRunNumber(), esd->GetEventNumber(), recStep); + esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep); if (gSystem->AccessPathName(fileName)) return kFALSE; AliInfo(Form("reading ESD from file %s", fileName)); @@ -1562,7 +1720,7 @@ void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const if (!esd) return; char fileName[256]; sprintf(fileName, "ESD_%d.%d_%s.root", - esd->GetRunNumber(), esd->GetEventNumber(), recStep); + esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep); AliDebug(1, Form("writing ESD to file %s", fileName)); TFile* file = TFile::Open(fileName, "recreate"); @@ -1581,6 +1739,11 @@ void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const //_____________________________________________________________________________ void AliReconstruction::CreateTag(TFile* file) { + //GRP + Float_t lhcLuminosity = 0.0; + TString lhcState = "test"; + UInt_t detectorMask = 0; + ///////////// //muon code// //////////// @@ -1628,17 +1791,17 @@ void AliReconstruction::CreateTag(TFile* file) 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); + Int_t lastEvent = 0; + TTree *b = (TTree*) file->Get("esdTree"); + AliESD *esd = new AliESD(); + esd->ReadFromTree(b); - b->GetEntry(0); + b->GetEntry(fFirstEvent); Int_t iInitRunNumber = esd->GetRunNumber(); - Int_t iNumberOfEvents = b->GetEntries(); - for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) { + Int_t iNumberOfEvents = (Int_t)b->GetEntries(); + if(fLastEvent != -1) iNumberOfEvents = fLastEvent + 1; + for (Int_t iEventNumber = fFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) { ntrack = 0; nPos = 0; nNeg = 0; @@ -1839,17 +2002,21 @@ void AliReconstruction::CreateTag(TFile* file) evTag->SetMeanPt(meanPt); evTag->SetMaxPt(maxPt); + tag->SetLHCTag(lhcLuminosity,lhcState); + tag->SetDetectorTag(detectorMask); + tag->SetRunId(iInitRunNumber); tag->AddEventTag(*evTag); } - lastEvent = iNumberOfEvents; + if(fLastEvent == -1) lastEvent = (Int_t)b->GetEntries(); + else lastEvent = fLastEvent; ttag.Fill(); tag->Clear(); char fileName[256]; sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root", - tag->GetRunId(),firstEvent,lastEvent ); + tag->GetRunId(),fFirstEvent,lastEvent ); AliInfo(Form("writing tags to file %s", fileName)); AliDebug(1, Form("writing tags to file %s", fileName)); @@ -1862,6 +2029,688 @@ void AliReconstruction::CreateTag(TFile* file) delete evTag; } +//_____________________________________________________________________________ +void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile) +{ + // write all files from the given esd file to an aod file + + // create an AliAOD object + AliAODEvent *aod = new AliAODEvent(); + aod->CreateStdContent(); + + // go to the file + aodFile->cd(); + + // create the tree + TTree *aodTree = new TTree("AOD", "AliAOD tree"); + aodTree->Branch(aod->GetList()); + + // connect to ESD + TTree *t = (TTree*) esdFile->Get("esdTree"); + TBranch *b = t->GetBranch("ESD"); + AliESD *esd = 0; + b->SetAddress(&esd); + + Int_t nEvents = b->GetEntries(); + + // set arrays and pointers + Float_t posF[3]; + Double_t pos[3]; + Double_t p[3]; + Double_t covVtx[6]; + Double_t covTr[21]; + Double_t pid[10]; + + // loop over events and fill them + for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) { + b->GetEntry(iEvent); + + // Multiplicity information needed by the header (to be revised!) + Int_t nTracks = esd->GetNumberOfTracks(); + Int_t nPosTracks = 0; + for (Int_t iTrack=0; iTrackGetTrack(iTrack)->GetSign()> 0) nPosTracks++; + + // create the header + aod->AddHeader(new AliAODHeader(esd->GetRunNumber(), + esd->GetBunchCrossNumber(), + esd->GetOrbitNumber(), + esd->GetPeriodNumber(), + nTracks, + nPosTracks, + nTracks-nPosTracks, + esd->GetMagneticField(), + -999., // fill muon magnetic field + -999., // centrality; to be filled, still + esd->GetZDCN1Energy(), + esd->GetZDCP1Energy(), + esd->GetZDCN2Energy(), + esd->GetZDCP2Energy(), + esd->GetZDCEMEnergy(), + esd->GetTriggerMask(), + esd->GetTriggerCluster(), + esd->GetEventType())); + + Int_t nV0s = esd->GetNumberOfV0s(); + Int_t nCascades = esd->GetNumberOfCascades(); + Int_t nKinks = esd->GetNumberOfKinks(); + Int_t nVertices = nV0s + nCascades + nKinks; + + aod->ResetStd(nTracks, nVertices); + AliAODTrack *aodTrack; + + + // Array to take into account the tracks already added to the AOD + Bool_t * usedTrack = NULL; + if (nTracks>0) { + usedTrack = new Bool_t[nTracks]; + for (Int_t iTrack=0; iTrack0) { + usedV0 = new Bool_t[nV0s]; + for (Int_t iV0=0; iV00) { + usedKink = new Bool_t[nKinks]; + for (Int_t iKink=0; iKinkGetVertices()); + Int_t jVertices=0; + + // Access to the AOD container of tracks + TClonesArray &tracks = *(aod->GetTracks()); + Int_t jTracks=0; + + // Add primary vertex. The primary tracks will be defined + // after the loops on the composite objects (V0, cascades, kinks) + const AliESDVertex *vtx = esd->GetPrimaryVertex(); + + vtx->GetXYZ(pos); // position + vtx->GetCovMatrix(covVtx); //covariance matrix + + AliAODVertex * primary = new(vertices[jVertices++]) + AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary); + + // Create vertices starting from the most complex objects + + // Cascades + for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) { + AliESDcascade *cascade = esd->GetCascade(nCascade); + + cascade->GetXYZ(pos[0], pos[1], pos[2]); + cascade->GetPosCovXi(covVtx); + + // Add the cascade vertex + AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos, + covVtx, + cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3 + primary, + AliAODVertex::kCascade); + + primary->AddDaughter(vcascade); + + // Add the V0 from the cascade. The ESD class have to be optimized... + // Now we have to search for the corresponding Vo in the list of V0s + // using the indeces of the positive and negative tracks + + Int_t posFromV0 = cascade->GetPindex(); + Int_t negFromV0 = cascade->GetNindex(); + + + AliESDv0 * v0 = 0x0; + Int_t indV0 = -1; + + for (Int_t iV0=0; iV0GetV0(iV0); + Int_t posV0 = v0->GetPindex(); + Int_t negV0 = v0->GetNindex(); + + if (posV0==posFromV0 && negV0==negFromV0) { + indV0 = iV0; + break; + } + } + + AliAODVertex * vV0FromCascade = 0x0; + + if (indV0>-1 && !usedV0[indV0] ) { + + // the V0 exists in the array of V0s and is not used + + usedV0[indV0] = kTRUE; + + v0->GetXYZ(pos[0], pos[1], pos[2]); + v0->GetPosCov(covVtx); + + vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos, + covVtx, + v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3 + vcascade, + AliAODVertex::kV0); + } else { + + // the V0 doesn't exist in the array of V0s or was used + cerr << "Error: event " << iEvent << " cascade " << nCascade + << " The V0 " << indV0 + << " doesn't exist in the array of V0s or was used!" << endl; + + cascade->GetXYZ(pos[0], pos[1], pos[2]); + cascade->GetPosCov(covVtx); + + vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos, + covVtx, + v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3 + vcascade, + AliAODVertex::kV0); + vcascade->AddDaughter(vV0FromCascade); + } + + // Add the positive tracks from the V0 + + if (! usedTrack[posFromV0]) { + + usedTrack[posFromV0] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(posFromV0); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + vV0FromCascade->AddDaughter(aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + vV0FromCascade, + kTRUE, // check if this is right + kFALSE, // check if this is right + AliAODTrack::kSecondary) + ); + aodTrack->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " cascade " << nCascade + << " track " << posFromV0 << " has already been used!" << endl; + } + + // Add the negative tracks from the V0 + + if (!usedTrack[negFromV0]) { + + usedTrack[negFromV0] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(negFromV0); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + vV0FromCascade->AddDaughter(aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + vV0FromCascade, + kTRUE, // check if this is right + kFALSE, // check if this is right + AliAODTrack::kSecondary) + ); + aodTrack->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " cascade " << nCascade + << " track " << negFromV0 << " has already been used!" << endl; + } + + // Add the bachelor track from the cascade + + Int_t bachelor = cascade->GetBindex(); + + if(!usedTrack[bachelor]) { + + usedTrack[bachelor] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(bachelor); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + vcascade->AddDaughter(aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + vcascade, + kTRUE, // check if this is right + kFALSE, // check if this is right + AliAODTrack::kSecondary) + ); + aodTrack->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " cascade " << nCascade + << " track " << bachelor << " has already been used!" << endl; + } + + // Add the primary track of the cascade (if any) + + } // end of the loop on cascades + + // V0s + + for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) { + + if (usedV0[nV0]) continue; // skip if aready added to the AOD + + AliESDv0 *v0 = esd->GetV0(nV0); + + v0->GetXYZ(pos[0], pos[1], pos[2]); + v0->GetPosCov(covVtx); + + AliAODVertex * vV0 = + new(vertices[jVertices++]) AliAODVertex(pos, + covVtx, + v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3 + primary, + AliAODVertex::kV0); + primary->AddDaughter(vV0); + + Int_t posFromV0 = v0->GetPindex(); + Int_t negFromV0 = v0->GetNindex(); + + // Add the positive tracks from the V0 + + if (!usedTrack[posFromV0]) { + + usedTrack[posFromV0] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(posFromV0); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + vV0->AddDaughter(aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + vV0, + kTRUE, // check if this is right + kFALSE, // check if this is right + AliAODTrack::kSecondary) + ); + aodTrack->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " V0 " << nV0 + << " track " << posFromV0 << " has already been used!" << endl; + } + + // Add the negative tracks from the V0 + + if (!usedTrack[negFromV0]) { + + usedTrack[negFromV0] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(negFromV0); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + vV0->AddDaughter(aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + vV0, + kTRUE, // check if this is right + kFALSE, // check if this is right + AliAODTrack::kSecondary) + ); + aodTrack->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " V0 " << nV0 + << " track " << negFromV0 << " has already been used!" << endl; + } + + } // end of the loop on V0s + + // Kinks: it is a big mess the access to the information in the kinks + // The loop is on the tracks in order to find the mother and daugther of each kink + + + for (Int_t iTrack=0; iTrackGetTrack(iTrack); + + Int_t ikink = esdTrack->GetKinkIndex(0); + + if (ikink) { + // Negative kink index: mother, positive: daughter + + // Search for the second track of the kink + + for (Int_t jTrack = iTrack+1; jTrackGetTrack(jTrack); + + Int_t jkink = esdTrack1->GetKinkIndex(0); + + if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) { + + // The two tracks are from the same kink + + if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks + + Int_t imother = -1; + Int_t idaughter = -1; + + if (ikink<0 && jkink>0) { + + imother = iTrack; + idaughter = jTrack; + } + else if (ikink>0 && jkink<0) { + + imother = jTrack; + idaughter = iTrack; + } + else { + cerr << "Error: Wrong combination of kink indexes: " + << ikink << " " << jkink << endl; + continue; + } + + // Add the mother track + + AliAODTrack * mother = NULL; + + if (!usedTrack[imother]) { + + usedTrack[imother] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(imother); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + mother = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + primary, + kTRUE, // check if this is right + kTRUE, // check if this is right + AliAODTrack::kPrimary); + primary->AddDaughter(mother); + mother->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1 + << " track " << imother << " has already been used!" << endl; + } + + // Add the kink vertex + AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1); + + AliAODVertex * vkink = + new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(), + NULL, + 0., + mother, + AliAODVertex::kKink); + // Add the daughter track + + AliAODTrack * daughter = NULL; + + if (!usedTrack[idaughter]) { + + usedTrack[idaughter] = kTRUE; + + AliESDtrack *esdTrack = esd->GetTrack(idaughter); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + daughter = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + vkink, + kTRUE, // check if this is right + kTRUE, // check if this is right + AliAODTrack::kPrimary); + vkink->AddDaughter(daughter); + daughter->ConvertAliPIDtoAODPID(); + } + else { + cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1 + << " track " << idaughter << " has already been used!" << endl; + } + + + } + } + + } + + } + + + // Tracks (primary and orphan) + + for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) { + + + if (usedTrack[nTrack]) continue; + + AliESDtrack *esdTrack = esd->GetTrack(nTrack); + esdTrack->GetPxPyPz(p); + esdTrack->GetXYZ(pos); + esdTrack->GetCovarianceXYZPxPyPz(covTr); + esdTrack->GetESDpid(pid); + + Float_t impactXY, impactZ; + + esdTrack->GetImpactParameters(impactXY,impactZ); + + if (impactXY<3) { + // track inside the beam pipe + + primary->AddDaughter(aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + primary, + kTRUE, // check if this is right + kTRUE, // check if this is right + AliAODTrack::kPrimary) + ); + aodTrack->ConvertAliPIDtoAODPID(); + } + else { + // outside the beam pipe: orphan track + aodTrack = + new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(), + esdTrack->GetLabel(), + p, + kTRUE, + pos, + kFALSE, + covTr, + (Short_t)esdTrack->GetSign(), + esdTrack->GetITSClusterMap(), + pid, + NULL, + kFALSE, // check if this is right + kFALSE, // check if this is right + AliAODTrack::kOrphan); + aodTrack->ConvertAliPIDtoAODPID(); + } + } // end of loop on tracks + + // muon tracks + Int_t nMuTracks = esd->GetNumberOfMuonTracks(); + for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) { + + AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack); + p[0] = esdMuTrack->Px(); + p[1] = esdMuTrack->Py(); + p[2] = esdMuTrack->Pz(); + pos[0] = primary->GetX(); + pos[1] = primary->GetY(); + pos[2] = primary->GetZ(); + + // has to be changed once the muon pid is provided by the ESD + for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.; + + primary->AddDaughter( + new(tracks[jTracks++]) AliAODTrack(0, // no ID provided + 0, // no label provided + p, + kTRUE, + pos, + kFALSE, + NULL, // no covariance matrix provided + (Short_t)-99, // no charge provided + 0, // no ITSClusterMap + pid, + primary, + kTRUE, // check if this is right + kTRUE, // not used for vertex fit + AliAODTrack::kPrimary) + ); + } + + // Access to the AOD container of clusters + TClonesArray &clusters = *(aod->GetClusters()); + Int_t jClusters=0; + + // Calo Clusters + Int_t nClusters = esd->GetNumberOfCaloClusters(); + + for (Int_t iClust=0; iClustGetCaloCluster(iClust); + + Int_t id = cluster->GetID(); + Int_t label = -1; + Float_t energy = cluster->GetClusterEnergy(); + cluster->GetGlobalPosition(posF); + AliAODVertex *prodVertex = primary; + AliAODTrack *primTrack = NULL; + Char_t ttype=AliAODCluster::kUndef; + + if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral; + else if (cluster->IsEMCAL()) { + + if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster) + ttype = AliAODCluster::kEMCALPseudoCluster; + else + ttype = AliAODCluster::kEMCALClusterv1; + + } + + new(clusters[jClusters++]) AliAODCluster(id, + label, + energy, + pos, + NULL, // no covariance matrix provided + NULL, // no pid for clusters provided + prodVertex, + primTrack, + ttype); + + } // end of loop on calo clusters + + delete [] usedTrack; + delete [] usedV0; + delete [] usedKink; + + // fill the tree for this event + aodTree->Fill(); + } // end of event loop + + aodTree->GetUserInfo()->Add(aod); + + // close ESD file + esdFile->Close(); + + // write the tree to the specified file + aodFile = aodTree->GetCurrentFile(); + aodFile->cd(); + aodTree->Write(); + + return; +} + + void AliReconstruction::WriteAlignmentData(AliESD* esd) { // Write space-points which are then used in the alignment procedures @@ -1913,3 +2762,72 @@ void AliReconstruction::WriteAlignmentData(AliESD* esd) fLoader[3]->UnloadRecPoints(); } } + +//_____________________________________________________________________________ +void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESD* esd) +{ + // The method reads the raw-data error log + // accumulated within the rawReader. + // It extracts the raw-data errors related to + // the current event and stores them into + // a TClonesArray inside the esd object. + + if (!fRawReader) return; + + for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) { + + AliRawDataErrorLog *log = fRawReader->GetErrorLog(i); + if (!log) continue; + if (iEvent != log->GetEventNumber()) continue; + + esd->AddRawDataErrorLog(log); + } + +} + +TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){ + ifstream in; + in.open(fPath.Data(),ios::in | ios::binary|ios::ate); + Int_t kBytes = (Int_t)in.tellg(); + printf("Size: %d \n",kBytes); + TNamed *fn = 0; + if(in.good()){ + char* memblock = new char [kBytes]; + in.seekg (0, ios::beg); + in.read (memblock, kBytes); + in.close(); + TString fData(memblock,kBytes); + fn = new TNamed(fName,fData); + printf("fData Size: %d \n",fData.Sizeof()); + printf("fName Size: %d \n",fName.Sizeof()); + printf("fn Size: %d \n",fn->Sizeof()); + delete[] memblock; + } + else{ + AliInfo(Form("Could not Open %s\n",fPath.Data())); + } + + return fn; +} + +void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){ + + // This is not really needed in AliReconstruction at the moment + // but can serve as a template + + TList *fList = fTree->GetUserInfo(); + TNamed *fn = (TNamed*)fList->FindObject(fName.Data()); + printf("fn Size: %d \n",fn->Sizeof()); + + TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works + const char* cdata = fn->GetTitle(); + printf("fTmp Size %d\n",fTmp.Sizeof()); + + int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()... + printf("calculated size %d\n",size); + ofstream out(fName.Data(),ios::out | ios::binary); + out.write(cdata,size); + out.close(); + +} +