[u/mrichter/AliRoot.git] / START / AliSTARTParameters.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id:  */

//____________________________________________________________________
//                                                                          
// START - T0. 
//
// This class is a singleton that handles various parameters of
// the START detectors.  
// Eventually, this class will use the Conditions DB to get the
// various parameters, which code can then request from here.
//                                                       
#include "AliLog.h"		  
#include "AliSTARTParameters.h"	  
#include "AliSTARTCalibData.h"   
#include <AliCDBManager.h>        
#include <AliCDBEntry.h>          
#include <AliCDBStorage.h>         
#include <Riostream.h>

AliSTARTCalibData* AliSTARTParameters::fgCalibData = 0;
//====================================================================
ClassImp(AliSTARTParameters)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliSTARTParameters* AliSTARTParameters::fgInstance = 0;
//____________________________________________________________________
AliSTARTParameters* 
AliSTARTParameters::Instance() 
{
  // Get static instance 
  if (!fgInstance) fgInstance = new AliSTARTParameters;
  return fgInstance;
}

//____________________________________________________________________
AliSTARTParameters::AliSTARTParameters()
  :fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fFixedGain(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry() 
{
  // Default constructor 

  for (Int_t ipmt=0; ipmt<24; ipmt++)
    {
      SetTimeDelayCablesCFD(ipmt);
      SetTimeDelayCablesLED(ipmt);
      SetTimeDelayElectronicCFD(ipmt);
      SetTimeDelayElectronicLED(ipmt);
      SetTimeDelayPMT(ipmt);
       SetVariableDelayLine(ipmt);
      SetSlewingLED(ipmt);
      SetSlewingRec(ipmt);
      SetPh2Mip();      
      SetmV2Mip();      
      SetChannelWidth();
      SetmV2channel();
      SetGain();
      SetQTmin();
      SetQTmax();
      SetPMTeff(ipmt);
   }
  SetTimeDelayTVD();
  SetZposition();
  
}

//__________________________________________________________________
void
AliSTARTParameters::Init()
{
  // Initialize the parameters manager.  We need to get stuff from the
  // CDB here. 
  //   if (fIsInit) return;
  
  AliCDBManager* cdb      = AliCDBManager::Instance();
  //  AliCDBStorage *stor = cdb->GetStorage("local://$ALICE_ROOT");
  fCalibentry  = cdb->Get("START/Calib/Gain_TimeDelay_Slewing_Walk");
  if (fCalibentry){
   fgCalibData  = (AliSTARTCalibData*)fCalibentry->GetObject();
  }

  fIsInit = kTRUE;
}


//__________________________________________________________________
Float_t
AliSTARTParameters::GetGain(Int_t ipmt) const
{
  // Returns the calibrated gain for each PMT 
  // 

  if (!fCalibentry) 
    return fFixedGain;
   
  return fgCalibData->GetGain(ipmt);
}

//__________________________________________________________________
Float_t
AliSTARTParameters::GetTimeDelayLED(Int_t ipmt) 
{
  // return time delay for LED channel
  // 
  if (!fCalibentry) {
    fTimeDelayLED = fTimeDelayCablesLED[ipmt] + fTimeDelayElectronicLED[ipmt] + fTimeDelayPMT[ipmt];
    return  fTimeDelayLED;
  } 
  return fgCalibData ->GetTimeDelayLED(ipmt);
}
//__________________________________________________________________
Float_t
AliSTARTParameters::GetTimeDelayCFD(Int_t ipmt) 
{
  // return time delay for CFD channel
   // 
  if (!fCalibentry) 
    {
      fTimeDelayCFD = fTimeDelayCablesCFD[ipmt] + fTimeDelayElectronicCFD[ipmt] + fTimeDelayPMT[ipmt] + fVariableDelayLine[ipmt];
      return fTimeDelayCFD+37;
    }
   
  return fgCalibData->GetTimeDelayCFD(ipmt);
}

//__________________________________________________________________

void 
AliSTARTParameters::SetSlewingLED(Int_t ipmt)
{
  //  Set Slweing Correction for LED channel 
     Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
		       400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
		       6000, 7000,8000};
      Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
		       1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
		       156, 78, 0};
      
      TGraph* gr = new TGraph(23,mv,y);
      fSlewingLED.AddAtAndExpand(gr,ipmt);
  }
