[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() 
{
  // 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	//____________________________________________________________________
	54	AliSTARTParameters::AliSTARTParameters()
5ac84465	55	{
5ac84465	56	// Default constructor
7bdc4686	57
5ac84465	58	for (Int_t ipmt=0; ipmt<24; ipmt++)
	59	{
	60	SetTimeDelayCablesCFD(ipmt);
	61	SetTimeDelayCablesLED(ipmt);
	62	SetTimeDelayElectronicCFD(ipmt);
	63	SetTimeDelayElectronicLED(ipmt);
	64	SetTimeDelayPMT(ipmt);
7bdc4686	65	SetVariableDelayLine(ipmt);
5ac84465	66	SetSlewingLED(ipmt);
7bdc4686	67	SetSlewingRec(ipmt);
5ac84465	68	SetPh2Mip();
4c7da157	69	SetmV2Mip();
5ac84465	70	SetChannelWidth();
	71	SetmV2channel();
	72	SetGain();
	73	SetQTmin();
	74	SetQTmax();
	75	SetPMTeff(ipmt);
	76	}
7bdc4686	77	SetTimeDelayTVD();
5ac84465	78	SetZposition();
	79
	80	}
	81
	82	//__________________________________________________________________
	83	void
	84	AliSTARTParameters::Init()
	85	{
	86	// Initialize the parameters manager. We need to get stuff from the
	87	// CDB here.
7bdc4686	88	// if (fIsInit) return;
5ac84465	89
5ac84465	90	AliCDBManager* cdb = AliCDBManager::Instance();
7bdc4686	91	// AliCDBStorage *stor = cdb->GetStorage("local://$ALICE_ROOT");
7bdc4686	92	fCalibentry = cdb->Get("START/Calib/Gain_TimeDelay_Slewing_Walk");
5ac84465	93	if (fCalibentry){
5ac84465	94	fgCalibData = (AliSTARTCalibData*)fCalibentry->GetObject();
5ac84465	95	}
5ac84465	96
	97	fIsInit = kTRUE;
	98	}
	99
	100
	101	//__________________________________________________________________
	102	Float_t
	103	AliSTARTParameters::GetGain(Int_t ipmt) const
	104	{
	105	// Returns the calibrated gain for each PMT
	106	//
	107
	108	if (!fCalibentry)
	109	return fFixedGain;
	110
	111	return fgCalibData->GetGain(ipmt);
	112	}
	113
	114	//__________________________________________________________________
	115	Float_t
	116	AliSTARTParameters::GetTimeDelayLED(Int_t ipmt)
	117	{
	118	// return time delay for LED channel
	119	//
	120	if (!fCalibentry) {
	121	fTimeDelayLED = fTimeDelayCablesLED[ipmt] + fTimeDelayElectronicLED[ipmt] + fTimeDelayPMT[ipmt];
	122	return fTimeDelayLED;
	123	}
	124	return fgCalibData ->GetTimeDelayLED(ipmt);
	125	}
	126	//__________________________________________________________________
	127	Float_t
	128	AliSTARTParameters::GetTimeDelayCFD(Int_t ipmt)
	129	{
	130	// return time delay for CFD channel
	131	//
	132	if (!fCalibentry)
	133	{
	134	fTimeDelayCFD = fTimeDelayCablesCFD[ipmt] + fTimeDelayElectronicCFD[ipmt] + fTimeDelayPMT[ipmt] + fVariableDelayLine[ipmt];
04faaba6	135
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];}
7bdc4686	195	TGraph* gr = new TGraph(23,y1,mv1);
	196	fSlewingRec.AddAtAndExpand(gr,ipmt);
	197
	198	}
	199	//__________________________________________________________________
	200
	201	Float_t AliSTARTParameters::GetSlewingRec(Int_t ipmt, Float_t mv) const
	202	{
	203	if (!fCalibentry) {
	204	return ((TGraph*)fSlewingRec.At(ipmt))->Eval(mv);
	205	}
	206	return fgCalibData -> GetSlewingRec(ipmt, mv) ;
	207	}
	208
	209	//__________________________________________________________________
	210
	211	TGraph *AliSTARTParameters::GetSlewRec(Int_t ipmt) const
	212	{
	213	if (!fCalibentry) {
	214	return (TGraph*)fSlewingRec.At(ipmt);
	215	}
	216	return fgCalibData -> GetSlewRec(ipmt) ;
	217	}
5ac84465	218
04faaba6	219	//
5ac84465	220	//__________________________________________________________________
	221	void
	222	AliSTARTParameters::SetPMTeff(Int_t ipmt)
	223	{
	224	Float_t lambda[50];
04faaba6	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	}