#include "AliMagWrapCheb.h"
#include "AliDetectorRecoParam.h"
+#include "AliGRPRecoParam.h"
#include "AliRunInfo.h"
#include "AliEventInfo.h"
#include "AliDAQ.h"
+#include "AliGRPObject.h"
+
ClassImp(AliReconstruction)
//_____________________________________________________________________________
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fLoadCDB(""),
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
fRawInput(""),
fRecoParam(),
fVertexer(NULL),
+ fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(kTRUE),
-
+
fGRPData(NULL),
fAlignObjArray(NULL),
fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
- fInLoopQA(kFALSE),
fSameQACycle(kFALSE),
fRunPlaneEff(kFALSE),
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQACycles[iDet] = 999999;
}
- fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ fQACycles[iDet] = 999999 ;
+ fQAWriteExpert[iDet] = kFALSE ;
+ }
+
AliPID pid;
}
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
+ fLoadCDB(rec.fLoadCDB),
fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
fRawInput(rec.fRawInput),
fRecoParam(rec.fRecoParam),
fVertexer(NULL),
+ fDiamondProfileSPD(rec.fDiamondProfileSPD),
fDiamondProfile(rec.fDiamondProfile),
fDiamondProfileTPC(rec.fDiamondProfileTPC),
- fMeanVertexConstraint(rec.fMeanVertexConstraint),
-
+
fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
- fInLoopQA(rec.fInLoopQA),
fSameQACycle(rec.fSameQACycle),
fRunPlaneEff(rec.fRunPlaneEff),
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQACycles[iDet] = rec.fQACycles[iDet];
+ }
+
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ fQACycles[iDet] = rec.fQACycles[iDet];
+ fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
+
for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
}
-
}
//_____________________________________________________________________________
fRunLocalReconstruction = rec.fRunLocalReconstruction;
fRunTracking = rec.fRunTracking;
fFillESD = rec.fFillESD;
+ fLoadCDB = rec.fLoadCDB;
fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
fGAliceFileName = rec.fGAliceFileName;
fRawInput = rec.fRawInput;
delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
delete fLoader[iDet]; fLoader[iDet] = NULL;
delete fTracker[iDet]; fTracker[iDet] = NULL;
- fQACycles[iDet] = rec.fQACycles[iDet];
}
-
+
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ fQACycles[iDet] = rec.fQACycles[iDet];
+ fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
+ }
+
fVertexer = NULL;
+ delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
+ if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
delete fDiamondProfile; fDiamondProfile = NULL;
if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
- fMeanVertexConstraint = rec.fMeanVertexConstraint;
delete fGRPData; fGRPData = NULL;
- if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
+ // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
+ if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
delete fAlignObjArray; fAlignObjArray = NULL;
fQATasks = rec.fQATasks;
fRunQA = rec.fRunQA;
fRunGlobalQA = rec.fRunGlobalQA;
- fInLoopQA = rec.fInLoopQA;
fSameQACycle = rec.fSameQACycle;
fRunPlaneEff = rec.fRunPlaneEff;
// clean up
CleanUp();
+ delete fGRPData;
delete fForcedFieldMap;
fOptions.Delete();
if (fAlignObjArray) {
TString loadAlObjsListOfDets = "";
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- loadAlObjsListOfDets += fgkDetectorName[iDet];
- loadAlObjsListOfDets += " ";
+ if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if(fgkDetectorName[iDet]=="HLT") continue;
+ if(AliGeomManager::IsModuleInGeom(fgkDetectorName[iDet]))
+ {
+ loadAlObjsListOfDets += fgkDetectorName[iDet];
+ loadAlObjsListOfDets += " ";
+ }
} // end loop over detectors
- loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
+ if(AliGeomManager::IsModuleInGeom("FRAME"))
+ loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
+ AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
}else{
// Check if the array with alignment objects was
// provided by the user. If yes, apply the objects
{
// Set custom reconstruction parameters for a given detector
// Single set of parameters for all the events
+
+ // First check if the reco-params are global
+ if(!strcmp(detector, "GRP")) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(fgkNDetectors,par);
+ return;
+ }
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if(!strcmp(detector, fgkDetectorName[iDet])) {
par->SetAsDefault();
AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
if (entry) {
- fGRPData = dynamic_cast<TMap*>(entry->GetObject());
- entry->SetOwner(0);
+
+ TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
+
+ if (m) {
+ AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
+ m->Print();
+ fGRPData = new AliGRPObject();
+ fGRPData->ReadValuesFromMap(m);
+ }
+
+ else {
+ AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
+ fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
+ entry->SetOwner(0);
+ }
+
AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
}
return kFALSE;
}
- TObjString *lhcState=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fLHCState"));
- if (!lhcState) {
+ TString lhcState = fGRPData->GetLHCState();
+ if (lhcState==AliGRPObject::GetInvalidString()) {
AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
+ lhcState = "UNKNOWN";
}
- TObjString *beamType=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamType"));
- if (!beamType) {
+ TString beamType = fGRPData->GetBeamType();
+ if (beamType==AliGRPObject::GetInvalidString()) {
AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
+ beamType = "UNKNOWN";
}
- TObjString *beamEnergyStr=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamEnergy"));
- if (!beamEnergyStr) {
+ Float_t beamEnergy = fGRPData->GetBeamEnergy();
+ if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
+ beamEnergy = 0;
}
- TObjString *runType=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fRunType"));
- if (!runType) {
+ TString runType = fGRPData->GetRunType();
+ if (runType==AliGRPObject::GetInvalidString()) {
AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
+ runType = "UNKNOWN";
}
- TObjString *activeDetectors=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fDetectorMask"));
- if (!activeDetectors) {
+ Int_t activeDetectors = fGRPData->GetDetectorMask();
+ if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
+ activeDetectors = 1074790399;
}
- fRunInfo = new AliRunInfo(lhcState ? lhcState->GetString().Data() : "UNKNOWN",
- beamType ? beamType->GetString().Data() : "UNKNOWN",
- beamEnergyStr ? beamEnergyStr->GetString().Atof() : 0,
- runType ? runType->GetString().Data() : "UNKNOWN",
- activeDetectors ? activeDetectors->GetString().Atoi() : 1074790399);
+ fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
+
+ fRunInfo->Dump();
+
// Process the list of active detectors
- if (activeDetectors && activeDetectors->GetString().IsDigit()) {
- UInt_t detMask = activeDetectors->GetString().Atoi();
+ if (activeDetectors) {
+ UInt_t detMask = activeDetectors;
+ fLoadCDB.Form("%s %s %s %s",
+ fRunLocalReconstruction.Data(),
+ fRunTracking.Data(),
+ fFillESD.Data(),
+ fQADetectors.Data());
fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
fRunTracking = MatchDetectorList(fRunTracking,detMask);
fFillESD = MatchDetectorList(fFillESD,detMask);
fQADetectors = MatchDetectorList(fQADetectors,detMask);
+ fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
+ if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
+ // switch off the vertexer
+ AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
+ fRunVertexFinder = kFALSE;
+ }
}
AliInfo("===================================================================================");
AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
+ AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
AliInfo("===================================================================================");
//*** Dealing with the magnetic field map
Bool_t ok = kTRUE;
// L3
+ Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
+ if (l3Current == AliGRPObject::GetInvalidFloat()) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 current !");
+ ok = kFALSE;
+ }
+
+ Char_t l3Polarity = fGRPData->GetL3Polarity();
+ if (l3Polarity == AliGRPObject::GetInvalidChar()) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
+ ok = kFALSE;
+ }
+
+ // Dipole
+ Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
+ if (diCurrent == AliGRPObject::GetInvalidFloat()) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole current !");
+ ok = kFALSE;
+ }
+
+ Char_t diPolarity = fGRPData->GetDipolePolarity();
+ if (diPolarity == AliGRPObject::GetInvalidChar()) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
+ ok = kFALSE;
+ }
+
+ /*
TObjString *l3Current=
dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
if (!l3Current) {
AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
ok = kFALSE;
}
-
+
// Dipole
TObjString *diCurrent=
dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
ok = kFALSE;
}
+ */
if (ok) {
- Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
- Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
- Float_t l3Pol=atof(l3Polarity->GetName());
+ Float_t l3Cur=TMath::Abs(l3Current);
+ Float_t diCur=TMath::Abs(diCurrent);
+ Float_t l3Pol=l3Polarity;
+ // Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
+ //Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
+ //Float_t l3Pol=atof(l3Polarity->GetName());
Float_t factor=1.;
if (l3Pol != 0.) factor=-1.;
}
- //*** Get the diamond profile from OCDB
+ //*** Get the diamond profiles from OCDB
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
+ if (entry) {
+ fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ AliError("No SPD diamond profile found in OCDB!");
+ }
+
entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
if (entry) {
- if (fMeanVertexConstraint)
- fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
} else {
AliError("No diamond profile found in OCDB!");
}
entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
if (entry) {
- if (fMeanVertexConstraint)
- fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
} else {
- AliError("No diamond profile found in OCDB!");
+ AliError("No TPC diamond profile found in OCDB!");
}
return kTRUE;
AliCDBManager::Instance()->Get("GRP/CTP/Config");
- TString detStr = fRunLocalReconstruction;
+ TString detStr = fLoadCDB;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
SlaveBegin(NULL);
if (GetAbort() != TSelector::kContinue) return kFALSE;
//******* The loop over events
+ AliInfo("Starting looping over events");
Int_t iEvent = 0;
while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
(fRawReader && fRawReader->NextEvent())) {
if (!ProcessEvent(iEvent)) {
- Abort("ProcessEvent",TSelector::kAbortFile);
- return kFALSE;
+ Abort("ProcessEvent",TSelector::kAbortFile);
+ return kFALSE;
}
iEvent++;
}
AliReconstruction *reco = NULL;
if (fInput) {
- if (reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
+ if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
*this = *reco;
}
AliSysInfo::AddStamp("ReadInputInBegin");
gGeoManager = NULL;
fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
- fInput->Add((AliMagF*)AliTracker::GetFieldMap());
+ AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap();
+ magFieldMap->SetName("MagneticFieldMap");
+ fInput->Add(magFieldMap);
}
}
AliCodeTimerAuto("");
TProofOutputFile *outProofFile = NULL;
- if (fInput) {
+ if (fInput) {
if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
*this = *reco;
}
man->Print();
}
}
- if (AliMagF *map = (AliMagF*)fInput->FindObject("Maps")) {
+ if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
AliTracker::SetFieldMap(map,fUniformField);
}
if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
AliSysInfo::AddStamp("LoadLoader");
ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
- if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
// get vertexer
if (fRunVertexFinder && !CreateVertexer()) {
ftree = new TTree("esdTree", "Tree with ESD objects");
fesd = new AliESDEvent();
fesd->CreateStdContent();
- fesd->WriteToTree(ftree);
-
- fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
- fhltesd = new AliESDEvent();
- fhltesd->CreateStdContent();
- fhltesd->WriteToTree(fhlttree);
-
-
if (fWriteESDfriend) {
fesdf = new AliESDfriend();
TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
br->SetFile("AliESDfriends.root");
fesd->AddObject(fesdf);
}
+ fesd->WriteToTree(ftree);
+ ftree->GetUserInfo()->Add(fesd);
+
+ fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
+ fhltesd = new AliESDEvent();
+ fhltesd->CreateStdContent();
+ fhltesd->WriteToTree(fhlttree);
+ fhlttree->GetUserInfo()->Add(fhltesd);
ProcInfo_t ProcInfo;
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
//QA
- fQASteer = new AliQADataMakerSteer("rec") ;
- fQASteer->SetActiveDetectors(fQADetectors) ;
- fQASteer->SetTasks(fQATasks) ;
-
- if ( !fInLoopQA ) {
- if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) {
- fQASteer->Run(fQADetectors, fRawReader) ;
- fSameQACycle = kTRUE ;
- }
- }
-
- //Initialize the QA and start of cycle for out-of-loop QA
+ //Initialize the QA and start of cycle
if (fRunQA) {
- fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, !fInLoopQA) ;
+ fQASteer = new AliQADataMakerSteer("rec") ;
+ fQASteer->SetActiveDetectors(fQADetectors) ;
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+ fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
+ if (fQAWriteExpert[det])
+ fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+ }
+
+ if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
+ fQASteer->SetTasks(fQATasks) ;
+ fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam) ;
}
-
+
if (fRunGlobalQA) {
- fSameQACycle = kFALSE;
+ Bool_t sameCycle = kFALSE ;
+ if (!fQASteer) fQASteer = new AliQADataMakerSteer("rec") ;
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
AliInfo(Form("Initializing the global QA data maker"));
if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- TObjArray *arr=qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
+ qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ TObjArray *arr=qadm->Init(AliQA::kRECPOINTS);
AliTracker::SetResidualsArray(arr);
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
+ sameCycle = kTRUE ;
}
if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
+ qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ qadm->Init(AliQA::kESDS);
}
}
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
- //Start of cycle for the in-loop QA
- if (fInLoopQA && fRunQA) {
- fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, fInLoopQA) ;
- }
- if (fInLoopQA && fRunGlobalQA) {
- fSameQACycle = kFALSE;
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
- fSameQACycle = kTRUE;
+ // Set the reco-params
+ {
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ AliReconstructor *reconstructor = GetReconstructor(iDet);
+ if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ reconstructor->SetRecoParam(par);
+ }
}
- }
+ }
fRunLoader->GetEvent(iEvent);
// QA on single raw
- if (fInLoopQA && fRunQA)
+ if (fRunQA)
fQASteer->RunOneEvent(fRawReader) ;
// local single event reconstruction
fesd->SetMagneticField(AliTracker::GetBz());
fhltesd->SetMagneticField(AliTracker::GetBz());
-
+ // Set most probable pt, for B=0 tracking
+ const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
+ if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
// Fill raw-data error log into the ESD
if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
//
// Improve the reconstructed primary vertex position using the tracks
//
- TObject *obj = fOptions.FindObject("ITS");
- if (obj) {
- TString optITS = obj->GetTitle();
- if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
- fRunVertexFinderTracks=kFALSE;
+ Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
+ if(fesd->GetPrimaryVertexSPD()) {
+ TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
+ if(vtitle.Contains("cosmics")) {
+ runVertexFinderTracks=kFALSE;
+ }
}
- if (fRunVertexFinderTracks) {
+
+ if (runVertexFinderTracks) {
+ // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
+ const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
+
// TPC + ITS primary vertex
- ftVertexer->SetITSrefitRequired();
- if(fDiamondProfile && fMeanVertexConstraint) {
- ftVertexer->SetVtxStart(fDiamondProfile);
- } else {
- ftVertexer->SetConstraintOff();
+ ftVertexer->SetITSMode();
+ ftVertexer->SetConstraintOff();
+ // get cuts for vertexer from AliGRPRecoParam
+ if (grpRecoParam) {
+ Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
+ Double_t *cutsVertexer = new Double_t[nCutsVertexer];
+ grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
+ ftVertexer->SetCuts(cutsVertexer);
+ delete [] cutsVertexer; cutsVertexer = NULL;
+ if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
+ ftVertexer->SetVtxStart(fDiamondProfile);
}
AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
}
// TPC-only primary vertex
- ftVertexer->SetITSrefitNotRequired();
- if(fDiamondProfileTPC && fMeanVertexConstraint) {
- ftVertexer->SetVtxStart(fDiamondProfileTPC);
- } else {
- ftVertexer->SetConstraintOff();
+ ftVertexer->SetTPCMode();
+ ftVertexer->SetConstraintOff();
+ // get cuts for vertexer from AliGRPRecoParam
+ if (grpRecoParam) {
+ Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
+ Double_t *cutsVertexer = new Double_t[nCutsVertexer];
+ grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
+ ftVertexer->SetCuts(cutsVertexer);
+ delete [] cutsVertexer; cutsVertexer = NULL;
+ if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
+ ftVertexer->SetVtxStart(fDiamondProfileTPC);
}
pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
if (pvtx) {
// write ESD
if (fCleanESD) CleanESD(fesd);
- if (fRunGlobalQA) {
+ if (fRunQA)
+ fQASteer->RunOneEvent(fesd) ;
+
+ if (fRunGlobalQA) {
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->Exec(AliQA::kESDS, fesd);
+ qadm->Exec(AliQA::kESDS, fesd);
}
if (fWriteESDfriend) {
- fesdf->~AliESDfriend();
- new (fesdf) AliESDfriend(); // Reset...
+ // fesdf->~AliESDfriend();
+ // new (fesdf) AliESDfriend(); // Reset...
fesd->GetESDfriend(fesdf);
}
ftree->Fill();
// Auto-save the ESD tree in case of prompt reco @P2
- if (fRawReader && fRawReader->UseAutoSaveESD())
+ if (fRawReader && fRawReader->UseAutoSaveESD()) {
ftree->AutoSave("SaveSelf");
+ TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
+ if (friendfile) friendfile->Save();
+ }
// write HLT ESD
fhlttree->Fill();
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
-
- // End of cycle for the in-loop
- if (fInLoopQA && fRunQA) {
- fQASteer->RunOneEvent(fesd) ;
- fQASteer->EndOfCycle() ;
- }
- if (fInLoopQA && fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (qadm) {
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
-
fEventInfo.Reset();
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (fReconstructor[iDet])
- fReconstructor[iDet]->SetRecoParam(NULL);
+ fReconstructor[iDet]->SetRecoParam(NULL);
}
+ if (fRunQA || fRunGlobalQA)
+ fQASteer->Increment() ;
+
return kTRUE;
}
fRunLoader->Write(0, TObject::kOverwrite);
}
- ftree->GetUserInfo()->Add(fesd);
- fhlttree->GetUserInfo()->Add(fhltesd);
-
const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
AliWarning("Finish PlaneEff evaluation failed");
}
- //Finish QA and end of cycle for out-of-loop QA
- if (!fInLoopQA && fRunQA)
- fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kNULLTASKINDEX, fSameQACycle) ;
- if (!fInLoopQA && fRunGlobalQA) {
+ // End of cycle for the in-loop
+ if (fRunQA) {
+ fQASteer->EndOfCycle() ;
+ }
+ if (fRunGlobalQA) {
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
if (qadm) {
if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->EndOfCycle(AliQA::kESDS);
+ qadm->EndOfCycle(AliQA::kESDS);
qadm->Finish();
}
}
-
gROOT->cd();
CleanUp();
}
loader->UnloadDigits();
}
- // In-loop QA for local reconstrucion
TString detQAStr(fQADetectors) ;
- if (fRunQA && fInLoopQA)
+ if (fRunQA)
fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
- }
- if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ }
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
if (fStopOnError) return kFALSE;
fLoader[0]->LoadRecPoints();
TTree* cltree = fLoader[0]->TreeR();
if (cltree) {
- if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
+ if(fDiamondProfileSPD) fVertexer->SetVtxStart(fDiamondProfileSPD);
vertex = fVertexer->FindVertexForCurrentEvent(cltree);
}
else {
Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
{
// create the trackers
+ AliInfo("Creating trackers");
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
ftVertexer = NULL;
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+ delete fDiamondProfileSPD;
+ fDiamondProfileSPD = NULL;
delete fDiamondProfile;
fDiamondProfile = NULL;
delete fDiamondProfileTPC;
fDiamondProfileTPC = NULL;
}
- delete fGRPData;
- fGRPData = NULL;
-
delete fRunLoader;
fRunLoader = NULL;
delete fRawReader;
AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
- gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
+ gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
gROOT->ProcessLine("alieve_online_init()");
return kTRUE;
// successful initialization of AliEVE.
AliInfo("Running AliEVE...");
- gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
- gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();");
+ gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
gSystem->Run();
}
Bool_t isOK = kTRUE;
+ TString detStr = fLoadCDB;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+
if (fRecoParam.GetDetRecoParamArray(iDet)) {
AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
continue;
}
}
- fRecoParam.Print();
+ if (AliDebugLevel() > 0) fRecoParam.Print();
return isOK;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff