[u/mrichter/AliRoot.git] / PWGPP / CalibMacros / CPass1 / AddTaskTPCCalib.C

/*

 This macros setup the TPC calibration task AddTaskTPCCalib
 for CPass1.
 - 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);

  AliTPCAnalysisTaskcalib *taskAlign=new AliTPCAnalysisTaskcalib("CalibObjectsTrain1");
  SetupCalibTaskTrainAlign(taskAlign);
  mgr->AddTask(taskAlign);

  AliAnalysisDataContainer *cinputAlign = mgr->GetCommonInputContainer();
  if (!cinputAlign) cinputAlign = mgr->CreateContainer("cchain",TChain::Class(), 
                                      AliAnalysisManager::kInputContainer);
  AliAnalysisDataContainer *coutputAlign = mgr->CreateContainer("TPCAlign",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");  

  mgr->ConnectInput(taskAlign,0,cinputAlign);
  mgr->ConnectOutput(taskAlign,0,coutputAlign);

  AliTPCAnalysisTaskcalib *taskCluster=new AliTPCAnalysisTaskcalib("CalibObjectsTrain1");
  SetupCalibTaskTrainCluster(taskCluster);
  mgr->AddTask(taskCluster);
  AliAnalysisDataContainer *coutputAlign = mgr->CreateContainer("TPCCluster",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");  
  mgr->ConnectInput(taskCluster,0,cinput1);
  mgr->ConnectOutput(taskCluster,0,coutputAlign);

  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
  //

  Bool_t useQmax = (grpData->GetBeamType()).Contains("Pb-Pb");

  AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
  AliTPCcalibTimeGain *calibTimeGain = new AliTPCcalibTimeGain(name,"calibTimeGain", startTime.GetSec(), stopTime.GetSec(), 10*60);
  calibTimeGain->SetIsCosmic(isCosmic);
  calibTimeGain->SetUseCookAnalytical(kTRUE);
  calibTimeGain->SetUseMax(useQmax);
  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(useQmax);
  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 5000 tracks per event
  calibTime->SetCutTracks(5000);

  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 AddCalibAlign(TObject* task){
  //
  // Responsible: Marian Ivanov
  // Description:
  //
  AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task; 
  AliTPCcalibAlign *calibAlign = new AliTPCcalibAlign("alignTPC","Alignment of the TPC sectors");
  calibAlign->SetDebugLevel(debugLevel);
  calibAlign->SetStreamLevel(streamLevel);
  calibAlign->SetTriggerMask(-1,-1,kTRUE);        //accept everything
  myTask->AddJob(calibAlign);
}


void AddCalibLaser(TObject* task){
  //
  // Responsible: Marian Ivanov
  // Description:
  //
  AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
  AliTPCcalibLaser *calibLaser = new AliTPCcalibLaser("laserTPC","laserTPC");
  calibLaser->SetDebugLevel(debugLevel);
  calibLaser->SetStreamLevel(streamLevel);
  calibLaser->SetTriggerMask(-1,-1,kFALSE);        //accept everything
  myTask->AddJob(calibLaser);
}


void AddCalibCosmic(TObject* task){
  //
  // Responsible: Marian Ivanov
  // Description:
  // Histogram residuals and pulls of the track parameters in bins of track parameters
  // Dump cosmic tracks to the tree
  //
  AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
  AliTPCcalibCosmic *calibCosmic = new AliTPCcalibCosmic("cosmicTPC","cosmicTPC");
  calibCosmic->SetDebugLevel(debugLevel);
  calibCosmic->SetStreamLevel(1);
  calibCosmic->SetTriggerMask(-1,-1,kTRUE);        //accept everything
  myTask->AddJob(calibCosmic);
}


//_____________________________________________________________________________
void SetupCalibTaskTrain1(TObject* task){
  //
  // Setup tasks for calibration train
  //
  // AddCalibCalib(task); - disable refitting
  AddCalibTimeGain(task);
  AddCalibTime(task);
  //AddCalibCosmic(task);
}


void SetupCalibTaskTrainAlign(TObject* task){
  //
  // Setup tasks for calibration train
  //
  AddCalibAlign(task);
  AddCalibLaser(task);
}


void SetupCalibTaskTrainCluster(TObject* task){
  //
  // Setup tasks for calibration train
  //
  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);
  // in CPass1 use a default setting
//   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); 
}
Commit	Line	Data
807998f3	1	/*
	2
	3	This macros setup the TPC calibration task AddTaskTPCCalib
054d9070	4	for CPass1.
807998f3	5	- the run number is required to config TPC OCDB
	6
	7	The following calibration components are added to the AliTPCAnalysisTaskcalib task:
	8	1. AliTPCcalibCalib - redo reconstruction with current calibration
	9	2. AliTPCcalibTimeGain - TPC time dependent gain calibration
	10	3. AliTPCcalibTime - TPC time dependent drift time calibration
	11
	12	*/
	13
	14	// function to set TPC OCDB parameters
	15	void ConfigOCDB(Int_t crun);
	16
	17	Int_t debugLevel=0;
	18	Int_t streamLevel=0;
	19
	20	//_____________________________________________________________________________
	21	AliAnalysisTask *AddTaskTPCCalib(Int_t runNumber)
	22	{
	23	//
	24	// add calibration task
	25	//
	26	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	27	if (!mgr) {
	28	::Error("AddTaskTPCCalib", "No analysis manager to connect to.");
	29	return NULL;
	30	}
	31
	32	// check the input handler
	33	if (!mgr->GetInputEventHandler()) {
	34	::Error("AddTaskTPCCalib", "This task requires an input event handler");
	35	return NULL;
	36	}
	37
	38	// set TPC OCDB parameters
	39	ConfigOCDB(runNumber);
	40
	41	// setup task
	42	AliTPCAnalysisTaskcalib *task1=new AliTPCAnalysisTaskcalib("CalibObjectsTrain1");
	43	SetupCalibTaskTrain1(task1);
	44	mgr->AddTask(task1);
	45
	46	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
	47	if (!cinput1) cinput1 = mgr->CreateContainer("cchain",TChain::Class(),
	48	AliAnalysisManager::kInputContainer);
	49	AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("TPCCalib",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
	50
	51	mgr->ConnectInput(task1,0,cinput1);
	52	mgr->ConnectOutput(task1,0,coutput1);
fe072aad	53
	54	AliTPCAnalysisTaskcalib *taskAlign=new AliTPCAnalysisTaskcalib("CalibObjectsTrain1");
	55	SetupCalibTaskTrainAlign(taskAlign);
	56	mgr->AddTask(taskAlign);
	57
	58	AliAnalysisDataContainer *cinputAlign = mgr->GetCommonInputContainer();
	59	if (!cinputAlign) cinputAlign = mgr->CreateContainer("cchain",TChain::Class(),
	60	AliAnalysisManager::kInputContainer);
	61	AliAnalysisDataContainer *coutputAlign = mgr->CreateContainer("TPCAlign",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
	62
	63	mgr->ConnectInput(taskAlign,0,cinputAlign);
	64	mgr->ConnectOutput(taskAlign,0,coutputAlign);
	65
	66	AliTPCAnalysisTaskcalib *taskCluster=new AliTPCAnalysisTaskcalib("CalibObjectsTrain1");
	67	SetupCalibTaskTrainCluster(taskCluster);
	68	mgr->AddTask(taskCluster);
	69	AliAnalysisDataContainer *coutputAlign = mgr->CreateContainer("TPCCluster",TObjArray::Class(), AliAnalysisManager::kOutputContainer, "AliESDfriends_v1.root");
	70	mgr->ConnectInput(taskCluster,0,cinput1);
	71	mgr->ConnectOutput(taskCluster,0,coutputAlign);
	72
807998f3	73	return task1;
	74	}
	75
	76	//_____________________________________________________________________________
	77	void AddCalibCalib(TObject* task){
	78	//
	79	// Responsible: Marian Ivanov
	80	// Description:
	81	// calibCalib is a prefilter
	82	// The current OCDB entries transformation are applied on cluster, tracks are refitted
	83	//
	84	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	85	AliTPCcalibCalib *calibCalib = new AliTPCcalibCalib("calibTPC","calibTPC");
	86	calibCalib->SetDebugLevel(0);
	87	calibCalib->SetStreamLevel(0);
	88	calibCalib->SetTriggerMask(-1,-1,kFALSE); //accept everything
	89	myTask->AddJob(calibCalib);
	90	}
	91
	92	//_____________________________________________________________________________
	93	void AddCalibTimeGain(TObject* task, Bool_t isCosmic = kFALSE, char * name = "calibTimeGain"){
	94	//
	95	// Responsible: Alexander Kalweit
	96	// Description: Time Gain calibration
	97	//
	98
	99	// Set run time ranges (time stamps)
	100	AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
	101	if(!entry) {
	102	::Error("AddCalibTimeGain","Cannot get AliCDBEntry");
	103	return;
	104	}
	105	const AliGRPObject* grpData = dynamic_cast<AliGRPObject*>(entry->GetObject());
	106	if(!grpData) {
	107	::Error("AddCalibTimeGain","Cannot get AliGRPObject");
	108	return;
	109	}
	110	time_t sTime = grpData->GetTimeStart();
	111	time_t eTime = grpData->GetTimeEnd();
	112	TTimeStamp startRunTime(sTime);
	113	TTimeStamp stopRunTime(eTime);
	114
	115	UInt_t year;
	116	startRunTime.GetDate(kTRUE,0,&year);
	117	TTimeStamp startTime(year,1,1,0,0,0);
	118	TTimeStamp stopTime(year,12,31,23,59,59);
	119
	120	//
	121	// setup calibration component
	122	//
1611b277	123
	124	Bool_t useQmax = (grpData->GetBeamType()).Contains("Pb-Pb");
	125
807998f3	126	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	127	AliTPCcalibTimeGain calibTimeGain = new AliTPCcalibTimeGain(name,"calibTimeGain", startTime.GetSec(), stopTime.GetSec(), 1060);
	128	calibTimeGain->SetIsCosmic(isCosmic);
	129	calibTimeGain->SetUseCookAnalytical(kTRUE);
1611b277	130	calibTimeGain->SetUseMax(useQmax);
807998f3	131	calibTimeGain->SetDebugLevel(0);
	132	calibTimeGain->SetStreamLevel(0);
	133	calibTimeGain->SetTriggerMask(-1,-1,kTRUE); //reject laser
	134	calibTimeGain->SetLowerTrunc(0.02);
	135	calibTimeGain->SetUpperTrunc(0.6);
	136
	137	myTask->AddJob(calibTimeGain);
	138
	139	AliTPCcalibGainMult *calibGainMult = new AliTPCcalibGainMult("calibGainMult","calibGainMult");
1611b277	140	calibGainMult->SetUseMax(useQmax);
807998f3	141	calibGainMult->SetDebugLevel(0);
	142	calibGainMult->SetStreamLevel(0);
	143	calibGainMult->SetTriggerMask(-1,-1,kTRUE); //reject laser
	144	calibGainMult->SetLowerTrunc(0.02);
	145	calibGainMult->SetUpperTrunc(0.6);
	146
8cf075d0	147	myTask->AddJob(calibGainMult);
807998f3	148
	149	}
	150
	151	//_____________________________________________________________________________
	152	void AddCalibTime(TObject* task){
	153	//
	154	// Responsible: Dag Larsen
	155	// Description: Time V drift calibration
	156	//
	157
	158	// Set run time ranges (time stamps)
	159	AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
	160	if(!entry) {
	161	::Error("AddCalibTime","Cannot get AliCDBEntry");
	162	return;
	163	}
	164	const AliGRPObject* grpData = dynamic_cast<AliGRPObject*>(entry->GetObject());
	165	if(!grpData) {
	166	::Error("AddCalibTime","Cannot get AliGRPObject");
	167	return;
	168	}
	169	time_t sTime = grpData->GetTimeStart();
	170	time_t eTime = grpData->GetTimeEnd();
	171
	172	TTimeStamp startRunTime(sTime);
	173	TTimeStamp stopRunTime(eTime);
	174
	175	UInt_t year;
	176	startRunTime.GetDate(kTRUE,0,&year);
	177	TTimeStamp startTime(year,1,1,0,0,0);
	178	TTimeStamp stopTime(year,12,31,23,59,59);
	179
	180	//
	181	// setup calibration component
	182	//
	183	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	184	AliTPCcalibTime calibTime = new AliTPCcalibTime("calibTime","calibTime", startTime.GetSec(), stopTime.GetSec(), 1060, 2);
	185	calibTime->SetDebugLevel(0);
	186	calibTime->SetStreamLevel(0);
	187	calibTime->SetTriggerMask(-1,-1,kFALSE); //accept everything
	188
fe072aad	189	// max 5000 tracks per event
fe072aad	190	calibTime->SetCutTracks(5000);
807998f3	191
	192	myTask->AddJob(calibTime);
	193	}
	194
	195
	196	void AddCalibTracks(TObject* task){
	197	//
	198	// Responsible: Marian Ivanov
	199	// Description:
	200	// Histogram residuals and pulls of the track parameters in bins of track parameters
	201	//
	202	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	203	AliTPCClusterParam * clusterParam = AliTPCcalibDB::Instance()->GetClusterParam();
	204
	205	AliTPCcalibTracksCuts *cuts = new AliTPCcalibTracksCuts(30, 0.4, 5, 0.13, 0.018);
	206	//
	207	AliTPCcalibTracks *calibTracks = new AliTPCcalibTracks("calibTracks", "Resolution calibration object for tracks", clusterParam, cuts);
	208	calibTracks->SetDebugLevel(debugLevel);
	209	calibTracks->SetStreamLevel(streamLevel);
	210	calibTracks->SetTriggerMask(-1,-1,kTRUE);
	211	myTask->AddJob(calibTracks);
	212	}
	213
	214
fe072aad	215	void AddCalibAlign(TObject* task){
	216	//
	217	// Responsible: Marian Ivanov
	218	// Description:
	219	//
	220	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	221	AliTPCcalibAlign *calibAlign = new AliTPCcalibAlign("alignTPC","Alignment of the TPC sectors");
	222	calibAlign->SetDebugLevel(debugLevel);
	223	calibAlign->SetStreamLevel(streamLevel);
	224	calibAlign->SetTriggerMask(-1,-1,kTRUE); //accept everything
	225	myTask->AddJob(calibAlign);
	226	}
	227
	228
	229	void AddCalibLaser(TObject* task){
	230	//
	231	// Responsible: Marian Ivanov
	232	// Description:
	233	//
	234	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	235	AliTPCcalibLaser *calibLaser = new AliTPCcalibLaser("laserTPC","laserTPC");
	236	calibLaser->SetDebugLevel(debugLevel);
	237	calibLaser->SetStreamLevel(streamLevel);
	238	calibLaser->SetTriggerMask(-1,-1,kFALSE); //accept everything
	239	myTask->AddJob(calibLaser);
	240	}
	241
	242
9e160db9	243	void AddCalibCosmic(TObject* task){
	244	//
	245	// Responsible: Marian Ivanov
	246	// Description:
	247	// Histogram residuals and pulls of the track parameters in bins of track parameters
	248	// Dump cosmic tracks to the tree
	249	//
	250	AliTPCAnalysisTaskcalib* myTask = (AliTPCAnalysisTaskcalib*) task;
	251	AliTPCcalibCosmic *calibCosmic = new AliTPCcalibCosmic("cosmicTPC","cosmicTPC");
	252	calibCosmic->SetDebugLevel(debugLevel);
	253	calibCosmic->SetStreamLevel(1);
	254	calibCosmic->SetTriggerMask(-1,-1,kTRUE); //accept everything
	255	myTask->AddJob(calibCosmic);
	256	}
	257
fe072aad	258
fe072aad	259
807998f3	260	//_____________________________________________________________________________
	261	void SetupCalibTaskTrain1(TObject* task){
	262	//
	263	// Setup tasks for calibration train
	264	//
fe072aad	265	// AddCalibCalib(task); - disable refitting
807998f3	266	AddCalibTimeGain(task);
807998f3	267	AddCalibTime(task);
9e160db9	268	//AddCalibCosmic(task);
807998f3	269	}
807998f3	270
fe072aad	271
	272	void SetupCalibTaskTrainAlign(TObject* task){
	273	//
	274	// Setup tasks for calibration train
	275	//
	276	AddCalibAlign(task);
	277	AddCalibLaser(task);
	278	}
	279
	280
	281	void SetupCalibTaskTrainCluster(TObject* task){
	282	//
	283	// Setup tasks for calibration train
	284	//
	285	AddCalibTracks(task);
	286	}
	287
	288
807998f3	289	//_____________________________________________________________________________
	290	void ConfigOCDB(Int_t run){
	291	//
	292	// Configure TPC OCDB
	293	//
	294	printf("SETUP OCBD for TPC\n");
	295	printf("SETUP OCBD for TPC\n");
	296	printf("SETUP OCBD for TPC Run =%d\n", run);
	297	//
	298	//
	299	AliTPCParam *param= AliTPCcalibDB::Instance()->GetParameters();
	300	param->ReadGeoMatrices();
	301	//
	302	AliMagF* magF= TGeoGlobalMagField::Instance()->GetField();
	303	printf("\n\nSET EXB FIELD\t\n\n");
	304	AliTPCcalibDB::Instance()->SetExBField(magF);
	305	//
	306	//
	307	//
	308	AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
	309	//
	310	//AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetCosmicTestParam(kTRUE);
	311	//
	312	AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/RecoParam");
	313	if (!entry){
	314	printf("TPC reco param not available");
	315	}
	316	TObjArray * array = (TObjArray*)entry->GetObject();
	317	if (!array){
	318	printf("TPC reco param not available");
	319	}
	320	// 0 - Low Flux (pp), 1- High Flux (Pb-Pb)
	321	AliTPCRecoParam * tpcRecoParam = (AliTPCRecoParam*)array->At(1);
	322
	323	transform->SetCurrentRecoParam(tpcRecoParam);
fe072aad	324	// in CPass1 use a default setting
	325	// tpcRecoParam->SetUseGainCorrectionTime(0);
	326	// tpcRecoParam->SetUseRPHICorrection(kFALSE);
	327	// tpcRecoParam->SetUseTOFCorrection(kFALSE);
	328	// //
	329	// tpcRecoParam->SetUseDriftCorrectionTime(0);
	330	// tpcRecoParam->SetUseDriftCorrectionGY(0);
	331	// //
	332	// tpcRecoParam->SetUseRadialCorrection(kFALSE);
	333	// tpcRecoParam->SetUseQuadrantAlignment(kFALSE);
	334	// //
	335	// tpcRecoParam->SetUseSectorAlignment(kFALSE);
	336	// tpcRecoParam->SetUseFieldCorrection(kFALSE);
	337	// tpcRecoParam->SetUseExBCorrection(kFALSE);
	338	// //
	339	// tpcRecoParam->SetUseMultiplicityCorrectionDedx(kFALSE);
	340	// tpcRecoParam->SetUseAlignmentTime(kFALSE);
	341	// tpcRecoParam->SetUseComposedCorrection(kTRUE);
807998f3	342
	343	AliTPCcalibDB::Instance()->SetRun(run);
	344	}