// //
///////////////////////////////////////////////////////////////////////////////
+#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 "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 "AliHeader.h"
+#include "AliLog.h"
+#include "AliMagF.h"
+#include "AliMultiplicity.h"
+#include "AliPID.h"
+#include "AliPlaneEff.h"
#include "AliQA.h"
+#include "AliQADataMakerRec.h"
#include "AliQADataMakerSteer.h"
-
-#include "AliPlaneEff.h"
-
-#include "AliSysInfo.h" // memory snapshots
+#include "AliRawEvent.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 "AliTriggerConfiguration.h"
+#include "AliV0vertexer.h"
+#include "AliVertexer.h"
+#include "AliVertexerTracks.h"
ClassImp(AliReconstruction)
AliReconstruction::AliReconstruction(const char* gAliceFilename) :
TSelector(),
fUniformField(kFALSE),
- fForcedFieldMap(NULL),
fRunVertexFinder(kTRUE),
fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
TSelector(),
fUniformField(rec.fUniformField),
- fForcedFieldMap(NULL),
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
if(&rec == this) return *this;
fUniformField = rec.fUniformField;
- fForcedFieldMap = NULL;
fRunVertexFinder = rec.fRunVertexFinder;
fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
fRunHLTTracking = rec.fRunHLTTracking;
CleanUp();
delete fGRPData;
- delete fForcedFieldMap;
fOptions.Delete();
if (fAlignObjArray) {
fAlignObjArray->Delete();
AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
} else {
- fCDBUri="local://$ALICE_ROOT";
+ fCDBUri="local://$ALICE_ROOT/OCDB";
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
AliWarning("Default CDB storage not yet set !!!!");
AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) {
+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
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...
+ //
+ 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; ";
fUniformField=kTRUE; // track with the uniform (zero) B field
} else {
- AliError(Form("Wrong L3 current (%f A)!",l3Current));
+ AliError(Form("Wrong L3 current (%f A)!",l3Cur));
return kFALSE;
}
-
- diCurrent = TMath::Abs(diCurrent);
- if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
+ //
+ diCur = TMath::Abs(diCur);
+ if (TMath::Abs(diCur-diNominalCurrent)/diNominalCurrent < tolerance) {
// 3% current tolerance...
- dipoleON=kTRUE;
- s+="Dipole ON";
- } else
- if (diCurrent < zero) { // some small current..
- dipoleON=kFALSE;
- s+="Dipole OFF";
+ 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)!",diCurrent));
+ AliError(Form("Wrong dipole current (%f A)!",diCur));
return kFALSE;
}
-
- delete fForcedFieldMap;
- fForcedFieldMap=
- new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path);
-
- fForcedFieldMap->Print();
-
- AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
-
+ //
+ 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;
}
AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
beamEnergy = 0;
}
+ // energy is provided in MeV*120
+ beamEnergy /= 120E3;
TString runType = fGRPData->GetRunType();
if (runType==AliGRPObject::GetInvalidString()) {
}
fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
-
+ printf("qqqqqqqqqqqqqqqqqqqqqqq %s %s %f %s %d\n", lhcState.Data(), beamType.Data(), beamEnergy, runType.Data(), activeDetectors);
fRunInfo->Dump();
AliInfo("===================================================================================");
//*** Dealing with the magnetic field map
- if (AliTracker::GetFieldMap()) {
- AliInfo("Running with the externally set B field !");
- } else {
+ if ( TGeoGlobalMagField::Instance()->IsLocked() ) {AliInfo("Running with the externally locked B field !");}
+ else {
// 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 !");
*/
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...");
- }
+ 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 !");
}
- 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) {
}
AliSysInfo::AddStamp("InitRecoParams");
- if (fInput) {
+ if (fInput && gProof) {
if (reco) *reco = *this;
- fInput->Add(gGeoManager);
+
+ 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);
}
}
}
}
if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
- AliTracker::SetFieldMap(map,fUniformField);
+ TGeoGlobalMagField::Instance()->SetField(map);
}
if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
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)) ;
+ 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) ;
+ fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
}
if (fRunGlobalQA) {
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);
+ TObjArray **arr=qadm->Init(AliQA::kRECPOINTS);
AliTracker::SetResidualsArray(arr);
sameCycle = kTRUE ;
}
AliInfo(Form("processing event %d", iEvent));
+ fRunLoader->GetEvent(iEvent);
+
// Fill Event-info object
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
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);
+ if (fRunQA) {
+ fQASteer->SetRecoParam(iDet, par) ;
+ }
}
}
}
- fRunLoader->GetEvent(iEvent);
-
// QA on single raw
- if (fRunQA)
- fQASteer->RunOneEvent(fRawReader) ;
-
+ if (fRunQA) {
+ fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ fQASteer->RunOneEvent(fRawReader) ;
+ }
// local single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
TString detectors=fRunLocalReconstruction;
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);
// write ESD
if (fCleanESD) CleanESD(fesd);
- if (fRunQA)
+ if (fRunQA) {
+ fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
fQASteer->RunOneEvent(fesd) ;
-
+ }
if (fRunGlobalQA) {
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
qadm->Exec(AliQA::kESDS, fesd);
}
}
// End of cycle for the in-loop
- if (fRunQA) {
+ if (fRunQA)
fQASteer->EndOfCycle() ;
- }
+
if (fRunGlobalQA) {
AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
if (qadm) {
AliCodeTimerAuto("");
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
- esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQA::Instance()->GetQA(), AliQA::Instance()->GetEventSpecies(), AliQA::kNDET, AliRecoParam::kNSpecies);
// Cleanup of CDB manager: cache and active storages!
AliCDBManager::Instance()->ClearCache();
}
TString detQAStr(fQADetectors) ;
- if (fRunQA)
+ if (fRunQA) {
+ fQASteer->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
-
+ }
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,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);
if (fTracker[iDet]->PropagateBack(esd) != 0) {
AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
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);
if (fTracker[iDet]->RefitInward(esd) != 0) {
AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
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;
}
isp2++;
if (!isvalid) continue;
+ if (iDet==0 && (isp-1)>=6) p.SetExtra();
sp->AddPoint(isptrack,&p); isptrack++;
}
}
// 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 < 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, specie, AliQA::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(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 ;
}
//_____________________________________________________________________________
// 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();
}