#include <TROOT.h>
#include <TSystem.h>
#include <THashTable.h>
+#include <TGrid.h>
+#include <TMessage.h>
#include "AliAlignObj.h"
#include "AliCDBEntry.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)
fGAliceFileName(gAliceFilename),
fRawInput(""),
fESDOutput(""),
+ fProofOutputFileName(""),
+ fProofOutputLocation(""),
+ fProofOutputDataset(kFALSE),
+ fProofOutputArchive(""),
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
fRunInfo(NULL),
fEventInfo(),
fRunScalers(NULL),
+ fCTPTimeParams(NULL),
fRunLoader(NULL),
fRawReader(NULL),
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),
fRunInfo(NULL),
fEventInfo(),
fRunScalers(NULL),
+ fCTPTimeParams(NULL),
fRunLoader(NULL),
fRawReader(NULL),
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;
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;
}
delete fGRPData;
delete fRunScalers;
+ delete fCTPTimeParams;
fOptions.Delete();
if (fAlignObjArray) {
fAlignObjArray->Delete();
void AliReconstruction::InitQA()
{
//Initialize the QA and start of cycle
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
if (fInitQACalled) return;
fInitQACalled = kTRUE;
- AliQAManager * qam = AliQAManager::QAManager("rec") ;
+ AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
if (fWriteQAExpertData)
qam->SetWriteExpert() ;
void AliReconstruction::MergeQA(const char *fileName)
{
//Initialize the QA and start of cycle
- AliCodeTimerAuto("") ;
+ AliCodeTimerAuto("",0) ;
AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
AliSysInfo::AddStamp("MergeQA") ;
}
// 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/OCDB";
+ 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
// 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.SetUrl(output);
+ if (output) fESDOutput = output;
}
//_____________________________________________________________________________
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol,
- Float_t diPol, Float_t beamenergy,
- const Char_t *beamtype, const Char_t *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)
- //
- TString s=(l3Pol < 0) ? "L3: -" : "L3: +";
- //
- AliMagF::BMap_t map = AliMagF::k5kG;
- //
- double fcL3,fcDip;
- //
- l3Cur = TMath::Abs(l3Cur);
- if (TMath::Abs(l3Cur-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
- fcL3 = l3Cur/l3NominalCurrent1;
- map = AliMagF::k5kG;
- s += "0.5 T; ";
- } else if (TMath::Abs(l3Cur-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
- fcL3 = l3Cur/l3NominalCurrent2;
- map = AliMagF::k2kG;
- s += "0.2 T; ";
- } else if (l3Cur <= zero) {
- fcL3 = 0;
- map = AliMagF::k5kGUniform;
- s += "0.0 T; ";
- } else {
- AliError(Form("Wrong L3 current (%f A)!",l3Cur));
- return kFALSE;
- }
- //
- diCur = TMath::Abs(diCur);
- if (TMath::Abs(diCur-diNominalCurrent)/diNominalCurrent < tolerance) {
- // 3% current tolerance...
- fcDip = diCur/diNominalCurrent;
- s += "Dipole ON";
- } else if (diCur <= zero) { // some small current..
- fcDip = 0.;
- s += "Dipole OFF";
- } else {
- AliError(Form("Wrong dipole current (%f A)!",diCur));
- return kFALSE;
- }
- //
- if (l3Pol!=diPol && (map==AliMagF::k5kG || map==AliMagF::k2kG) && fcDip!=0) {
- AliError("L3 and Dipole polarities must be the same");
- return kFALSE;
- }
- //
- if (l3Pol<0) fcL3 = -fcL3;
- if (diPol<0) fcDip = -fcDip;
- //
- AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
- TString btypestr = beamtype;
- btypestr.ToLower();
- TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1");
- TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1");
- if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
- else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
- else {
- AliInfo(Form("Cannot determine the beam type from %s, assume no LHC magnet field",beamtype));
- }
-
- AliMagF* fld = new AliMagF("MagneticFieldMap", s.Data(), 2, fcL3, fcDip, 10., map, path,
- btype,beamenergy);
- TGeoGlobalMagField::Instance()->SetField( fld );
- TGeoGlobalMagField::Instance()->Lock();
- //
- 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;
}
- // energy is provided in MeV*120
- beamEnergy /= 120E3;
+ // LHC: "multiply by 120 to get the energy in MeV"
+ beamEnergy *= 0.120;
TString runType = fGRPData->GetRunType();
if (runType==AliGRPObject::GetInvalidString()) {
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 ( TGeoGlobalMagField::Instance()->IsLocked() ) {AliInfo("Running with the externally locked 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
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) {
- if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1) )
- AliFatal("Failed to creat a B field map ! Exiting...");
- AliInfo("Running with the B field constructed out of GRP !");
+ 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 !");
+ }
+ else AliFatal("Failed to create a B field map !");
}
else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
-
}
//*** Get the diamond profiles from OCDB
//_____________________________________________________________________________
Bool_t AliReconstruction::LoadCDB()
{
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliCDBManager::Instance()->Get("GRP/CTP/Config");
//_____________________________________________________________________________
Bool_t AliReconstruction::LoadTriggerScalersCDB()
{
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
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);
- if (!fESDOutput.IsValid()) {
- fESDOutput.SetProtocol("root",kTRUE);
- fESDOutput.SetHost(gSystem->HostName());
- fESDOutput.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
- }
- AliInfo(Form("Output file with ESDs is %s",fESDOutput.GetUrl()));
- gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",fESDOutput.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
{
// 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");
if (fInput && gProof) {
if (reco) *reco = *this;
+ gGeoManager->SetName("Geometry");
gProof->AddInputData(gGeoManager,kTRUE);
gGeoManager = NULL;
gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),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")) {
- TGeoGlobalMagField::Instance()->SetField(map);
- }
- 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");
}
}
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()),
{
// run the reconstruction over a single entry
// from the chain with raw data
- AliCodeTimerAuto("");
+ AliCodeTimerAuto("",0);
TTree *currTree = fChain->GetTree();
AliRawVEvent *event = NULL;
// 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);
if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
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())) ;
// 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(kNDetectors));
// 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;
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);
}
}
}
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);
}
}
}
fEventInfo.Reset();
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
- if (fReconstructor[iDet])
+ if (fReconstructor[iDet]) {
fReconstructor[iDet]->SetRecoParam(NULL);
+ fReconstructor[iDet]->SetEventInfo(NULL);
+ }
+ if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
}
if (fRunQA || fRunGlobalQA)
// 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->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()) {
}
if (fRunQA || fRunGlobalQA) {
- if (fInput) {
- if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
- TString qaOutputFile = outputFileName->GetTitle();
- qaOutputFile.ReplaceAll(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()),
- Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
- TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
- qaProofFile->SetOutputFileName(qaOutputFile.Data());
- fOutput->Add(qaProofFile);
- MergeQA(qaProofFile->GetFileName());
- }
+ 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);
// Do not call the ESD tag creator in case of PROOF-based reconstruction
if (!fInput) {
// run the local reconstruction
static Int_t eventNr=0;
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
TString detStr = detectors;
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
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();
{
// run the SPD trackleting (for SPD efficiency purpouses)
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
Double_t vtxPos[3] = {0, 0, 0};
Double_t vtxErr[3] = {0.0, 0.0, 0.0};
{
// run the barrel tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliVertexer *vertexer = CreateVertexer();
if (!vertexer) return kFALSE;
{
// run the HLT barrel tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
if (!fRunLoader) {
AliError("Missing runLoader!");
{
// run the muon spectrometer tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
if (!fRunLoader) {
AliError("Missing runLoader!");
{
// 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");
{
// fill the event summary data
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
static Int_t eventNr=0;
TString detStr = detectors;
// stored in Trigger.root file and fills
// the corresponding esd entries
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliInfo("Filling trigger information into the ESD");
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 interaction records
}
+ return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
+{
//Scalers
- if(fRunScalers){
- //AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
- AliTimeStamp* timestamp = new AliTimeStamp(14322992, 5, (ULong64_t)486238);
+ //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((1<<i) & esd->GetTriggerMask()){
- AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i);
- esdheader->SetTriggerScalersRecord(scalesd);
+ if((1<<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 < kNDetectors; iDet++) {
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;
}
AliVertexer* vertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
- if (itsReconstructor && (fRunLocalReconstruction.Contains("ITS"))) {
+ if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || fRunTracking.Contains("ITS"))) {
vertexer = itsReconstructor->CreateVertexer();
}
if (!vertexer) {
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 < kNDetectors; iDet++) {
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) {
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;
+}