// //
// 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 "AliESDtrack.h"
#include "AliRunTag.h"
-//#include "AliLHCTag.h"
#include "AliDetectorTag.h"
#include "AliEventTag.h"
#include "AliTrackPointArray.h"
#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliAlignObj.h"
+
+#include "AliCentralTrigger.h"
+#include "AliCTPRawStream.h"
ClassImp(AliReconstruction)
const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename,
+AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri,
const char* name, const char* title) :
TNamed(name, title),
- fRunLocalReconstruction("ALL"),
fUniformField(kTRUE),
fRunVertexFinder(kTRUE),
fRunHLTTracking(kFALSE),
+ fStopOnError(kFALSE),
+ fWriteAlignmentData(kFALSE),
+ fWriteESDfriend(kFALSE),
+ fFillTriggerESD(kTRUE),
+
+ fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
fGAliceFileName(gAliceFilename),
fInput(""),
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)
{
// create reconstruction object with default parameters
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),
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)
{
// copy constructor
fOptions.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 not yet set");
+ AliWarning(Form("Using default storage declared in AliSimulation: %s",fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ SetDefaultStorage(fCDBUri);
+
+ Int_t cdbRun = AliCDBManager::Instance()->GetRun();
+ if(cdbRun == -1){
+ AliWarning("AliCDBManager's run number temporarily set to 0!!");
+ AliCDBManager::Instance()->SetRun(0);
+ }
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetDefaultStorage(const char* uri) {
+// activate a default CDB storage
+
+ AliCDBManager::Instance()->SetDefaultStorage(uri);
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetSpecificStorage(const char* detName, const char* uri) {
+// activate a detector-specific CDB storage
+
+ AliCDBManager::Instance()->SetSpecificStorage(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
+ AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
+ AliInfo(Form("Run number: %d",AliCDBManager::Instance()->GetRun()));
+ }
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::ApplyAlignObjsToGeom(TObjArray* alObjArray)
+{
+ // Read collection of alignment objects (AliAlignObj derived) saved
+ // in the TClonesArray ClArrayName and apply them to the geometry
+ // manager singleton.
+ //
+ alObjArray->Sort();
+ Int_t nvols = alObjArray->GetEntriesFast();
+
+ Bool_t flag = kTRUE;
+
+ for(Int_t j=0; j<nvols; j++)
+ {
+ AliAlignObj* alobj = (AliAlignObj*) alObjArray->UncheckedAt(j);
+ if (alobj->ApplyToGeometry() == kFALSE) flag = kFALSE;
+ }
+
+ if (AliDebugLevelClass() >= 1) {
+ gGeoManager->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)
{
// run the reconstruction
- // 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("No default CDB storage set, so I will use $ALICE_ROOT");
- AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- man->SetDefaultStorage("local://$ALICE_ROOT");
- }
+ InitCDBStorage();
// set the input
if (!input) input = fInput.Data();
// get the run loader
if (!InitRunLoader()) return kFALSE;
+ // 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)) {
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();
// loop over events
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");
+ }
+ }
+
// 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);
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 {
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 nMu1GeV, nMu3GeV, nMu10GeV;
Int_t nEl1GeV, nEl3GeV, nEl10GeV;
Float_t maxPt = .0, meanPt = .0, totalP = .0;
+ Int_t fVertexflag;
+ TString fVertexName;
AliRunTag *tag = new AliRunTag();
AliEventTag *evTag = new AliEventTag();
maxPt = .0;
meanPt = .0;
totalP = .0;
-
+ fVertexflag = 1;
+
b->GetEntry(iEventNumber);
const AliESDVertex * vertexIn = esd->GetVertex();
-
+ fVertexName = vertexIn->GetName();
+ if(fVertexName == "default") fVertexflag = 0;
for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
UInt_t status = esdTrack->GetStatus();
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->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());
{
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) {
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++;
}