#include <TPluginManager.h>
#include <TGeoManager.h>
#include <TLorentzVector.h>
+#include <TArrayS.h>
+#include <TArrayD.h>
#include "AliReconstruction.h"
#include "AliCodeTimer.h"
#include "AliPID.h"
#include "AliESDpid.h"
#include "AliESDtrack.h"
+#include "AliESDPmdTrack.h"
#include "AliESDTagCreator.h"
#include "AliAODTagCreator.h"
#include "AliAODHeader.h"
#include "AliAODTrack.h"
#include "AliAODVertex.h"
-#include "AliAODCluster.h"
+#include "AliAODv0.h"
+#include "AliAODJet.h"
+#include "AliAODCaloCells.h"
+#include "AliAODCaloCluster.h"
+#include "AliAODPmdCluster.h"
+#include "AliAODFmdCluster.h"
+#include "AliAODTracklets.h"
+
+#include "AliQADataMaker.h"
+
+#include "AliSysInfo.h" // memory snapshots
-#include "AliQualAssDataMaker.h"
ClassImp(AliReconstruction)
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQualAssDataMaker[iDet] = NULL;
+ fQADataMaker[iDet] = NULL;
fQACycles[iDet] = 999999;
}
AliPID pid;
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQualAssDataMaker[iDet] = NULL;
+ fQADataMaker[iDet] = NULL;
fQACycles[iDet] = rec.fQACycles[iDet];
}
for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
}
// read run number from gAlice
if(fRunLoader->GetAliRun())
- AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
+ AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
else {
if(fRawReader) {
if(fRawReader->NextEvent()) {
if (!fEquipIdMap.IsNull() && fRawReader)
fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
-
+ AliSysInfo::AddStamp("Start");
// get the run loader
if (!InitRunLoader()) return kFALSE;
+ AliSysInfo::AddStamp("LoadLoader");
// Initialize the CDB storage
InitCDBStorage();
+ AliSysInfo::AddStamp("LoadCDB");
// 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;
+ AliSysInfo::AddStamp("LoadGeom");
// local reconstruction
if (!fRunLocalReconstruction.IsNull()) {
return kFALSE;
}
}
+ AliSysInfo::AddStamp("Vertexer");
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
return kFALSE;
}
}
+ AliSysInfo::AddStamp("LoadTrackers");
// get the possibly already existing ESD file and tree
AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
ProcInfo_t ProcInfo;
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())
- RunQualAss(fFillESD.Data(), esd);
+ RunQA(fFillESD.Data(), esd);
// fill Event header information from the RawEventHeader
if (fRawReader){FillRawEventHeaderESD(esd);}
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr))
continue;
- AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
if (!qadm) continue;
- qadm->EndOfCycle(AliQualAss::kRECPOINTS);
- qadm->EndOfCycle(AliQualAss::kESDS);
- qadm->Finish(AliQualAss::kRECPOINTS);
- qadm->Finish(AliQualAss::kESDS) ;
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish(AliQA::kRECPOINTS);
+ qadm->Finish(AliQA::kESDS) ;
}
tree->GetUserInfo()->Add(esd);
file->cd();
if (fWriteESDfriend)
tree->SetBranchStatus("ESDfriend*",0);
- tree->Write();
+ // we want to have only one tree version number
+ tree->Write(tree->GetName(),TObject::kOverwrite);
hlttree->Write();
if (fWriteAOD) {
Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
{
// run the local reconstruction
-
+ static Int_t eventNr=0;
AliCodeTimerAuto("")
// AliCDBManager* man = AliCDBManager::Instance();
// }
// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
// // unload calibration data
// man->UnloadFromCache(calibPath);
// if (fStopOnError) return kFALSE;
// }
+ eventNr++;
return kTRUE;
}
Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
{
// run the local reconstruction
-
+ static Int_t eventNr=0;
AliCodeTimerAuto("")
TString detStr = detectors;
loader->UnloadDigits();
}
- AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+ 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(AliQualAss::kRECPOINTS) ;
- qadm->EndOfCycle(AliQualAss::kESDS) ;
- qadm->StartOfCycle(AliQualAss::kRECPOINTS) ;
- qadm->StartOfCycle(AliQualAss::kESDS, "same") ;
- }
- qadm->Exec(AliQualAss::kRECPOINTS, clustersTree) ;
+ 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->UnloadRecPoints();
+ AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
detStr.Data()));
if (fStopOnError) return kFALSE;
}
-
+ eventNr++;
return kTRUE;
}
Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
{
// run the barrel tracking
-
+ static Int_t eventNr=0;
AliCodeTimerAuto("")
AliInfo("running tracking");
// load clusters
fLoader[iDet]->LoadRecPoints("read");
+ AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
TTree* tree = fLoader[iDet]->TreeR();
if (!tree) {
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
}
fTracker[iDet]->LoadClusters(tree);
-
+ AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
// run tracking
if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
if (iDet == 1) {
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
AliESDpid::MakePID(esd);
- }
+ }
+ AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
}
// pass 2: ALL backwards
if (iDet > 1) { // all except ITS, TPC
TTree* tree = NULL;
fLoader[iDet]->LoadRecPoints("read");
+ AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
tree = fLoader[iDet]->TreeR();
if (!tree) {
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
}
- fTracker[iDet]->LoadClusters(tree);
+ fTracker[iDet]->LoadClusters(tree);
+ AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
}
// run tracking
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
AliESDpid::MakePID(esd);
}
+ AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
}
// write space-points to the ESD in case alignment data output
if (fCheckPointLevel > 1) {
WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
}
-
+ AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
// unload clusters
fTracker[iDet]->UnloadClusters();
+ AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
fLoader[iDet]->UnloadRecPoints();
+ AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
}
//
// Propagate track to the vertex - if not done by ITS
AliTracker::PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
}
-
+ eventNr++;
return kTRUE;
}
// fill the event summary data
AliCodeTimerAuto("")
-
+ static Int_t eventNr=0;
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
detStr.Data()));
if (fStopOnError) return kFALSE;
}
-
+ AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
+ eventNr++;
return kTRUE;
}
//PH This is a temporary fix to give access to the kinematics
//PH that is needed for the labels of ITS clusters
+ fRunLoader->LoadHeader();
fRunLoader->LoadKinematics();
} else { // galice.root does not exist
TString recName = "Ali" + detName + "Reconstructor";
if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
- if (detName == "HLT") {
- if (!gROOT->GetClass("AliLevel3")) {
- gSystem->Load("libAliHLTSrc.so");
- gSystem->Load("libAliHLTMisc.so");
- gSystem->Load("libAliHLTHough.so");
- gSystem->Load("libAliHLTComp.so");
- }
- }
-
AliReconstructor* reconstructor = NULL;
// first check if a plugin is defined for the reconstructor
TPluginHandler* pluginHandler =
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
if (fStopOnError) return kFALSE;
}
+ AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
}
return kTRUE;
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
- delete fQualAssDataMaker[iDet];
- fQualAssDataMaker[iDet] = NULL;
+ delete fQADataMaker[iDet];
+ fQADataMaker[iDet] = NULL;
}
delete fVertexer;
fVertexer = NULL;
Float_t posF[3];
Double_t pos[3];
Double_t p[3];
+ Double_t p_pos[3];
+ Double_t p_neg[3];
Double_t covVtx[6];
Double_t covTr[21];
Double_t pid[10];
// loop over events and fill them
for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+ //cout << "event: " << iEvent << endl;
t->GetEntry(iEvent);
// Multiplicity information needed by the header (to be revised!)
Int_t nV0s = esd->GetNumberOfV0s();
Int_t nCascades = esd->GetNumberOfCascades();
Int_t nKinks = esd->GetNumberOfKinks();
- Int_t nVertices = nV0s + nCascades + nKinks;
-
- aod->ResetStd(nTracks, nVertices);
- AliAODTrack *aodTrack;
+ Int_t nVertices = nV0s + nCascades + nKinks + 1 /* = prim. vtx*/;
+ Int_t nJets = 0;
+ Int_t nCaloClus = esd->GetNumberOfCaloClusters();
+ Int_t nFmdClus = 0;
+ Int_t nPmdClus = esd->GetNumberOfPmdTracks();
+
+ aod->ResetStd(nTracks, nVertices, nV0s+nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
// Array to take into account the tracks already added to the AOD
Bool_t * usedTrack = NULL;
usedKink = new Bool_t[nKinks];
for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
}
-
+
// Access to the AOD container of vertices
TClonesArray &vertices = *(aod->GetVertices());
Int_t jVertices=0;
// Access to the AOD container of tracks
TClonesArray &tracks = *(aod->GetTracks());
Int_t jTracks=0;
-
+
+ // Access to the AOD container of V0s
+ TClonesArray &V0s = *(aod->GetV0s());
+ Int_t jV0s=0;
+
// Add primary vertex. The primary tracks will be defined
// after the loops on the composite objects (V0, cascades, kinks)
const AliESDVertex *vtx = esd->GetPrimaryVertex();
AliAODVertex * primary = new(vertices[jVertices++])
AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
+
+ AliAODTrack *aodTrack = 0x0;
+
// Create vertices starting from the most complex objects
-
+
// Cascades
for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
AliESDcascade *cascade = esd->GetCascade(nCascade);
- cascade->GetXYZcascade(pos[0], pos[1], pos[2]); // Bo: bug correction
+ cascade->GetXYZ(pos[0], pos[1], pos[2]);
cascade->GetPosCovXi(covVtx);
// Add the cascade vertex
nCascade,
AliAODVertex::kCascade);
- primary->AddDaughter(vcascade);
+ primary->AddDaughter(vcascade); // the cascade 'particle' (represented by a vertex) is added as a daughter to the primary vertex
// Add the V0 from the cascade. The ESD class have to be optimized...
// Now we have to search for the corresponding V0 in the list of V0s
Int_t posFromV0 = cascade->GetPindex();
Int_t negFromV0 = cascade->GetNindex();
+
AliESDv0 * v0 = 0x0;
Int_t indV0 = -1;
AliAODVertex * vV0FromCascade = 0x0;
- if (indV0>-1 && !usedV0[indV0] ) {
+ if (indV0>-1 && !usedV0[indV0]) {
// the V0 exists in the array of V0s and is not used
indV0,
AliAODVertex::kV0);
vcascade->AddDaughter(vV0FromCascade);
+
}
// Add the positive tracks from the V0
usedTrack[posFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
- esdTrack->GetPxPyPz(p);
+ esdTrack->GetPxPyPz(p_pos);
esdTrack->GetXYZ(pos);
esdTrack->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);
vV0FromCascade->AddDaughter(aodTrack =
new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
esdTrack->GetLabel(),
- p,
+ p_pos,
kTRUE,
pos,
kFALSE,
usedTrack[negFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
- esdTrack->GetPxPyPz(p);
+ esdTrack->GetPxPyPz(p_neg);
esdTrack->GetXYZ(pos);
esdTrack->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);
vV0FromCascade->AddDaughter(aodTrack =
new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
esdTrack->GetLabel(),
- p,
+ p_neg,
kTRUE,
pos,
kFALSE,
<< " track " << negFromV0 << " has already been used!" << endl;
}
+ // add it to the V0 array as well
+ Double_t d0[2] = { -999., -99.};
+ // counting is probably wrong
+ new(V0s[jV0s++]) AliAODv0(vV0FromCascade, -999., -99., p_pos, p_neg, d0); // to be refined
+
// Add the bachelor track from the cascade
Int_t bachelor = cascade->GetBindex();
cerr << "Error: event " << iEvent << " cascade " << nCascade
<< " track " << bachelor << " has already been used!" << endl;
}
-
+
// Add the primary track of the cascade (if any)
-
+
} // end of the loop on cascades
-
+
// V0s
for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
if (usedV0[nV0]) continue; // skip if aready added to the AOD
- AliESDv0 *v0 = esd->GetV0(nV0);
-
+ AliESDv0 *v0 = esd->GetV0(nV0);
+
v0->GetXYZ(pos[0], pos[1], pos[2]);
v0->GetPosCov(covVtx);
usedTrack[posFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
- esdTrack->GetPxPyPz(p);
+ esdTrack->GetPxPyPz(p_pos);
esdTrack->GetXYZ(pos);
esdTrack->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);
vV0->AddDaughter(aodTrack =
new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
esdTrack->GetLabel(),
- p,
+ p_pos,
kTRUE,
pos,
kFALSE,
usedTrack[negFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
- esdTrack->GetPxPyPz(p);
+ esdTrack->GetPxPyPz(p_neg);
esdTrack->GetXYZ(pos);
esdTrack->GetCovarianceXYZPxPyPz(covTr);
esdTrack->GetESDpid(pid);
vV0->AddDaughter(aodTrack =
new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
esdTrack->GetLabel(),
- p,
+ p_neg,
kTRUE,
pos,
kFALSE,
<< " track " << negFromV0 << " has already been used!" << endl;
}
+ // 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
// Kinks: it is a big mess the access to the information in the kinks
for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
-
AliESDtrack * esdTrack = esd->GetTrack(iTrack);
Int_t ikink = esdTrack->GetKinkIndex(0);
cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
<< " track " << idaughter << " has already been used!" << endl;
}
-
-
}
}
-
- }
-
+ }
}
-
// Tracks (primary and orphan)
-
for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
esdTrack->GetImpactParameters(impactXY,impactZ);
- if (impactXY<3) {
+ if (impactXY<3.) {
// track inside the beam pipe
primary->AddDaughter(aodTrack =
}
else {
// outside the beam pipe: orphan track
- aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- NULL,
- kFALSE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kOrphan);
- aodTrack->ConvertAliPIDtoAODPID();
+ // Don't write them anymore!
+ continue;
}
} // end of loop on tracks
-
+
// muon tracks
Int_t nMuTracks = esd->GetNumberOfMuonTracks();
for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
else
aodTrack->SetChi2MatchTrigger(0.);
}
-
+
+ // Access to the AOD container of PMD clusters
+ TClonesArray &pmdClusters = *(aod->GetPmdClusters());
+ Int_t jPmdClusters=0;
+
+ for (Int_t iPmd = 0; iPmd < nPmdClus; ++iPmd) {
+ // file pmd clusters, to be revised!
+ AliESDPmdTrack *pmdTrack = esd->GetPmdTrack(iPmd);
+ Int_t nLabel = 0;
+ Int_t *label = 0x0;
+ Double_t pos[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ() };
+ Double_t pid[9] = { 0., 0., 0., 0., 0., 0., 0., 0., 0. }; // to be revised!
+ // type not set!
+ // assoc cluster not set
+ new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), pos, pid);
+ }
+
// Access to the AOD container of clusters
- TClonesArray &clusters = *(aod->GetClusters());
+ TClonesArray &caloClusters = *(aod->GetCaloClusters());
Int_t jClusters=0;
// Calo Clusters
- Int_t nClusters = esd->GetNumberOfCaloClusters();
-
- for (Int_t iClust=0; iClust<nClusters; ++iClust) {
+ TArrayS EMCCellNumber(15000);
+ TArrayD EMCCellAmplitude(15000);
+ Int_t nEMCCells = 0;
+ const Float_t fEMCAmpScale = 1./500;
+
+ for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
Int_t id = cluster->GetID();
- Int_t label = -1;
+ Int_t nLabel = 0;
+ Int_t *label = 0x0;
Float_t energy = cluster->E();
cluster->GetPosition(posF);
- AliAODVertex *prodVertex = primary;
- AliAODTrack *primTrack = NULL;
Char_t ttype=AliAODCluster::kUndef;
- if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
- else if (cluster->IsEMCAL()) {
-
- if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
- ttype = AliAODCluster::kEMCALPseudoCluster;
- else
- ttype = AliAODCluster::kEMCALClusterv1;
-
+ if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
+ ttype=AliAODCluster::kPHOSNeutral;
+ }
+ else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
+ ttype = AliAODCluster::kEMCALClusterv1;
}
-
- new(clusters[jClusters++]) AliAODCluster(id,
- label,
- energy,
- pos,
- NULL, // no covariance matrix provided
- NULL, // no pid for clusters provided
- prodVertex,
- primTrack,
- ttype);
+ 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,
+ label,
+ energy,
+ pos,
+ NULL,
+ ttype);
+
+ caloCluster->SetCaloCluster(); // to be refined!
} // end of loop on calo clusters
- // tracklets
+ // 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]);
+ }
+ EMCCells.Sort();
+
+ // tracklets
+ AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
const AliMultiplicity *mult = esd->GetMultiplicity();
if (mult) {
if (mult->GetNumberOfTracklets()>0) {
- aod->GetTracklets()->CreateContainer(mult->GetNumberOfTracklets());
+ SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
- aod->GetTracklets()->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
+ SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
}
}
} else {
out.close();
}
+
+
//_____________________________________________________________________________
-AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet)
+AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet)
{
// get the quality assurance data maker object and the loader for a detector
- if (fQualAssDataMaker[iDet])
- return fQualAssDataMaker[iDet];
+ if (fQADataMaker[iDet])
+ return fQADataMaker[iDet];
// load the QA data maker object
TPluginManager* pluginManager = gROOT->GetPluginManager();
TString detName = fgkDetectorName[iDet];
- TString qadmName = "Ali" + detName + "QualAssDataMaker";
+ TString qadmName = "Ali" + detName + "QADataMaker";
if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
return NULL;
- AliQualAssDataMaker * qadm = NULL;
+ AliQADataMaker * qadm = NULL;
// first check if a plugin is defined for the quality assurance data maker
- TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
+ TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
// if not, add a plugin for it
if (!pluginHandler) {
AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
TString libs = gSystem->GetLibraries();
if (libs.Contains("lib" + detName + "base.so") ||
(gSystem->Load("lib" + detName + "base.so") >= 0)) {
- pluginManager->AddHandler("AliQualAssDataMaker", detName,
+ pluginManager->AddHandler("AliQADataMaker", detName,
qadmName, detName + "qadm", qadmName + "()");
} else {
- pluginManager->AddHandler("AliQualAssDataMaker", detName,
+ pluginManager->AddHandler("AliQADataMaker", detName,
qadmName, detName, qadmName + "()");
}
- pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
+ pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
}
if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- qadm = (AliQualAssDataMaker *) pluginHandler->ExecPlugin(0);
+ qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0);
}
if (qadm) {
AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet]));
- qadm->Init(AliQualAss::kRECPOINTS, fRawReader->GetRunNumber(), GetQACycles(fgkDetectorName[iDet]));
- qadm->StartOfCycle(AliQualAss::kRECPOINTS);
- qadm->StartOfCycle(AliQualAss::kESDS, "same") ;
- fQualAssDataMaker[iDet] = qadm;
+ qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
+ qadm->StartOfCycle(AliQA::kRECPOINTS);
+ qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ fQADataMaker[iDet] = qadm;
}
return qadm;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
+Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
{
// run the Quality Assurance data producer
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr))
continue;
- AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
if (!qadm)
continue;
AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- qadm->Exec(AliQualAss::kESDS, esd) ;
+ qadm->Exec(AliQA::kESDS, esd) ;
qadm->Increment() ;
AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
}
return kTRUE;
+
+}
+
+
+//_____________________________________________________________________________
+void AliReconstruction::CheckQA()
+{
+// check the QA of SIM for this run and remove the detectors
+// with status Fatal
+
+ TString newDetList ;
+ 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)) {
+ 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 += " " ;
+ }
+ }
+ }
+ fRunLocalReconstruction = newDetList ;
}
//_____________________________________________________________________________