[u/mrichter/AliRoot.git] / TOF / AliTOFRunParams.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.                  *
 **************************************************************************/

// *
// *
// *
// * this class defines the TOF object to be stored
// * in OCDB on a run-by-run basis in order to have the measurement
// * of the time evolution of T0 and of TOF resolution including
// * average T0 uncertainty
// *
// *
// *

#include "AliTOFRunParams.h"
#include "TGraph.h"

ClassImp(AliTOFRunParams)

//_________________________________________________________

AliTOFRunParams::AliTOFRunParams() :
  TObject(),
  fNPoints(0),
  fTimestamp(NULL),
  fT0(NULL),
  fTOFResolution(NULL),
  fT0Spread(NULL),
  fNRuns(0),
  fRunNb(NULL),
  fRunFirstPoint(NULL),
  fRunLastPoint(NULL),
  fUseLHCClockPhase(kFALSE)
{
  /*
   * default constructor
   */
}

//_________________________________________________________

AliTOFRunParams::AliTOFRunParams(Int_t nPoints, Int_t nRuns) :
  TObject(),
  fNPoints(nPoints),
  fTimestamp(new UInt_t[nPoints]),
  fT0(new Float_t[nPoints]),
  fTOFResolution(new Float_t[nPoints]),
  fT0Spread(new Float_t[nPoints]),
  fNRuns(nRuns),
  fRunNb(new UInt_t[nRuns]),
  fRunFirstPoint(new UInt_t[nRuns]),
  fRunLastPoint(new UInt_t[nRuns]),
  fUseLHCClockPhase(kFALSE)
{
  /*
   * standard constructor
   */
}

//_________________________________________________________

AliTOFRunParams::~AliTOFRunParams()
{
  /*
   * default destructor
   */

  if (fTimestamp) delete [] fTimestamp;
  if (fT0) delete [] fT0;
  if (fTOFResolution) delete [] fTOFResolution;
  if (fT0Spread) delete [] fT0Spread;
  if (fRunNb) delete [] fRunNb;
  if (fRunFirstPoint) delete [] fRunFirstPoint;
  if (fRunLastPoint) delete [] fRunLastPoint;
}

//_________________________________________________________

AliTOFRunParams::AliTOFRunParams(const AliTOFRunParams &source) :
  TObject(source),
  fNPoints(source.fNPoints),
  fTimestamp(new UInt_t[source.fNPoints]),
  fT0(new Float_t[source.fNPoints]),
  fTOFResolution(new Float_t[source.fNPoints]),
  fT0Spread(new Float_t[source.fNPoints]),
  fNRuns(source.fNRuns),
  fRunNb(new UInt_t[source.fNRuns]),
  fRunFirstPoint(new UInt_t[source.fNRuns]),
  fRunLastPoint(new UInt_t[source.fNRuns]),
  fUseLHCClockPhase(source.fUseLHCClockPhase)
{
  /*
   * copy constructor
   */

  for (Int_t i = 0; i < fNPoints; i++) {
    fTimestamp[i] = source.fTimestamp[i];
    fT0[i] = source.fT0[i];
    fTOFResolution[i] = source.fTOFResolution[i];
    fT0Spread[i] = source.fT0Spread[i];
  }

  for (Int_t i = 0; i < fNRuns; i++) {
    fRunNb[i] = source.fRunNb[i];
    fRunFirstPoint[i] = source.fRunFirstPoint[i];
    fRunLastPoint[i] = source.fRunLastPoint[i];
  }
  
}

//_________________________________________________________

AliTOFRunParams &
AliTOFRunParams::operator=(const AliTOFRunParams &source)
{
  /*
   * operator=
   */

  if (this == &source) return *this;
  TObject::operator=(source);
  
  if (fNPoints != source.fNPoints) {
    if (fTimestamp) delete [] fTimestamp;
    if (fT0) delete [] fT0;
    if (fTOFResolution) delete [] fTOFResolution;
    if (fT0Spread) delete [] fT0Spread;
    fNPoints = source.fNPoints;
    fTimestamp = new UInt_t[source.fNPoints];
    fT0 = new Float_t[source.fNPoints];
    fTOFResolution = new Float_t[source.fNPoints];
    fT0Spread = new Float_t[source.fNPoints];
  }

  for (Int_t i = 0; i < fNPoints; i++) {
    fTimestamp[i] = source.fTimestamp[i];
    fT0[i] = source.fT0[i];
    fTOFResolution[i] = source.fTOFResolution[i];
    fT0Spread[i] = source.fT0Spread[i];
  }

  if (fNRuns != source.fNRuns) {
    if (fRunNb) delete [] fRunNb;
    if (fRunFirstPoint) delete [] fRunFirstPoint;
    if (fRunLastPoint) delete [] fRunLastPoint;
    fNRuns = source.fNRuns;
    fRunNb = new UInt_t[source.fNRuns];
    fRunFirstPoint = new UInt_t[source.fNRuns];
    fRunLastPoint = new UInt_t[source.fNRuns];
  }

  for (Int_t i = 0; i < fNRuns; i++) {
    fRunNb[i] = source.fRunNb[i];
    fRunFirstPoint[i] = source.fRunFirstPoint[i];
    fRunLastPoint[i] = source.fRunLastPoint[i];
  }

  fUseLHCClockPhase = source.fUseLHCClockPhase;

  return *this;
}

//_________________________________________________________

Float_t
AliTOFRunParams::EvalT0(UInt_t timestamp)
{
  /*
   * eval T0
   */

  /* critical cases:
     1. no measurement -> 0.
     2. single measurement -> single value
     3. timestamp before first measurement -> first value
     4. timestamp after last measurement -> last value
  */
  if (fNPoints <= 0 || !fT0 || !fTimestamp) return 0.;
  if (fNPoints == 1) return fT0[0];
  if (timestamp <= fTimestamp[0]) return fT0[0];
  if (timestamp >= fTimestamp[fNPoints - 1]) return fT0[fNPoints - 1];

  /* interpolate value */
  Int_t ipoint;
  for (ipoint = 0; ipoint < fNPoints - 1; ipoint++)
    if (timestamp >= fTimestamp[ipoint] && timestamp < fTimestamp[ipoint + 1])
      break;
  Float_t coeff = (fT0[ipoint + 1] - fT0[ipoint]) / (Float_t)(fTimestamp[ipoint + 1] - fTimestamp[ipoint]);
  Float_t t0 = fT0[ipoint] + coeff * (timestamp - fTimestamp[ipoint]);
  
  return t0;
}

//_________________________________________________________

Float_t
AliTOFRunParams::EvalTOFResolution(UInt_t timestamp)
{
  /*
   * eval TOF resolution
   */

  /* critical cases:
     1. no measurement -> 0.
     2. single measurement -> single value
     3. timestamp before first measurement -> first value
     4. timestamp after last measurement -> last value
  */
  if (fNPoints <= 0 || !fTOFResolution || !fTimestamp) return 0.;
  if (fNPoints == 1) return fTOFResolution[0];
  if (timestamp <= fTimestamp[0]) return fTOFResolution[0];
  if (timestamp >= fTimestamp[fNPoints - 1]) return fTOFResolution[fNPoints - 1];

  /* interpolate value */
  Int_t ipoint;
  for (ipoint = 0; ipoint < fNPoints - 1; ipoint++)
    if (timestamp >= fTimestamp[ipoint] && timestamp < fTimestamp[ipoint + 1])
      break;
  Float_t coeff = (fTOFResolution[ipoint + 1] - fTOFResolution[ipoint]) / (Float_t)(fTimestamp[ipoint + 1] - fTimestamp[ipoint]);
  Float_t reso = fTOFResolution[ipoint] + coeff * (timestamp - fTimestamp[ipoint]);
  
  return reso;
}

//_________________________________________________________

Float_t
AliTOFRunParams::EvalT0Spread(UInt_t timestamp)
{
  /*
   * eval T0 spread
   */

  /* critical cases:
     1. no measurement -> 0.
     2. single measurement -> single value
     3. timestamp before first measurement -> first value
     4. timestamp after last measurement -> last value
  */
  if (fNPoints <= 0 || !fT0Spread || !fTimestamp) return 0.;
  if (fNPoints == 1) return fT0Spread[0];
  if (timestamp <= fTimestamp[0]) return fT0Spread[0];
  if (timestamp >= fTimestamp[fNPoints - 1]) return fT0Spread[fNPoints - 1];

  /* interpolate value */
  Int_t ipoint;
  for (ipoint = 0; ipoint < fNPoints - 1; ipoint++)
    if (timestamp >= fTimestamp[ipoint] && timestamp < fTimestamp[ipoint + 1])
      break;
  Float_t coeff = (fT0Spread[ipoint + 1] - fT0Spread[ipoint]) / (Float_t)(fTimestamp[ipoint + 1] - fTimestamp[ipoint]);
  Float_t spread = fT0Spread[ipoint] + coeff * (timestamp - fTimestamp[ipoint]);
  
  return spread;
}

//_________________________________________________________

Float_t
AliTOFRunParams::Average(Float_t *data, Int_t first, Int_t last)
{
  /*
   * average
   */

  if (first < 0) first = 0;
  if (last >= fNPoints) last = fNPoints - 1;
  Float_t value = 0.;
  Int_t npt = 0;
  for (Int_t i = first; i <= last; i++) {
    value += data[i];
    npt++;
  }
  if (npt <= 0) return 0.;
  value /= npt;
  return value;

}

//_________________________________________________________

Float_t
AliTOFRunParams::Average(Float_t *data, UInt_t runNb)
{
  /*
   * average
   */

  /* critical cases:
     1. no measurement -> 0.
     2. no runNb structure -> average over all points
     3. runNb not found -> average over all points
  */
  if (fNPoints <= 0 || !fT0 || !fTimestamp) return 0.;
  if (fNRuns <= 0 || !fRunNb || !fRunFirstPoint || !fRunLastPoint) return Average(data, 0, fNPoints - 1);


  /* search for runNb */
  UInt_t runPoint = 0;
  Bool_t gotRunNb = kFALSE;
  for (Int_t irun = 0; irun < fNRuns; irun++) {
    if (fRunNb[irun] == runNb) {
      runPoint = irun;
      gotRunNb = kTRUE;
      break;
    }
  }
  if (!gotRunNb) return Average(data, 0, fNPoints - 1);

  /* average between first and last run points */
  UInt_t firstPoint = fRunFirstPoint[runPoint];
  UInt_t lastPoint = fRunLastPoint[runPoint];
  return Average(data, firstPoint, lastPoint);

}

//_________________________________________________________

TGraph *
AliTOFRunParams::DrawGraph(Float_t *data, Option_t* option)
{
  /*
   * draw
   */

  if (fNPoints == 0 || !data || !fTimestamp) return NULL;

  Float_t ts[1000000];
  for (Int_t i = 0; i < fNPoints; i++)
    ts[i] = fTimestamp[i];

  TGraph *graph = new TGraph(fNPoints, ts, data);
  graph->Draw(option);
  return graph;
}

//_________________________________________________________

TGraph *
AliTOFRunParams::DrawCorrelationGraph(Float_t *datax, Float_t *datay, Option_t* option)
{
  /*
   * draw
   */

  if (fNPoints == 0 || !datax || !datay) return NULL;

  TGraph *graph = new TGraph(fNPoints, datax, datay);
  graph->Draw(option);
  return graph;
}
Commit	Line	Data
f04b3a69	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	// *
	17	// *
	18	// *
	19	// * this class defines the TOF object to be stored
	20	// * in OCDB on a run-by-run basis in order to have the measurement
	21	// * of the time evolution of T0 and of TOF resolution including
	22	// * average T0 uncertainty
	23	// *
	24	// *
	25	// *
	26
	27	#include "AliTOFRunParams.h"
53408dc1	28	#include "TGraph.h"
f04b3a69	29
	30	ClassImp(AliTOFRunParams)
	31
	32	//_________________________________________________________
	33
	34	AliTOFRunParams::AliTOFRunParams() :
	35	TObject(),
	36	fNPoints(0),
	37	fTimestamp(NULL),
	38	fT0(NULL),
	39	fTOFResolution(NULL),
53408dc1	40	fT0Spread(NULL),
	41	fNRuns(0),
	42	fRunNb(NULL),
	43	fRunFirstPoint(NULL),
3fd7a5cd	44	fRunLastPoint(NULL),
3fd7a5cd	45	fUseLHCClockPhase(kFALSE)
f04b3a69	46	{
	47	/*
	48	* default constructor
	49	*/
	50	}
	51
	52	//_________________________________________________________
	53
53408dc1	54	AliTOFRunParams::AliTOFRunParams(Int_t nPoints, Int_t nRuns) :
f04b3a69	55	TObject(),
	56	fNPoints(nPoints),
	57	fTimestamp(new UInt_t[nPoints]),
	58	fT0(new Float_t[nPoints]),
	59	fTOFResolution(new Float_t[nPoints]),
53408dc1	60	fT0Spread(new Float_t[nPoints]),
	61	fNRuns(nRuns),
	62	fRunNb(new UInt_t[nRuns]),
	63	fRunFirstPoint(new UInt_t[nRuns]),
3fd7a5cd	64	fRunLastPoint(new UInt_t[nRuns]),
3fd7a5cd	65	fUseLHCClockPhase(kFALSE)
f04b3a69	66	{
	67	/*
	68	* standard constructor
	69	*/
	70	}
	71
	72	//_________________________________________________________
	73
	74	AliTOFRunParams::~AliTOFRunParams()
	75	{
	76	/*
	77	* default destructor
	78	*/
	79
	80	if (fTimestamp) delete [] fTimestamp;
	81	if (fT0) delete [] fT0;
	82	if (fTOFResolution) delete [] fTOFResolution;
	83	if (fT0Spread) delete [] fT0Spread;
53408dc1	84	if (fRunNb) delete [] fRunNb;
	85	if (fRunFirstPoint) delete [] fRunFirstPoint;
	86	if (fRunLastPoint) delete [] fRunLastPoint;
f04b3a69	87	}
	88
	89	//_________________________________________________________
	90
	91	AliTOFRunParams::AliTOFRunParams(const AliTOFRunParams &source) :
	92	TObject(source),
	93	fNPoints(source.fNPoints),
	94	fTimestamp(new UInt_t[source.fNPoints]),
	95	fT0(new Float_t[source.fNPoints]),
	96	fTOFResolution(new Float_t[source.fNPoints]),
53408dc1	97	fT0Spread(new Float_t[source.fNPoints]),
	98	fNRuns(source.fNRuns),
	99	fRunNb(new UInt_t[source.fNRuns]),
	100	fRunFirstPoint(new UInt_t[source.fNRuns]),
