// //
// 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 "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliESD.h"
+#include "AliESDfriend.h"
#include "AliESDVertex.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),
fVertexer(NULL),
fAlignObjArray(NULL),
- fWriteAlignmentData(kFALSE),
fCDBUri(cdbUri)
{
// 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),
fVertexer(NULL),
fAlignObjArray(rec.fAlignObjArray),
- fWriteAlignmentData(rec.fWriteAlignmentData),
fCDBUri(rec.fCDBUri)
{
// copy constructor
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) {
}
}
- return kTRUE;
+ return 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;
}
}
fRawReader = new AliRawReaderDate(fileName);
fRawReader->SelectEvents(7);
}
+ if (!fEquipIdMap.IsNull() && fRawReader)
+ fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
+
// get the run loader
if (!InitRunLoader()) return kFALSE;
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();
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;
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);
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::IsSelected(TString detName, TString& detectors) const
Int_t nEl1GeV, nEl3GeV, nEl10GeV;
Float_t maxPt = .0, meanPt = .0, totalP = .0;
Int_t fVertexflag;
- TString fVertexName;
+ TString fVertexName("default");
AliRunTag *tag = new AliRunTag();
AliEventTag *evTag = new AliEventTag();
maxPt = .0;
meanPt = .0;
totalP = .0;
- fVertexflag = 1;
+ fVertexflag = 0;
b->GetEntry(iEventNumber);
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->SetTrigger(esd->GetTriggerMask());
evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff