#include "AliESDkink.h"
#include "AliESDtrack.h"
#include "AliESDCaloCluster.h"
+#include "AliESDCaloCells.h"
#include "AliMultiplicity.h"
#include "AliTracker.h"
#include "AliVertexer.h"
#include "AliGeomManager.h"
#include "AliTrackPointArray.h"
#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliAlignObj.h"
#include "AliAODTracklets.h"
#include "AliQADataMaker.h"
+#include "AliQA.h"
+#include "AliQADataMakerSteer.h"
#include "AliSysInfo.h" // memory snapshots
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,
+AliReconstruction::AliReconstruction(const char* gAliceFilename,
const char* name, const char* title) :
TNamed(name, title),
fFillTriggerESD(kTRUE),
fCleanESD(kTRUE),
+ fV0DCAmax(3.),
+ fV0CsPmin(0.),
fDmax(50.),
fZmax(50.),
fGRPList(NULL),
fAlignObjArray(NULL),
- fCDBUri(cdbUri),
- fRemoteCDBUri(""),
- fSpecCDBUri()
+ fCDBUri(),
+ fSpecCDBUri(),
+ fInitCDBCalled(kFALSE),
+ fSetRunNumberFromDataCalled(kFALSE),
+ fRunQA(kTRUE),
+ fQAInLoop(kFALSE)
+
{
// create reconstruction object with default parameters
fFillTriggerESD(rec.fFillTriggerESD),
fCleanESD(rec.fCleanESD),
+ fV0DCAmax(rec.fV0DCAmax),
+ fV0CsPmin(rec.fV0CsPmin),
fDmax(rec.fDmax),
fZmax(rec.fZmax),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
- fRemoteCDBUri(rec.fRemoteCDBUri),
- fSpecCDBUri()
+ fSpecCDBUri(),
+ fInitCDBCalled(rec.fInitCDBCalled),
+ fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
+ fRunQA(kTRUE),
+ fQAInLoop(kFALSE)
+
{
// copy constructor
}
//_____________________________________________________________________________
-void AliReconstruction::InitCDBStorage()
+void AliReconstruction::InitCDB()
{
// 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
+ if (fInitCDBCalled) return;
+ fInitCDBCalled = kTRUE;
+
AliCDBManager* man = AliCDBManager::Instance();
if (man->IsDefaultStorageSet())
{
AliWarning("Default CDB storage has been already set !");
AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- fCDBUri = "";
+ fCDBUri = man->GetDefaultStorage()->GetURI();
}
else {
- AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
- AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ if (fCDBUri.Length() > 0)
+ {
+ AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ } else {
+ fCDBUri="local://$ALICE_ROOT";
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default CDB storage not yet set !!!!");
+ AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
man->SetDefaultStorage(fCDBUri);
}
- // Remote storage (the Grid storage) is used if it is activated
- // and if the object is not found in the default storage
- // OBSOLETE: Removed
- // if (man->IsRemoteStorageSet())
- // {
- // AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- // AliWarning("Remote CDB storage has been already set !");
- // AliWarning(Form("Ignoring the remote storage declared in AliReconstruction: %s",fRemoteCDBUri.Data()));
- // AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- // fRemoteCDBUri = "";
- // }
- // else {
- // AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- // AliDebug(2, Form("Remote CDB storage is set to: %s",fRemoteCDBUri.Data()));
- // AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- // man->SetRemoteStorage(fRemoteCDBUri);
- // }
-
// Now activate the detector specific CDB storage locations
for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
TObject* obj = fSpecCDBUri[i];
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
}
- man->Print();
+
}
//_____________________________________________________________________________
}
-//_____________________________________________________________________________
-void AliReconstruction::SetRemoteStorage(const char* uri) {
-// Store the desired remote CDB storage location
-// Activate it later within the Run() method
-// Remote storage (the Grid storage) is used if it is activated
-// and if the object is not found in the default storage
-
- fRemoteCDBUri = uri;
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
}
-
-
-
//_____________________________________________________________________________
-Bool_t AliReconstruction::SetRunNumber()
+Bool_t AliReconstruction::SetRunNumberFromData()
{
// 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) {
+ if (fSetRunNumberFromDataCalled) return kTRUE;
+ fSetRunNumberFromDataCalled = kTRUE;
+
+ AliCDBManager* man = AliCDBManager::Instance();
+
+ if(man->GetRun() > 0) {
+ AliWarning("Run number is taken from event header! Ignoring settings in AliCDBManager!");
+ }
+
+ if (!fRunLoader) {
AliError("No run loader is found !");
return kFALSE;
}
AliError("Neither gAlice nor RawReader objects are found !");
return kFALSE;
}
- }
- AliInfo(Form("CDB Run number: %d",AliCDBManager::Instance()->GetRun()));
}
+
+ man->Print();
+
return kTRUE;
}
+//_____________________________________________________________________________
+void AliReconstruction::SetCDBLock() {
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+
+ AliCDBManager::Instance()->SetLock(1);
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
{
AliSysInfo::AddStamp("LoadLoader");
// Initialize the CDB storage
- InitCDBStorage();
- AliSysInfo::AddStamp("LoadCDB");
+ InitCDB();
+
+ AliSysInfo::AddStamp("LoadCDB");
// Set run number in CDBManager (if it is not already set by the user)
- if (!SetRunNumber()) if (fStopOnError) return kFALSE;
-
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+ SetCDBLock();
+
// Import ideal TGeo geometry and apply misalignment
if (!gGeoManager) {
TString geom(gSystem->DirName(fGAliceFileName));
if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
AliSysInfo::AddStamp("LoadGeom");
+ //QA
+ AliQADataMakerSteer qas ;
+ if ( fRunQA && fRawReader)
+ qas.Run("ALL", fRawReader) ;
+
+ // checking the QA of previous steps
+ CheckQA() ;
+
// local reconstruction
if (!fRunLocalReconstruction.IsNull()) {
if (!RunLocalReconstruction(fRunLocalReconstruction)) {
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
- // checking the QA of previous steps
- CheckQA() ;
-
for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
if (fRawReader) fRawReader->NextEvent();
if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
}
}
- if (!fFillESD.IsNull())
- RunQA(fFillESD.Data(), esd);
+// if (!fFillESD.IsNull())
+
+ // do QA in the event loop if requested
+ if (fQAInLoop)
+ RunQA(fFillESD.Data(), esd);
// fill Event header information from the RawEventHeader
if (fRawReader){FillRawEventHeaderESD(esd);}
}
detStr = fFillESD ;
+
+
// write quality assurance ESDs data (one entry for all events)
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQADataMaker * qadm = GetQADataMaker(iDet);
- if (!qadm) continue;
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish(AliQA::kRECPOINTS);
- qadm->Finish(AliQA::kESDS) ;
+ if (fQAInLoop) {
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr))
+ continue;
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ if (!qadm) continue;
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
}
tree->GetUserInfo()->Add(esd);
hlttree->GetUserInfo()->Add(hltesd);
-
+
+ const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
+ const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
+
+ TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
+ cdbMapCopy->SetOwner(1);
+ cdbMapCopy->SetName("cdbMap");
+ TIter iter(cdbMap->GetTable());
+
+ TPair* pair = 0;
+ while((pair = dynamic_cast<TPair*> (iter.Next()))){
+ TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
+ TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
+ cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
+ }
+
+ TList *cdbListCopy = new TList();
+ cdbListCopy->SetOwner(1);
+ cdbListCopy->SetName("cdbList");
+
+ TIter iter2(cdbList);
+
+ AliCDBId* id=0;
+ while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
+ cdbListCopy->Add(new TObjString(id->ToString().Data()));
+ }
+
+ tree->GetUserInfo()->Add(cdbMapCopy);
+ tree->GetUserInfo()->Add(cdbListCopy);
if(fESDPar.Contains("ESD.par")){
gROOT->cd();
CleanUp(file, fileOld);
-
+
// 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
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
}
+ //QA fone outside the event loop
+ if (!fQAInLoop) {
+ if ( fRunQA ) {
+ qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS) ;
+ // qas.Reset() ;
+ qas.Run(fRunTracking.Data(), AliQA::kESDS) ;
+ }
+ }
+
+ // Cleanup of CDB manager: cache and active storages!
+ AliCDBManager::Instance()->ClearCache();
+
+
return kTRUE;
}
loader->UnloadDigits();
}
- AliQADataMaker * qadm = GetQADataMaker(iDet);
- if (qadm) {
- AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-
- if (qadm->IsCycleDone() ) {
- qadm->EndOfCycle(AliQA::kRECPOINTS) ;
- qadm->EndOfCycle(AliQA::kESDS) ;
- qadm->StartOfCycle(AliQA::kRECPOINTS) ;
- qadm->StartOfCycle(AliQA::kESDS, "same") ;
- }
- qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
- AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- }
+ // do QA in the event loop if requested
+ if (fQAInLoop) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ if (qadm) {
+ AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ if (qadm->IsCycleDone() ) {
+ qadm->EndOfCycle(AliQA::kRECPOINTS) ;
+ qadm->EndOfCycle(AliQA::kESDS) ;
+ qadm->StartOfCycle(AliQA::kRECPOINTS) ;
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ }
+ qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
+ AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ }
+ }
- loader->WriteRecPoints("OVERWRITE");
+ loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
}
return kFALSE;
}
- // create Tracks
- fLoader[iDet]->LoadTracks("update");
- fLoader[iDet]->CleanTracks();
- fLoader[iDet]->MakeTracksContainer();
-
// read RecPoints
fLoader[iDet]->LoadRecPoints("read");
+
tracker->LoadClusters(fLoader[iDet]->TreeR());
Int_t rv = tracker->Clusters2Tracks(esd);
- fLoader[iDet]->UnloadRecPoints();
-
if ( rv )
{
AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
return kFALSE;
}
- tracker->UnloadClusters();
-
fLoader[iDet]->UnloadRecPoints();
- fLoader[iDet]->WriteTracks("OVERWRITE");
- fLoader[iDet]->UnloadTracks();
-
+ tracker->UnloadClusters();
+
delete tracker;
return kTRUE;
// Remove the data which are not needed for the physics analysis.
//
- AliInfo("Cleaning the ESD...");
Int_t nTracks=esd->GetNumberOfTracks();
- AliInfo(Form("Number of ESD tracks before cleaning %d",nTracks));
+ Int_t nV0s=esd->GetNumberOfV0s();
+ AliInfo
+ (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
- Float_t cleanPars[]={fDmax,fZmax};
+ Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
Bool_t rc=esd->Clean(cleanPars);
nTracks=esd->GetNumberOfTracks();
- AliInfo(Form("Number of ESD tracks after cleaning %d",nTracks));
+ nV0s=esd->GetNumberOfV0s();
+ AliInfo
+ (Form("Number of ESD tracks and V0s after cleaning %d",nTracks,nV0s));
return rc;
}
AliCodeTimerAuto("")
static Int_t eventNr=0;
TString detStr = detectors;
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
-
if (!ReadESD(esd, fgkDetectorName[iDet])) {
AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
TTree* clustersTree = NULL;
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
- delete fQADataMaker[iDet];
- fQADataMaker[iDet] = NULL;
+// delete fQADataMaker[iDet];
+// fQADataMaker[iDet] = NULL;
}
delete fVertexer;
fVertexer = NULL;
- delete fDiamondProfile;
- fDiamondProfile = NULL;
+
+ if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
+ }
delete fGRPList;
fGRPList = NULL;
header->SetZDCP1Energy (esd->GetZDCP1Energy() );
header->SetZDCN2Energy (esd->GetZDCN2Energy() );
header->SetZDCP2Energy (esd->GetZDCP2Energy() );
- header->SetZDCEMEnergy (esd->GetZDCEMEnergy() );
+ header->SetZDCEMEnergy (esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
header->SetRefMultiplicity (nTracks);
header->SetRefMultiplicityPos(nPosTracks);
header->SetRefMultiplicityNeg(nTracks - nPosTracks);
Int_t nV0s = esd->GetNumberOfV0s();
Int_t nCascades = esd->GetNumberOfCascades();
Int_t nKinks = esd->GetNumberOfKinks();
- Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
- Int_t nJets = 0;
+ Int_t nVertices = nV0s + 2*nCascades /*could lead to two vertices, one V0 and the Xi */+ nKinks + 1 /* = prim. vtx*/;
+ Int_t nJets = 0;
Int_t nCaloClus = esd->GetNumberOfCaloClusters();
Int_t nFmdClus = 0;
Int_t nPmdClus = esd->GetNumberOfPmdTracks();
// add it to the V0 array as well
Double_t d0[2] = { 999., 99.};
new(V0s[jV0s++]) AliAODv0(vV0, 999., 99., p_pos, p_neg, d0); // to be refined
- } // end of the loop on V0s
+ }
+ V0s.Expand(jV0s);
+ // 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
}
}
}
+ vertices.Expand(jVertices);
// Tracks (primary and orphan)
for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
-
if (usedTrack[nTrack]) continue;
else
aodTrack->SetChi2MatchTrigger(0.);
}
-
+ tracks.Expand(jTracks); // remove 'empty slots' due to unwritten tracks
+
// Access to the AOD container of PMD clusters
TClonesArray &pmdClusters = *(aod->GetPmdClusters());
Int_t jPmdClusters=0;
// Access to the AOD container of clusters
TClonesArray &caloClusters = *(aod->GetCaloClusters());
Int_t jClusters=0;
-
- // Calo Clusters
- TArrayS EMCCellNumber(15000);
- TArrayD EMCCellAmplitude(15000);
- Int_t nEMCCells = 0;
- const Float_t fEMCAmpScale = 1./500;
for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
ttype = AliAODCluster::kEMCALClusterv1;
}
- else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALPseudoCluster) {
- // Collect raw tower info
- for (Int_t iDig = 0; iDig < cluster->GetNumberOfDigits(); iDig++) {
- EMCCellNumber[nEMCCells] = cluster->GetDigitIndex()->At(iDig);
- EMCCellAmplitude[nEMCCells] = fEMCAmpScale*cluster->GetDigitAmplitude()->At(iDig);
- nEMCCells++;
- }
- // don't write cluster data (it's just a pseudo cluster, holding the tower information)
- continue;
- }
+
AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
nLabel,
caloCluster->SetCaloCluster(); // to be refined!
- } // end of loop on calo clusters
+ }
+ caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
+ // end of loop on calo clusters
+
+ // fill PHOS cell info
+
+ AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
+ Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
+
+ AliAODCaloCells &aodEMcells = *(aod->GetEMCALCells());
+ aodEMcells.CreateContainer(nEMcell);
+ aodEMcells.SetType(AliAODCaloCells::kEMCAL);
+ for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
+ aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
+ }
+ aodEMcells.Sort();
+
+ // fill PHOS cell info
+
+ AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
+ Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
- // fill EMC cell info
- AliAODCaloCells &EMCCells = *(aod->GetCaloCells());
- EMCCells.CreateContainer(nEMCCells);
- EMCCells.SetType(AliAODCaloCells::kEMCAL);
- for (Int_t iCell = 0; iCell < nEMCCells; iCell++) {
- EMCCells.SetCell(iCell,EMCCellNumber[iCell],EMCCellAmplitude[iCell]);
+ AliAODCaloCells &aodPHcells = *(aod->GetPHOSCells());
+ aodPHcells.CreateContainer(nPHcell);
+ aodPHcells.SetType(AliAODCaloCells::kPHOS);
+ for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
+ aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
}
- EMCCells.Sort();
+ aodPHcells.Sort();
// tracklets
AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
aodTree->GetUserInfo()->Add(aod);
- // close ESD file
- esdFile->Close();
-
// write the tree to the specified file
aodFile = aodTree->GetCurrentFile();
aodFile->cd();
}
-
-
//_____________________________________________________________________________
AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet)
{
-// get the quality assurance data maker object and the loader for a detector
+ // get the quality assurance data maker object and the loader for a detector
if (fQADataMaker[iDet])
return fQADataMaker[iDet];
}
-
//_____________________________________________________________________________
void AliReconstruction::CheckQA()
{
// check the QA of SIM for this run and remove the detectors
// with status Fatal
- TString newDetList ;
+ TString newRunLocalReconstruction ;
+ TString newRunTracking ;
+ TString newFillESD ;
+
for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
TString detName(AliQA::GetDetName(iDet)) ;
- if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
- fRunLocalReconstruction.Contains("ALL") ) {
- AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX(iDet)) ;
- if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kFATAL)) {
+ AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX(iDet)) ;
+ if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kFATAL)) {
AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
- } else if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kERROR)) {
- AliError(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was ERROR", detName.Data())) ;
- newDetList += detName ;
- newDetList += " " ;
- } else if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kWARNING) ) {
- AliWarning(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was WARNING", detName.Data())) ;
- newDetList += detName ;
- newDetList += " " ;
- } else if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kINFO) ) {
- AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was INFO", detName.Data())) ;
- newDetList += detName ;
- newDetList += " " ;
- } else {
- newDetList += detName ;
- newDetList += " " ;
+ } else {
+ if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
+ fRunLocalReconstruction.Contains("ALL") ) {
+ newRunLocalReconstruction += detName ;
+ newRunLocalReconstruction += " " ;
+ }
+ if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
+ fRunTracking.Contains("ALL") ) {
+ newRunTracking += detName ;
+ newRunTracking += " " ;
+ }
+ if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
+ fFillESD.Contains("ALL") ) {
+ newFillESD += detName ;
+ newFillESD += " " ;
}
}
}
- fRunLocalReconstruction = newDetList ;
+ fRunLocalReconstruction = newRunLocalReconstruction ;
+ fRunTracking = newRunTracking ;
+ fFillESD = newFillESD ;
}
//_____________________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff