X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliReconstruction.cxx;h=d26f1f4a59e4b79a83e0b07f06ff34e9ea0365d8;hb=aebb712cce4f4dac9e2e31a2ef8d20bb555d223d;hp=726c261f3bfea6fdce05fad24a34aa0524d3c8f5;hpb=7ebb06c3470d021dd5535401dcfbb36d0694e09a;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index 726c261f3bf..d26f1f4a59e 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -73,7 +73,7 @@ // // // 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 // // // @@ -123,20 +123,29 @@ #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 "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) @@ -145,30 +154,39 @@ 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), - fWriteAlignmentData(kFALSE) + fAlignObjArray(NULL), + fCDBUri(cdbUri), + fSpecCDBUri() { // create reconstruction object with default parameters @@ -178,40 +196,45 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fTracker[iDet] = NULL; } AliPID pid; - // Import TGeo geometry - TString geom(gSystem->DirName(gAliceFilename)); - geom += "/geometry.root"; - TGeoManager::Import(geom.Data()); } //_____________________________________________________________________________ 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), - fWriteAlignmentData(rec.fWriteAlignmentData) + 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++) { @@ -219,6 +242,9 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : 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()); + } } //_____________________________________________________________________________ @@ -238,8 +264,230 @@ AliReconstruction::~AliReconstruction() 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 { + AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + AliWarning(Form("Default CDB storage is set to: %s",fCDBUri.Data())); + AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + man->SetDefaultStorage(fCDBUri); + } + + // Now activate the detector specific CDB storage locations + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + TString detName = fgkDetectorName[iDet]; + TObject* obj = fSpecCDBUri.FindObject(detName.Data()); + if (obj) { + AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + AliWarning(Form("Specific CDB storage for %s is set to: %s",detName.Data(),obj->GetTitle())); + AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); + man->SetSpecificStorage(detName.Data(),obj->GetTitle()); + } + } + +} + +//_____________________________________________________________________________ +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* detName, const char* uri) { +// Store a detector-specific CDB storage location +// Activate it later within the Run() method + + TObject* obj = fSpecCDBUri.FindObject(detName); + if (obj) fSpecCDBUri.Remove(obj); + fSpecCDBUri.Add(new TNamed(detName, 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; 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) +{ + // 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; + 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!"); + 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) @@ -277,10 +525,43 @@ Bool_t AliReconstruction::Run(const char* input, 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; + + // Temporary fix by A.Gheata + // Could be removed with the next Root version (>5.11) + if (gGeoManager) { + TIter next(gGeoManager->GetListOfVolumes()); + TGeoVolume *vol; + while ((vol = (TGeoVolume *)next())) { + if (vol->GetVoxels()) { + if (vol->GetVoxels()->NeedRebuild()) { + vol->GetVoxels()->Voxelize(); + vol->FindOverlaps(); + } + } + } + } + // local reconstruction if (!fRunLocalReconstruction.IsNull()) { if (!RunLocalReconstruction(fRunLocalReconstruction)) { @@ -337,8 +618,22 @@ Bool_t AliReconstruction::Run(const char* input, 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; + // loop over events if (fRawReader) fRawReader->RewindEvents(); @@ -380,12 +675,10 @@ Bool_t AliReconstruction::Run(const char* input, hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun()); esd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun()); hltesd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun()); - if (gAlice) { - esd->SetMagneticField(AliTracker::GetBz()); - hltesd->SetMagneticField(AliTracker::GetBz()); - } else { - // ??? - } + + // Set magnetic field from the tracker + esd->SetMagneticField(AliTracker::GetBz()); + hltesd->SetMagneticField(AliTracker::GetBz()); // vertex finder if (fRunVertexFinder) { @@ -428,11 +721,29 @@ Bool_t AliReconstruction::Run(const char* input, 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; @@ -446,6 +757,11 @@ Bool_t AliReconstruction::Run(const char* input, 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); @@ -595,9 +911,11 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd) 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 { @@ -613,6 +931,10 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd) 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); } @@ -786,7 +1108,22 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd) 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; itrackGetTrack(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())); @@ -861,6 +1198,45 @@ Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors) 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 @@ -1221,6 +1597,9 @@ void AliReconstruction::CreateTag(TFile* file) 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(); AliEventTag *evTag = new AliEventTag(); @@ -1240,8 +1619,9 @@ void AliReconstruction::CreateTag(TFile* file) TBranch * b = t->GetBranch("ESD"); AliESD *esd = 0; b->SetAddress(&esd); - - tag->SetRunId(esd->GetRunNumber()); + + b->GetEntry(0); + Int_t iInitRunNumber = esd->GetRunNumber(); Int_t iNumberOfEvents = b->GetEntries(); for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) { @@ -1270,10 +1650,15 @@ void AliReconstruction::CreateTag(TFile* file) 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(); @@ -1382,16 +1767,23 @@ void AliReconstruction::CreateTag(TFile* file) meanPt = meanPt/ntrack; evTag->SetEventId(iEventNumber+1); - evTag->SetVertexX(vertexIn->GetXv()); - evTag->SetVertexY(vertexIn->GetYv()); - evTag->SetVertexZ(vertexIn->GetZv()); - + 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->SetTrigger(esd->GetTrigger()); + evTag->SetTriggerMask(esd->GetTriggerMask()); + evTag->SetTriggerCluster(esd->GetTriggerCluster()); - evTag->SetZDCNeutronEnergy(esd->GetZDCNEnergy()); - evTag->SetZDCProtonEnergy(esd->GetZDCPEnergy()); + evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy()); + evTag->SetZDCProton1Energy(esd->GetZDCP1Energy()); + evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy()); + evTag->SetZDCProton2Energy(esd->GetZDCP2Energy()); evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy()); evTag->SetNumOfParticipants(esd->GetZDCParticipants()); @@ -1426,13 +1818,14 @@ void AliReconstruction::CreateTag(TFile* file) evTag->SetNumOfElectronsAbove3GeV(nEl3GeV); evTag->SetNumOfElectronsAbove10GeV(nEl10GeV); - evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles()); - evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles()); + 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; @@ -1475,7 +1868,7 @@ void AliReconstruction::WriteAlignmentData(AliESD* esd) { AliESDtrack *track = esd->GetTrack(itrack); Int_t nsp = 0; - UInt_t idx[200]; + Int_t idx[200]; for (Int_t iDet = 3; iDet >= 0; iDet--) nsp += track->GetNcls(iDet); if (nsp) { @@ -1493,6 +1886,8 @@ void AliReconstruction::WriteAlignmentData(AliESD* esd) 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++; }