//__________________________________________________________________

Float_t AliSTARTParameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
{
  if (!fCalibentry) {
    return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv); 
  } 
  return fgCalibData->GetSlewingLED(ipmt, mv) ;
}


//__________________________________________________________________

TGraph *AliSTARTParameters::GetSlew(Int_t ipmt) const
{
  if (!fCalibentry) {
    return  (TGraph*)fSlewingLED.At(ipmt); 
  } 
  return fgCalibData -> GetSlew(ipmt) ;
}

//__________________________________________________________________


void 
AliSTARTParameters::SetSlewingRec(Int_t ipmt)
{
  //  Set Slweing Correction for LED channel 
      Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
			400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
			6000, 7000,8000};
      Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781, 
		       1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234, 
		       156, 78, 0};
      Float_t y1[23], mv1[23];
      for (Int_t i=0; i<23; i++){
	y1[i] = y[22-i]; mv1[i] = mv[22-i];}

      TGraph* gr = new TGraph(23,y1,mv1);
      fSlewingRec.AddAtAndExpand(gr,ipmt);

}
//__________________________________________________________________

Float_t AliSTARTParameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
{
  if (!fCalibentry) {
    return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv); 
  } 
  return fgCalibData -> GetSlewingRec(ipmt, mv) ;
}

//__________________________________________________________________

TGraph *AliSTARTParameters::GetSlewRec(Int_t ipmt) const
{
  if (!fCalibentry) {
    return  (TGraph*)fSlewingRec.At(ipmt); 
  } 
  return fgCalibData -> GetSlewRec(ipmt) ;
}

//__________________________________________________________________
void 
AliSTARTParameters::SetPMTeff(Int_t ipmt)
{
  Float_t lambda[50];
  Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913, 
		    0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
		    0.252276, 0.256267,0.26,     0.27125,  0.281818,
		    0.288118, 0.294057,0.296222, 0.301622, 0.290421, 
		    0.276615, 0.2666,  0.248,    0.23619,  0.227814, 
		    0.219818, 0.206667,0.194087, 0.184681, 0.167917, 
		    0.154367, 0.1364,  0.109412, 0.0834615,0.0725283, 
		    0.0642963,0.05861, 0.0465,   0.0413333,0.032069, 
		    0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
		    0.003875, 0.00190, 0,        0,        0          } ;
  for (Int_t i=0; i<50; i++) lambda[i]=200+10*i; 

  TGraph* gr = new TGraph(50,lambda,eff);
  fPMTeff.AddAtAndExpand(gr,ipmt);
}
Commit	Line	Data
5ac84465	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id: */
	17
	18	//____________________________________________________________________
	19	//
	20	// START - T0.
	21	//
	22	// This class is a singleton that handles various parameters of
	23	// the START detectors.
	24	// Eventually, this class will use the Conditions DB to get the
	25	// various parameters, which code can then request from here.
	26	//
	27	#include "AliLog.h"
	28	#include "AliSTARTParameters.h"
	29	#include "AliSTARTCalibData.h"
5ac84465	30	#include <AliCDBManager.h>
	31	#include <AliCDBEntry.h>
	32	#include <AliCDBStorage.h>
	33	#include <Riostream.h>
	34
5ac84465	35	AliSTARTCalibData* AliSTARTParameters::fgCalibData = 0;
	36	//====================================================================
	37	ClassImp(AliSTARTParameters)
	38	#if 0
	39	; // This is here to keep Emacs for indenting the next line
	40	#endif
	41
	42	//____________________________________________________________________
	43	AliSTARTParameters* AliSTARTParameters::fgInstance = 0;
	44	//____________________________________________________________________
	45	AliSTARTParameters*
	46	AliSTARTParameters::Instance()
	47	{
	48	// Get static instance
	49	if (!fgInstance) fgInstance = new AliSTARTParameters;
	50	return fgInstance;
	51	}
	52
	53	//____________________________________________________________________
51f1bdcf	54	AliSTARTParameters::AliSTARTParameters()
51f1bdcf	55	:fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fFixedGain(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry()
5ac84465	56	{
5ac84465	57	// Default constructor
7bdc4686	58
5ac84465	59	for (Int_t ipmt=0; ipmt<24; ipmt++)
	60	{
	61	SetTimeDelayCablesCFD(ipmt);
	62	SetTimeDelayCablesLED(ipmt);
	63	SetTimeDelayElectronicCFD(ipmt);
	64	SetTimeDelayElectronicLED(ipmt);
	65	SetTimeDelayPMT(ipmt);
7bdc4686	66	SetVariableDelayLine(ipmt);
5ac84465	67	SetSlewingLED(ipmt);
7bdc4686	68	SetSlewingRec(ipmt);
5ac84465	69	SetPh2Mip();
4c7da157	70	SetmV2Mip();
5ac84465	71	SetChannelWidth();
	72	SetmV2channel();
	73	SetGain();
	74	SetQTmin();
	75	SetQTmax();
	76	SetPMTeff(ipmt);
	77	}
7bdc4686	78	SetTimeDelayTVD();
5ac84465	79	SetZposition();
	80
	81	}
	82
	83	//__________________________________________________________________
	84	void
	85	AliSTARTParameters::Init()
	86	{
	87	// Initialize the parameters manager. We need to get stuff from the
	88	// CDB here.
7bdc4686	89	// if (fIsInit) return;
5ac84465	90
5ac84465	91	AliCDBManager* cdb = AliCDBManager::Instance();
7bdc4686	92	// AliCDBStorage *stor = cdb->GetStorage("local://$ALICE_ROOT");
7bdc4686	93	fCalibentry = cdb->Get("START/Calib/Gain_TimeDelay_Slewing_Walk");
5ac84465	94	if (fCalibentry){
5ac84465	95	fgCalibData = (AliSTARTCalibData*)fCalibentry->GetObject();
5ac84465	96	}
5ac84465	97
	98	fIsInit = kTRUE;
	99	}
	100
	101
	102	//__________________________________________________________________
	103	Float_t
	104	AliSTARTParameters::GetGain(Int_t ipmt) const
	105	{
	106	// Returns the calibrated gain for each PMT
	107	//
	108
	109	if (!fCalibentry)
	110	return fFixedGain;
	111
	112	return fgCalibData->GetGain(ipmt);
	113	}
	114
	115	//__________________________________________________________________
	116	Float_t
	117	AliSTARTParameters::GetTimeDelayLED(Int_t ipmt)
	118	{
	119	// return time delay for LED channel
	120	//
	121	if (!fCalibentry) {
	122	fTimeDelayLED = fTimeDelayCablesLED[ipmt] + fTimeDelayElectronicLED[ipmt] + fTimeDelayPMT[ipmt];
	123	return fTimeDelayLED;
	124	}
	125	return fgCalibData ->GetTimeDelayLED(ipmt);
	126	}
	127	//__________________________________________________________________
	128	Float_t
	129	AliSTARTParameters::GetTimeDelayCFD(Int_t ipmt)
	130	{
	131	// return time delay for CFD channel
	132	//
	133	if (!fCalibentry)
	134	{
	135	fTimeDelayCFD = fTimeDelayCablesCFD[ipmt] + fTimeDelayElectronicCFD[ipmt] + fTimeDelayPMT[ipmt] + fVariableDelayLine[ipmt];
04faaba6	136	return fTimeDelayCFD+37;
5ac84465	137	}
	138
	139	return fgCalibData->GetTimeDelayCFD(ipmt);
	140	}
	141
	142	//__________________________________________________________________
	143
	144	void
	145	AliSTARTParameters::SetSlewingLED(Int_t ipmt)
	146	{
	147	// Set Slweing Correction for LED channel
7bdc4686	148	Float_t mv[23] = {25, 30,40,60, 80,100,150,200,250,300,
	149	400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
	150	6000, 7000,8000};
	151	Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
	152	1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
	153	156, 78, 0};
	154
	155	TGraph* gr = new TGraph(23,mv,y);
	156	fSlewingLED.AddAtAndExpand(gr,ipmt);
	157	}
	158	//__________________________________________________________________
	159
	160	Float_t AliSTARTParameters::GetSlewingLED(Int_t ipmt, Float_t mv) const
	161	{
	162	if (!fCalibentry) {
	163	return ((TGraph*)fSlewingLED.At(ipmt))->Eval(mv);
	164	}
	165	return fgCalibData->GetSlewingLED(ipmt, mv) ;
	166	}
	167
	168
	169	//__________________________________________________________________
	170
	171	TGraph *AliSTARTParameters::GetSlew(Int_t ipmt) const
	172	{
	173	if (!fCalibentry) {
	174	return (TGraph*)fSlewingLED.At(ipmt);
	175	}
	176	return fgCalibData -> GetSlew(ipmt) ;
	177	}
	178
	179	//__________________________________________________________________
	180
5ac84465	181
7bdc4686	182	void
	183	AliSTARTParameters::SetSlewingRec(Int_t ipmt)
	184	{
	185	// Set Slweing Correction for LED channel
	186	Float_t mv[23] = {25, 30, 40,60, 80,100,150,200,250,300,
	187	400,500,600,800,1000,1500, 2000, 3000, 4000, 5500,
	188	6000, 7000,8000};
	189	Float_t y[23] = {5044, 4719, 3835, 3224, 2847, 2691,2327, 2067, 1937, 1781,
	190	1560, 1456 ,1339, 1163.5, 1027, 819, 650, 520, 370.5, 234,
	191	156, 78, 0};
	192	Float_t y1[23], mv1[23];
	193	for (Int_t i=0; i<23; i++){
	194	y1[i] = y[22-i]; mv1[i] = mv[22-i];}
0c1330a8	195
7bdc4686	196	TGraph* gr = new TGraph(23,y1,mv1);
	197	fSlewingRec.AddAtAndExpand(gr,ipmt);
	198
	199	}
	200	//__________________________________________________________________
	201
	202	Float_t AliSTARTParameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
	203	{
	204	if (!fCalibentry) {
	205	return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv);
	206	}
	207	return fgCalibData -> GetSlewingRec(ipmt, mv) ;
	208	}
	209
	210	//__________________________________________________________________
	211
	212	TGraph *AliSTARTParameters::GetSlewRec(Int_t ipmt) const
	213	{
	214	if (!fCalibentry) {
	215	return (TGraph*)fSlewingRec.At(ipmt);
	216	}
	217	return fgCalibData -> GetSlewRec(ipmt) ;
	218	}
5ac84465	219
5ac84465	220	//__________________________________________________________________
	221	void
	222	AliSTARTParameters::SetPMTeff(Int_t ipmt)
	223	{
	224	Float_t lambda[50];
0c1330a8	225	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
5ac84465	226	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	227	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	228	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	229	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	230	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	231	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	232	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	233	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	234	0.003875, 0.00190, 0, 0, 0 } ;
	235	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	236
	237	TGraph* gr = new TGraph(50,lambda,eff);
	238	fPMTeff.AddAtAndExpand(gr,ipmt);
	239	}