void Rec(TString file="raw.root")
{
// Reconstruction of RAW data from the input file raw.root
// Boris Polichtchouk, 13 Mar 2008
//AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
//AliCDBManager::Instance()->SetSpecificStorage("PHOS/*","local://BadMap");
AliReconstruction rec ;
rec.SetRunTracking("") ;
rec.SetRunVertexFinder(kFALSE) ;
rec.SetRunLocalReconstruction("PHOS") ;
rec.SetFillESD("PHOS") ;
//Set rec. parameters different from the default ones.
AliPHOSRecoParam* recEmc = new AliPHOSRecoParamEmc();
recEmc->SetSubtractPedestals(kTRUE);
recEmc->SetMinE(0.01); //Minimal Digit energy
recEmc->SetClusteringThreshold(0.02); //Minimal cluster seed energy
recEmc->SetDecoderVersion("v1"); //Comment out to choose Max-Ped version
recEmc->SetOldRCUFormat(kTRUE);
AliPHOSReconstructor::SetRecoParamEmc(recEmc);
rec.SetInput(file.Data()); // read RAW data
rec.SetNumberOfEventsPerFile(5000);
rec.Run();
}
void rec() {
AliReconstruction MuonRec;
MuonRec.SetInput("raw.root");
MuonRec.SetRunLocalReconstruction("MUON ITS VZERO");
MuonRec.SetRunTracking("MUON ITS VZERO");
MuonRec.SetRunVertexFinder(kTRUE);
MuonRec.SetFillESD("MUON VZERO HLT");
MuonRec.SetRunQA("MUON:ALL");
MuonRec.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/");
// QA reference
MuonRec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
// HLT
MuonRec.SetSpecificStorage("HLT/ConfigMUON/DecisionComponent","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
MuonRec.SetSpecificStorage("HLT/ConfigMUON/HitReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
MuonRec.SetSpecificStorage("HLT/ConfigMUON/MansoTrackerFSM","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
MuonRec.SetSpecificStorage("HLT/ConfigMUON/TriggerReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
// CTP
MuonRec.SetSpecificStorage("GRP/CTP/Config","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
// tracker masks
MuonRec.SetSpecificStorage("MUON/Calib/Gains","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb/rec");
MuonRec.SetSpecificStorage("MUON/Calib/Pedestals","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb/rec");
// reconstruction parameters
AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
for (Int_t i = 0; i < 10; i++) {
muonRecoParam->SetDefaultNonBendingReso(i, 0.1524);
muonRecoParam->SetDefaultBendingReso(i, 0.05099);
}
//muonRecoParam->Print("FULL");
MuonRec.SetRecoParam("MUON",muonRecoParam);
MuonRec.SetNumberOfEventsPerFile(500);
TStopwatch timer;
timer.Start();
MuonRec.Run();
timer.Stop();
timer.Print();
}
void runReconstruction(int seed, const char* input, const char* recoptions, bool rawocdb)
{
AliCDBManager* man = AliCDBManager::Instance();
if ( rawocdb )
{
cout << "**** WILL USE RAW OCDB" << endl;
man->SetDefaultStorage("raw://"); //alien://folder=/alice/data/2011/OCDB?cacheFold=/Users/laurent/OCDBcache");
man->SetSpecificStorage("ITS/Calib/RecoParam","alien://folder=/alice/cern.ch/user/p/ppillot/OCDB_PbPbSim");
}
else
{
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
man->SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
}
gRandom->SetSeed(seed);
AliReconstruction* MuonRec = new AliReconstruction("galice.root");
MuonRec->SetInput(gSystem->ExpandPathName(input));
MuonRec->SetRunReconstruction("MUON ITS");
MuonRec->SetFillESD("HLT");
MuonRec->SetOption("HLT", "libAliHLTMUON.so");
MuonRec->SetNumberOfEventsPerFile(10000);
MuonRec->SetOption("MUON",recoptions);
MuonRec->SetRunQA("MUON:ALL");
MuonRec->SetQAWriteExpert(AliQAv1::kMUON);
MuonRec->SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
MuonRec->SetWriteESDfriend(kFALSE);
MuonRec->SetCleanESD(kFALSE);
MuonRec->SetStopOnError(kFALSE);
// uncomment the following lines if you want to set custom RecoParam
// instead of getting them from the OCDB
// AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
// muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
// MuonRec->SetRecoParam("MUON",muonRecoParam);
MuonRec->Run();
delete MuonRec;
//gObjectTable->Print();
}
void rec() {
AliReconstruction MuonRec;
MuonRec.SetInput("raw.root");
MuonRec.SetRunLocalReconstruction("MUON ITS VZERO");
MuonRec.SetRunTracking("MUON ITS VZERO");
MuonRec.SetRunVertexFinder(kTRUE);
MuonRec.SetFillESD("MUON VZERO HLT");
MuonRec.SetRunQA("MUON:ALL");
MuonRec.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/");
// QA reference
MuonRec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
// GRP
MuonRec.SetSpecificStorage("GRP/GRP/Data",Form("local://%s",gSystem->pwd()));
// HLT
MuonRec.SetSpecificStorage("HLT/ConfigMUON/DecisionComponent","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
MuonRec.SetSpecificStorage("HLT/ConfigMUON/HitReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
MuonRec.SetSpecificStorage("HLT/ConfigMUON/MansoTrackerFSM","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
MuonRec.SetSpecificStorage("HLT/ConfigMUON/TriggerReconstructor","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
// CTP
MuonRec.SetSpecificStorage("GRP/CTP/Config","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb");
// alignment
MuonRec.SetSpecificStorage("MUON/Align/Data","alien://Folder=/alice/cern.ch/user/b/bogdan/prod2009/cdb/ideal");
// reconstruction parameters
AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
muonRecoParam->SaveFullClusterInESD(kTRUE,100.);
//muonRecoParam->Print("FULL");
MuonRec.SetRecoParam("MUON",muonRecoParam);
MuonRec.SetNumberOfEventsPerFile(500);
TStopwatch timer;
timer.Start();
MuonRec.Run();
timer.Stop();
timer.Print();
}
void recTPC(Int_t type, const char *filename="data.root")
{
/// Set path to calibration data
///
/// type variable = 0 - cosmic test
/// = 1 - laser test
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
//man->SetRun(0);
//man->SetSpecificStorage("TPC/*/*","local:///afs/cern.ch/user/m/mivanov/public/Calib");
//
// Set reconstruction parameters
//
AliLog::SetClassDebugLevel("AliTPCclusterer",2);
AliTPCRecoParam * tpcRecoParam = 0;
if (type==0) tpcRecoParam = AliTPCRecoParam::GetCosmicTestParam(kTRUE);
if (type>0) tpcRecoParam = AliTPCRecoParam::GetLaserTestParam(kTRUE);
tpcRecoParam->Dump();
AliTPCReconstructor::SetRecoParam(tpcRecoParam);
AliTPCReconstructor::SetStreamLevel(1);
//
//
//
AliReconstruction rec;
rec.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
rec.SetSpecificStorage("TPC/*/*","local:///afs/cern.ch/user/m/mivanov/public/Calib");
rec.SetLoadAlignData("");
rec.SetWriteESDfriend(kTRUE);
rec.SetInput(filename);
rec.SetEquipmentIdMap("EquipmentIdMap.data");
rec.SetRunReconstruction("TPC");
rec.SetOption("TPC","PedestalSubtraction");
// rec.SetRunLocalReconstruction("");
// rec.SetRunTracking("TPC");
rec.SetFillESD("TPC");
rec.SetFillTriggerESD(kFALSE);
rec.SetRunVertexFinder(kFALSE);
rec.SetWriteAlignmentData(kTRUE);
rec.Run();
}
void AliPMDRec()
{
// This macro for the full reconstruction chain. Only PMD is ON.
//
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
man->SetRun(0);
Int_t firstEvent = 0;
Int_t lastEvent = 1;
AliReconstruction rec;
rec.SetRunReconstruction("PMD");
rec.SetRunVertexFinder(kFALSE);
rec.SetFillESD("PMD");
rec.SetFillTriggerESD(kFALSE);
// rec.Run("./");
// rec.Run("raw.date");
rec.Run("raw_6b_61.root",firstEvent,lastEvent);
}
void histogramHandlerTest(const char* input="./"){
if (!input) {
cerr << "please specify input or run without arguments" << endl;
return;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// init the HLT system in order to define the analysis chain below
//
AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// define the analysis chain to be run
//
int iMinSlice=0;
int iMaxSlice=35;
int iMinPart=0;
int iMaxPart=5;
TString histogramHandlerInput1;
TString histogramHandlerInput2;
TString histogramHandlerOutput1;
TString histogramHandlerOutput2;
TString rootFileWriterInput1;
TString rootFileWriterInput2;
for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
for (int part=iMinPart; part<=iMaxPart; part++) {
TString clusterFinderOutput1;
TString clusterFinderOutput2;
TString clusterHistoInput1;
TString clusterHistoInput2;
TString clusterHistoOutput1;
TString clusterHistoOutput2;
TString arg, publisher;
// digit publisher components
int ddlno=768;
if (part>1) ddlno+=72+4*slice+(part-2);
else ddlno+=2*slice+part;
arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC ' -dataspec 0x%02x%02x%02x%02x", ddlno, slice, slice, part, part);
publisher.Form("DP_%02d_%d", slice, part);
AliHLTConfiguration pubconf(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());
// first clusterfinder
clusterFinderOutput1.Form("CF1_%02d_%d", slice, part);
AliHLTConfiguration cfconf(clusterFinderOutput1.Data(), "TPCClusterFinderDecoder", publisher.Data(), "-timebins 446");//-timebins set to simulated data
if (clusterHistoInput1.Length()>0) clusterHistoInput1+=" ";
clusterHistoInput1+=clusterFinderOutput1;
// second clusterfinder
clusterFinderOutput2.Form("CF2_%02d_%d", slice, part);
AliHLTConfiguration cfconf(clusterFinderOutput2.Data(), "TPCClusterFinderDecoder", publisher.Data(), "-timebins 446");//-timebins set to simulated data
if (clusterHistoInput2.Length()>0) clusterHistoInput2+=" ";
clusterHistoInput2+=clusterFinderOutput2;
// first cluster histo component
clusterHistoOutput1.Form("CH1_%02d_%d", slice, part);
AliHLTConfiguration cfconf(clusterHistoOutput1.Data(), "TPCClusterHisto", clusterHistoInput1.Data(), "");
if (histogramHandlerInput1.Length()>0) histogramHandlerInput1+=" ";
histogramHandlerInput1+=clusterHistoOutput1;
//second cluster histo component
clusterHistoOutput2.Form("CH2_%02d_%d", slice, part);
AliHLTConfiguration cfconf(clusterHistoOutput2.Data(), "TPCClusterHisto", clusterHistoInput2.Data(), "");
if (histogramHandlerInput1.Length()>0) histogramHandlerInput1+=" ";
histogramHandlerInput1+=clusterHistoOutput2;
if (histogramHandlerInput2.Length()>0) histogramHandlerInput2+=" ";
histogramHandlerInput2+=clusterHistoOutput2;
}
}
// first histogram handler component
histogramHandlerOutput1.Form("HH1_%02d_%d", slice, part);
AliHLTConfiguration cfconf(histogramHandlerOutput1.Data(), "TPCHistogramHandler", histogramHandlerInput1.Data(), "-use-general");
if (rootFileWriterInput1.Length()>0) rootFileWriterInput1+=" ";
rootFileWriterInput1+=histogramHandlerOutput1;
// second histogram handler component
histogramHandlerOutput2.Form("HH2_%02d_%d", slice, part);
AliHLTConfiguration cfconf(histogramHandlerOutput2.Data(), "TPCHistogramHandler", histogramHandlerInput2.Data(), "-use-general");
if (rootFileWriterInput2.Length()>0) rootFileWriterInput2+=" ";
rootFileWriterInput2+=histogramHandlerOutput2;
AliHLTConfiguration rootFileWriter1("RootFileWriter1", "ROOTFileWriter", rootFileWriterInput1.Data() , "-datafile histogramHandlerFile1");
AliHLTConfiguration rootFileWriter2("RootFileWriter2", "ROOTFileWriter", rootFileWriterInput2.Data() , "-datafile histogramHandlerFile2");
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Init and run the reconstruction
// All but HLT reconstruction is switched off
//
AliReconstruction rec;
rec.SetInput(input);
rec.SetRunVertexFinder(kFALSE);
rec.SetRunLocalReconstruction("HLT");
rec.SetRunTracking("");
rec.SetLoadAlignFromCDB(0);
rec.SetRunQA(":");
//rec.SetFillESD("HLT");
rec.SetFillESD("");
rec.SetFillTriggerESD(false);
rec.SetOption("HLT", "libAliHLTUtil.so libAliHLTRCU.so libAliHLTTPC.so loglevel=0x7c chains=RootFileWriter1,RootFileWriter2");
rec.Run();
}
/**
* @file cal-hlt-tpc-offline.C
* @brief Test macro for the HLT TPC offline calibration.
*
* The macro runs an HLT chain of TPC analysis, using the offline
* algorithms and appropriate wrappers. The final output is
* processed by the TPCOfflineCalibration component.
*
* Usage:
* <pre>
* aliroot -b -q cal-hlt-tpc-offline.C | tee cal-hlt-tpc-offline.log
* </pre>
*
* The chain to be run is defined by the macro given to the parameter
* 'config='
*
* The macro asumes raw data to be available in the rawx folders, either
* simulated or real data. A different input can be specified as parameter
* <pre>
* aliroot -b -q cal-hlt-tpc-offline.C'("input.root")'
* </pre>
*
* In the first section, an analysis chain is defined. The scale of the
* chain can be defined by choosing the range of sectors and partitions.
*
* The reconstruction is steered by the AliReconstruction object in the
* usual way.
*
* @ingroup alihlt_tpc
* @author Jacek Otwinowski <*****@*****.**>, [email protected]
*/
void cal_hlt_tpc_offline(const char* input="./")
{
if (!input) {
cerr << "please specify input or run without arguments" << endl;
return;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// init the HLT system in order to define the analysis chain below
//
AliHLTSystem* gHLT=AliHLTPluginBase::GetInstance();
//gHLT.SwitchAliLog(0);
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// define the analysis chain to be run
//
bool sectorClusterer=true; // run clusterer on sector or DDL level
// check if the AliRawReaderMemory supports multiple buffers
TClass* info=TClass::GetClass("AliRawReaderMemory");
TList* methods=info->GetListOfAllPublicMethods();
if (sectorClusterer && !methods->FindObject("AddBuffer")) {
cerr << "warning: AliRawReaderMemory does not support multiple buffers, falling back to run clusterer on DDL level" << endl;
sectorClusterer=false;
}
int iMinSlice=0;
int iMaxSlice=35;
int iMinPart=0;
int iMaxPart=5;
int DDLNoFromSlicePatch(int, int);
TString writerInput;
TString trackerInput;
TString calibratorInput;
for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
TString arg, clustererInput;
for (int part=iMinPart; part<=iMaxPart; part++) {
TString publisher, cf;
// raw data publisher components
int ddlno=DDLNoFromSlicePatch(slice, part);
arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC ' -dataspec 0x%02x%02x%02x%02x -verbose", ddlno, slice, slice, part, part);
publisher.Form("DP_%02d_%d", slice, part);
AliHLTConfiguration pubconf(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());
if (!sectorClusterer) {
// cluster finder components
cf.Form("CF_%02d_%d", slice, part);
AliHLTConfiguration cfconf(cf.Data(), "TPCOfflineClusterer", publisher.Data(), "");
if (trackerInput.Length()>0) trackerInput+=" ";
trackerInput+=cf;
//if (writerInput.Length()>0) writerInput+=" ";
//writerInput+=cf;
} else {
if (clustererInput.Length()>0) clustererInput+=" ";
clustererInput+=publisher;
}
}
if (sectorClusterer) {
// cluster finder components
cf.Form("CF_%02d", slice);
AliHLTConfiguration cfconf(cf.Data(), "TPCOfflineClusterer", clustererInput.Data(), "");
if (trackerInput.Length()>0) trackerInput+=" ";
trackerInput+=cf;
}
}
// one global tracker component
TString tracker;
tracker.Form("Global_TR");
AliHLTConfiguration trackerconf(tracker.Data(), "TPCOfflineTrackerCalib", trackerInput.Data(), "");
if (writerInput.Length()>0) writerInput+=" ";
calibratorInput+=tracker;
// one global calibration component
TString calibrator;
calibrator.Form("Global_Calib");
AliHLTConfiguration calibconf(calibrator.Data(), "TPCOfflineCalibration", calibratorInput.Data(), "");
if (writerInput.Length()>0) writerInput+=" ";
writerInput+=calibrator;
// the writer configuration
AliHLTConfiguration rootfwconf("sink1", "ROOTFileWriter", writerInput.Data(), "-specfmt=_%d -subdir=out_%d -idfmt=_0x%08x");
//AliHLTConfiguration esdwconf("sink1", "EsdCollector" , writerInput.Data(), "-directory hlt-tpc-offline");
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// Init and run the reconstruction
// All but HLT reconstructio is switched off
//
AliReconstruction rec;
rec.SetInput(input);
rec.SetRunVertexFinder(kFALSE);
rec.SetRunLocalReconstruction("HLT");
rec.SetRunTracking("");
rec.SetLoadAlignFromCDB(0);
rec.SetFillESD("");
rec.SetRunQA(":");
rec.SetRunGlobalQA(kFALSE);
rec.SetFillTriggerESD(kFALSE);
rec.SetOption("HLT", "libAliHLTUtil.so libAliHLTRCU.so libANALYSIS.so libANALYSISalice.so libTPCcalib.so libAliHLTTPC.so loglevel=0x7c chains=sink1");
rec.Run();
}
void AliTRDReconstructandFill()
{
//
// This macro fills 2d histo or vectors during the reconstruction
// If it is vectors, it fits them directly after the reconstruction
// and writes the result in the file coeftest.root
//
TStopwatch timer;
timer.Start();
////Set the parameters of AliTRDCalibra***************
AliTRDCalibra *calibra = AliTRDCalibra::Instance();
////What do you want to use?
calibra->SetMITracking(); //Offline tracking
//calibra->Setmcmtracking();
////Do you want to try the correction due to the angles of the tracks for mcm tracklets?
calibra->SetMcmCorrectAngle();
////What do you want to fill?
calibra->SetCH2dOn();//relative gain calibration
calibra->SetPH2dOn();//drift velocity and time0 calibration
calibra->SetPRF2dOn();//Pad Response Function calibration
////How do you want to store the infos?
calibra->SetVector2d();//vector method
calibra->SetHisto2d();//2Dhistograms
////Which mode do you want?
calibra->SetNz(2,2);//For the PRF z direction
calibra->SetNrphi(2,2);//For The PRF rphi direction
calibra->SetNz(0,0);//For the gain z direction
calibra->SetNrphi(0,0);//For the gain rphi direction
calibra->SetNz(1,3);//For the drift velocity and time0 z direction
calibra->SetNrphi(1,3);//For the drift velocity and time 0 rphi direction
////How many bins?
calibra->SetNumberBinCharge(100);
calibra->SetNumberBinPRF(20);
////Do you want to accept more tracks?
calibra->SetProcent(1.2);//For the gain if one group has a signal above 1.2 the other group then fill
calibra->SetDifference(10);//For the drift velocity if one group has at least 10 time bins then fill
calibra->SetNumberClusters(18);//For mcm tracklets only fill only with tracklet with at least 18 clusters
////Do you want to take only the middle pad for gain or Vdrift?
//calibra->SetTraMaxPad();
//Do you want to apply more strict cut on the clusters for the PRF calibration?
calibra->SetThresholdClusterPRF1(2);//The neighbors pads must have a signal smaller than 2 ADC counts
calibra->SetThresholdClusterPRF2(10);//The 3 pads in the cluster must have a signal above 10 ADC counts
////What do you want to write?
calibra->SetWrite(0);//For the gain
calibra->SetWrite(1);//For the average pulse height
calibra->SetWrite(2);//For the PRF
////If you want to change the name of the file where it is stored (not very good)
//calibra->SetWriteName("test.root");
//Begin the reconstruction
AliReconstruction rec;
rec.SetGAliceFile("galice.root");
rec.SetLoadAlignFromCDB(kFALSE);
rec.SetRunHLTTracking(kFALSE);
rec.SetFillESD("");
rec.SetFillTriggerESD(kFALSE);
rec.SetRunVertexFinder(kFALSE);
rec.Run();
timer.Stop();
timer.Print();
calibra->Write2d();
TStopwatch timerfit;
timerfit.Start();
////Fit directly after having filling****
////Do you want to try with less statistics?
calibra->SetMinEntries(10);//If there is at least 10 entries in the histo, it will fit
////Do you want to write the result?
calibra->SetWriteCoef(0);//gain
calibra->SetWriteCoef(1);//time 0 and drift velocity
calibra->SetWriteCoef(2);//PRF
////Do you want to change the name of the file (TRD.coefficient.root)?
calibra->SetWriteNameCoef("coeftest.root");
////Do you want to see something?
calibra->SetDebug(1);
////Do you want to fit?
calibra->FitPHOnline();
calibra->FitCHOnline();
calibra->FitPRFOnline();
timerfit.Stop();
timerfit.Print();
}
void main_recCPass1_OuterDet(const char *filename="raw.root",Int_t nevents=-1, const char *ocdb="raw://", Bool_t useFullITS=kFALSE)
{
// Load some system libs for Grid and monitoring
// Set the CDB storage location
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage(ocdb);
// Reconstruction settings
AliReconstruction rec;
// Upload CDB entries from the snapshot (local root file) if snapshot exist
if (gSystem->AccessPathName("OCDB.root", kFileExists)==0) {
man->SetDefaultStorage("local://");
man->SetRaw(kFALSE);
man->SetSnapshotMode("OCDB.root");
}
if (gSystem->AccessPathName("localOCDBaccessConfig.C", kFileExists)==0) {
gInterpreter->ProcessLine("localOCDBaccessConfig();");
}
if(!useFullITS){
// only SPD-trackletting will be done
printf("Special ITS configuration: only SPD-trackletting will be done\n");
rec.SetRecoParam("ITS",GetSpecialITSRecoParam());
}
// All friends
rec.SetFractionFriends(1.0);
// AliReconstruction settings - hardwired MB trigger for calibration
TString newfilename = filename;
newfilename += "?Trigger=kCalibOuter";
rec.SetInput(newfilename.Data());
// Set protection against too many events in a chunk (should not happen)
if (nevents>0) rec.SetEventRange(0,nevents);
// Remove recpoints after each event
rec.SetDeleteRecPoints("ITS MUON EMCAL PHOS VZERO T0");
// Switch off the V0 finder - saves time!
rec.SetRunV0Finder(kFALSE);
//
// QA options - all QA is off
//
rec.SetRunQA(":");
rec.SetRunGlobalQA(kFALSE);
// AliReconstruction settings
rec.SetWriteESDfriend(kFALSE);
if(!useFullITS) rec.SetWriteAlignmentData(kFALSE);
else rec.SetWriteAlignmentData();
rec.SetUseTrackingErrorsForAlignment("ITS");
rec.SetRunReconstruction("ITS MUON EMCAL PHOS VZERO T0");
rec.SetFillESD("ITS MUON EMCAL PHOS VZERO T0");
rec.SetCleanESD(kFALSE);
// Specific reco params for ZDC (why isn't this automatic?)
// rec.SetRecoParam("ZDC",AliZDCRecoParamPbPb::GetHighFluxParam(2760));
//Ignore SetStopOnError
rec.SetStopOnError(kFALSE);
AliLog::Flush();
rec.Run();
}