3fd7a5cd	101	fRunLastPoint(new UInt_t[source.fNRuns]),
3fd7a5cd	102	fUseLHCClockPhase(source.fUseLHCClockPhase)
f04b3a69	103	{
	104	/*
	105	* copy constructor
	106	*/
	107
	108	for (Int_t i = 0; i < fNPoints; i++) {
	109	fTimestamp[i] = source.fTimestamp[i];
	110	fT0[i] = source.fT0[i];
	111	fTOFResolution[i] = source.fTOFResolution[i];
	112	fT0Spread[i] = source.fT0Spread[i];
	113	}
53408dc1	114
	115	for (Int_t i = 0; i < fNRuns; i++) {
	116	fRunNb[i] = source.fRunNb[i];
	117	fRunFirstPoint[i] = source.fRunFirstPoint[i];
	118	fRunLastPoint[i] = source.fRunLastPoint[i];
	119	}
f04b3a69	120
	121	}
	122
	123	//_________________________________________________________
	124
	125	AliTOFRunParams &
	126	AliTOFRunParams::operator=(const AliTOFRunParams &source)
	127	{
	128	/*
	129	* operator=
	130	*/
	131
	132	if (this == &source) return *this;
	133	TObject::operator=(source);
	134
	135	if (fNPoints != source.fNPoints) {
	136	if (fTimestamp) delete [] fTimestamp;
	137	if (fT0) delete [] fT0;
	138	if (fTOFResolution) delete [] fTOFResolution;
	139	if (fT0Spread) delete [] fT0Spread;
	140	fNPoints = source.fNPoints;
	141	fTimestamp = new UInt_t[source.fNPoints];
	142	fT0 = new Float_t[source.fNPoints];
	143	fTOFResolution = new Float_t[source.fNPoints];
	144	fT0Spread = new Float_t[source.fNPoints];
	145	}
	146
	147	for (Int_t i = 0; i < fNPoints; i++) {
	148	fTimestamp[i] = source.fTimestamp[i];
	149	fT0[i] = source.fT0[i];
	150	fTOFResolution[i] = source.fTOFResolution[i];
	151	fT0Spread[i] = source.fT0Spread[i];
	152	}
	153
53408dc1	154	if (fNRuns != source.fNRuns) {
	155	if (fRunNb) delete [] fRunNb;
	156	if (fRunFirstPoint) delete [] fRunFirstPoint;
	157	if (fRunLastPoint) delete [] fRunLastPoint;
	158	fNRuns = source.fNRuns;
	159	fRunNb = new UInt_t[source.fNRuns];
	160	fRunFirstPoint = new UInt_t[source.fNRuns];
	161	fRunLastPoint = new UInt_t[source.fNRuns];
	162	}
	163
	164	for (Int_t i = 0; i < fNRuns; i++) {
	165	fRunNb[i] = source.fRunNb[i];
	166	fRunFirstPoint[i] = source.fRunFirstPoint[i];
	167	fRunLastPoint[i] = source.fRunLastPoint[i];
	168	}
	169
3fd7a5cd	170	fUseLHCClockPhase = source.fUseLHCClockPhase;
3fd7a5cd	171
f04b3a69	172	return *this;
	173	}
	174
	175	//_________________________________________________________
	176
	177	Float_t
	178	AliTOFRunParams::EvalT0(UInt_t timestamp)
	179	{
	180	/*
	181	* eval T0
	182	*/
	183
	184	/* critical cases:
	185	1. no measurement -> 0.
	186	2. single measurement -> single value
	187	3. timestamp before first measurement -> first value
	188	4. timestamp after last measurement -> last value
	189	*/
	190	if (fNPoints <= 0 \|\| !fT0 \|\| !fTimestamp) return 0.;
	191	if (fNPoints == 1) return fT0[0];
	192	if (timestamp <= fTimestamp[0]) return fT0[0];
	193	if (timestamp >= fTimestamp[fNPoints - 1]) return fT0[fNPoints - 1];
	194
	195	/* interpolate value */
	196	Int_t ipoint;
	197	for (ipoint = 0; ipoint < fNPoints - 1; ipoint++)
	198	if (timestamp >= fTimestamp[ipoint] && timestamp < fTimestamp[ipoint + 1])
	199	break;
	200	Float_t coeff = (fT0[ipoint + 1] - fT0[ipoint]) / (Float_t)(fTimestamp[ipoint + 1] - fTimestamp[ipoint]);
	201	Float_t t0 = fT0[ipoint] + coeff * (timestamp - fTimestamp[ipoint]);
	202
	203	return t0;
	204	}
	205
	206	//_________________________________________________________
	207
	208	Float_t
	209	AliTOFRunParams::EvalTOFResolution(UInt_t timestamp)
	210	{
	211	/*
	212	* eval TOF resolution
	213	*/
	214
	215	/* critical cases:
	216	1. no measurement -> 0.
	217	2. single measurement -> single value
	218	3. timestamp before first measurement -> first value
	219	4. timestamp after last measurement -> last value
	220	*/
	221	if (fNPoints <= 0 \|\| !fTOFResolution \|\| !fTimestamp) return 0.;
	222	if (fNPoints == 1) return fTOFResolution[0];
	223	if (timestamp <= fTimestamp[0]) return fTOFResolution[0];
	224	if (timestamp >= fTimestamp[fNPoints - 1]) return fTOFResolution[fNPoints - 1];
	225
	226	/* interpolate value */
	227	Int_t ipoint;
	228	for (ipoint = 0; ipoint < fNPoints - 1; ipoint++)
	229	if (timestamp >= fTimestamp[ipoint] && timestamp < fTimestamp[ipoint + 1])
	230	break;
	231	Float_t coeff = (fTOFResolution[ipoint + 1] - fTOFResolution[ipoint]) / (Float_t)(fTimestamp[ipoint + 1] - fTimestamp[ipoint]);
	232	Float_t reso = fTOFResolution[ipoint] + coeff * (timestamp - fTimestamp[ipoint]);
	233
	234	return reso;
	235	}
236
237	//_________________________________________________________
238
239	Float_t
240	AliTOFRunParams::EvalT0Spread(UInt_t timestamp)
241	{
242	/*
243	* eval T0 spread
244	*/
245
246	/* critical cases:
247	1. no measurement -> 0.
248	2. single measurement -> single value
249	3. timestamp before first measurement -> first value
250	4. timestamp after last measurement -> last value
251	*/
252	if (fNPoints <= 0 \|\| !fT0Spread \|\| !fTimestamp) return 0.;
253	if (fNPoints == 1) return fT0Spread[0];
254	if (timestamp <= fTimestamp[0]) return fT0Spread[0];
255	if (timestamp >= fTimestamp[fNPoints - 1]) return fT0Spread[fNPoints - 1];
256
257	/* interpolate value */
258	Int_t ipoint;
259	for (ipoint = 0; ipoint < fNPoints - 1; ipoint++)
260	if (timestamp >= fTimestamp[ipoint] && timestamp < fTimestamp[ipoint + 1])
261	break;
262	Float_t coeff = (fT0Spread[ipoint + 1] - fT0Spread[ipoint]) / (Float_t)(fTimestamp[ipoint + 1] - fTimestamp[ipoint]);
263	Float_t spread = fT0Spread[ipoint] + coeff * (timestamp - fTimestamp[ipoint]);
264
265	return spread;
266	}
267
53408dc1	268	//_________________________________________________________
	269
	270	Float_t
	271	AliTOFRunParams::Average(Float_t *data, Int_t first, Int_t last)
	272	{
	273	/*
	274	* average
	275	*/
	276
	277	if (first < 0) first = 0;
	278	if (last >= fNPoints) last = fNPoints - 1;
	279	Float_t value = 0.;
	280	Int_t npt = 0;
	281	for (Int_t i = first; i <= last; i++) {
	282	value += data[i];
	283	npt++;
	284	}
a44583b8	285	if (npt <= 0) return 0.;
53408dc1	286	value /= npt;
	287	return value;
	288
	289	}
	290
	291	//_________________________________________________________
	292
	293	Float_t
	294	AliTOFRunParams::Average(Float_t *data, UInt_t runNb)
	295	{
	296	/*
	297	* average
	298	*/
	299
	300	/* critical cases:
	301	1. no measurement -> 0.
	302	2. no runNb structure -> average over all points
	303	3. runNb not found -> average over all points
	304	*/
	305	if (fNPoints <= 0 \|\| !fT0 \|\| !fTimestamp) return 0.;
	306	if (fNRuns <= 0 \|\| !fRunNb \|\| !fRunFirstPoint \|\| !fRunLastPoint) return Average(data, 0, fNPoints - 1);
	307
	308
	309	/* search for runNb */
	310	UInt_t runPoint = 0;
	311	Bool_t gotRunNb = kFALSE;
	312	for (Int_t irun = 0; irun < fNRuns; irun++) {
	313	if (fRunNb[irun] == runNb) {
	314	runPoint = irun;
	315	gotRunNb = kTRUE;
	316	break;
	317	}
	318	}
	319	if (!gotRunNb) return Average(data, 0, fNPoints - 1);
	320
	321	/* average between first and last run points */
	322	UInt_t firstPoint = fRunFirstPoint[runPoint];
	323	UInt_t lastPoint = fRunLastPoint[runPoint];
	324	return Average(data, firstPoint, lastPoint);
	325
	326	}
	327
	328	//_________________________________________________________
	329
	330	TGraph *
	331	AliTOFRunParams::DrawGraph(Float_t data, Option_t option)
	332	{
	333	/*
	334	* draw
	335	*/
	336
	337	if (fNPoints == 0 \|\| !data \|\| !fTimestamp) return NULL;
	338
	339	Float_t ts[1000000];
	340	for (Int_t i = 0; i < fNPoints; i++)
	341	ts[i] = fTimestamp[i];
	342
	343	TGraph *graph = new TGraph(fNPoints, ts, data);
	344	graph->Draw(option);
	345	return graph;
	346	}
584e3067	347
	348	//_________________________________________________________
	349
	350	TGraph *
	351	AliTOFRunParams::DrawCorrelationGraph(Float_t datax, Float_t datay, Option_t* option)
	352	{
	353	/*
	354	* draw
	355	*/
	356
	357	if (fNPoints == 0 \|\| !datax \|\| !datay) return NULL;
	358
	359	TGraph *graph = new TGraph(fNPoints, datax, datay);
	360	graph->Draw(option);
	361	return graph;
	362	}
	363