--- /dev/null
+AliTOFAnalysisTaskCalibPass0 *
+AddTOFAnalysisTaskCalibPass0()
+{
+
+ /* check analysis manager */
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddAnalysisTaskEventTime", "cannot get analysis manager");
+ return NULL;
+ }
+
+ /* check input event handler */
+ if (!mgr->GetInputEventHandler()) {
+ Error("AddAnalysisTaskEventTime", "cannot get input event handler");
+ return NULL;
+ }
+
+ /* check input data type */
+ TString str = mgr->GetInputEventHandler()->GetDataType();
+ if (str.CompareTo("ESD")) {
+ Error("AddAnalysisTaskEventTime", "input data type is not \"ESD\"");
+ return NULL;
+ }
+
+ /* get common input data container */
+ AliAnalysisDataContainer *inputc = mgr->GetCommonInputContainer();
+ if (!inputc) {
+ Error("AddAnalysisTaskEventTime", "cannot get common input container");
+ return NULL;
+ }
+
+ /* create output data container */
+ AliAnalysisDataContainer *outputc1 = mgr->CreateContainer("TOFHistos", TList::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
+ if (!outputc1) {
+ Error("AddAnalysisTaskEventTime", "cannot create output container \"Histos\"");
+ return NULL;
+ }
+
+ /* create task and connect input/output */
+ AliTOFAnalysisTaskCalibPass0 *task = new AliTOFAnalysisTaskCalibPass0();
+
+ // adding the task
+ mgr->AddTask(task);
+
+ mgr->ConnectInput(task, 0, inputc);
+ mgr->ConnectOutput(task, 1, outputc1);
+
+ /* setup task */
+ task->SetEventSelectionFlag(kFALSE);
+ task->SetVertexSelectionFlag(kTRUE);
+ task->SetVertexCut(25.0);
+ /* setup TOF calib */
+ task->GetTOFcalib()->SetRemoveMeanT0(kFALSE);
+ task->GetTOFcalib()->SetUseLHCClockPhase(kTRUE);
+ task->GetTOFcalib()->SetCalibrateTOFsignal(kTRUE);
+ task->GetTOFcalib()->SetCorrectTExp(kFALSE);
+ /* setup track cuts */
+ AliESDtrackCuts *trackCuts = task->GetTrackCuts();
+ trackCuts->SetPtRange(0.5, 10.);
+ trackCuts->SetEtaRange(-1.0, 1.0);
+ trackCuts->SetRequireITSRefit(kTRUE);
+ trackCuts->SetMinNClustersITS(1);
+ trackCuts->SetRequireTPCRefit(kTRUE);
+ trackCuts->SetMinNClustersTPC(70);
+ trackCuts->SetMaxChi2PerClusterTPC(4.);
+ trackCuts->SetAcceptKinkDaughters(kFALSE);
+ trackCuts->SetMaxDCAToVertexZ(3.2);
+ trackCuts->SetMaxDCAToVertexXY(2.4);
+ trackCuts->SetDCAToVertex2D(kTRUE);
+
+ /* return task */
+ return task;
+
+}
--- /dev/null
+AliMeanVertexCalibTask *AddTaskMeanVertexCalib(){
+ //
+ //AddTask for MeanVertex Task to run with pass0
+ //Author: D.Caffarri davide.caffarri@pd.infn.it
+ //
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskMeanVertex", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+
+ if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTaskMeanVertex", "This task requires an input event handler");
+ return NULL;
+ }
+
+
+ AliMeanVertexCalibTask *meanVertexTask = new AliMeanVertexCalibTask("AliMeanVertexCalibTask");
+
+ AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
+ if (!cinput1) cinput1 = mgr->CreateContainer("cchain",TChain::Class(), AliAnalysisManager::kInputContainer);
+
+
+ AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("MeanVertex", TList::Class(),AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
+
+ mgr->ConnectInput(meanVertexTask,0,cinput1);
+ mgr->ConnectOutput(meanVertexTask,1,coutput1);
+
+ return meanVertexTask;
+
+}
--- /dev/null
+AliAnalysisTaskITSAlignQA *AddTaskSDDCalib(Int_t nrun=0)
+{
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskITSAlign", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+ if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTaskITSAlign", "This task requires an input event handler");
+ return NULL;
+ }
+
+ TString type = mgr->GetInputEventHandler()->GetDataType();
+ if(type.Contains("AOD")){
+ ::Error("AddTaskITSAlign", "This task requires to run on ESD");
+ return NULL;
+ }
+
+ // Create and configure the task
+ AliAnalysisTaskITSAlignQA *taskali = new AliAnalysisTaskITSAlignQA();
+ // taskali->SelectCollisionCandidates();
+ if (nrun>0) taskali->SetOCDBInfo(nrun,Form("raw://")) ;
+ taskali->SetLoadGeometryFromOCDB(kFALSE);
+ mgr->AddTask(taskali);
+ //
+ taskali->SetUseVertex(kTRUE);
+ taskali->SetUseVertexForZOnly(kFALSE);
+ taskali->SetDoSPDResiduals(kFALSE);
+ taskali->SetDoSDDResiduals(kFALSE);
+ taskali->SetDoSSDResiduals(kFALSE);
+ taskali->SetDoSDDDriftTime(kFALSE);
+ taskali->SetMinMaxMult(20.,1070.);
+ //
+ //
+ TString outputFileName = AliAnalysisManager::GetCommonFileName();
+
+ AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("clistSDDCalib",
+ TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ outputFileName );
+
+ mgr->ConnectInput(taskali, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(taskali, 1, coutput1);
+ return taskali;
+}
--- /dev/null
+
+void readCDB (TObject *task1);
+//_____________________________________________________________________________
+AliAnalysisTask *AddTaskT0Calib(Int_t runNumber)
+{
+ //
+ // add calibration task
+ //
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskT0Calib", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+ // check the input handler
+ if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTaskT0Calib", "This task requires an input event handler");
+ return NULL;
+ }
+
+ // set TPC OCDB parameters
+ //ConfigOCDB(runNumber);
+
+ // setup task
+ AliT0CalibOffsetChannelsTask *task1 = new AliT0CalibOffsetChannelsTask("CalibObjectsTrain1");
+ readCDB(task1, runNumber);
+ mgr->AddTask(task1);
+
+ // AliT0AnalysisTaskQA * task2 = new AliT0AnalysisTaskQA("QA task");
+ // mgr->AddTask(task2);
+
+ AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
+ if (!cinput1) cinput1 = mgr->CreateContainer("cchain",TChain::Class(),
+ AliAnalysisManager::kInputContainer);
+ AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("T0Calib",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
+
+ mgr->ConnectInput(task1,0,cinput1);
+ mgr->ConnectOutput(task1,1,coutput1);
+ return task1;
+}
+//_____________________________________________________________________________
+void readCDB (TObject *task1, Int_t runNumber) {
+
+ Float_t zero_timecdb[24]={0};
+ Float_t *timecdb = zero_timecdb;
+ Float_t cfdvalue[24][5];
+ for(Int_t i=0; i<24; i++)
+ for (Int_t i0=0; i0<5; i0++)
+ cfdvalue[i][i0] = 0;
+
+ Float_t zero_shiftcdb[4]={0};
+ Float_t *shiftcdb = zero_shiftcdb;
+ AliT0CalibOffsetChannelsTask *mytask = (AliT0CalibOffsetChannelsTask*)task1;
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ man->SetDefaultStorage("raw://");
+ man->SetRun(runNumber);
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
+ if (!entry) AliFatal("CTP timing parameters are not found in OCDB !");
+ AliCTPTimeParams *ctpParams = (AliCTPTimeParams*)entry->GetObject();
+ Float_t l1Delay = (Float_t)ctpParams->GetDelayL1L0()*25.0;
+
+ AliCDBEntry *entry1 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
+ if (!entry1) AliFatal("CTP time-alignment is not found in OCDB !");
+ AliCTPTimeParams *ctpTimeAlign = (AliCTPTimeParams*)entry1->GetObject();
+ l1Delay += ((Float_t)ctpTimeAlign->GetDelayL1L0()*25.0);
+
+ AliCDBEntry *entry4 = AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
+ if (!entry4) AliFatal("LHC clock-phase shift is not found in OCDB !");
+ AliLHCClockPhase *phase = (AliLHCClockPhase*)entry4->GetObject();
+ Float_t fGRPdelays = l1Delay - phase->GetMeanPhase();
+
+ AliCDBEntry *entryCalib0 = man->Get("T0/Calib/Latency");
+ if(!entryCalib0) {
+ AliError::(Form("Cannot find any AliCDBEntry for [Calib, Latency]!"));
+ return;
+ }
+ AliT0CalibLatency *calibda=(AliT0CalibLatency*)entryCalib0->GetObject();
+ Float_t fLatencyL1 = calibda->GetLatencyL1();
+ Float_t fLatencyHPTDC = calibda->GetLatencyHPTDC();
+
+ AliCDBEntry *entryCalib1 = man->Get("T0/Calib/TimeDelay");
+ if(!entryCalib1) {
+ AliError::(Form("Cannot find any AliCDBEntry for [Calib, TimeDelay]!"));
+ return;
+ }
+ else
+ {
+ AliT0CalibTimeEq *clb = (AliT0CalibTimeEq*)entryCalib1->GetObject();
+ timecdb = clb->GetTimeEq();
+ for(Int_t i=0; i<24; i++)
+ for (Int_t i0=0; i0<5; i0++){
+ cfdvalue[i][i0] = clb->GetCFDvalue(i, i0);
+ }
+ }
+
+ for (Int_t i=0; i<24; i++) {
+ Float_t cfdmean = cfdvalue[i][0];
+ if( cfdvalue[i][0] < 500 || cfdvalue[i][0] > 50000) cfdmean = ( 1000.*fLatencyHPTDC - 1000.*fLatencyL1 + 1000.*fGRPdelays)/24.4;
+ mytask->SetCFDvalue(i, cfdmean);
+ mytask->SetTimeEq(i, timecdb[i]);
+ }
+
+ AliCDBEntry *entryCalib2 = man->Get("T0/Calib/TimeAdjust");
+ if(!entryCalib2) {
+ AliError(Form("Cannot find any AliCDBEntry for [Calib, TimeAdjust]!"));
+ }
+ else
+ {
+ AliT0CalibSeasonTimeShift *clb1 = (AliT0CalibSeasonTimeShift*)entryCalib2->GetObject();
+ shiftcdb = clb1->GetT0Means();
+ }
+
+ for (Int_t i=0; i<4; i++) mytask->SetT0Means(i,shiftcdb[i]);
+}
--- /dev/null
+/*
+
+ This macros setup the TPC calibration task AddTaskTPCCalib
+ for CPass0.
+ - the run number is required to config TPC OCDB
+
+ The following calibration components are added to the AliTPCAnalysisTaskcalib task:
+ 1. AliTPCcalibCalib - redo reconstruction with current calibration
+ 2. AliTPCcalibTimeGain - TPC time dependent gain calibration
+ 3. AliTPCcalibTime - TPC time dependent drift time calibration
+
+*/
+
+// function to set TPC OCDB parameters
+void ConfigOCDB(Int_t crun);
+
+Int_t debugLevel=0;
+Int_t streamLevel=0;
+
+//_____________________________________________________________________________
+AliAnalysisTask *AddTaskTPCCalib(Int_t runNumber)
+{
+ //
+ // add calibration task
+ //
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddTaskTPCCalib", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+ // check the input handler
+ if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTaskTPCCalib", "This task requires an input event handler");
+ return NULL;
+ }
+
+ // set TPC OCDB parameters
+ ConfigOCDB(runNumber);
+
+ // setup task
+ AliTPCAnalysisTaskcalib *task1=new AliTPCAnalysisTaskcalib("CalibObjectsTrain1");
+ SetupCalibTaskTrain1(task1);
+ mgr->AddTask(task1);
+
+ AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
+ if (!cinput1) cinput1 = mgr->CreateContainer("cchain",TChain::Class(),
+ AliAnalysisManager::kInputContainer);
+ AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("TPCCalib",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
+
+ mgr->ConnectInput(task1,0,cinput1);
+ mgr->ConnectOutput(task1,0,coutput1);
+ return task1;
+}
+
+//_____________________________________________________________________________
+void AddCalibCalib(TObject* task){
+ //
+ // Responsible: Marian Ivanov
+ // Description:
+ // calibCalib is a prefilter
+ // The current OCDB entries transformation are applied on cluster, tracks are refitted
+ //
+ AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
+ AliTPCcalibCalib *calibCalib = new AliTPCcalibCalib("calibTPC","calibTPC");
+ calibCalib->SetDebugLevel(0);
+ calibCalib->SetStreamLevel(0);
+ calibCalib->SetTriggerMask(-1,-1,kFALSE); //accept everything
+ myTask->AddJob(calibCalib);
+}
+
+//_____________________________________________________________________________
+void AddCalibTimeGain(TObject* task, Bool_t isCosmic = kFALSE, char * name = "calibTimeGain"){
+ //
+ // Responsible: Alexander Kalweit
+ // Description: Time Gain calibration
+ //
+
+ // Set run time ranges (time stamps)
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+ if(!entry) {
+ ::Error("AddCalibTimeGain","Cannot get AliCDBEntry");
+ return;
+ }
+ const AliGRPObject* grpData = dynamic_cast<AliGRPObject*>(entry->GetObject());
+ if(!grpData) {
+ ::Error("AddCalibTimeGain","Cannot get AliGRPObject");
+ return;
+ }
+ time_t sTime = grpData->GetTimeStart();
+ time_t eTime = grpData->GetTimeEnd();
+ TTimeStamp startRunTime(sTime);
+ TTimeStamp stopRunTime(eTime);
+
+ UInt_t year;
+ startRunTime.GetDate(kTRUE,0,&year);
+ TTimeStamp startTime(year,1,1,0,0,0);
+ TTimeStamp stopTime(year,12,31,23,59,59);
+
+ //
+ // setup calibration component
+ //
+ AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
+ AliTPCcalibTimeGain *calibTimeGain = new AliTPCcalibTimeGain(name,"calibTimeGain", startTime.GetSec(), stopTime.GetSec(), 10*60);
+ calibTimeGain->SetIsCosmic(isCosmic);
+ calibTimeGain->SetUseCookAnalytical(kTRUE);
+ calibTimeGain->SetUseMax(kTRUE);
+ calibTimeGain->SetDebugLevel(0);
+ calibTimeGain->SetStreamLevel(0);
+ calibTimeGain->SetTriggerMask(-1,-1,kTRUE); //reject laser
+ calibTimeGain->SetLowerTrunc(0.02);
+ calibTimeGain->SetUpperTrunc(0.6);
+
+ myTask->AddJob(calibTimeGain);
+
+ AliTPCcalibGainMult *calibGainMult = new AliTPCcalibGainMult("calibGainMult","calibGainMult");
+ calibGainMult->SetUseMax(kTRUE);
+ calibGainMult->SetDebugLevel(0);
+ calibGainMult->SetStreamLevel(0);
+ calibGainMult->SetTriggerMask(-1,-1,kTRUE); //reject laser
+ calibGainMult->SetLowerTrunc(0.02);
+ calibGainMult->SetUpperTrunc(0.6);
+
+ myTask->AddJob(calibGainMult);
+
+}
+
+//_____________________________________________________________________________
+void AddCalibTime(TObject* task){
+ //
+ // Responsible: Dag Larsen
+ // Description: Time V drift calibration
+ //
+
+ // Set run time ranges (time stamps)
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+ if(!entry) {
+ ::Error("AddCalibTime","Cannot get AliCDBEntry");
+ return;
+ }
+ const AliGRPObject* grpData = dynamic_cast<AliGRPObject*>(entry->GetObject());
+ if(!grpData) {
+ ::Error("AddCalibTime","Cannot get AliGRPObject");
+ return;
+ }
+ time_t sTime = grpData->GetTimeStart();
+ time_t eTime = grpData->GetTimeEnd();
+
+ TTimeStamp startRunTime(sTime);
+ TTimeStamp stopRunTime(eTime);
+
+ UInt_t year;
+ startRunTime.GetDate(kTRUE,0,&year);
+ TTimeStamp startTime(year,1,1,0,0,0);
+ TTimeStamp stopTime(year,12,31,23,59,59);
+
+ //
+ // setup calibration component
+ //
+ AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
+ AliTPCcalibTime *calibTime = new AliTPCcalibTime("calibTime","calibTime", startTime.GetSec(), stopTime.GetSec(), 10*60, 2);
+ calibTime->SetDebugLevel(0);
+ calibTime->SetStreamLevel(0);
+ calibTime->SetTriggerMask(-1,-1,kFALSE); //accept everything
+
+ // max 600 tracks per event
+ calibTime->SetCutTracks(600);
+
+ myTask->AddJob(calibTime);
+}
+
+
+void AddCalibTracks(TObject* task){
+ //
+ // Responsible: Marian Ivanov
+ // Description:
+ // Histogram residuals and pulls of the track parameters in bins of track parameters
+ //
+ AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
+ AliTPCClusterParam * clusterParam = AliTPCcalibDB::Instance()->GetClusterParam();
+
+ AliTPCcalibTracksCuts *cuts = new AliTPCcalibTracksCuts(30, 0.4, 5, 0.13, 0.018);
+ //
+ AliTPCcalibTracks *calibTracks = new AliTPCcalibTracks("calibTracks", "Resolution calibration object for tracks", clusterParam, cuts);
+ calibTracks->SetDebugLevel(debugLevel);
+ calibTracks->SetStreamLevel(streamLevel);
+ calibTracks->SetTriggerMask(-1,-1,kTRUE);
+ myTask->AddJob(calibTracks);
+}
+
+
+//_____________________________________________________________________________
+void SetupCalibTaskTrain1(TObject* task){
+ //
+ // Setup tasks for calibration train
+ //
+ AddCalibCalib(task);
+ AddCalibTimeGain(task);
+ AddCalibTime(task);
+ //AddCalibTracks(task);
+}
+
+//_____________________________________________________________________________
+void ConfigOCDB(Int_t run){
+ //
+ // Configure TPC OCDB
+ //
+ printf("SETUP OCBD for TPC\n");
+ printf("SETUP OCBD for TPC\n");
+ printf("SETUP OCBD for TPC Run =%d\n", run);
+ //
+ //
+ AliTPCParam *param= AliTPCcalibDB::Instance()->GetParameters();
+ param->ReadGeoMatrices();
+ //
+ AliMagF* magF= TGeoGlobalMagField::Instance()->GetField();
+ printf("\n\nSET EXB FIELD\t\n\n");
+ AliTPCcalibDB::Instance()->SetExBField(magF);
+ //
+ //
+ //
+ AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
+ //
+ //AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetCosmicTestParam(kTRUE);
+ //
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/RecoParam");
+ if (!entry){
+ printf("TPC reco param not available");
+ }
+ TObjArray * array = (TObjArray*)entry->GetObject();
+ if (!array){
+ printf("TPC reco param not available");
+ }
+ // 0 - Low Flux (pp), 1- High Flux (Pb-Pb)
+ AliTPCRecoParam * tpcRecoParam = (AliTPCRecoParam*)array->At(1);
+
+ transform->SetCurrentRecoParam(tpcRecoParam);
+ tpcRecoParam->SetUseGainCorrectionTime(0);
+ tpcRecoParam->SetUseRPHICorrection(kFALSE);
+ tpcRecoParam->SetUseTOFCorrection(kFALSE);
+ //
+ tpcRecoParam->SetUseDriftCorrectionTime(0);
+ tpcRecoParam->SetUseDriftCorrectionGY(0);
+ //
+ tpcRecoParam->SetUseRadialCorrection(kFALSE);
+ tpcRecoParam->SetUseQuadrantAlignment(kFALSE);
+ //
+ tpcRecoParam->SetUseSectorAlignment(kFALSE);
+ tpcRecoParam->SetUseFieldCorrection(kFALSE);
+ tpcRecoParam->SetUseExBCorrection(kFALSE);
+ //
+ tpcRecoParam->SetUseMultiplicityCorrectionDedx(kFALSE);
+ tpcRecoParam->SetUseAlignmentTime(kFALSE);
+ tpcRecoParam->SetUseComposedCorrection(kTRUE);
+
+ AliTPCcalibDB::Instance()->SetRun(run);
+}
--- /dev/null
+//=============================================================================
+//
+// *** AddTaskTRDCalib
+//
+// This macros setup the TRD calibration task
+//
+//=============================================================================
+
+AliAnalysisTask *AddTaskTRDCalib(Int_t runNumber)
+{
+ gSystem->Load("libTRDcalib");
+ // pointer to the analysis manager
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ Error("AddTaskTRDCalib", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+ // check the input handler
+ if (!mgr->GetInputEventHandler()) {
+ ::Error("AddTask", "This task requires an input event handler");
+ return NULL;
+ }
+
+ ////////////////////////////////////////////
+ // Number of timebins
+ ///////////////////////////////////////////
+ AliTRDcalibDB *calib = AliTRDcalibDB::Instance();
+ Int_t nbOfTimeBins = calib->GetNumberOfTimeBinsDCS();
+ if(nbOfTimeBins < 0) nbOfTimeBins = 27;
+ ////////////////////////////////////////////
+ //
+ /////////////////////////////////////////////
+ Int_t versiongain, subversiongain, versionvdrift, subversionvdrift;
+
+ /////////////////////////
+ // The TRD calib Task
+ /////////////////////////
+ AliTRDCalibTask *calibTask = new AliTRDCalibTask();
+
+ // Disabling TRD CPAss0 as per https://savannah.cern.ch/bugs/?88813
+ //calibTask->SetMaxEvent(-1);
+
+ calibTask->SetMaxNbTracks(1600);
+ calibTask->SetHisto2d(kTRUE);
+ calibTask->SetVector2d(kFALSE);
+ calibTask->SetVdriftLinear(kTRUE);
+ calibTask->SetExbAlt(kFALSE);
+ calibTask->SetNz(0,0);
+ calibTask->SetNrphi(0,0);
+ calibTask->SetNz(0,1);
+ calibTask->SetNrphi(0,1);
+ calibTask->SetNz(0,2);
+ calibTask->SetNrphi(0,2);
+ calibTask->SetLow(0);
+ calibTask->SetHigh(30);
+ calibTask->SetFillZero(kFALSE);
+ // now
+ calibTask->AddSelectedTriggerClass("C0OB0-ABCE-NOPF-ALL");
+ calibTask->AddSelectedTriggerClass("CTRDCO2-ABCE-NOPF-CENT");
+ calibTask->AddSelectedTriggerClass("CTRDCO2-ABCE-NOPF-TRD");
+ calibTask->AddSelectedTriggerClass("CTRDCO2-ABCE-NOPF-ALL");
+ calibTask->SetReject(kTRUE);
+ // before
+ //calibTask->AddSelectedTriggerClass("CINT1B-ABCE-NOPF-ALL");
+ //calibTask->AddSelectedTriggerClass("CINT1WU-B-NOPF-ALL");
+ //calibTask->AddSelectedTriggerClass("CINT7WU-B-NOPF-ALL");
+ //calibTask->AddSelectedTriggerClass("CINT7WU-I-NOPF-ALL");
+ //calibTask->SetReject(kFALSE);
+ //calibTask->SetDebug(2);
+ calibTask->SetNbTimeBins(nbOfTimeBins);
+ //calibTask->SetMaxEvent(10);
+ //calibTask->SetThresholdP(1.0);
+ calibTask->SetRequirePrimaryVertex(kTRUE);
+ calibTask->SetMinNbOfContributors(1);
+ calibTask->SetMaxCluster(100.0);
+ calibTask->SetNbMaxCluster(2);
+ //calibTask->SetLimitChargeIntegration(kTRUE);
+
+
+ /////////////////////////////
+ // Track cuts
+ /////////////////////////////
+ AliESDtrackCuts *trackCuts = new AliESDtrackCuts("trackcuts","trackcuts");
+ trackCuts->SetMinNClustersTPC(50);
+ trackCuts->SetMaxChi2PerClusterTPC(3.5);
+ //trackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+ trackCuts->SetRequireTPCRefit(kTRUE);
+ //trackCuts->SetRequireITSRefit(kTRUE);
+ //trackCuts->SetMinNsigmaToVertex(10);
+ trackCuts->SetRequireSigmaToVertex(kFALSE);
+ trackCuts->SetAcceptKinkDaughters(kFALSE);
+ trackCuts->SetMaxDCAToVertexZ(30.0);
+ trackCuts->SetMaxDCAToVertexXY(3.0);
+ trackCuts->SetDCAToVertex2D(kFALSE);
+
+ calibTask->SetESDtrackCuts(trackCuts);
+
+ mgr->AddTask(calibTask);
+
+ AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
+ //AliAnalysisDataContainer *cinput = mgr->GetCommonOutputContainer();
+
+ if (!cinput) cinput = mgr->CreateContainer("cchain",TChain::Class(),
+ AliAnalysisManager::kInputContainer);
+
+ AliAnalysisDataContainer *coutput =mgr->CreateContainer("TRDCalib",TList::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
+
+
+ mgr->ConnectInput(calibTask,0,cinput);
+ mgr->ConnectOutput(calibTask,1,coutput);
+ return calibTask;
+
+}
--- /dev/null
+//___________________________________________________________________________
+
+LoadLibraries()
+{
+ gSystem->Load("libANALYSIS");
+ gSystem->Load("libANALYSISalice");
+
+}
+
+//___________________________________________________________________________
+
+MakeOCDB(const Char_t *filename = "AliESDfriends_v1.root", const Char_t *dbString = "raw://", Int_t runNB)
+{
+ LoadLibraries();
+ AliMeanVertexPreprocessorOffline meanVertexCalib;
+ meanVertexCalib.ProcessOutput(filename, dbString, runNB);
+}
+
+
--- /dev/null
+/*
+ merge output calib objects on Alien
+ using AliFileMerger functionality
+
+ Directory with runCalibTrain output: outputDir
+ pattern: AliESDfriends_v1.root
+ Output file name: CalibObjects.root
+
+ Example:
+ .L $ALICE_ROOT/ANALYSIS/CalibMacros/MergeCalibration/merge.C
+ merge("alien:///alice/cern.ch/user/j/jotwinow/CalibTrain/output","AliESDfriends_v1.root");
+*/
+void mergeInChunksTXT(const char* mlist, const char* dest, int maxFiles=700);
+
+
+void merge(const char* outputDir, const char* pattern, Bool_t copyLocal=kFALSE)
+{
+ //
+ // load libraries
+ //
+ printf("Merging with chunks copying turned %s\n",copyLocal ? "ON":"OFF");
+ gROOT->Macro("LoadLibraries.C");
+ //
+ cpTimeOut(outputDir, pattern,10, copyLocal);
+ //
+ // local
+ mergeInChunksTXT("calib.list","CalibObjects.root");
+ // AliFileMerger merger;
+ // merger.AddReject("esdFriend"); // do not merge
+ // merger.SetMaxFilesOpen(700);
+ // merger.IterTXT("calib.list","CalibObjects.root",kFALSE);
+
+ // alien
+ //merger.IterAlien(outputDir, "CalibObjects.root", pattern);
+
+ return;
+}
+
+void cpTimeOut(const char * searchdir, const char* pattern, Int_t timeOut=10, Bool_t copyLocal)
+{
+
+ gSystem->Setenv("XRDCLIENTMAXWAIT",Form("%d",timeOut));
+ gEnv->SetValue("XNet.RequestTimeout", timeOut);
+ gEnv->SetValue("XNet.ConnectTimeout", timeOut);
+ gEnv->SetValue("XNet.TransactionTimeout", timeOut);
+ TFile::SetOpenTimeout(timeOut);
+
+ TGrid::Connect("alien");
+
+ TString filelist;
+ TString command;
+ command = Form("find %s/ %s", searchdir, pattern);
+ cerr<<"command: "<<command<<endl;
+ TGridResult *res = gGrid->Command(command);
+ if (!res) return;
+ res->Print();
+ TIter nextmap(res);
+ TMap *map = 0;
+
+ ofstream outputFile;
+ outputFile.open(Form("calib.list"));
+ Int_t counter=0;
+
+ while((map=(TMap*)nextmap()))
+ {
+ TObjString *objs = dynamic_cast<TObjString*>(map->GetValue("turl"));
+ if (!objs || !objs->GetString().Length())
+ {
+ delete res;
+ break;
+ }
+
+ TString src=Form("%s",objs->GetString().Data());
+ TString dst=src;
+ Bool_t result = kTRUE;
+ if (copyLocal) {
+ dst.ReplaceAll("alien:///","");
+ dst.ReplaceAll("/","_");
+ TTimeStamp s1;
+ result = TFile::Cp(src.Data(),dst.Data(),kTRUE);
+ TTimeStamp s2;
+ AliSysInfo::AddStamp(dst.Data(),counter, result);
+ }
+ if (result) {
+ counter++;
+ outputFile << dst.Data()<< endl;
+ }
+ }
+ if (copyLocal) cout<<counter<<" files copied!"<<endl;
+ else cout<<counter<<" files registerd!"<<endl;
+ outputFile.close();
+ gSystem->Exec("mv syswatch.log syswatch_copy.log");
+ return;
+}
+
+void mergeInChunksTXT(const char* mlist, const char* dest, int maxFiles)
+{
+ TH1::AddDirectory(0);
+ AliFileMerger merger;
+ // merger.SetMaxFilesOpen(999);
+ merger.AddReject("esdFriend"); // do not merge
+ //
+ if (maxFiles<2) maxFiles = 2;
+ TString filesToMerge = mlist, fileDest = dest;
+ if (filesToMerge.IsNull()) {printf("List to merge is not provided\n"); return;}
+ if (fileDest.IsNull()) {printf("Merging destination is not provided\n"); return;}
+ const char* tmpMerge[3]={"__merge_part0.root","__merge_part1.root","__part_of_calib.list"};
+ //
+ gSystem->ExpandPathName(filesToMerge);
+ ofstream outfile;
+ ifstream infile(filesToMerge.Data());
+ if (!infile) {printf("No %s file\n",filesToMerge.Data()); return;}
+ //
+ int currTmp = 0, nfiles = 0, nparts = 0; // counter for number of merging operations
+ string line;
+ TString lineS;
+ while ( !infile.eof() ) {
+ getline(infile, line);
+ lineS = line;
+ if (lineS.IsNull() || lineS.BeginsWith("#")) continue;
+ int st = nfiles%maxFiles;
+ if (st==0) { // new chunk should be started
+ if (nfiles) { // merge prev. chunk
+ outfile.close();
+ merger.IterTXT(tmpMerge[2], tmpMerge[currTmp] ,kFALSE);
+ printf("Merging to %s | %d files at step %d\n",tmpMerge[currTmp], nfiles,nparts);
+ }
+ outfile.open(tmpMerge[2], ios::out); // start list for new chunk
+ if (nparts++) {
+ printf("Adding previous result %s | %d files %d at part\n",tmpMerge[currTmp], nfiles,nparts);
+ outfile << tmpMerge[currTmp] << endl; // result of previous merge goes 1st
+ }
+ currTmp = (currTmp==0) ? 1:0; // swap tmp files
+ }
+ outfile << line << endl;
+ nfiles++;
+ }
+ // merge the rest
+ merger.IterTXT(tmpMerge[2], dest ,kFALSE);
+ outfile.close();
+ infile.close();
+ for (int i=0;i<3;i++) gSystem->Exec(Form("if [ -e %s ]; then \nrm %s\nfi",tmpMerge[i],tmpMerge[i]));
+ printf("Merged %d files in %d steps\n",nfiles, nparts);
+ //
+}
+
--- /dev/null
+//___________________________________________________________________
+
+void merge(TString component, const Char_t *inputstring)
+{
+
+ /* load libs */
+ gROOT->Macro("LoadLibraries.C");
+ TH1::AddDirectory(0);
+
+ /* copy only */
+ if (component == "COPY") {
+ CopyCPass(inputstring, "AliESDfriends_v1.root");
+ return;
+ }
+
+ /* merge component */
+ MergeCPass(inputstring, component);
+
+}
+
+//___________________________________________________________________
+
+void MergeCPass(const Char_t *list, TString component)
+{
+ AliFileMerger merger;
+ /* select what to merge */
+ if (component == "ALL")
+ merger.AddReject("esdFriend");
+ else
+ merger.AddAccept(component.Data());
+ /* merge */
+ merger.IterTXT(list, "CalibObjects.root", kFALSE);
+ /* notify */
+ gSystem->Exec(Form("touch %s_merge_done", component.Data()));
+ return;
+}
+
+//___________________________________________________________________
+
+void CopyCPass(const char *searchdir, const char *pattern, Int_t timeOut=10)
+{
+
+ gSystem->Setenv("XRDCLIENTMAXWAIT",Form("%d",timeOut));
+ gEnv->SetValue("XNet.RequestTimeout", timeOut);
+ gEnv->SetValue("XNet.ConnectTimeout", timeOut);
+ gEnv->SetValue("XNet.TransactionTimeout", timeOut);
+ TFile::SetOpenTimeout(timeOut);
+
+ TGrid::Connect("alien");
+
+ TString filelist;
+ TString command;
+ command = Form("find %s/ %s", searchdir, pattern);
+ cerr<<"command: "<<command<<endl;
+ TGridResult *res = gGrid->Command(command);
+ if (!res) return;
+ TIter nextmap(res);
+ TMap *map = 0;
+
+ ofstream outputFile;
+ outputFile.open(Form("calib.list"));
+ Int_t counter=0;
+
+ while((map=(TMap*)nextmap()))
+ {
+ TObjString *objs = dynamic_cast<TObjString*>(map->GetValue("turl"));
+ if (!objs || !objs->GetString().Length())
+ {
+ delete res;
+ break;
+ }
+
+ TString src=Form("%s",objs->GetString().Data());
+ TString dst=src;
+ dst.ReplaceAll("alien:///","");
+ dst.ReplaceAll("/","_");
+ TTimeStamp s1;
+ Bool_t result = TFile::Cp(src.Data(),dst.Data(),kTRUE);
+ TTimeStamp s2;
+ AliSysInfo::AddStamp(dst.Data(),counter, result);
+ if (result)
+ {
+ counter++;
+ outputFile << dst.Data()<< endl;
+ }
+ }
+ cout<<counter<<" files copied!"<<endl;
+
+ outputFile.close();
+ gSystem->Exec("touch copy_done");
+ return;
+}
+
--- /dev/null
+#! /bin/bash
+
+# init
+path=$1
+run=$2
+ocdb=$3
+echo "***********************" 2>&1 | tee -a merge.log
+echo mergeMakeOCDB.sh started 2>&1 | tee -a merge.log
+echo path = $path 2>&1 | tee -a merge.log
+echo run = $run 2>&1 | tee -a merge.log
+echo ocdb = $ocdb 2>&1 | tee -a merge.log
+echo "***********************" 2>&1 | tee -a merge.log
+
+# setup components
+components="TOF MeanVertex T0 TRD TPC SDD"
+
+# copy
+echo "***********************" 2>&1 | tee -a merge.log
+echo copying files for run $run 2>&1 | tee -a merge.log
+echo from $path 2>&1 | tee -a merge.log
+echo "***********************" 2>&1 | tee -a merge.log
+aliroot -b -q "merge.C(\"COPY\", \"$path\")" 2>&1 | tee -a merge.log
+mv syswatch.log copy_syswatch.log
+
+# process by component
+for det in $components; do
+
+ # merge
+ echo "***********************" 2>&1 | tee -a merge.log
+ echo merging $det data 2>&1 | tee -a merge.log
+ echo "***********************" 2>&1 | tee -a merge.log
+ aliroot -b -q "merge.C(\"$det\", \"calib.list\")" 2>&1 | tee -a merge.log
+ mv syswatch.log $det\_merge_syswatch.log
+
+ # make OCDB
+ echo "***********************" 2>&1 | tee -a ocdb.log
+ echo making $det OCDB 2>&1 | tee -a ocdb.log
+ echo "***********************" 2>&1 | tee -a ocdb.log
+ aliroot -b -q "makeOCDB.C(\"CalibObjects.root\", \"$det\", \"$run\", \"$ocdb\")" 2>&1 | tee -a ocdb.log
+ mv CalibObjects.root $det\_CalibObjects.root
+
+done
+
+# global merge
+echo "***********************" 2>&1 | tee -a merge.log
+echo merging ALL data 2>&1 | tee -a merge.log
+echo "***********************" 2>&1 | tee -a merge.log
+ls *CalibObjects.root > objects.list
+aliroot -b -q "merge.C(\"ALL\", \"objects.list\")" 2>&1 | tee -a merge.log
+touch CalibObjects.root
+
+# summary
+echo "***********************" 2>&1 | tee -a ocdb.log
+echo SUMMARY 2>&1 | tee -a ocdb.log
+echo "***********************" 2>&1 | tee -a ocdb.log
+ls -altr *CalibObjects.root *done 2>&1 | tee -a ocdb.log
\ No newline at end of file
--- /dev/null
+Executable="/alice/cern.ch/user/j/jotwinow/bin/mergeMakeOCDB.sh";
+
+Packages= { "VO_ALICE@AliRoot::v5-02-Rev-04",
+ "VO_ALICE@ROOT::v5-30-06-1",
+ "VO_ALICE@APISCONFIG::V1.1x" };
+
+Jobtag = { "Merging Calibration Objects from calib train and make OCDB params" };
+
+GUIDFILE="guid.txt";
+TTL = "28000";
+Price = 1;
+
+Validationcommand ="/alice/cern.ch/user/j/jotwinow/CPass0/MergeCalibration/validationMerging.sh";
+
+JDLVariables={"Packages", "OutputDir"};
+GUIDFILE="guid.txt";
+
+Arguments = "$1 $2 $3";
+
+Workdirectorysize={"6000MB"};
+
+InputFile={"LF:/alice/cern.ch/user/j/jotwinow/CPass0/MergeCalibration/ConfigCalibTrain.C",
+ "LF:/alice/cern.ch/user/j/jotwinow/CPass0/MergeCalibration/LoadLibraries.C",
+ "LF:/alice/cern.ch/user/j/jotwinow/CPass0/MergeCalibration/makeOCDB.C",
+ "LF:/alice/cern.ch/user/j/jotwinow/CPass0/MergeCalibration/merge.C"
+};
+
+OutputDir="/alice/cern.ch/user/j/jotwinow/CPass0/output/$2/";
+
+OutputArchive={"log_archive:*.log@disk=1",
+ "root_archive.zip:CalibObjects.root,meanITSVertex.root,fitITSVertex.root@disk=1"};
+
--- /dev/null
+#!/bin/bash
+
+# Script to merge objects coming out of the calibration train:
+# Arguments:
+# 1 - directory on which to look for the files to be merged
+# 2 - pattern
+# 3 - OCDB output path
+
+# example:
+# mergeMakeOCDB.sh /alice/cern.ch/user/a/aliprod/CPass0/output/ 000120691 alien://folder=/alice/cern.ch/user/a/aliprod/CPass0/output
+
+#ALIEN setting
+# $1 = directory where to perform the find
+# $2 = pattern
+# $3 = OCDB path
+
+if [ -f Run0_999999999_v3_s0.root ]; then
+ mkdir -p TPC/Calib/Correction
+ mv Run0_999999999_v3_s0.root TPC/Calib/Correction/
+fi
+
+echo ">>>>>>> Running AliRoot to merge calib objects found in $1 with pattern AliESDfriends_v1.root"
+aliroot -l -b -q merge.C\(\"$1\",\"AliESDfriends_v1.root\"\) 2>&1 | tee merge.log
+mv syswatch.log syswatch_merge.log
+
+echo ">>>>>>> Extract OCDB entries for run = $2, to be stored in $3"
+aliroot -l -b -q makeOCDB.C\(\"$2\",\"$3\"\) 2>&1 | tee ocdb.log
+mv syswatch.log syswatch_makeOCDB.log
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff