// //
// 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 "AliRawReaderFile.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
+#include "AliRawEventHeaderBase.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 "AliESDtrack.h"
#include "AliRunTag.h"
-//#include "AliLHCTag.h"
#include "AliDetectorTag.h"
#include "AliEventTag.h"
#include "AliCDBEntry.h"
#include "AliAlignObj.h"
+#include "AliCentralTrigger.h"
+#include "AliCTPRawStream.h"
+
ClassImp(AliReconstruction)
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),
fRawReader(NULL),
fVertexer(NULL),
+ fDiamondProfile(NULL),
fAlignObjArray(NULL),
- fWriteAlignmentData(kFALSE),
- fCDBUri(cdbUri)
+ 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),
fRawReader(NULL),
fVertexer(NULL),
+ fDiamondProfile(NULL),
fAlignObjArray(rec.fAlignObjArray),
- fWriteAlignmentData(rec.fWriteAlignmentData),
- fCDBUri(rec.fCDBUri)
+ 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();
}
//_____________________________________________________________________________
// to retrieve the calibration and alignment constants
AliCDBManager* man = AliCDBManager::Instance();
- if (!man->IsDefaultStorageSet())
+ if (man->IsDefaultStorageSet())
{
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- AliWarning("Default CDB storage not yet set");
- AliWarning(Form("Using default storage declared in AliSimulation: %s",fCDBUri.Data()));
+ AliWarning("Default CDB storage has been already set !");
+ AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- SetDefaultStorage(fCDBUri);
- }
-
+ 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) {
-// activate a default CDB storage
+// Store the desired default CDB storage location
+// Activate it later within the Run() method
- AliCDBManager::Instance()->SetDefaultStorage(uri);
+ fCDBUri = uri;
}
//_____________________________________________________________________________
-void AliReconstruction::SetSpecificStorage(const char* detName, const char* uri) {
-// activate a detector-specific CDB storage
+void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
+// Store a detector-specific CDB storage location
+// Activate it later within the Run() method
- AliCDBManager::Instance()->SetSpecificStorage(detName, uri);
+ 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));
}
return kFALSE;
}
// read run number from gAlice
- AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
- AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
+ 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;
}
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)
- return kFALSE;
+ if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
}
if (AliDebugLevelClass() >= 1) {
- gGeoManager->CheckOverlaps(20);
+ 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 kTRUE;
+ return flag;
}
if ((detStr.CompareTo("ALL") == 0)) detStr = "";
dataNotLoaded += detStr;
- AliInfo(Form("Alignment data loaded for: %s",
+ if(!dataLoaded.IsNull()) AliInfo(Form("Alignment data loaded for: %s",
dataLoaded.Data()));
- AliInfo(Form("Didn't/couldn't load alignment data for: %s",
+ if(!dataNotLoaded.IsNull()) AliInfo(Form("Didn't/couldn't load alignment data for: %s",
dataNotLoaded.Data()));
} // fLoadAlignFromCDB flag
if (fAlignObjArray) {
if (gGeoManager && gGeoManager->IsClosed()) {
if (ApplyAlignObjsToGeom(fAlignObjArray) == kFALSE) {
- AliError("The application of misalignment failed! Restart aliroot and try again. ");
+ AliError("The misalignment of one or more volumes failed!"
+ "Compare the list of simulated detectors and the list of detector alignment data!");
return kFALSE;
}
}
{
// run the reconstruction
- InitCDBStorage();
-
// set the input
if (!input) input = fInput.Data();
TString fileName(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;
}
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)) {
hlttree->Branch("ESD", "AliESD", &hltesd);
delete esd; delete hltesd;
esd = NULL; hltesd = NULL;
- gROOT->cd();
+
+ // create the branch with ESD additions
+ AliESDfriend *esdf=0;
+ if (fWriteESDfriend) {
+ TBranch *br=tree->Branch("ESDfriend.", "AliESDfriend", &esdf);
+ br->SetFile("AliESDfriends.root");
+ }
+
+ 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(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) {
if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
}
+ // fill Event header information from the RawEventHeader
+ if (fRawReader){FillRawEventHeaderESD(esd);}
// combined PID
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
+ if (fWriteESDfriend) {
+ esdf=new AliESDfriend();
+ esd->GetESDfriend(esdf);
+ }
tree->Fill();
+
// write HLT ESD
hlttree->Fill();
if (fCheckPointLevel > 0) WriteESD(esd, "final");
- delete esd; delete hltesd;
- esd = NULL; hltesd = NULL;
+ delete esd; delete esdf; delete hltesd;
+ esd = NULL; esdf=NULL; hltesd = NULL;
}
AliInfo(Form("Execution time for filling ESD : R:%.2fs C:%.2fs",
stopwatch.RealTime(),stopwatch.CpuTime()));
file->cd();
+ tree->SetBranchStatus("ESDfriend*",0);
tree->Write();
hlttree->Write();
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);
}
AliESDtrack * track = esd->GetTrack(itrack);
if (!track) continue;
if (track->IsOn(AliESDtrack::kITSrefit)) continue;
- track->PropagateTo(kRadius, track->GetMass(),kMaxStep,kTRUE);
+ track->PropagateTo(kRadius, fieldZ, track->GetMass(),kMaxStep,kTRUE);
track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
}
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::FillRawEventHeaderESD(AliESD*& esd)
+{
+ //
+ // Filling information from RawReader Header
+ //
+
+ AliInfo("Filling information from RawReader Header");
+ esd->SetTimeStamp(0);
+ esd->SetEventType(0);
+ const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
+ if (eventHeader){
+ esd->SetTimeStamp((eventHeader->Get("Timestamp")));
+ esd->SetEventType((eventHeader->Get("Type")));
+ }
+
+ return kTRUE;
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
}
delete fVertexer;
fVertexer = NULL;
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
delete fRunLoader;
fRunLoader = NULL;
Int_t nEl1GeV, nEl3GeV, nEl10GeV;
Float_t maxPt = .0, meanPt = .0, totalP = .0;
Int_t fVertexflag;
- TString fVertexName;
+ Int_t iRunNumber = 0;
+ TString fVertexName("default");
AliRunTag *tag = new AliRunTag();
AliEventTag *evTag = new AliEventTag();
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++) {
maxPt = .0;
meanPt = .0;
totalP = .0;
- fVertexflag = 1;
+ fVertexflag = 0;
b->GetEntry(iEventNumber);
+ iRunNumber = esd->GetRunNumber();
+ if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
const AliESDVertex * vertexIn = esd->GetVertex();
- fVertexName = vertexIn->GetName();
- if(fVertexName == "default") fVertexflag = 0;
+ 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();
meanPt = meanPt/ntrack;
evTag->SetEventId(iEventNumber+1);
- evTag->SetVertexX(vertexIn->GetXv());
- evTag->SetVertexY(vertexIn->GetYv());
- evTag->SetVertexZ(vertexIn->GetZv());
- evTag->SetVertexZError(vertexIn->GetZRes());
+ 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->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
evTag->SetMeanPt(meanPt);
evTag->SetMaxPt(maxPt);
+ tag->SetRunId(iInitRunNumber);
tag->AddEventTag(*evTag);
}
lastEvent = iNumberOfEvents;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff