// //
///////////////////////////////////////////////////////////////////////////////
+#include <TArrayD.h>
#include <TArrayF.h>
+#include <TArrayS.h>
+#include <TChain.h>
#include <TFile.h>
-#include <TList.h>
-#include <TSystem.h>
-#include <TROOT.h>
-#include <TPluginManager.h>
+#include <TGeoGlobalMagField.h>
#include <TGeoManager.h>
+#include <TList.h>
#include <TLorentzVector.h>
-#include <TArrayS.h>
-#include <TArrayD.h>
-#include <TObjArray.h>
#include <TMap.h>
-#include <TChain.h>
+#include <TObjArray.h>
+#include <TPRegexp.h>
+#include <TParameter.h>
+#include <TPluginManager.h>
#include <TProof.h>
#include <TProofOutputFile.h>
-#include <TParameter.h>
+#include <TROOT.h>
+#include <TSystem.h>
+#include <THashTable.h>
+#include <TGrid.h>
+#include <TMessage.h>
-#include "AliReconstruction.h"
+#include "AliAlignObj.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliCTPRawStream.h"
+#include "AliCascadeVertexer.h"
+#include "AliCentralTrigger.h"
#include "AliCodeTimer.h"
-#include "AliReconstructor.h"
-#include "AliLog.h"
-#include "AliRunLoader.h"
-#include "AliRun.h"
-#include "AliRawReaderFile.h"
-#include "AliRawReaderDate.h"
-#include "AliRawReaderRoot.h"
-#include "AliRawEventHeaderBase.h"
-#include "AliRawEvent.h"
+#include "AliDAQ.h"
+#include "AliDetectorRecoParam.h"
+#include "AliESDCaloCells.h"
+#include "AliESDCaloCluster.h"
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
-#include "AliESDfriend.h"
+#include "AliESDPmdTrack.h"
+#include "AliESDTagCreator.h"
#include "AliESDVertex.h"
#include "AliESDcascade.h"
+#include "AliESDfriend.h"
#include "AliESDkink.h"
-#include "AliESDtrack.h"
-#include "AliESDCaloCluster.h"
-#include "AliESDCaloCells.h"
-#include "AliMultiplicity.h"
-#include "AliTracker.h"
-#include "AliVertexer.h"
-#include "AliVertexerTracks.h"
-#include "AliV0vertexer.h"
-#include "AliCascadeVertexer.h"
-#include "AliHeader.h"
-#include "AliGenEventHeader.h"
-#include "AliPID.h"
#include "AliESDpid.h"
#include "AliESDtrack.h"
-#include "AliESDPmdTrack.h"
-
-#include "AliESDTagCreator.h"
-
+#include "AliESDtrack.h"
+#include "AliEventInfo.h"
+#include "AliGRPObject.h"
+#include "AliGRPRecoParam.h"
+#include "AliGenEventHeader.h"
#include "AliGeomManager.h"
-#include "AliTrackPointArray.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliCDBEntry.h"
-#include "AliAlignObj.h"
-
-#include "AliCentralTrigger.h"
-#include "AliTriggerConfiguration.h"
-#include "AliTriggerClass.h"
-#include "AliTriggerCluster.h"
-#include "AliCTPRawStream.h"
-
-#include "AliQADataMakerRec.h"
#include "AliGlobalQADataMaker.h"
-#include "AliQA.h"
-#include "AliQADataMakerSteer.h"
-
+#include "AliHeader.h"
+#include "AliLog.h"
+#include "AliMagF.h"
+#include "AliMultiplicity.h"
+#include "AliPID.h"
#include "AliPlaneEff.h"
-
-#include "AliSysInfo.h" // memory snapshots
+#include "AliQAv1.h"
+#include "AliQADataMakerRec.h"
+#include "AliQAManager.h"
+#include "AliRawVEvent.h"
+#include "AliRawEventHeaderBase.h"
#include "AliRawHLTManager.h"
-
-#include "AliMagWrapCheb.h"
-
-#include "AliDetectorRecoParam.h"
-#include "AliGRPRecoParam.h"
+#include "AliRawReaderDate.h"
+#include "AliRawReaderFile.h"
+#include "AliRawReaderRoot.h"
+#include "AliReconstruction.h"
+#include "AliReconstructor.h"
+#include "AliRun.h"
#include "AliRunInfo.h"
-#include "AliEventInfo.h"
-
-#include "AliDAQ.h"
-
-#include "AliGRPObject.h"
+#include "AliRunLoader.h"
+#include "AliSysInfo.h" // memory snapshots
+#include "AliTrackPointArray.h"
+#include "AliTracker.h"
+#include "AliTriggerClass.h"
+#include "AliTriggerCluster.h"
+#include "AliTriggerIR.h"
+#include "AliTriggerConfiguration.h"
+#include "AliV0vertexer.h"
+#include "AliVertexer.h"
+#include "AliVertexerTracks.h"
+#include "AliTriggerRunScalers.h"
+#include "AliCTPTimeParams.h"
ClassImp(AliReconstruction)
//_____________________________________________________________________________
-const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
+const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const char* gAliceFilename) :
TSelector(),
- fUniformField(kFALSE),
- fForcedFieldMap(NULL),
fRunVertexFinder(kTRUE),
fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
fRawInput(""),
+ fESDOutput(""),
+ fProofOutputFileName(""),
+ fProofOutputLocation(""),
+ fProofOutputDataset(kFALSE),
+ fProofOutputArchive(""),
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
- fNumberOfEventsPerFile(1),
+ fNumberOfEventsPerFile((UInt_t)-1),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
- fESDPar(""),
fUseHLTData(),
fRunInfo(NULL),
fEventInfo(),
+ fRunScalers(NULL),
+ fCTPTimeParams(NULL),
fRunLoader(NULL),
fRawReader(NULL),
fRecoParam(),
- fVertexer(NULL),
+ fSPDTrackleter(NULL),
+
fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
+ fListOfCosmicTriggers(NULL),
fGRPData(NULL),
fAlignObjArray(NULL),
fCDBUri(),
+ fQARefUri(),
fSpecCDBUri(),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fQADetectors("ALL"),
- fQASteer(NULL),
fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
fSameQACycle(kFALSE),
-
+ fInitQACalled(kFALSE),
+ fWriteQAExpertData(kTRUE),
fRunPlaneEff(kFALSE),
fesd(NULL),
// create reconstruction object with default parameters
gGeoManager = NULL;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
fQACycles[iDet] = 999999 ;
fQAWriteExpert[iDet] = kFALSE ;
}
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
TSelector(),
- fUniformField(rec.fUniformField),
- fForcedFieldMap(NULL),
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
fRawInput(rec.fRawInput),
+ fESDOutput(rec.fESDOutput),
+ fProofOutputFileName(rec.fProofOutputFileName),
+ fProofOutputLocation(rec.fProofOutputLocation),
+ fProofOutputDataset(rec.fProofOutputDataset),
+ fProofOutputArchive(rec.fProofOutputArchive),
fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
- fESDPar(rec.fESDPar),
fUseHLTData(rec.fUseHLTData),
fRunInfo(NULL),
fEventInfo(),
+ fRunScalers(NULL),
+ fCTPTimeParams(NULL),
fRunLoader(NULL),
fRawReader(NULL),
fRecoParam(rec.fRecoParam),
- fVertexer(NULL),
+ fSPDTrackleter(NULL),
+
fDiamondProfileSPD(rec.fDiamondProfileSPD),
fDiamondProfile(rec.fDiamondProfile),
fDiamondProfileTPC(rec.fDiamondProfileTPC),
+ fListOfCosmicTriggers(NULL),
fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
+ fQARefUri(rec.fQARefUri),
fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
fQADetectors(rec.fQADetectors),
- fQASteer(NULL),
fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
fSameQACycle(rec.fSameQACycle),
+ fInitQACalled(rec.fInitQACalled),
+ fWriteQAExpertData(rec.fWriteQAExpertData),
fRunPlaneEff(rec.fRunPlaneEff),
fesd(NULL),
for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
}
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
fQACycles[iDet] = rec.fQACycles[iDet];
fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
// TSelector members should not be touched
if(&rec == this) return *this;
- fUniformField = rec.fUniformField;
- fForcedFieldMap = NULL;
fRunVertexFinder = rec.fRunVertexFinder;
fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
fRunHLTTracking = rec.fRunHLTTracking;
fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
fGAliceFileName = rec.fGAliceFileName;
fRawInput = rec.fRawInput;
+ fESDOutput = rec.fESDOutput;
+ fProofOutputFileName = rec.fProofOutputFileName;
+ fProofOutputLocation = rec.fProofOutputLocation;
+ fProofOutputDataset = rec.fProofOutputDataset;
+ fProofOutputArchive = rec.fProofOutputArchive;
fEquipIdMap = rec.fEquipIdMap;
fFirstEvent = rec.fFirstEvent;
fLastEvent = rec.fLastEvent;
fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
fLoadAlignData = rec.fLoadAlignData;
- fESDPar = rec.fESDPar;
fUseHLTData = rec.fUseHLTData;
delete fRunInfo; fRunInfo = NULL;
fEventInfo = rec.fEventInfo;
+ delete fRunScalers; fRunScalers = NULL;
+ if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
+
+ delete fCTPTimeParams; fCTPTimeParams = NULL;
+ if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
+
fRunLoader = NULL;
fRawReader = NULL;
fParentRawReader = NULL;
fRecoParam = rec.fRecoParam;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
delete fLoader[iDet]; fLoader[iDet] = NULL;
delete fTracker[iDet]; fTracker[iDet] = NULL;
}
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
fQACycles[iDet] = rec.fQACycles[iDet];
fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
+
+ delete fSPDTrackleter; fSPDTrackleter = NULL;
- fVertexer = NULL;
delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
delete fDiamondProfile; fDiamondProfile = NULL;
delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
+ delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
+ if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
+
delete fGRPData; fGRPData = NULL;
// if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
delete fAlignObjArray; fAlignObjArray = NULL;
fCDBUri = "";
+ fQARefUri = rec.fQARefUri;
fSpecCDBUri.Delete();
fInitCDBCalled = rec.fInitCDBCalled;
fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
fQADetectors = rec.fQADetectors;
- fQASteer = NULL;
fQATasks = rec.fQATasks;
fRunQA = rec.fRunQA;
fRunGlobalQA = rec.fRunGlobalQA;
fSameQACycle = rec.fSameQACycle;
+ fInitQACalled = rec.fInitQACalled;
+ fWriteQAExpertData = rec.fWriteQAExpertData;
fRunPlaneEff = rec.fRunPlaneEff;
fesd = NULL;
// clean up
CleanUp();
+ if (fListOfCosmicTriggers) {
+ fListOfCosmicTriggers->Delete();
+ delete fListOfCosmicTriggers;
+ }
delete fGRPData;
- delete fForcedFieldMap;
+ delete fRunScalers;
+ delete fCTPTimeParams;
fOptions.Delete();
if (fAlignObjArray) {
fAlignObjArray->Delete();
delete fAlignObjArray;
}
fSpecCDBUri.Delete();
- delete fQASteer;
+
AliCodeTimer::Instance()->Print();
}
+//_____________________________________________________________________________
+void AliReconstruction::InitQA()
+{
+ //Initialize the QA and start of cycle
+ AliCodeTimerAuto("",0);
+
+ if (fInitQACalled) return;
+ fInitQACalled = kTRUE;
+
+ AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
+ if (fWriteQAExpertData)
+ qam->SetWriteExpert() ;
+
+ if (qam->IsDefaultStorageSet()) {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default QA reference storage has been already set !");
+ AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ fQARefUri = qam->GetDefaultStorage()->GetURI();
+ } else {
+ if (fQARefUri.Length() > 0) {
+ AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ } else {
+ fQARefUri="local://$ALICE_ROOT/QAref";
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default QA refeference storage not yet set !!!!");
+ AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
+ qam->SetDefaultStorage(fQARefUri);
+ }
+
+ if (fRunQA) {
+ qam->SetActiveDetectors(fQADetectors) ;
+ for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
+ qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
+ qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
+ }
+ if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
+ qam->SetTasks(fQATasks) ;
+ qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
+ }
+ if (fRunGlobalQA) {
+ Bool_t sameCycle = kFALSE ;
+ AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
+ AliInfo(Form("Initializing the global QA data maker"));
+ if (IsInTasks(AliQAv1::kRECPOINTS)) {
+ qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
+ AliTracker::SetResidualsArray(arr);
+ sameCycle = kTRUE ;
+ }
+ if (IsInTasks(AliQAv1::kESDS)) {
+ qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ qadm->Init(AliQAv1::kESDS);
+ }
+ }
+ AliSysInfo::AddStamp("InitQA") ;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::MergeQA(const char *fileName)
+{
+ //Initialize the QA and start of cycle
+ AliCodeTimerAuto("",0) ;
+ AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
+ AliSysInfo::AddStamp("MergeQA") ;
+}
+
//_____________________________________________________________________________
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
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
if (fInitCDBCalled) return;
fInitCDBCalled = kTRUE;
AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- } else {
- fCDBUri="local://$ALICE_ROOT";
+ man->SetDefaultStorage(fCDBUri);
+ }
+ else if (!man->GetRaw()){
+ fCDBUri="local://$ALICE_ROOT/OCDB";
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
AliWarning("Default CDB storage not yet set !!!!");
AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-
+ man->SetDefaultStorage(fCDBUri);
+ }
+ else {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default storage will be set after setting the Run Number!!!");
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
- man->SetDefaultStorage(fCDBUri);
}
// Now activate the detector specific CDB storage locations
}
+//_____________________________________________________________________________
+void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
+ // Store the desired default CDB storage location
+ // Activate it later within the Run() method
+
+ fQARefUri = uri;
+ AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
+
+}
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
AliCDBPath aPath(calibType);
if(!aPath.IsValid()){
// if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!strcmp(calibType, fgkDetectorName[iDet])) {
aPath.SetPath(Form("%s/*", calibType));
AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
// // check that calibType refers to a "valid" detector name
// Bool_t isDetector = kFALSE;
-// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+// for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
// TString detName = fgkDetectorName[iDet];
// if(aPath.GetLevel0() == detName) {
// isDetector = kTRUE;
TString detStr = detectors;
TString loadAlObjsListOfDets = "";
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
if (input) fRawInput = input;
}
+//_____________________________________________________________________________
+void AliReconstruction::SetOutput(const char* output)
+{
+ // Set the output ESD filename
+ // 'output' is a normalt ROOT url
+ // The method is used in case of raw-data reco with PROOF
+ if (output) fESDOutput = output;
+}
+
//_____________________________________________________________________________
void AliReconstruction::SetOption(const char* detector, const char* option)
{
// First check if the reco-params are global
if(!strcmp(detector, "GRP")) {
par->SetAsDefault();
- fRecoParam.AddDetRecoParam(fgkNDetectors,par);
+ fRecoParam.AddDetRecoParam(kNDetectors,par);
return;
}
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!strcmp(detector, fgkDetectorName[iDet])) {
par->SetAsDefault();
fRecoParam.AddDetRecoParam(iDet,par);
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) {
- //------------------------------------------------
- // The magnetic field map, defined externally...
- // L3 current 30000 A -> 0.5 T
- // L3 current 12000 A -> 0.2 T
- // dipole current 6000 A
- // The polarities must be the same
- //------------------------------------------------
- const Float_t l3NominalCurrent1=30000.; // (A)
- const Float_t l3NominalCurrent2=12000.; // (A)
- const Float_t diNominalCurrent =6000. ; // (A)
-
- const Float_t tolerance=0.03; // relative current tolerance
- const Float_t zero=77.; // "zero" current (A)
-
- Int_t map=0;
- Bool_t dipoleON=kFALSE;
-
- TString s=(factor < 0) ? "L3: -" : "L3: +";
-
- l3Current = TMath::Abs(l3Current);
- if (TMath::Abs(l3Current-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
- map=AliMagWrapCheb::k5kG;
- s+="0.5 T; ";
- } else
- if (TMath::Abs(l3Current-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
- map=AliMagWrapCheb::k2kG;
- s+="0.2 T; ";
- } else
- if (l3Current < zero) {
- map=AliMagWrapCheb::k2kG;
- s+="0.0 T; ";
- factor=0.; // in fact, this is a global factor...
- fUniformField=kTRUE; // track with the uniform (zero) B field
- } else {
- AliError(Form("Wrong L3 current (%f A)!",l3Current));
- return kFALSE;
- }
-
- diCurrent = TMath::Abs(diCurrent);
- if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
- // 3% current tolerance...
- dipoleON=kTRUE;
- s+="Dipole ON";
- } else
- if (diCurrent < zero) { // some small current..
- dipoleON=kFALSE;
- s+="Dipole OFF";
- } else {
- AliError(Form("Wrong dipole current (%f A)!",diCurrent));
- return kFALSE;
- }
-
- delete fForcedFieldMap;
- fForcedFieldMap=
- new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path);
-
- fForcedFieldMap->Print();
-
- AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
-
- return kTRUE;
-}
-
-
Bool_t AliReconstruction::InitGRP() {
//------------------------------------
// Initialization of the GRP entry
entry->SetOwner(0);
}
- AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
+ // FIX ME: The unloading of GRP entry is temporarily disabled
+ // because ZDC and VZERO are using it in order to initialize
+ // their reconstructor objects. In the future one has to think
+ // of propagating AliRunInfo to the reconstructors.
+ // AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
}
if (!fGRPData) {
AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
beamEnergy = 0;
}
+ // LHC: "multiply by 120 to get the energy in MeV"
+ beamEnergy *= 0.120;
TString runType = fGRPData->GetRunType();
if (runType==AliGRPObject::GetInvalidString()) {
}
fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
-
fRunInfo->Dump();
fFillESD.Data(),
fQADetectors.Data());
fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
- if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
+ if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
+ !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
+ !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
// switch off the vertexer
- AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
+ AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer switched off.");
fRunVertexFinder = kFALSE;
}
if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
AliInfo("===================================================================================");
//*** Dealing with the magnetic field map
- if (AliTracker::GetFieldMap()) {
- AliInfo("Running with the externally set B field !");
- } else {
+ if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
+ if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
+ AliInfo("ExpertMode!!! GRP information will be ignored !");
+ AliInfo("ExpertMode!!! Running with the externally locked B field !");
+ }
+ else {
+ AliInfo("Destroying existing B field instance!");
+ delete TGeoGlobalMagField::Instance();
+ }
+ }
+ if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
// Construct the field map out of the information retrieved from GRP.
-
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;
}
- /*
- TObjString *l3Current=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
- if (!l3Current) {
- AliError("GRP/GRP/Data entry: missing value for the L3 current !");
- ok = kFALSE;
- }
- TObjString *l3Polarity=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
- if (!l3Polarity) {
- AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
- ok = kFALSE;
- }
-
- // Dipole
- TObjString *diCurrent=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
- if (!diCurrent) {
- AliError("GRP/GRP/Data entry: missing value for the dipole current !");
- ok = kFALSE;
- }
- TObjString *diPolarity=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
- if (!diPolarity) {
- AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
- ok = kFALSE;
- }
- */
+ // read special bits for the polarity convention and map type
+ Int_t polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
+ Bool_t uniformB = fGRPData->IsUniformBMap();
if (ok) {
- 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.;
-
-
- if (!SetFieldMap(l3Cur, diCur, factor)) {
- AliFatal("Failed to creat a B field map ! Exiting...");
+ AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
+ TMath::Abs(diCurrent) * (diPolarity ? -1:1),
+ polConvention,uniformB,beamEnergy, beamType.Data());
+ if (fld) {
+ TGeoGlobalMagField::Instance()->SetField( fld );
+ TGeoGlobalMagField::Instance()->Lock();
+ AliInfo("Running with the B field constructed out of GRP !");
}
- AliInfo("Running with the B field constructed out of GRP !");
+ else AliFatal("Failed to create a B field map !");
}
- else {
- AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
- }
-
+ else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
}
-
+
//*** Get the diamond profiles from OCDB
entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
if (entry) {
AliError("No TPC diamond profile found in OCDB!");
}
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
+ if (entry) {
+ fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
+ entry->SetOwner(0);
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
+ }
+
+ if (!fListOfCosmicTriggers) {
+ AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
+ }
+
return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliReconstruction::LoadCDB()
{
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliCDBManager::Instance()->Get("GRP/CTP/Config");
TString detStr = fLoadCDB;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
}
+
+ // Temporary fix - one has to define the correct policy in order
+ // to load the trigger OCDB entries only for the detectors that
+ // in the trigger or that are needed in order to put correct
+ // information in ESD
+ AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
+
return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::LoadTriggerScalersCDB()
+{
+ AliCodeTimerAuto("",0);
+
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
+ if (entry) {
+
+ AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
+ fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
+ entry->SetOwner(0);
+ if (fRunScalers->CorrectScalersOverflow() == 0) AliInfo("32bit Trigger counters corrected for overflow");
+
+ }
+ return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
+{
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
+
+ if (entry) {
+
+ AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
+ fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
+ entry->SetOwner(0);
+ return kTRUE;
+ }
+
+ return kFALSE;
+}
//_____________________________________________________________________________
Bool_t AliReconstruction::Run(const char* input)
{
// Run Run Run
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
InitRun(input);
if (GetAbort() != TSelector::kContinue) return kFALSE;
TChain *chain = NULL;
if (fRawReader && (chain = fRawReader->GetChain())) {
+ Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
// Proof mode
if (gProof) {
+ // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
+ gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
+
+ if (gGrid)
+ gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
+
+ TMessage::EnableSchemaEvolutionForAll(kTRUE);
+ gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
+
gProof->AddInput(this);
- TUrl outputFile;
- outputFile.SetProtocol("root",kTRUE);
- outputFile.SetHost(gSystem->HostName());
- outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
- AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl()));
- gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl()));
+
+ if (!ParseOutput()) return kFALSE;
+
+ gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
chain->SetProof();
- chain->Process("AliReconstruction");
+ chain->Process("AliReconstruction","",nEntries,fFirstEvent);
}
else {
- chain->Process(this);
+ chain->Process(this,"",nEntries,fFirstEvent);
}
}
else {
//_____________________________________________________________________________
void AliReconstruction::InitRawReader(const char* input)
{
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
// Init raw-reader and
// set the input in case of raw data
if (input) fRawInput = input;
fRawReader = AliRawReader::Create(fRawInput.Data());
- if (!fRawReader)
- AliInfo("Reconstruction will run over digits");
+ if (!fRawReader) {
+ if (fRawInput.IsNull()) {
+ AliInfo("Reconstruction will run over digits");
+ }
+ else {
+ AliFatal("Can not create raw-data reader ! Exiting...");
+ }
+ }
if (!fEquipIdMap.IsNull() && fRawReader)
fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
{
// Initialization of raw-reader,
// run number, CDB etc.
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliSysInfo::AddStamp("Start");
// Initialize raw-reader if any
// going into the event loop
// Should follow the TSelector convention
// i.e. initialize only the object on the client side
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliReconstruction *reco = NULL;
if (fInput) {
}
AliSysInfo::AddStamp("LoadCDB");
+ if (!LoadTriggerScalersCDB()) {
+ Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadTriggerScalersCDB");
+
+ if (!LoadCTPTimeParamsCDB()) {
+ Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
+
// Read the reconstruction parameters from OCDB
if (!InitRecoParams()) {
AliWarning("Not all detectors have correct RecoParam objects initialized");
}
AliSysInfo::AddStamp("InitRecoParams");
- if (fInput) {
+ if (fInput && gProof) {
if (reco) *reco = *this;
- fInput->Add(gGeoManager);
+
+ gGeoManager->SetName("Geometry");
+ gProof->AddInputData(gGeoManager,kTRUE);
gGeoManager = NULL;
- fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
+ gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
- AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap();
+ AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
magFieldMap->SetName("MagneticFieldMap");
- fInput->Add(magFieldMap);
+ gProof->AddInputData(magFieldMap,kTRUE);
}
}
// Initialization related to run-loader,
// vertexer, trackers, recontructors
// In proof mode it is executed on the slave
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
TProofOutputFile *outProofFile = NULL;
- if (fInput) {
+ if (fInput) {
+ if (AliDebugLevel() > 0) fInput->Print();
+ if (AliDebugLevel() > 10) fInput->Dump();
if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
*this = *reco;
}
}
}
if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
- AliTracker::SetFieldMap(map,fUniformField);
- }
- if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
- outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
- outProofFile->SetOutputFileName(outputFileName->GetTitle());
+ AliMagF *newMap = new AliMagF(*map);
+ if (!newMap->LoadParameterization()) {
+ Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
+ return;
+ }
+ TGeoGlobalMagField::Instance()->SetField(newMap);
+ TGeoGlobalMagField::Instance()->Lock();
+ }
+ if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
+ fProofOutputFileName = outputFileName->GetTitle();
+ if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
+ fProofOutputLocation = outputLocation->GetTitle();
+ if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
+ fProofOutputDataset = kTRUE;
+ if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
+ fProofOutputArchive = archiveList->GetTitle();
+ if (!fProofOutputFileName.IsNull() &&
+ !fProofOutputLocation.IsNull() &&
+ fProofOutputArchive.IsNull()) {
+ if (!fProofOutputDataset) {
+ outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
+ outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
+ }
+ else {
+ outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
+ }
+ if (AliDebugLevel() > 0) outProofFile->Dump();
fOutput->Add(outProofFile);
}
AliSysInfo::AddStamp("ReadInputInSlaveBegin");
ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
- // get vertexer
- if (fRunVertexFinder && !CreateVertexer()) {
- Abort("CreateVertexer", TSelector::kAbortProcess);
- return;
- }
- AliSysInfo::AddStamp("CreateVertexer");
-
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
Abort("CreateTrackers", TSelector::kAbortProcess);
}
}
else {
+ AliInfo(Form("Opening output PROOF file: %s/%s",
+ outProofFile->GetDir(), outProofFile->GetFileName()));
if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
Abort(Form("Problems opening output PROOF file: %s/%s",
outProofFile->GetDir(), outProofFile->GetFileName()),
ftree = new TTree("esdTree", "Tree with ESD objects");
fesd = new AliESDEvent();
fesd->CreateStdContent();
+
+ fesd->WriteToTree(ftree);
if (fWriteESDfriend) {
+ // careful:
+ // Since we add the branch manually we must
+ // book and add it after WriteToTree
+ // otherwise it is created twice,
+ // once via writetotree and once here.
+ // The case for AliESDfriend is now
+ // caught also in AlIESDEvent::WriteToTree but
+ // be careful when changing the name (AliESDfriend is not
+ // a TNamed so we had to hardwire it)
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->WriteToTree(fhlttree);
fhlttree->GetUserInfo()->Add(fhltesd);
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ ProcInfo_t procInfo;
+ gSystem->GetProcInfo(&procInfo);
+ AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
//QA
//Initialize the QA and start of cycle
- if (fRunQA) {
- 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) {
- 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))) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
- TObjArray *arr=qadm->Init(AliQA::kRECPOINTS);
- AliTracker::SetResidualsArray(arr);
- sameCycle = kTRUE ;
- }
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
- qadm->Init(AliQA::kESDS);
- }
- }
+ if (fRunQA || fRunGlobalQA)
+ InitQA() ;
//Initialize the Plane Efficiency framework
if (fRunPlaneEff && !InitPlaneEff()) {
{
// run the reconstruction over a single entry
// from the chain with raw data
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
TTree *currTree = fChain->GetTree();
- AliRawEvent *event = new AliRawEvent;
+ AliRawVEvent *event = NULL;
currTree->SetBranchAddress("rawevent",&event);
currTree->GetEntry(entry);
fRawReader = new AliRawReaderRoot(event);
// run the reconstruction over a single event
// The event loop is steered in Run method
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
if (iEvent >= fRunLoader->GetNumberOfEvents()) {
fRunLoader->SetEventNumber(iEvent);
AliInfo(Form("processing event %d", iEvent));
+ fRunLoader->GetEvent(iEvent);
+
// Fill Event-info object
GetEventInfo();
- fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
+ fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
// Set the reco-params
{
TString detStr = fLoadCDB;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; 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);
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ reconstructor->SetRecoParam(par);
+ reconstructor->SetEventInfo(&fEventInfo);
+ if (fRunQA) {
+ AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
+ AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
+ }
}
}
}
- fRunLoader->GetEvent(iEvent);
-
// QA on single raw
- if (fRunQA)
- fQASteer->RunOneEvent(fRawReader) ;
-
+ if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
+ }
// local single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
TString detectors=fRunLocalReconstruction;
// Set magnetic field from the tracker
fesd->SetMagneticField(AliTracker::GetBz());
fhltesd->SetMagneticField(AliTracker::GetBz());
-
+ //
+ AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
+ if (fld) { // set info needed for field initialization
+ fesd->SetCurrentL3(fld->GetCurrentSol());
+ fesd->SetCurrentDip(fld->GetCurrentDip());
+ fesd->SetBeamEnergy(fld->GetBeamEnergy());
+ fesd->SetBeamType(fld->GetBeamTypeText());
+ fesd->SetUniformBMap(fld->IsUniform());
+ fesd->SetBInfoStored();
+ //
+ fhltesd->SetCurrentL3(fld->GetCurrentSol());
+ fhltesd->SetCurrentDip(fld->GetCurrentDip());
+ fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
+ fhltesd->SetBeamType(fld->GetBeamTypeText());
+ fhltesd->SetUniformBMap(fld->IsUniform());
+ fhltesd->SetBInfoStored();
+ }
+ //
// Set most probable pt, for B=0 tracking
// 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));
+ const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
// Fill raw-data error log into the ESD
}
}
+ // For Plane Efficiency: run the SPD trackleter
+ if (fRunPlaneEff && fSPDTrackleter) {
+ if (!RunSPDTrackleting(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+ }
+
// Muon tracking
if (!fRunTracking.IsNull()) {
if (fRunMuonTracking) {
// Temporary fix to avoid problems with HLT that overwrites the offline ESDs
if (detectors.Contains("ALL")) {
detectors="";
- for (Int_t idet=0; idet<fgkNDetectors; ++idet){
+ for (Int_t idet=0; idet<kNDetectors; ++idet){
detectors += fgkDetectorName[idet];
detectors += " ";
}
// fill Event header information from the RawEventHeader
if (fRawReader){FillRawEventHeaderESD(fesd);}
+ if (fRawReader){FillRawEventHeaderESD(fhltesd);}
// combined PID
AliESDpid::MakePID(fesd);
if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
+ // Always fill scalers
+ if (!FillTriggerScalers(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+
ffile->cd();
// Propagate track to the beam pipe (if not already done by ITS)
//
const Int_t ntracks = fesd->GetNumberOfTracks();
- const Double_t kBz = fesd->GetMagneticField();
const Double_t kRadius = 2.8; //something less than the beam pipe radius
TObjArray trkArray;
UShort_t *selectedIdx=new UShort_t[ntracks];
for (Int_t itrack=0; itrack<ntracks; itrack++){
- const Double_t kMaxStep = 5; //max step over the material
+ const Double_t kMaxStep = 1; //max step over the material
Bool_t ok;
AliESDtrack *track = fesd->GetTrack(itrack);
ok = kFALSE;
if (tpcTrack)
ok = AliTracker::
- PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
+ PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
if (ok) {
Int_t n=trkArray.GetEntriesFast();
if (track->IsOn(AliESDtrack::kITSrefit)) continue;
AliTracker::
- PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
- track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
+ PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
+ Double_t x[3]; track->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
}
fesd->SetPrimaryVertexTracks(pvtx);
for (Int_t i=0; i<ntracks; i++) {
AliESDtrack *t = fesd->GetTrack(i);
- t->RelateToVertex(pvtx, kBz, kVeryBig);
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
}
}
+ delete pvtx; pvtx=NULL;
}
// TPC-only primary vertex
fesd->SetPrimaryVertexTPC(pvtx);
for (Int_t i=0; i<ntracks; i++) {
AliESDtrack *t = fesd->GetTrack(i);
- t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
}
}
+ delete pvtx; pvtx=NULL;
}
}
// write ESD
if (fCleanESD) CleanESD(fesd);
- if (fRunQA)
- fQASteer->RunOneEvent(fesd) ;
-
+ if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEvent(fesd) ;
+ }
if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->Exec(AliQA::kESDS, fesd);
- }
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ if (qadm && IsInTasks(AliQAv1::kESDS))
+ qadm->Exec(AliQAv1::kESDS, fesd);
+ }
if (fWriteESDfriend) {
// fesdf->~AliESDfriend();
new (fesdf) AliESDfriend(); // Reset...
}
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ ProcInfo_t procInfo;
+ gSystem->GetProcInfo(&procInfo);
+ AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
fEventInfo.Reset();
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (fReconstructor[iDet])
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (fReconstructor[iDet]) {
fReconstructor[iDet]->SetRecoParam(NULL);
+ fReconstructor[iDet]->SetEventInfo(NULL);
+ }
+ if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
}
if (fRunQA || fRunGlobalQA)
- fQASteer->Increment() ;
+ AliQAManager::QAManager()->Increment() ;
return kTRUE;
}
// Finalize the run on the slave side
// Called after the exit
// from the event loop
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
if (fIsNewRunLoader) { // galice.root didn't exist
fRunLoader->WriteHeader("OVERWRITE");
ftree->GetUserInfo()->Add(cdbListCopy);
- if(fESDPar.Contains("ESD.par")){
- AliInfo("Attaching ESD.par to Tree");
- TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
- ftree->GetUserInfo()->Add(fn);
- }
-
-
ffile->cd();
if (fWriteESDfriend)
ftree->SetBranchStatus("ESDfriend*",0);
// we want to have only one tree version number
ftree->Write(ftree->GetName(),TObject::kOverwrite);
- fhlttree->Write();
+ fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
// Finish with Plane Efficiency evaluation: before of CleanUp !!!
if (fRunPlaneEff && !FinishPlaneEff()) {
}
// End of cycle for the in-loop
- if (fRunQA) {
- fQASteer->EndOfCycle() ;
- }
+ if (fRunQA)
+ AliQAManager::QAManager()->EndOfCycle() ;
+
if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::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);
+ if (IsInTasks(AliQAv1::kRECPOINTS))
+ qadm->EndOfCycle(AliQAv1::kRECPOINTS);
+ if (IsInTasks(AliQAv1::kESDS))
+ qadm->EndOfCycle(AliQAv1::kESDS);
qadm->Finish();
}
}
+
+ if (fRunQA || fRunGlobalQA) {
+ if (fInput &&
+ !fProofOutputLocation.IsNull() &&
+ fProofOutputArchive.IsNull() &&
+ !fProofOutputDataset) {
+ TString qaOutputFile(Form("%sMerged.%s.Data.root",
+ fProofOutputLocation.Data(),
+ AliQAv1::GetQADataFileName()));
+ TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
+ AliQAv1::GetQADataFileName()));
+ qaProofFile->SetOutputFileName(qaOutputFile.Data());
+ if (AliDebugLevel() > 0) qaProofFile->Dump();
+ fOutput->Add(qaProofFile);
+ MergeQA(qaProofFile->GetFileName());
+ }
+ else {
+ MergeQA();
+ }
+ }
+
gROOT->cd();
CleanUp();
+
+ if (fInput) {
+ if (!fProofOutputFileName.IsNull() &&
+ !fProofOutputLocation.IsNull() &&
+ fProofOutputDataset &&
+ !fProofOutputArchive.IsNull()) {
+ TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
+ "DROV",
+ fProofOutputLocation.Data());
+ if (AliDebugLevel() > 0) zipProofFile->Dump();
+ fOutput->Add(zipProofFile);
+ TString fileList(fProofOutputArchive.Data());
+ fileList.ReplaceAll(","," ");
+ TString command;
+#if ROOT_SVN_REVISION >= 30174
+ command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
+#else
+ command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
+#endif
+ AliInfo(Form("Executing: %s",command.Data()));
+ gSystem->Exec(command.Data());
+ }
+ }
}
//_____________________________________________________________________________
{
// 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
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
- AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
- esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
+ // Do not call the ESD tag creator in case of PROOF-based reconstruction
+ if (!fInput) {
+ AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
+ delete esdtagCreator;
+ }
// Cleanup of CDB manager: cache and active storages!
AliCDBManager::Instance()->ClearCache();
// run the local reconstruction
static Int_t eventNr=0;
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
// although the HLT loader is missing
if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
if (fRawReader) {
- reconstructor->Reconstruct(fRawReader, NULL);
+ reconstructor->Reconstruct(fRawReader, NULL);
} else {
- TTree* dummy=NULL;
- reconstructor->Reconstruct(dummy, NULL);
+ TTree* dummy=NULL;
+ reconstructor->Reconstruct(dummy, NULL);
}
continue;
}
AliInfo(Form("converting raw data digits into root objects for %s",
fgkDetectorName[iDet]));
// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
-// fgkDetectorName[iDet]));
+// fgkDetectorName[iDet]),0);
loader->LoadDigits("update");
loader->CleanDigits();
loader->MakeDigitsContainer();
}
// local reconstruction
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
loader->LoadRecPoints("update");
loader->CleanRecPoints();
loader->MakeRecPointsContainer();
loader->LoadDigits("read");
TTree* digitsTree = loader->TreeD();
if (!digitsTree) {
- AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
- if (fStopOnError) return kFALSE;
+ AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
+ if (fStopOnError) return kFALSE;
} else {
- reconstructor->Reconstruct(digitsTree, clustersTree);
+ reconstructor->Reconstruct(digitsTree, clustersTree);
+ if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
+ }
}
loader->UnloadDigits();
}
-
- TString detQAStr(fQADetectors) ;
- if (fRunQA)
- fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
-
- loader->WriteRecPoints("OVERWRITE");
- loader->UnloadRecPoints();
- AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
+ if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->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()) {
AliError(Form("the following detectors were not found: %s",
eventNr++;
return kTRUE;
}
-
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
+Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
{
-// run the barrel tracking
+// run the SPD trackleting (for SPD efficiency purpouses)
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
- AliESDVertex* vertex = NULL;
Double_t vtxPos[3] = {0, 0, 0};
- Double_t vtxErr[3] = {0.07, 0.07, 0.1};
- TArrayF mcVertex(3);
+ Double_t vtxErr[3] = {0.0, 0.0, 0.0};
+/*
+ TArrayF mcVertex(3);
+ // if(MC)
if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
}
+*/
+ const AliESDVertex *vertex = esd->GetVertex();
+ if(!vertex){
+ AliWarning("Vertex not found");
+ return kFALSE;
+ }
+ vertex->GetXYZ(vtxPos);
+ vertex->GetSigmaXYZ(vtxErr);
+ if (fSPDTrackleter) {
+ AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
- if (fVertexer) {
- AliInfo("running the ITS vertex finder");
- if (fLoader[0]) {
- fLoader[0]->LoadRecPoints();
- TTree* cltree = fLoader[0]->TreeR();
- if (cltree) {
- if(fDiamondProfileSPD) fVertexer->SetVtxStart(fDiamondProfileSPD);
- vertex = fVertexer->FindVertexForCurrentEvent(cltree);
- }
- else {
- AliError("Can't get the ITS cluster tree");
- }
- fLoader[0]->UnloadRecPoints();
+ // load clusters
+ fLoader[0]->LoadRecPoints("read");
+ TTree* tree = fLoader[0]->TreeR();
+ if (!tree) {
+ AliError("Can't get the ITS cluster tree");
+ return kFALSE;
}
- else {
- AliError("Can't get the ITS loader");
+ fSPDTrackleter->LoadClusters(tree);
+ fSPDTrackleter->SetVertex(vtxPos, vtxErr);
+ // run trackleting
+ if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
+ AliError("AliITSTrackleterSPDEff Clusters2Tracks failed");
+ // fLoader[0]->UnloadRecPoints();
+ return kFALSE;
}
- if(!vertex){
- AliWarning("Vertex not found");
- vertex = new AliESDVertex();
- vertex->SetName("default");
+//fSPDTrackleter->UnloadRecPoints();
+ } else {
+ AliWarning("SPDTrackleter not available");
+ return kFALSE;
+ }
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
+{
+// run the barrel tracking
+
+ AliCodeTimerAuto("",0)
+
+ AliVertexer *vertexer = CreateVertexer();
+ if (!vertexer) return kFALSE;
+
+ AliInfo("running the ITS vertex finder");
+ AliESDVertex* vertex = NULL;
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
+ vertex = vertexer->FindVertexForCurrentEvent(cltree);
}
else {
- vertex->SetName("reconstructed");
+ AliError("Can't get the ITS cluster tree");
}
-
- } else {
- AliInfo("getting the primary vertex from MC");
- vertex = new AliESDVertex(vtxPos, vtxErr);
+ fLoader[0]->UnloadRecPoints();
}
-
- if (vertex) {
- vertex->GetXYZ(vtxPos);
- vertex->GetSigmaXYZ(vtxErr);
- } else {
- AliWarning("no vertex reconstructed");
- vertex = new AliESDVertex(vtxPos, vtxErr);
+ else {
+ AliError("Can't get the ITS loader");
}
+ if(!vertex){
+ AliWarning("Vertex not found");
+ vertex = new AliESDVertex();
+ vertex->SetName("default");
+ }
+ else {
+ vertex->SetName("reconstructed");
+ }
+
+ Double_t vtxPos[3];
+ Double_t vtxErr[3];
+ vertex->GetXYZ(vtxPos);
+ vertex->GetSigmaXYZ(vtxErr);
+
esd->SetPrimaryVertexSPD(vertex);
+ AliESDVertex *vpileup = NULL;
+ Int_t novertices = 0;
+ vpileup = vertexer->GetAllVertices(novertices);
+ if(novertices>1){
+ for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
+ }
// if SPD multiplicity has been determined, it is stored in the ESD
- AliMultiplicity *mult = fVertexer->GetMultiplicity();
+ AliMultiplicity *mult = vertexer->GetMultiplicity();
if(mult)esd->SetMultiplicity(mult);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
}
delete vertex;
+ delete vertexer;
+
return kTRUE;
}
{
// run the HLT barrel tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
if (!fRunLoader) {
AliError("Missing runLoader!");
AliInfo("running HLT tracking");
// Get a pointer to the HLT reconstructor
- AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
+ AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
if (!reconstructor) return kFALSE;
// TPC + ITS
{
// run the muon spectrometer tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
if (!fRunLoader) {
AliError("Missing runLoader!");
Int_t rv = tracker->Clusters2Tracks(esd);
- if ( rv )
- {
- AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
- return kFALSE;
- }
-
fLoader[iDet]->UnloadRecPoints();
tracker->UnloadClusters();
delete tracker;
+ if ( rv )
+ {
+ AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
+ return kFALSE;
+ }
+
return kTRUE;
}
{
// run the barrel tracking
static Int_t eventNr=0;
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliInfo("running tracking");
+ // Set the event info which is used
+ // by the trackers in order to obtain
+ // information about read-out detectors,
+ // trigger etc.
+ AliDebug(1, "Setting event info");
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (!fTracker[iDet]) continue;
+ fTracker[iDet]->SetEventInfo(&fEventInfo);
+ }
+
//Fill the ESD with the T0 info (will be used by the TOF)
if (fReconstructor[11] && fLoader[11]) {
fLoader[11]->LoadRecPoints("READ");
// pass 2: ALL backwards
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
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;
+ AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
+ return kFALSE;
}
fTracker[iDet]->LoadClusters(tree);
AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
// run tracking
if (iDet>1) // start filling residuals for the "outer" detectors
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
-
+ if (fRunGlobalQA) {
+ AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
+ TObjArray ** arr = AliTracker::GetResidualsArray() ;
+ if (arr) {
+ AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
+ TObjArray * elem = arr[AliRecoParam::AConvert(es)];
+ if ( elem && (! elem->At(0)) ) {
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ if (qadm) qadm->InitRecPointsForTracker() ;
+ }
+ }
+ }
if (fTracker[iDet]->PropagateBack(esd) != 0) {
AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
// return kFALSE;
AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
}
//stop filling residuals for the "outer" detectors
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
// pass 3: TRD + TPC + ITS refit inwards
// run tracking
if (iDet<2) // start filling residuals for TPC and ITS
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
-
+ if (fRunGlobalQA) {
+ AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
+ TObjArray ** arr = AliTracker::GetResidualsArray() ;
+ if (arr) {
+ AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
+ TObjArray * elem = arr[AliRecoParam::AConvert(es)];
+ if ( elem && (! elem->At(0)) ) {
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ if (qadm) qadm->InitRecPointsForTracker() ;
+ }
+ }
+ }
+
if (fTracker[iDet]->RefitInward(esd) != 0) {
AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
// return kFALSE;
AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
}
// stop filling residuals for TPC and ITS
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
eventNr++;
return kTRUE;
{
// fill the event summary data
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
static Int_t eventNr=0;
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
// stored in Trigger.root file and fills
// the corresponding esd entries
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliInfo("Filling trigger information into the ESD");
if (esd->GetBunchCrossNumber() != input.GetBCID())
AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
input.GetBCID(),esd->GetBunchCrossNumber()));
+ AliESDHeader* esdheader = esd->GetHeader();
+ esdheader->SetL0TriggerInputs(input.GetL0Inputs());
+ esdheader->SetL1TriggerInputs(input.GetL1Inputs());
+ esdheader->SetL2TriggerInputs(input.GetL2Inputs());
+ // IR
+ UInt_t orbit=input.GetOrbitID();
+ for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
+ if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
+ esdheader->AddTriggerIR(input.GetIR(i));
+ }
}
-
- // Here one has to add the filling of trigger inputs and
- // interaction records
- // ...
}
return kTRUE;
}
-
-
-
-
-
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
+{
+ //Scalers
+ //fRunScalers->Print();
+ if(fRunScalers && fRunScalers->CheckRunScalers()){
+ AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
+ //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
+ AliESDHeader* esdheader = fesd->GetHeader();
+ for(Int_t i=0;i<50;i++){
+ if((1ull<<i) & esd->GetTriggerMask()){
+ AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
+ if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
+ }
+ }
+ }
+ return kTRUE;
+}
//_____________________________________________________________________________
Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
{
if (gAlice) delete gAlice;
gAlice = NULL;
- if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+ TFile *gafile = TFile::Open(fGAliceFileName.Data());
+ // if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+ if (gafile) { // galice.root exists
+ gafile->Close();
+ delete gafile;
+
// load all base libraries to get the loader classes
TString libs = gSystem->GetLibraries();
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
TString detName = fgkDetectorName[iDet];
if (detName == "HLT") continue;
if (libs.Contains("lib" + detName + "base.so")) continue;
if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
fReconstructor[iDet]->SetRecoParam(par);
+ fReconstructor[iDet]->SetRunInfo(fRunInfo);
}
return fReconstructor[iDet];
}
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
+ reconstructor->SetRunInfo(fRunInfo);
reconstructor->Init();
fReconstructor[iDet] = reconstructor;
}
if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
reconstructor->SetRecoParam(par);
+ reconstructor->SetRunInfo(fRunInfo);
}
return reconstructor;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::CreateVertexer()
+AliVertexer* AliReconstruction::CreateVertexer()
{
// create the vertexer
+// Please note that the caller is the owner of the
+// vertexer
- fVertexer = NULL;
+ AliVertexer* vertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
- if (itsReconstructor) {
- fVertexer = itsReconstructor->CreateVertexer();
+ if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || fRunTracking.Contains("ITS"))) {
+ vertexer = itsReconstructor->CreateVertexer();
}
- if (!fVertexer) {
+ if (!vertexer) {
AliWarning("couldn't create a vertexer for ITS");
- if (fStopOnError) return kFALSE;
}
- return kTRUE;
+ return vertexer;
}
//_____________________________________________________________________________
AliInfo("Creating trackers");
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
{
// delete trackers and the run loader and close and delete the file
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
delete fReconstructor[iDet];
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
delete fRunInfo;
fRunInfo = NULL;
- delete fVertexer;
- fVertexer = NULL;
+ delete fSPDTrackleter;
+ fSPDTrackleter = NULL;
delete ftVertexer;
ftVertexer = NULL;
- if(!(AliCDBManager::Instance()->GetCacheFlag())) {
- delete fDiamondProfileSPD;
- fDiamondProfileSPD = NULL;
- delete fDiamondProfile;
- fDiamondProfile = NULL;
- delete fDiamondProfileTPC;
- fDiamondProfileTPC = NULL;
- }
delete fRunLoader;
fRunLoader = NULL;
delete fRawReader;
delete ffile;
ffile = NULL;
}
+
+ if (AliQAManager::QAManager())
+ AliQAManager::QAManager()->ShowQA() ;
+ AliQAManager::Destroy() ;
+
}
void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
AliESDtrack *track = esd->GetTrack(itrack);
Int_t nsp = 0;
Int_t idx[200];
+ for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
nsp += track->GetNcls(iDet);
}
isp2++;
if (!isvalid) continue;
+ if (iDet==0 && (isp-1)>=6) p.SetExtra();
sp->AddPoint(isptrack,&p); isptrack++;
}
}
}
-TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
- // Dump a file content into a char in TNamed
- ifstream in;
- in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
- Int_t kBytes = (Int_t)in.tellg();
- printf("Size: %d \n",kBytes);
- TNamed *fn = 0;
- if(in.good()){
- char* memblock = new char [kBytes];
- in.seekg (0, ios::beg);
- in.read (memblock, kBytes);
- in.close();
- TString fData(memblock,kBytes);
- fn = new TNamed(pName,fData);
- printf("fData Size: %d \n",fData.Sizeof());
- printf("pName Size: %d \n",pName.Sizeof());
- printf("fn Size: %d \n",fn->Sizeof());
- delete[] memblock;
- }
- else{
- AliInfo(Form("Could not Open %s\n",fPath.Data()));
- }
-
- return fn;
-}
-
-void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
- // This is not really needed in AliReconstruction at the moment
- // but can serve as a template
-
- TList *fList = fTree->GetUserInfo();
- TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
- printf("fn Size: %d \n",fn->Sizeof());
-
- TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
- const char* cdata = fn->GetTitle();
- printf("fTmp Size %d\n",fTmp.Sizeof());
-
- int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
- printf("calculated size %d\n",size);
- ofstream out(pName.Data(),ios::out | ios::binary);
- out.write(cdata,size);
- out.close();
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::CheckQA()
{
// check the QA of SIM for this run and remove the detectors
// with status Fatal
- TString newRunLocalReconstruction ;
- TString newRunTracking ;
- TString newFillESD ;
-
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
- TString detName(AliQA::GetDetName(iDet)) ;
- AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
- if ( qa->IsSet(AliQA::DETECTORINDEX_t(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 ( 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 = newRunLocalReconstruction ;
- fRunTracking = newRunTracking ;
- fFillESD = newFillESD ;
+// TString newRunLocalReconstruction ;
+// TString newRunTracking ;
+// TString newFillESD ;
+//
+// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
+// TString detName(AliQAv1::GetDetName(iDet)) ;
+// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
+// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
+// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
+// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
+// } else {
+// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
+// fRunLocalReconstruction.Contains("ALL") ) {
+// newRunLocalReconstruction += detName ;
+// newRunLocalReconstruction += " " ;
+// }
+// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
+// fRunTracking.Contains("ALL") ) {
+// newRunTracking += detName ;
+// newRunTracking += " " ;
+// }
+// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
+// fFillESD.Contains("ALL") ) {
+// newFillESD += detName ;
+// newFillESD += " " ;
+// }
+// }
+// }
+// fRunLocalReconstruction = newRunLocalReconstruction ;
+// fRunTracking = newRunTracking ;
+// fFillESD = newFillESD ;
}
//_____________________________________________________________________________
{
// return the detector index corresponding to detector
Int_t index = -1 ;
- for (index = 0; index < fgkNDetectors ; index++) {
+ for (index = 0; index < kNDetectors ; index++) {
if ( strcmp(detector, fgkDetectorName[index]) == 0 )
break ;
}
//for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
//if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- if(fTracker[iDet]) {
+ if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
TString name=planeeff->GetName();
name+=".root";
ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
}
}
+ if(fSPDTrackleter) {
+ AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
+ TString name="AliITSPlaneEffSPDtracklet.root";
+ TFile* pefile = TFile::Open(name, "RECREATE");
+ ret=(Bool_t)planeeff->Write();
+ pefile->Close();
+ AliESDEvent *dummy=NULL;
+ ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
+ }
}
return ret;
}
//
// Here execute all the necessary operations, before of the tracking phase,
// for the evaluation of PlaneEfficiencies, in case required for some detectors.
- // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
+ // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
// which should be updated/recalculated.
//
// This Preliminary version will work only FOR ITS !!!!!
// Input: none
// Return: kTRUE if all operations have been done properly, kFALSE otherwise
//
- AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
+ AliWarning(Form("Implementation of this method not yet completed !! Method return kTRUE"));
+
+ fSPDTrackleter = NULL;
+ AliReconstructor* itsReconstructor = GetReconstructor(0);
+ if (itsReconstructor) {
+ fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
+ }
+ if (fSPDTrackleter) {
+ AliInfo("Trackleter for SPD has been created");
+ }
+
return kTRUE;
}
// successful initialization of AliEVE.
AliInfo("Running AliEVE...");
- gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
+ gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
gSystem->Run();
}
Bool_t AliReconstruction::SetRunQA(TString detAndAction)
{
// Allows to run QA for a selected set of detectors
- // and a selected set of tasks among RAWS, RECPOINTS and ESDS
+ // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
// all selected detectors run the same selected tasks
if (!detAndAction.Contains(":")) {
}
Int_t colon = detAndAction.Index(":") ;
fQADetectors = detAndAction(0, colon) ;
- if (fQADetectors.Contains("ALL") )
- fQADetectors = fFillESD ;
- fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
+ if (fQADetectors.Contains("ALL") ){
+ TString tmp = fFillESD ;
+ Int_t minus = fQADetectors.Last('-') ;
+ TString toKeep = fFillESD ;
+ TString toRemove("") ;
+ while (minus >= 0) {
+ toRemove = fQADetectors(minus+1, fQADetectors.Length()) ;
+ toRemove = toRemove.Strip() ;
+ toKeep.ReplaceAll(toRemove, "") ;
+ fQADetectors.ReplaceAll(Form("-%s", toRemove.Data()), "") ;
+ minus = fQADetectors.Last('-') ;
+ }
+ fQADetectors = toKeep ;
+ }
+ fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
if (fQATasks.Contains("ALL") ) {
- fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
+ fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
} else {
fQATasks.ToUpper() ;
TString tempo("") ;
if ( fQATasks.Contains("RAW") )
- tempo = Form("%d ", AliQA::kRAWS) ;
+ tempo = Form("%d ", AliQAv1::kRAWS) ;
+ if ( fQATasks.Contains("DIGIT") )
+ tempo += Form("%d ", AliQAv1::kDIGITSR) ;
if ( fQATasks.Contains("RECPOINT") )
- tempo += Form("%d ", AliQA::kRECPOINTS) ;
+ tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
if ( fQATasks.Contains("ESD") )
- tempo += Form("%d ", AliQA::kESDS) ;
+ tempo += Form("%d ", AliQAv1::kESDS) ;
fQATasks = tempo ;
if (fQATasks.IsNull()) {
AliInfo("No QA requested\n") ;
}
}
TString tempo(fQATasks) ;
- tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ;
- tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
- tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
fRunQA = kTRUE ;
return kTRUE;
Bool_t isOK = kTRUE;
+ if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
+ AliInfo("Using custom GRP reconstruction parameters");
+ }
+ else {
+ AliInfo("Loading GRP reconstruction parameter objects");
+
+ AliCDBPath path("GRP","Calib","RecoParam");
+ AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
+ if(!entry){
+ AliWarning("Couldn't find GRP RecoParam entry in OCDB");
+ isOK = kFALSE;
+ }
+ else {
+ TObject *recoParamObj = entry->GetObject();
+ if (dynamic_cast<TObjArray*>(recoParamObj)) {
+ // GRP has a normal TobjArray of AliDetectorRecoParam objects
+ // Registering them in AliRecoParam
+ fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
+ }
+ else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
+ // GRP has only onse set of reco parameters
+ // Registering it in AliRecoParam
+ AliInfo("Single set of GRP reconstruction parameters found");
+ dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
+ fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
+ }
+ else {
+ AliError("No valid GRP RecoParam object found in the OCDB");
+ isOK = kFALSE;
+ }
+ entry->SetOwner(0);
+ }
+ }
+
TString detStr = fLoadCDB;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
isOK = kFALSE;
}
entry->SetOwner(0);
- AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
+ // FIX ME: We have to disable the unloading of reco-param CDB
+ // entries because QA framework is using them. Has to be fix in
+ // a way that the QA takes the objects already constructed in
+ // this method.
+ // AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
}
}
{
// Fill the event info object
// ...
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliCentralTrigger *aCTP = NULL;
if (fRawReader) {
if (fRunLoader && (!fRunLoader->LoadTrigger())) {
aCTP = fRunLoader->GetTrigger();
fEventInfo.SetTriggerMask(aCTP->GetClassMask());
+ // get inputs from actp - just get
+ AliESDHeader* esdheader = fesd->GetHeader();
+ esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
+ esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
+ esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
}
else {
Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
fesd->SetTriggerClass(trclass->GetName(),trindex);
if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
- if (trmask & (1 << trindex)) {
+ if (trmask & (1ull << trindex)) {
trclasses += " ";
trclasses += trclass->GetName();
trclasses += " ";
Info(mess, whyMess.Data());
}
+//______________________________________________________________________________
+Bool_t AliReconstruction::ProcessEvent(void* event)
+{
+ // Method that is used in case the event loop
+ // is steered from outside, for example by AMORE
+ // 'event' is a pointer to the DATE event in the memory
+
+ if (fRawReader) delete fRawReader;
+ fRawReader = new AliRawReaderDate(event);
+ fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
+ delete fRawReader;
+ fRawReader = NULL;
+
+ return fStatus;
+}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::ParseOutput()
+{
+ // The method parses the output file
+ // location string in order to steer
+ // properly the selector
+
+ TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
+ TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
+
+ if (re1.Match(fESDOutput) == 4) {
+ // root archive with output files stored and regustered
+ // in proof dataset
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
+ AliInfo(Form("%s files will be stored within %s in dataset %s",
+ re1[2].Data(),
+ re1[1].Data(),
+ re1[3].Data()));
+ }
+ else if (re2.Match(fESDOutput) == 3) {
+ // output file stored and registered
+ // in proof dataset
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
+ AliInfo(Form("%s will be stored in dataset %s",
+ (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
+ re2[2].Data()));
+ }
+ else {
+ if (fESDOutput.IsNull()) {
+ // Output location not given.
+ // Assuming xrootd has been already started and
+ // the output file has to be sent back
+ // to the client machine
+ TString esdUrl(Form("root://%s/%s/",
+ TUrl(gSystem->HostName()).GetHostFQDN(),
+ gSystem->pwd()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
+ AliInfo(Form("AliESDs.root will be stored in %s",
+ esdUrl.Data()));
+ }
+ else {
+ // User specified an output location.
+ // Ones has just to parse it here
+ TUrl outputUrl(fESDOutput.Data());
+ TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
+ TString outputLocation(outputUrl.GetUrl());
+ outputLocation.ReplaceAll(outputFile.Data(),"");
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
+ AliInfo(Form("%s will be stored in %s",
+ outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
+ outputLocation.Data()));
+ }
+ }
+
+ return kTRUE;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff