void rec() {
// AliLog::SetGlobalDebugLevel(10);
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-10-Release/Residual/");
man->SetSpecificStorage("EMCAL/*","local://DB");
AliReconstruction reco;
AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
AliTracker::SetFieldMap(field,kTRUE);
reco.SetUniformFieldTracking(kFALSE);
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetLowFluxParam();
AliTPCReconstructor::SetRecoParam(tpcRecoParam);
AliTPCReconstructor::SetStreamLevel(0);
reco.SetRunReconstruction("ITS TPC TRD TOF HMPID PHOS EMCAL MUON T0 VZERO FMD PMD ZDC");
//reco.SetInput("raw.root") ;
//AliPHOSRecoParam* recEmc = new AliPHOSRecoParamEmc();
// recEmc->SetSubtractPedestals(kFALSE);
// AliPHOSReconstructor::SetRecoParamEmc(recEmc);
reco.SetRunQA(kFALSE) ;
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
AliReconstruction reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
reco.SetRecoParam("ITS",AliITSRecoParam::GetLowFluxParam());
reco.SetRecoParam("TPC",AliTPCRecoParam::GetLowFluxParam());
reco.SetRecoParam("TRD",AliTRDrecoParam::GetLowFluxParam());
reco.SetRecoParam("PHOS",AliPHOSRecoParam::GetDefaultParameters());
reco.SetRecoParam("MUON",AliMUONRecoParam::GetLowFluxParam());
reco.SetRecoParam("EMCAL",AliEMCALRecParam::GetLowFluxParam());
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/?cacheFold=/tmp/CDBCache?operateDisconnected=kFALSE");
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
// add TRD standalone tracks
reco.SetOption("TRD", "sl_tr_1");
reco.SetRunGlobalQA(kTRUE);
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
AliReconstruction reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
reco.SetDefaultStorage(Form("local://%s/OCDB", gSystem->pwd()));
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
reco.SetRunPlaneEff(kTRUE);
//reco.SetRunQA("ALL:ALL") ;
reco.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
reco.SetQACycles((AliQAv1::DETECTORINDEX_t)det, 999) ;
reco.SetQAWriteExpert((AliQAv1::DETECTORINDEX_t)det) ;
}
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
AliReconstruction reco;
reco.SetRunReconstruction("ITS TPC TOF PHOS HMPID EMCAL MUON FMD ZDC PMD T0 VZERO");
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
reco.SetDefaultStorage("alien://Folder=/alice/data/2011/OCDB");
// Total number of specific storages - 28
//
// ITS (2 objects)
reco.SetSpecificStorage("ITS/Align/Data", "alien://folder=/alice/simulation/2008/v4-15-Release/Residual");
reco.SetSpecificStorage("ITS/Calib/SPDNoisy", "alien://folder=/alice/simulation/2008/v4-15-Release/Residual");
//
// MUON (1 objects)
// MCH
reco.SetSpecificStorage("MUON/Align/Data", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
//
// TPC (25 objects)
reco.SetSpecificStorage("TPC/Align/Data", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/GainFactorDedx", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/PadTime0", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/ClusterParam", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Pedestals", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Parameters", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/ExB", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Mapping", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/PadNoise", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/PadGainFactor", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Temperature", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/RecoParam", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/TimeGain", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/AltroConfig", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/CE", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Pulser", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Distortion", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Ref", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Raw", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/QA", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/TimeDrift", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Goofie", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/HighVoltage", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/LaserTracks", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("TPC/Calib/Correction", "alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec(const char *filename="raw.root")
{
/////////////////////////////////////////////////////////////////////////////////////////
//
// Reconstruction script for 2011 RAW data - muon fast reco
//
/////////////////////////////////////////////////////////////////////////////////////////
// Set the CDB storage location
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage("alien://folder=/alice/data/2011/OCDB");
AliReconstruction rec;
// Generate or use the local OCDB.root file
// rec.SetFromCDBSnapshot("OCDB.root");
// Set reconstruction flags (skip detectors here if neded with -<detector name>
// rec.SetRunReconstruction("MUON ITS VZERO ZDC T0");
rec.SetRunReconstruction("MUON ITS");
// QA options
rec.SetRunQA("Global MUON:ALL") ;
rec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
// MUON only reco - recoparameters
rec.SetRecoParam("ITS",GetSpecialITSRecoParam());
// AliReconstruction settings
rec.SetWriteESDfriend(kTRUE);
rec.SetWriteAlignmentData();
// rec.SetInput(filename);
rec.SetUseTrackingErrorsForAlignment("ITS");
// switch off cleanESD
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();
}
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 reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
// Use the GRP from the backgr
reco.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s/../backgr",gSystem->pwd()));
reco.SetRunPlaneEff(kTRUE);
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
AliReconstruction reco;
reco.SetUniformFieldTracking(kFALSE);
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetLowFluxParam();
AliTPCReconstructor::SetRecoParam(tpcRecoParam);
AliTPCReconstructor::SetStreamLevel(1);
// reco.SetInput("raw.root");
reco.SetRunReconstruction("ITS TPC TRD TOF HMPID PHOS EMCAL MUON VZERO T0 FMD PMD ZDC");
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-12-Release/Ideal/");
reco.SetRunQA(kFALSE);
reco.SetRunGlobalQA(kFALSE);
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
AliReconstruction reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/?cacheFold=/tmp/CDBCache?operateDisconnected=kFALSE");
// No write access to the OCDB => specific storage
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
reco.SetRunQA("ALL:ALL");
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
AliReconstruction reco;
reco.SetUniformFieldTracking(kFALSE);
reco.SetWriteESDfriend(kFALSE);
reco.SetWriteAlignmentData(kFALSE);
AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetHighFluxParam();
AliTPCReconstructor::SetRecoParam(tpcRecoParam);
AliTPCReconstructor::SetStreamLevel(0);
reco.SetRunReconstruction("ITS TPC TRD TOF PHOS HMPID EMCAL MUON FMD ZDC T0 VZERO");
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2007/PDC07_1/Ideal/CDB/");
AliCDBManager::Instance()->SetSpecificStorage("EMCAL/*","local://DBpp");
TStopwatch timer;
timer.Start();
reco.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 rec() {
/* AliLog::SetGlobalLogLevel(AliLog::kInfo);
AliLog::SetClassDebugLevel("AliTOFtracker",2);
AliLog::SetClassDebugLevel("AliTOFtrackerV1",2);
AliLog::SetClassDebugLevel("AliTOFGeometry",2);*/
AliReconstruction reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
// reco.SetRecoParam("ITS",AliITSRecoParam::GetHighFluxParam());
AliITSRecoParam * itsRecoParam = AliITSRecoParam::GetHighFluxParam(); //Pb-Pb
// trackleter options ...
itsRecoParam->SetTrackleterOnlyOneTrackletPerC2(kFALSE);
itsRecoParam->SetTrackleterPhiWindow(0.015); //rad
itsRecoParam->SetTrackleterZetaWindow(0.03); //cm
reco.SetRecoParam("ITS",itsRecoParam);
reco.SetRecoParam("TPC",AliTPCRecoParam::GetHighFluxParam());
reco.SetRecoParam("TRD",AliTRDrecoParam::GetHighFluxParam());
reco.SetRecoParam("TOF",AliTOFRecoParam::GetPbPbparam());
reco.SetRecoParam("PHOS",AliPHOSRecoParam::GetDefaultParameters());
reco.SetRecoParam("MUON",AliMUONRecoParam::GetHighFluxParam());
reco.SetRunVertexFinderTracks(kFALSE);
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal");
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void recraw() {
// AliReconstruction settings
AliReconstruction reco;
reco.SetWriteESDfriend(kTRUE);
reco.SetWriteAlignmentData();
reco.SetInput("raw.root");
reco.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s/..",gSystem->pwd()));
reco.SetUseTrackingErrorsForAlignment("ITS");
// all events in one single file
reco.SetNumberOfEventsPerFile(-1);
// switch off cleanESD
reco.SetCleanESD(kFALSE);
reco.SetRunQA("ALL:ALL") ;
reco.SetQARefDefaultStorage("local://$ALICE_ROOT/OCDB") ;
for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
reco.SetQACycles(det, 9999) ;
reco.SetQAWriteExpert(det) ;
}
AliLog::Flush();
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
void rec() {
if (!strcmp(gSystem->GetBuildArch(),"win32gcc")) {
gSystem->Load("libProof");
gSystem->Load("libGui");
gROOT->Macro("loadlibsrec.C");
new AliRun("gAlice","The ALICE Off-line Simulation Framework");
}
AliReconstruction reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
reco.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
reco.SetRunPlaneEff(kTRUE);
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
// ----------------------------------------------------------------------------
void HLTT0Test(const Char_t *filename, const Char_t *cdbURI,
Int_t minEvent=-1, Int_t maxEvent=-1) {
printf (" ============================================= \n\n");
printf (" TEST T0 RECONSTRUCTION \n\n");
printf (" ============================================= \n");
if(!gSystem->AccessPathName("galice.root")){
cerr << "AliReconstruction on raw data requires to delete galice.root, ";
cerr << "or run at different place." << endl;
cerr << "!!! DO NOT DELETE the galice.root of your simulation, ";
cerr << "but create a subfolder !!!!" << endl;
return;
}
TGrid::Connect("alien");
if (gSystem->AccessPathName(filename)) {
cerr << "can not find file " << filename << endl;
return;
}
// -- connect to the GRID if we use a file or OCDB from the GRID
TString struri=cdbURI;
TString strfile=filename;
if (struri.BeginsWith("raw://") ||
strfile.Contains("://") && !strfile.Contains("local://")) {
TGrid::Connect("alien");
}
// -- Set the CDB storage location
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage(cdbURI);
if (struri.BeginsWith("local://")) {
// set specific storage for GRP entry
// search in the working directory and one level above, the latter
// follows the standard simulation setup like e.g. in test/ppbench
if (!gSystem->AccessPathName("GRP/GRP/Data")) {
man->SetSpecificStorage("GRP/GRP/Data", "local://$PWD");
} else if (!gSystem->AccessPathName("../GRP/GRP/Data")) {
man->SetSpecificStorage("GRP/GRP/Data", "local://$PWD/..");
} else {
cerr << "can not find a GRP entry, please run the macro in the folder" << endl;
cerr << "of a simulated data sample, or specify a GRID OCDB" << endl;
HLTT0Test();
return;
}
}
//////////////////////////////////////////////////////////////////////////////////////
//
// Reconstruction settings
AliReconstruction rec;
if (minEvent>=0 || maxEvent>minEvent) {
if (minEvent<0) minEvent=0;
if (maxEvent<minEvent) maxEvent=minEvent;
rec.SetEventRange(minEvent,maxEvent);
}
rec.SetRunReconstruction("HLT");
rec.SetLoadAlignFromCDB(kFALSE);
rec.SetWriteESDfriend(kFALSE);
// due to bug ...
// StopOnError needs to be disabled
rec.SetStopOnError(kFALSE);
rec.SetRunVertexFinder(kFALSE);
rec.SetInput(filename);
// QA options
rec.SetRunQA(":") ;
//rec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
//////////////////////////////////////////////////////////////////////////////////////
//
// setup the HLT system
AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
/*
// define a data publisher configuration for T0 raw data
AliHLTConfiguration publisher("RAW-Publisher",
"AliRawReaderPublisher",
"",
"-equipmentid 3584 "
"-datatype 'DDL_RAW ' 'VZRO' "
"-dataspec 0x01"
);
// define configuration of the T0Reconstruction component
AliHLTConfiguration vzeroReco("T0-Reconstruction",
"T0Reconstruction",
"RAW-Publisher",
""
);
// define configuration of the GlobalEsdConverter component
AliHLTConfiguration esdConverter("GLOBAL-ESD-Converter",
"GlobalEsdConverter",
"T0-Reconstruction",
""
);
// define configuration for Root file writer of T0 output
AliHLTConfiguration rootWriter("RootWriter",
"ROOTFileWriter",
"T0-Reconstruction GLOBAL-ESD-Converter",
"-directory analysis -datafile vzeroRec"
);
*/
// set option for the HLT module in AliReconstruction
// arguments
// - ignore-hltout : ignore the HLTOUT payload from the HLT DDLs
// - libraries to be used as plugins
// - loglevel=0x7c : Important, Info, Warning, Error, Fatal
rec.SetOption("HLT",
"ignore-hltout "
"libAliHLTUtil.so libAliHLTGlobal.so libAliHLTITS.so libAliHLTT0.so "
"loglevel=0x7c "
"chains=T0-RECO"//"GLOBAL-ESD-Converter,RootWriter"
);
rec.SetRunPlaneEff(kFALSE);
// switch off cleanESD
rec.SetCleanESD(kFALSE);
AliLog::Flush();
rec.Run();
}
void rec() {
AliReconstruction reco;
//
// switch off cleanESD, write ESDfriends and Alignment data
reco.SetCleanESD(kFALSE);
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
//
// ITS Efficiency and tracking errors
reco.SetRunPlaneEff(kTRUE);
reco.SetUseTrackingErrorsForAlignment("ITS");
//
// Residual OCDB
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
//
// GRP from local OCDB
reco.SetSpecificStorage("GRP/GRP/Data",
Form("local://%s",gSystem->pwd()));
//
// Vertex from RAW OCDB
reco.SetSpecificStorage("GRP/Calib/MeanVertexTPC","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("GRP/Calib/MeanVertex","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("GRP/Calib/MeanVertexSPD", "alien://folder=/alice/data/2010/OCDB");
//
// EMCAL from RAW OCDB
reco.SetSpecificStorage("EMCAL/Calib/Data","alien://Folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("EMCAL/Calib/Pedestals","alien://Folder=/alice/data/2010/OCDB");
//
// PHOS from RAW OCDB
reco.SetSpecificStorage("PHOS/Calib/EmcBadChannels","alien://Folder=/alice/data/2010/OCDB");
//
// SPD and SDD from RAW OCDB
reco.SetSpecificStorage("ITS/Calib/SPDDead","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("TRIGGER/SPD/PITConditions","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("ITS/Calib/SPDNoise","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("ITS/Calib/CalibSDD","alien://Folder=/alice/data/2010/OCDB");
//
// TRD from RAW OCDB
reco.SetSpecificStorage("TRD/Calib/ChamberStatus","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("TRD/Calib/PadStatus","alien://folder=/alice/data/2010/OCDB");
//
// TPC from RAW OCDB
reco.SetSpecificStorage("TPC/Calib/PadGainFactor","alien://folder=/alice/data/2010/OCDB");
//
// V0 from RAW OCDB
reco.SetSpecificStorage("VZERO/Trigger/Data","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("VZERO/Calib/RecoParam","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("VZERO/Calib/Data","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("VZERO/Calib/TimeSlewing","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("VZERO/Calib/TimeDelays","alien://folder=/alice/data/2010/OCDB");
//
// TOF from RAW OCDB
reco.SetSpecificStorage("TOF/Calib/Status","alien://folder=/alice/data/2010/OCDB");
//
// FMD from RAW OCDB
reco.SetSpecificStorage("FMD/Calib/Pedestal", "alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("FMD/Calib/PulseGain","alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("FMD/Calib/Dead", "alien://folder=/alice/data/2010/OCDB");
reco.SetSpecificStorage("FMD/Calib/AltroMap","alien://folder=/alice/data/2010/OCDB");
//
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.Print();
}
/**
* @file sampleRawAnalysis.C
* @brief Example macro to run the AliHLTSampleRawAnalysisComponent in
* AliReconstruction.
*
* The component subscribes to DDL raw data published by the
* AliHLTRawReaderPublisherComponent. The macros requires a raw data file
* and a corresponding GRP entry.
*
* <pre>
* Usage: aliroot -b -q -l \
* sampleRawAnalysis.C'("rawfile", "cdb", minEvent, maxEvent)'
*
* Examples:
* sampleRawAnalysis.C'("raw.root", minEvent, MaxEvent)'
* sampleRawAnalysis.C'("./", minEvent, MaxEvent)'
* sampleRawAnalysis.C'("alien:///alice/data/2010/.../raw/....root")'
*
* Defaults
* cdb="local://$ALICE_ROOT/OCDB" -> take local OCDB from distribution
* minEvent=-1 -> no lower event selection
* maxEvent=-1 -> no upper event selection
*
* </pre>
*
* The input file can be a local raw.root file but also a file from the
* GRID. The separate DDL files generated in simulation can be accessed
* using AliRawReaderFile by speficying "directory/".
*
* Since the macro runs AliReconstruction the OCDB needs to be set up, in
* particular the GRP entry. If testing with a local OCDB you have to
* simulate some events and run the macro in the folder of the simulation.
* Also HLT components configure from objects in the OCDB.
*
* Note: You need a valid GRID token, if you want to access files directly
* from the Grid, use 'alien-token-init' of your alien installation.
*
* @author [email protected]
* @ingroup alihlt_tutorial
*/
void sampleRawAnalysis(const char *filename,
const char *cdbURI,
int minEvent=-1,
int maxEvent=-1)
{
if(!gSystem->AccessPathName("galice.root")){
cerr << "AliReconstruction on raw data requires to delete galice.root, or run at different place." << endl;
cerr << "!!! DO NOT DELETE the galice.root of your simulation, but create a subfolder !!!!" << endl;
return;
}
if (gSystem->AccessPathName(filename)) {
cerr << "can not find file " << filename << endl;
return;
}
// connect to the GRID if we use a file or OCDB from the GRID
TString struri=cdbURI;
TString strfile=filename;
if (struri.BeginsWith("raw://") ||
strfile.Contains("://") && !strfile.Contains("local://")) {
TGrid::Connect("alien");
}
// Set the CDB storage location
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage(cdbURI);
if (struri.BeginsWith("local://")) {
// set specific storage for GRP entry
// search in the working directory and one level above, the latter
// follows the standard simulation setup like e.g. in test/ppbench
if (!gSystem->AccessPathName("GRP/GRP/Data")) {
man->SetSpecificStorage("GRP/GRP/Data", "local://$PWD");
} else if (!gSystem->AccessPathName("../GRP/GRP/Data")) {
man->SetSpecificStorage("GRP/GRP/Data", "local://$PWD/..");
} else {
cerr << "can not find a GRP entry, please run the macro in the folder" << endl;
cerr << "of a simulated data sample, or specify a GRID OCDB" << endl;
sampleRawAnalysis();
return;
}
}
//////////////////////////////////////////////////////////////////////////////////////
//
// Reconstruction settings
AliReconstruction rec;
if (minEvent>=0 || maxEvent>minEvent) {
if (minEvent<0) minEvent=0;
if (maxEvent<minEvent) maxEvent=minEvent;
rec.SetEventRange(minEvent,maxEvent);
}
rec.SetRunReconstruction("HLT");
rec.SetLoadAlignFromCDB(kFALSE);
rec.SetWriteESDfriend(kFALSE);
// due to bug ...
// StopOnError needs to be disabled
rec.SetStopOnError(kFALSE);
rec.SetRunVertexFinder(kFALSE);
rec.SetInput(filename);
// QA options
rec.SetRunQA(":") ;
//rec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
//////////////////////////////////////////////////////////////////////////////////////
//
// setup the HLT system
AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance();
// define a data publisher configuration
// arguments:
// 1) id of the configuartion, later used to refer to this configuration
// 2) id of the component to run
// 3) parents, no parents for publisher components
// 4) optional component arguments
// publish link #512, the first link (numbered 0) of SSD
AliHLTConfiguration publisher("RAW-Publisher",
"AliRawReaderPublisher",
"",
"-minid 512 "
"-datatype 'DDL_RAW ' 'ISSD' "
"-dataspec 0x01"
);
// define configuration of the SampleRawAnalyis component
// arguments:
// 1) id of the configuartion, later used to refer to this configuration
// 2) id of the component to run
// 3) parents, here the publisher configuration defined above
// 4) optional component arguments
AliHLTConfiguration rawanalysis("RAW-Analysis",
"SampleRawAnalysis",
"RAW-Publisher",
"-mandatory1 test "
"-verbose"
);
// set option for the HLT module in AliReconstruction
// arguments
// - ignore-hltout : ignore the HLTOUT payload from the HLT DDLs
// - libraries to be used as plugins
// - loglevel=0x7c : Important, Info, Warning, Error, Fatal
// - chains=RAW-Analysis : chains to be run
rec.SetOption("HLT",
"ignore-hltout "
"libAliHLTUtil.so libAliHLTSample.so "
"loglevel=0x7c "
"chains=RAW-Analysis "
);
rec.SetRunPlaneEff(kFALSE);
// switch off cleanESD
rec.SetCleanESD(kFALSE);
AliLog::Flush();
rec.Run();
}
void recCPass0(const char *filename="raw.root",Int_t nevents=-1, const char *ocdb="raw://", const char* options="?Trigger=kCalibBarrel")
{
if (gSystem->Getenv("ALIROOT_FORCE_COREDUMP"))
{
printf("ALIROOT_FORCE_COREDUMP set\n");
gSystem->ResetSignal(kSigFloatingException);
gSystem->ResetSignal(kSigSegmentationViolation);
}
// addopt errors to account for calibration imprefection before cpass0
// 1) For TPC
Double_t tpcSystematicErrors[5]={1,1.5,1./100.,1./100.,0.1};
Double_t tpcSystematicErrorClusters[2]={1.5,1.5};
Double_t tpcExtendedRoads[2]={2.5,2.5};
Double_t tpcPrimDCACuts[2] = {10.,30.}; // Y,Z
TVectorD *vectpcSystematicErrors=new TVectorD(5, tpcSystematicErrors);
TVectorD *vectpcSystematicErrorClusters=new TVectorD(2, tpcSystematicErrorClusters);
TVectorD *vectpcExtendedRoads= new TVectorD(2, tpcExtendedRoads);
TVectorD *vectpcPrimDCACuts = new TVectorD(2, tpcPrimDCACuts);
const double kZOutSectorCut = 3.; // cut on clusters on wrong side of CE (added to extendedRoadZ)
const double kPrimaryZ2XCut = 1.2; // cut on clusters Z/X (large eta)
AliTPCReconstructor::SetSystematicError(vectpcSystematicErrors);
AliTPCReconstructor::SetSystematicErrorCluster(vectpcSystematicErrorClusters);
AliTPCReconstructor::SetExtendedRoads(vectpcExtendedRoads);
AliTPCReconstructor::SetPrimaryDCACut(vectpcPrimDCACuts);
AliTPCReconstructor::SetZOutSectorCut(kZOutSectorCut);
AliTPCReconstructor::SetPrimaryZ2XCut(kPrimaryZ2XCut);
//
if (gSystem->Getenv("streamLevel")){
SetStreamLevel( AliTPCtracker::kStreamErrParam| AliTPCtracker::kStreamTransform);
}
// 2) For ITS
AliITSReconstructor::SetCheckInvariant(kFALSE); // no invariant check with extended TPC errors
// 3) For TOF
// extra tolerance on top of default from recoparam
AliTOFReconstructor::SetExtraTolerance(5.0);
// 4) For TRD
AliTRDReconstructor::SetExtraMaxClPerLayer(3); // to allow >6 cluster candidates per layer
AliTRDReconstructor::SetExtraBoundaryTolerance(3); // relax boundary check
AliTRDReconstructor::SetExtraRoadY(4); // extra road in Y
AliTRDReconstructor::SetExtraRoadZ(6); // extra road in Z
AliTRDReconstructor::SetExtraChi2Out(25); // extra chi2 tolerance on backpropagation
//
// Load some system libs for Grid and monitoring
// Set the CDB storage location
AliCDBManager * man = AliCDBManager::Instance();
man->SetDefaultStorage(ocdb);
// Reconstruction settings
AliReconstruction rec;
//
// do we extract the TPC recpoints in advance
Int_t preclustTPC = TString(gSystem->Getenv("preclusterizeTPC")).Atoi();
Bool_t noTPCLocalRec = preclustTPC==1;
if (noTPCLocalRec) printf("preclustTPC = %d: TPC local reconstruction assumed to be already done\n", preclustTPC);
else printf("preclustTPC = %d: TPC local reconstruction assumed to NOT be already done\n", preclustTPC);
//
if (gSystem->Getenv("disableOuter")!=NULL){
TString disOuter = gSystem->Getenv("disableOuter");
TString disOuterLoc = disOuter;
if (noTPCLocalRec) {
disOuterLoc.ReplaceAll("TPC","");
disOuterLoc.ReplaceAll("HLT","");
}
rec.SetRunReconstruction(disOuter.Data());
rec.SetRunLocalReconstruction(disOuterLoc.Data());
}
else if (noTPCLocalRec) {
rec.SetRunReconstruction("ALL -HLT");
rec.SetRunLocalReconstruction("ALL -TPC -HLT");
}
else {
rec.SetRunLocalReconstruction("ALL");
}
// Upload CDB entries from the snapshot (local root file) if snapshot exist
if (gSystem->AccessPathName("OCDB.root", kFileExists)==0) {
rec.SetDefaultStorage("local://");
rec.SetCDBSnapshotMode("OCDB.root");
}
else {
// setup ocdb by custom (if any) or default settings
if (gSystem->AccessPathName("localOCDBaccessConfig.C", kFileExists)==0) {
gROOT->LoadMacro("localOCDBaccessConfig.C");
localOCDBaccessConfig();
}else { // default settings
AliCDBManager* man = AliCDBManager::Instance();
man->SetRaw(kTRUE);
}
TString cdbMode = gSystem->Getenv("OCDB_SNAPSHOT_CREATE");
if (cdbMode == "kTRUE") {
gROOT->LoadMacro("$ALIDPG_ROOT/MC/CreateSnapshot.C");
CreateSnapshot("OCDB.root",filename);
return;
}
}
// All friends
rec.SetFractionFriends(2.0);
// AliReconstruction settings - hardwired MB trigger for calibration
TString newfilename = filename;
newfilename += options;
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
TString delRecPoints="TPC TRD ITS";
if (noTPCLocalRec) delRecPoints.ReplaceAll("TPC","");
rec.SetDeleteRecPoints(delRecPoints.Data());
//
// Switch off the V0 finder - saves time!
// rec.SetRunMultFinder(kFALSE);
rec.SetRunV0Finder(kFALSE);
//
// QA options - all QA is off
//
rec.SetRunQA(":");
rec.SetRunGlobalQA(kFALSE);
// AliReconstruction settings
rec.SetWriteESDfriend(kTRUE);
rec.SetWriteAlignmentData();
rec.SetUseTrackingErrorsForAlignment("ITS");
rec.SetCleanESD(kFALSE);
// ITS options (see ALIROOT-7179)
float itsErrY2[6]={0., 0., 0.1*0.1, 0.1*.1, 0.,0.};
TVectorF *vecITSErrY2 = new TVectorF(6, itsErrY2);
AliITSReconstructor::SetExtraErrorY2(vecITSErrY2);
//Ignore SetStopOnError
rec.SetStopOnError(kFALSE);
AliLog::Flush();
rec.Run();
}
void rec(const char *filename="raw.root", const char* options="")
{
/////////////////////////////////////////////////////////////////////////////////////////
//
// Reconstruction script for RAW data
//
/////////////////////////////////////////////////////////////////////////////////////////
AliReconstruction rec;
// Set reconstruction flags (skip detectors here if neded with -<detector name>
// do we extract the TPC recpoints in advance
Int_t preclustTPC = TString(gSystem->Getenv("preclusterizeTPC")).Atoi();
Bool_t noTPCLocalRec = preclustTPC==1;
if (noTPCLocalRec) printf("preclustTPC = %d: TPC local reconstruction assumed to be already done\n", preclustTPC);
else printf("preclustTPC = %d: TPC local reconstruction assumed to NOT be already done\n", preclustTPC);
//
if (noTPCLocalRec) {
rec.SetRunReconstruction("ALL -HLT");
rec.SetRunLocalReconstruction("ALL -TPC -HLT");
}
else {
rec.SetRunLocalReconstruction("ALL");
}
// Upload CDB entries from the snapshot (local root file) if snapshot exist
if (gSystem->AccessPathName("OCDB.root", kFileExists)==0) {
rec.SetDefaultStorage("local://");
rec.SetCDBSnapshotMode("OCDB.root");
}
else {
// setup ocdb by custom (if any) or default settings
if (gSystem->AccessPathName("OCDBconfig.C", kFileExists)==0) {
gROOT->Macro("OCDBconfig.C");
}
else { // default settings
AliCDBManager* man = AliCDBManager::Instance();
man->SetRaw(kTRUE);
}
//
TString cdbMode = gSystem->Getenv("OCDB_SNAPSHOT_CREATE");
if (cdbMode == "kTRUE") {
gROOT->LoadMacro("$ALIDPG_ROOT/MC/CreateSnapshot.C");
CreateSnapshot("OCDB.root",filename);
return;
}
}
// removing apparently pile-up clusters to speadup reconstruction
const double kZOutSectorCut = 3.; // cut on clusters on wrong side of CE (added to extendedRoadZ)
AliTPCReconstructor::SetZOutSectorCut(kZOutSectorCut);
// QA options
// rec.SetRunQA("Global:ESDs") ;
// rec.SetRunQA(":") ;
// rec.SetRunQA("ALL:ALL") ;
rec.SetRunQA("Global MUON:ALL") ;
rec.SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
// AD stuff (see ALIROOT-6663)
// rec.SetOption("AD", "+SaturationCorrection"); // --> not needed anymore, see https://alice.its.cern.ch/jira/browse/ALIROOT-6778
// AliReconstruction settings
rec.SetWriteESDfriend(kTRUE);
rec.SetWriteAlignmentData();
TString filenamewithopt = filename;
filenamewithopt += options;
rec.SetInput(filenamewithopt.Data());
rec.SetUseTrackingErrorsForAlignment("ITS");
// Specific AD storage, see https://alice.its.cern.ch/jira/browse/ALIROOT-6056
// rec.SetSpecificStorage("AD/Calib/TimeSlewing", "alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal");
// switch off cleanESD
rec.SetCleanESD(kFALSE);
//Ignore SetStopOnError
rec.SetStopOnError(kFALSE);
// Delete recpoints
// Remove recpoints after each event
TString delRecPoints="TPC TRD";
if (noTPCLocalRec) delRecPoints.ReplaceAll("TPC","");
rec.SetDeleteRecPoints(delRecPoints.Data());
//
// Set 0.7% as fraction of friends (Ruben, 2017-08-22)
rec.SetFractionFriends(0.007);
AliLog::Flush();
rec.Run();
}
void rec() {
AliLog::SetGlobalLogLevel(AliLog::kError);
AliReconstruction reco;
reco.SetWriteESDfriend();
reco.SetWriteAlignmentData();
AliITSRecoParam * itspar = AliITSRecoParam::GetLowFluxParam();
itspar->SetStoreLikeSignV0s(kTRUE);
reco.SetRecoParam("ITS",itspar);
reco.SetRecoParam("TPC",AliTPCRecoParam::GetLowFluxParam());
reco.SetRecoParam("TRD",AliTRDrecoParam::GetLowFluxParam());
reco.SetRecoParam("PHOS",AliPHOSRecoParam::GetDefaultParameters());
reco.SetRecoParam("MUON",AliMUONRecoParam::GetLowFluxParam());
reco.SetRecoParam("EMCAL",AliEMCALRecParam::GetLowFluxParam());
reco.SetRecoParam("GRP",AliGRPRecoParam::GetLowFluxParam());
reco.SetOption("TRD","sl_tr_1"); // Stream Level for the tracker equal to 1
// Only in case of Full misalignment
// AliGRPRecoParam *grpRecoParam = AliGRPRecoParam::GetLowFluxParam();
// grpRecoParam->SetVertexerTracksConstraintITS(kFALSE);
// grpRecoParam->SetVertexerTracksConstraintTPC(kFALSE);
// reco.SetRecoParam("GRP",grpRecoParam);
reco.SetDefaultStorage("alien://Folder=/alice/simulation/2008/v4-15-Release/Residual/");
reco.SetSpecificStorage("GRP/GRP/Data/","alien://Folder=/alice/simulation/2008/v4-15-Release/Ideal/");
// No write access to the OCDB => local specific storage
// reco.SetSpecificStorage("GRP/GRP/Data",
// Form("local://%s",gSystem->pwd()));
//-------------------------------------------------------------------------
// Setting the cuts for the V0 and cascade finding
// The values of the cuts below are "reasonable" for pp events
//-------------------------------------------------------------------------
Double_t v0sels[]={33, // max allowed chi2
0.05, // min allowed impact parameter for the 1st daughter
0.05, // min allowed impact parameter for the 2nd daughter
0.5, // max allowed DCA between the daughter tracks
0.99, // max allowed cosine of V0's pointing angle
0.2, // min radius of the fiducial volume
100 // max radius of the fiducial volume
};
AliV0vertexer::SetDefaultCuts(v0sels);
Double_t xisels[]={33., // max allowed chi2 (same as PDC07)
0.025, // min allowed V0 impact parameter (PDC07 was 0.05)
0.010, // "window" around the Lambda mass (PDC07 was 0.008)
0.025, // min allowed bachelor's impact parameter (PDC07 was 0.035)
0.2, // max allowed DCA between the V0 and the bachelor (PDC07 was 0.1)
0.998, // max allowed cosine of the cascade pointing angle (PDC07 was 0.9985)
0.2, // min radius of the fiducial volume (PDC07 was 0.9)
100 // max radius of the fiducial volume (same as PDC07)
};
AliCascadeVertexer::SetDefaultCuts(xisels);
reco.SetRunQA("ALL:ALL");
TStopwatch timer;
timer.Start();
reco.Run();
timer.Stop();
timer.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();
}