/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
+ * *QARef
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
// //
///////////////////////////////////////////////////////////////////////////////
+#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 "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 "AliQA.h"
+#include "AliQADataMakerRec.h"
+#include "AliQAManager.h"
+#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)
//_____________________________________________________________________________
-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),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
- fESDPar(""),
fUseHLTData(),
fRunInfo(NULL),
fEventInfo(),
fRecoParam(),
- fVertexer(NULL),
fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
fAlignObjArray(NULL),
fCDBUri(),
+ fQARefUri(),
fSpecCDBUri(),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fQADetectors("ALL"),
- fQASteer(NULL),
+ fQAManager(NULL),
fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
fSameQACycle(kFALSE),
-
+ fInitQACalled(kFALSE),
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;
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
TSelector(),
fUniformField(rec.fUniformField),
- fForcedFieldMap(NULL),
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
- fESDPar(rec.fESDPar),
fUseHLTData(rec.fUseHLTData),
fRunInfo(NULL),
fEventInfo(),
fRecoParam(rec.fRecoParam),
- fVertexer(NULL),
fDiamondProfileSPD(rec.fDiamondProfileSPD),
fDiamondProfile(rec.fDiamondProfile),
fDiamondProfileTPC(rec.fDiamondProfileTPC),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
+ fQARefUri(rec.fQARefUri),
fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
fQADetectors(rec.fQADetectors),
- fQASteer(NULL),
+ fQAManager(NULL),
fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
fSameQACycle(rec.fSameQACycle),
+ fInitQACalled(rec.fInitQACalled),
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;
if(&rec == this) return *this;
fUniformField = rec.fUniformField;
- fForcedFieldMap = NULL;
fRunVertexFinder = rec.fRunVertexFinder;
fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
fRunHLTTracking = rec.fRunHLTTracking;
fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
fLoadAlignData = rec.fLoadAlignData;
- fESDPar = rec.fESDPar;
fUseHLTData = rec.fUseHLTData;
delete fRunInfo; fRunInfo = 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;
fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
- fVertexer = NULL;
delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
delete fDiamondProfile; fDiamondProfile = NULL;
delete fAlignObjArray; fAlignObjArray = NULL;
fCDBUri = "";
+ fQARefUri = rec.fQARefUri;
fSpecCDBUri.Delete();
fInitCDBCalled = rec.fInitCDBCalled;
fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
fQADetectors = rec.fQADetectors;
- fQASteer = NULL;
+ fQAManager = NULL;
fQATasks = rec.fQATasks;
fRunQA = rec.fRunQA;
fRunGlobalQA = rec.fRunGlobalQA;
fSameQACycle = rec.fSameQACycle;
+ fInitQACalled = rec.fInitQACalled;
fRunPlaneEff = rec.fRunPlaneEff;
fesd = NULL;
CleanUp();
delete fGRPData;
- delete fForcedFieldMap;
fOptions.Delete();
if (fAlignObjArray) {
fAlignObjArray->Delete();
delete fAlignObjArray;
}
fSpecCDBUri.Delete();
- delete fQASteer;
+ delete fQAManager;
AliCodeTimer::Instance()->Print();
}
+//_____________________________________________________________________________
+void AliReconstruction::InitQA()
+{
+ //Initialize the QA and start of cycle
+ AliCodeTimerAuto("");
+
+ if (fInitQACalled) return;
+ fInitQACalled = kTRUE;
+
+ fQAManager = AliQAManager::QAManager("rec") ;
+ if (fQAManager->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 = fQAManager->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("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
+ fQAManager->SetDefaultStorage(fQARefUri);
+ }
+
+ if (fRunQA) {
+ fQAManager->SetActiveDetectors(fQADetectors) ;
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+ fQAManager->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
+ fQAManager->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+ }
+ if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
+ fQAManager->SetTasks(fQATasks) ;
+ fQAManager->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
+ }
+ if (fRunGlobalQA) {
+ Bool_t sameCycle = kFALSE ;
+ AliQADataMaker *qadm = fQAManager->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);
+ }
+ AliSysInfo::AddStamp("InitQA");
+ }
+}
+
//_____________________________________________________________________________
void AliReconstruction::InitCDB()
{
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()));
}
+//_____________________________________________________________________________
+void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
+ // Store the desired default CDB storage location
+ // Activate it later within the Run() method
+
+ fQARefUri = uri;
+ AliQA::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;
// 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) {
+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);
-
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) {
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]));
}
}
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()));
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);
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()) {
AliInfo(Form("processing event %d", iEvent));
+ fRunLoader->GetEvent(iEvent);
+
// Fill Event-info object
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
// 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);
+ if (fRunQA) {
+ fQAManager->SetRecoParam(iDet, par) ;
+ }
}
}
}
- fRunLoader->GetEvent(iEvent);
-
// QA on single raw
- if (fRunQA)
- fQASteer->RunOneEvent(fRawReader) ;
-
+ if (fRunQA) {
+ fQAManager->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ fQAManager->RunOneEvent(fRawReader) ;
+ }
// local single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
TString detectors=fRunLocalReconstruction;
// 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
// 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 += " ";
}
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)
- fQASteer->RunOneEvent(fesd) ;
-
+ if (fRunQA) {
+ fQAManager->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ fQAManager->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 = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
+ qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
+ qadm->Exec(AliQA::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++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fReconstructor[iDet])
fReconstructor[iDet]->SetRecoParam(NULL);
}
if (fRunQA || fRunGlobalQA)
- fQASteer->Increment() ;
+ fQAManager->Increment() ;
return kTRUE;
}
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)
}
// End of cycle for the in-loop
- if (fRunQA) {
- fQASteer->EndOfCycle() ;
- }
+ if (fRunQA)
+ fQAManager->EndOfCycle() ;
+
if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ AliQADataMaker *qadm = fQAManager->GetQADataMaker(AliQA::kGLOBAL);
if (qadm) {
if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
qadm->EndOfCycle(AliQA::kRECPOINTS);
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();
AliCodeTimerAuto("")
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;
}
TString detQAStr(fQADetectors) ;
- if (fRunQA)
- fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
-
+ if (fRunQA) {
+ fQAManager->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ fQAManager->RunOneEventInOneDetector(iDet, clustersTree) ;
+ }
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
AliCodeTimerAuto("")
+ AliVertexer *vertexer = CreateVertexer();
+ if (!vertexer) return kFALSE;
+
+ AliInfo("running the ITS vertex finder");
AliESDVertex* vertex = NULL;
- Double_t vtxPos[3] = {0, 0, 0};
- Double_t vtxErr[3] = {0.07, 0.07, 0.1};
- TArrayF mcVertex(3);
- if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
- fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
- for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
- }
-
- 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();
- }
- else {
- AliError("Can't get the ITS loader");
- }
- if(!vertex){
- AliWarning("Vertex not found");
- vertex = new AliESDVertex();
- vertex->SetName("default");
+ 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);
// 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;
}
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
// 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]));
// 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;
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;
if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
// 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;
}
//_____________________________________________________________________________
-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();
+ 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 ftVertexer;
ftVertexer = NULL;
}
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 < 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 ;
}
//_____________________________________________________________________________
{
// 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 ;
}
// Return: kTRUE if all operations have been done properly, kFALSE otherwise
//
Bool_t ret=kFALSE;
- //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ //for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
//if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
if(fTracker[iDet]) {
// 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 isOK = kTRUE;
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;