[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveT0Module.cxx

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// The main AliEVE drawing module for the T0 detector                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "AliEveT0Module.h"

#include <EveBase/AliEveEventManager.h>

#include <AliT0digit.h>
#include <AliRawReader.h>
#include <AliRawReaderRoot.h>
#include <AliT0RawReader.h>
#include <AliCDBStorage.h>

#include <TEveTrans.h>
#include <TEveManager.h>
#include <TTree.h>
#include <TArrayI.h>
#include <TStyle.h>
#include <TMath.h>
#include <TRandom.h>


ClassImp(AliEveT0Module)

/******************************************************************************/
AliEveT0Module::AliEveT0Module(const Text_t* n, Int_t sigType,
			       AliT0digit *digits, AliT0RawReader *start,
			       Double_t zvertex) :
  TEveQuadSet(n),  fSigType(sigType),
  fDigits(digits), fStart(start),
  fZVertex(zvertex)
{
  //
  // Default constructor
  //
}

void AliEveT0Module::PrintEventInfo()
{
  printf("Z-vertex = %f\n", fZVertex);
}

/******************************************************************************/

void AliEveT0Module::LoadRaw(AliRawReader* reader)
{
  // Load raw-data from file.

  AliT0digit *digits = 0;

  // ??? How / when is this called during reco from raw?
  reader->LoadEquipmentIdsMap("T0map.txt");
  reader->RequireHeader(kTRUE);

  AliT0RawReader *start = new AliT0RawReader(reader);
  Int_t allData[110][5];

  Float_t angle  = 2 * TMath::Pi() / 12;
  start->Next();
  for (Int_t i=0; i<110; i++)
  {
    for (Int_t iHit=0; iHit<5; iHit++)
    {
      allData[i][iHit]= start->GetData(i,iHit);
    }
  }
  Double_t zvertex = (allData[51][0] - allData[52][0])/2*25*2.99752/100;
  //std::cout<<"zvertex= "<< zvertex <<endl;

  TEveRGBAPalette *rawPalette    = new TEveRGBAPalette(0, 3000);
  TEveRGBAPalette *vertexPalette = new TEveRGBAPalette(-100, 100);

  TEveFrameBox *box = new TEveFrameBox();
  {
    Float_t  frame[3*36];
    Float_t *p = frame;
    for (Int_t i = 0; i < 36; ++i, p += 3) {
      p[0] = 8.0f * TMath::Cos(TMath::TwoPi()*i/36);
      p[1] = 8.0f * TMath::Sin(TMath::TwoPi()*i/36);
      p[2] = 0;
    }
    box->SetQuadByPoints(frame, 36);
  }
  box->SetFrameColor(kGray);


  rawPalette->SetLimits(1, 3000); // Set proper raw time range.
  TEveQuadSet* rawA = new AliEveT0Module("T0_RAW_A", 2, digits, start, zvertex);
  rawA->SetPalette(rawPalette);
  rawA->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
  rawA->SetFrame(box);
  TEveQuadSet* rawC = new AliEveT0Module("T0_RAW_C", 3, digits, start, zvertex);
  rawC->SetPalette(rawPalette);
  rawC->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32); 
  rawC->SetFrame(box);

  TEveQuadSet* vertexT0 = new AliEveT0Module("T0_Vertex", 5, digits, start, zvertex);
  vertexT0->SetPalette(vertexPalette);
  vertexT0->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
 
  for (Int_t i=0; i<12; i++)
  {
    Float_t x = 6.5 * TMath::Sin(i * angle);
    Float_t y = 6.5 * TMath::Cos(i * angle);
    rawA->AddHexagon(x, y, 0, 1.0);
    rawA->QuadValue(start->GetData(i+37,0)-start->GetData(0,0));
    rawC->AddHexagon(x, y, 0, 1.0);
    rawC->QuadValue(start->GetData(i+25,0)-start->GetData(0,0));
  }
  vertexT0->AddHexagon(0, 0, 0, 1);
  vertexT0->QuadValue(TMath::Nint(zvertex));

  rawA->RefitPlex();
  rawC->RefitPlex();
  vertexT0->RefitPlex();

  TEveTrans& taA = rawA->RefMainTrans();
  taA.SetPos(0, 0, 373);
  TEveTrans& tcC = rawC->RefMainTrans();
  tcC.SetPos(0, 0, -69.7);

  TEveTrans& tver = vertexT0->RefMainTrans();
  tver.SetPos(0, 0, zvertex);

  gEve->AddElement(rawA);
  gEve->AddElement(rawC);
  gEve->AddElement(vertexT0);
  gEve->Redraw3D();
}

/******************************************************************************/

void AliEveT0Module::MakeModules(AliT0digit *digits)
{
  // Make modules for digits.

  TArrayI adc(24);
  TArrayI tdc(24);

  digits->GetQT1(adc);
  digits->GetTimeCFD(tdc);
  // printf("%3d\n",besttimeright);
  // for (Int_t i=0;i<24; i++) {
  //   printf("%3d %3d\n  ",adc[i], tdc[i]);
  // }

  TEveRGBAPalette* adcPalette  = new TEveRGBAPalette(5, 1024);
  adcPalette->SetLimits(1, 1024); // Set proper ADC range.
  TEveRGBAPalette* tdcPalette  = new TEveRGBAPalette(0, 9999);
  tdcPalette->SetLimits(1, 9999); // Set proper TDC range.

  TEveQuadSet* qa = new AliEveT0Module("T0A_ADC", 0, digits); qa->SetPalette(adcPalette);
  TEveQuadSet* qc = new AliEveT0Module("T0C_ADC", 0, digits); qc->SetPalette(adcPalette);
  TEveQuadSet* qat = new AliEveT0Module("T0A_TDC", 1, digits); qat->SetPalette(tdcPalette);
  TEveQuadSet* qct = new AliEveT0Module("T0C_TDC", 1, digits); qct->SetPalette(tdcPalette);

  Float_t angle  = 2 * TMath::Pi() / 12;

  qa->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
  qc->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
  qat->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
  qct->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);

  for (Int_t i=0; i<12; i++) {
    Float_t x = 6.5 * TMath::Sin(i * angle);
    Float_t y = 6.5 * TMath::Cos(i * angle);

    qa->AddHexagon(x, y, 0, 1.0);
    qa->QuadValue(adc[i+12]);
    //    qa->QuadId(new TNamed(Form("PMT   with idx=%d", i), "PMT's aplitude in side A."));

    qat->AddHexagon(x, y, 0, 1.0);
    qat->QuadValue(tdc[i+12]);
    //    qat->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side A."));

    qc->AddHexagon(x, y, 0, 1.0);
    qc->QuadValue(adc[i]);
    // qc->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's amplitude in side C."));

    qct->AddHexagon(x, y, 0, 1.0);
    qct->QuadValue(tdc[i]);
    // qct->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side C."));
  }

  qa->RefitPlex();
  qc->RefitPlex();
  qat->RefitPlex();
  qct->RefitPlex();

  TEveTrans& ta = qa->RefMainTrans();
  ta.SetPos(0, 0, 373);
  TEveTrans& tc = qc->RefMainTrans();
  tc.SetPos(0, 0, -69.7);

  TEveTrans& tat = qat->RefMainTrans();
  tat.SetPos(0, 0, 373);
  TEveTrans& tct = qct->RefMainTrans();
  tct.SetPos(0, 0, -69.7);

  gEve->AddElement(qa);
  gEve->AddElement(qc);
  gEve->AddElement(qat);
  gEve->AddElement(qct);

  gEve->Redraw3D();
}

/******************************************************************************/

void AliEveT0Module::DigitSelected(Int_t idx)
{
  // Override control-click from TEveQuadSet

  DigitBase_t* qb   = GetDigit(idx);
  if (fSigType == 0) { //ADC
    printf("adc====================\n");
    Int_t   besttimeright = fDigits->BestTimeA();
    Int_t   besttimeleft = fDigits->BestTimeC();
    Int_t   meantime = fDigits->MeanTime();
    Int_t   timediff = fDigits->TimeDiff();
    Int_t   summult = fDigits->SumMult();

    printf("besttimeA = %3d\n", besttimeright);
    printf("besttimeC = %3d\n", besttimeleft);
    printf("meantime  = %3d\n", meantime);
    printf("timediff  = %3d\n", timediff);
    printf("summult   = %3d\n", summult);

    printf("  idx=%d, amplitude=%d\n",  idx, qb->fValue);

  }
  if (fSigType == 1) {
    printf("tdc====================\n");

    Int_t   besttimeright = fDigits->BestTimeA();
    Int_t   besttimeleft = fDigits->BestTimeC();
    Int_t   meantime = fDigits->MeanTime();
    Int_t   timediff = fDigits->TimeDiff();
    Int_t   summult = fDigits->SumMult();

    printf("besttimeA = %3d\n",besttimeright);
    printf("besttimeC = %3d\n",besttimeleft);
    printf("meantime  = %3d\n",meantime);
    printf("timediff  = %3d\n",timediff);
    printf("summult   = %3d\n",summult);

    printf("  idx=%d, amplitude=%d\n",  idx, qb->fValue);
  }
  if (fSigType == 2) {
    printf("raw====================\n");
    printf("besttimeA = %3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
    printf("besttimeC = %3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
    printf("meantime  = %3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
    printf("amplitude = %3d\n",fStart->GetData(idx+1,0));

    printf("  idx=%d, time %d\n",  idx, qb->fValue);
  }
  if (fSigType == 3) {
    printf("raw====================\n");
    printf("besttimeA = %3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
    printf("besttimeC = %3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
    printf("meantime  = %3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
    printf("amplitude = %3d\n",fStart->GetData(idx+13,0));

    printf("  idx=%d, time %d\n",  idx, qb->fValue);
  }
  if (fSigType == 5) {

    printf("vertex====================\n");
    printf("  idx=%d, zvertex pozition %d\n",  idx, qb->fValue);

  }
}
Commit	Line	Data
d810d0de	1	// $Id$
	2	// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	6	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
51346b82	7	* full copyright notice. *
d810d0de	8	**************************************************************************/
16718cdc	9
03916485	10	//////////////////////////////////////////////////////////////////////////
	11	// //
	12	// The main AliEVE drawing module for the T0 detector //
	13	// //
	14	//////////////////////////////////////////////////////////////////////////
51346b82	15
d810d0de	16	#include "AliEveT0Module.h"
707b281a	17
	18	#include <EveBase/AliEveEventManager.h>
	19
03916485	20	#include <AliT0digit.h>
03916485	21	#include <AliRawReader.h>
03916485	22	#include <AliRawReaderRoot.h>
707b281a	23	#include <AliT0RawReader.h>
51346b82	24	#include <AliCDBStorage.h>
03916485	25
a15e6d7d	26	#include <TEveTrans.h>
	27	#include <TEveManager.h>
	28	#include <TTree.h>
707b281a	29	#include <TArrayI.h>
	30	#include <TStyle.h>
	31	#include <TMath.h>
	32	#include <TRandom.h>
03916485	33
d810d0de	34
d810d0de	35	ClassImp(AliEveT0Module)
03916485	36
57ffa5fb	37	/******************************************************************************/
249bb876	38	AliEveT0Module::AliEveT0Module(const Text_t* n, Int_t sigType,
	39	AliT0digit digits, AliT0RawReader start,
	40	Double_t zvertex) :
	41	TEveQuadSet(n), fSigType(sigType),
	42	fDigits(digits), fStart(start),
	43	fZVertex(zvertex)
03916485	44	{
	45	//
	46	// Default constructor
	47	//
03916485	48	}
03916485	49
6c841fa2	50	void AliEveT0Module::PrintEventInfo()
6c841fa2	51	{
249bb876	52	printf("Z-vertex = %f\n", fZVertex);
6c841fa2	53	}
6c841fa2	54
57ffa5fb	55	/******************************************************************************/
03916485	56
6c841fa2	57	void AliEveT0Module::LoadRaw(AliRawReader* reader)
03916485	58	{
a15e6d7d	59	// Load raw-data from file.
a15e6d7d	60
03916485	61	AliT0digit *digits = 0;
6c841fa2	62
6c841fa2	63	// ??? How / when is this called during reco from raw?
03916485	64	reader->LoadEquipmentIdsMap("T0map.txt");
03916485	65	reader->RequireHeader(kTRUE);
6c841fa2	66
03916485	67	AliT0RawReader *start = new AliT0RawReader(reader);
03916485	68	Int_t allData[110][5];
249bb876	69
	70	Float_t angle = 2 * TMath::Pi() / 12;
	71	start->Next();
	72	for (Int_t i=0; i<110; i++)
	73	{
	74	for (Int_t iHit=0; iHit<5; iHit++)
	75	{
	76	allData[i][iHit]= start->GetData(i,iHit);
	77	}
	78	}
	79	Double_t zvertex = (allData[51][0] - allData[52][0])/2252.99752/100;
	80	//std::cout<<"zvertex= "<< zvertex <<endl;
6c841fa2	81
	82	TEveRGBAPalette *rawPalette = new TEveRGBAPalette(0, 3000);
	83	TEveRGBAPalette *vertexPalette = new TEveRGBAPalette(-100, 100);
	84
	85	TEveFrameBox *box = new TEveFrameBox();
	86	{
	87	Float_t frame[3*36];
	88	Float_t *p = frame;
	89	for (Int_t i = 0; i < 36; ++i, p += 3) {
	90	p[0] = 8.0f * TMath::Cos(TMath::TwoPi()*i/36);
	91	p[1] = 8.0f * TMath::Sin(TMath::TwoPi()*i/36);
	92	p[2] = 0;
	93	}
	94	box->SetQuadByPoints(frame, 36);
	95	}
	96	box->SetFrameColor(kGray);
	97
	98
03916485	99	rawPalette->SetLimits(1, 3000); // Set proper raw time range.
249bb876	100	TEveQuadSet* rawA = new AliEveT0Module("T0_RAW_A", 2, digits, start, zvertex);
a15e6d7d	101	rawA->SetPalette(rawPalette);
a15e6d7d	102	rawA->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
6c841fa2	103	rawA->SetFrame(box);
249bb876	104	TEveQuadSet* rawC = new AliEveT0Module("T0_RAW_C", 3, digits, start, zvertex);
a15e6d7d	105	rawC->SetPalette(rawPalette);
6c841fa2	106	rawC->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	107	rawC->SetFrame(box);
	108
249bb876	109	TEveQuadSet* vertexT0 = new AliEveT0Module("T0_Vertex", 5, digits, start, zvertex);
cff55d04	110	vertexT0->SetPalette(vertexPalette);
	111	vertexT0->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	112
03916485	113	for (Int_t i=0; i<12; i++)
	114	{
	115	Float_t x = 6.5 * TMath::Sin(i * angle);
	116	Float_t y = 6.5 * TMath::Cos(i * angle);
249bb876	117	rawA->AddHexagon(x, y, 0, 1.0);
a15e6d7d	118	rawA->QuadValue(start->GetData(i+37,0)-start->GetData(0,0));
249bb876	119	rawC->AddHexagon(x, y, 0, 1.0);
a15e6d7d	120	rawC->QuadValue(start->GetData(i+25,0)-start->GetData(0,0));
03916485	121	}
249bb876	122	vertexT0->AddHexagon(0, 0, 0, 1);
249bb876	123	vertexT0->QuadValue(TMath::Nint(zvertex));
03916485	124
a15e6d7d	125	rawA->RefitPlex();
a15e6d7d	126	rawC->RefitPlex();
cff55d04	127	vertexT0->RefitPlex();
03916485	128
a15e6d7d	129	TEveTrans& taA = rawA->RefMainTrans();
	130	taA.SetPos(0, 0, 373);
	131	TEveTrans& tcC = rawC->RefMainTrans();
	132	tcC.SetPos(0, 0, -69.7);
03916485	133
cff55d04	134	TEveTrans& tver = vertexT0->RefMainTrans();
	135	tver.SetPos(0, 0, zvertex);
	136
a15e6d7d	137	gEve->AddElement(rawA);
a15e6d7d	138	gEve->AddElement(rawC);
cff55d04	139	gEve->AddElement(vertexT0);
84aff7a4	140	gEve->Redraw3D();
03916485	141	}
03916485	142
57ffa5fb	143	/******************************************************************************/
a15e6d7d	144
d810d0de	145	void AliEveT0Module::MakeModules(AliT0digit *digits)
03916485	146	{
a15e6d7d	147	// Make modules for digits.
a15e6d7d	148
a15e6d7d	149	TArrayI adc(24);
a15e6d7d	150	TArrayI tdc(24);
51346b82	151
a15e6d7d	152	digits->GetQT1(adc);
a15e6d7d	153	digits->GetTimeCFD(tdc);
249bb876	154	// printf("%3d\n",besttimeright);
	155	// for (Int_t i=0;i<24; i++) {
	156	// printf("%3d %3d\n ",adc[i], tdc[i]);
	157	// }
03916485	158
84aff7a4	159	TEveRGBAPalette* adcPalette = new TEveRGBAPalette(5, 1024);
03916485	160	adcPalette->SetLimits(1, 1024); // Set proper ADC range.
84aff7a4	161	TEveRGBAPalette* tdcPalette = new TEveRGBAPalette(0, 9999);
03916485	162	tdcPalette->SetLimits(1, 9999); // Set proper TDC range.
03916485	163
d810d0de	164	TEveQuadSet* qa = new AliEveT0Module("T0A_ADC", 0, digits); qa->SetPalette(adcPalette);
	165	TEveQuadSet* qc = new AliEveT0Module("T0C_ADC", 0, digits); qc->SetPalette(adcPalette);
	166	TEveQuadSet* qat = new AliEveT0Module("T0A_TDC", 1, digits); qat->SetPalette(tdcPalette);
	167	TEveQuadSet* qct = new AliEveT0Module("T0C_TDC", 1, digits); qct->SetPalette(tdcPalette);
03916485	168
	169	Float_t angle = 2 * TMath::Pi() / 12;
	170
84aff7a4	171	qa->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	172	qc->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	173	qat->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	174	qct->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
03916485	175
03916485	176	for (Int_t i=0; i<12; i++) {
	177	Float_t x = 6.5 * TMath::Sin(i * angle);
	178	Float_t y = 6.5 * TMath::Cos(i * angle);
	179
249bb876	180	qa->AddHexagon(x, y, 0, 1.0);
a15e6d7d	181	qa->QuadValue(adc[i+12]);
03916485	182	// qa->QuadId(new TNamed(Form("PMT with idx=%d", i), "PMT's aplitude in side A."));
03916485	183
249bb876	184	qat->AddHexagon(x, y, 0, 1.0);
a15e6d7d	185	qat->QuadValue(tdc[i+12]);
03916485	186	// qat->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side A."));
51346b82	187
249bb876	188	qc->AddHexagon(x, y, 0, 1.0);
a15e6d7d	189	qc->QuadValue(adc[i]);
03916485	190	// qc->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's amplitude in side C."));
03916485	191
249bb876	192	qct->AddHexagon(x, y, 0, 1.0);
a15e6d7d	193	qct->QuadValue(tdc[i]);
03916485	194	// qct->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side C."));
	195	}
	196
	197	qa->RefitPlex();
	198	qc->RefitPlex();
	199	qat->RefitPlex();
	200	qct->RefitPlex();
	201
a15e6d7d	202	TEveTrans& ta = qa->RefMainTrans();
03916485	203	ta.SetPos(0, 0, 373);
a15e6d7d	204	TEveTrans& tc = qc->RefMainTrans();
03916485	205	tc.SetPos(0, 0, -69.7);
51346b82	206
a15e6d7d	207	TEveTrans& tat = qat->RefMainTrans();
03916485	208	tat.SetPos(0, 0, 373);
a15e6d7d	209	TEveTrans& tct = qct->RefMainTrans();
03916485	210	tct.SetPos(0, 0, -69.7);
51346b82	211
84aff7a4	212	gEve->AddElement(qa);
	213	gEve->AddElement(qc);
	214	gEve->AddElement(qat);
	215	gEve->AddElement(qct);
03916485	216
84aff7a4	217	gEve->Redraw3D();
03916485	218	}
03916485	219
57ffa5fb	220	/******************************************************************************/
03916485	221
d810d0de	222	void AliEveT0Module::DigitSelected(Int_t idx)
03916485	223	{
84aff7a4	224	// Override control-click from TEveQuadSet
03916485	225
84aff7a4	226	DigitBase_t* qb = GetDigit(idx);
03916485	227	if (fSigType == 0) { //ADC
	228	printf("adc====================\n");
	229	Int_t besttimeright = fDigits->BestTimeA();
	230	Int_t besttimeleft = fDigits->BestTimeC();
	231	Int_t meantime = fDigits->MeanTime();
	232	Int_t timediff = fDigits->TimeDiff();
	233	Int_t summult = fDigits->SumMult();
	234
249bb876	235	printf("besttimeA = %3d\n", besttimeright);
	236	printf("besttimeC = %3d\n", besttimeleft);
	237	printf("meantime = %3d\n", meantime);
	238	printf("timediff = %3d\n", timediff);
	239	printf("summult = %3d\n", summult);
03916485	240
	241	printf(" idx=%d, amplitude=%d\n", idx, qb->fValue);
	242
51346b82	243	}
03916485	244	if (fSigType == 1) {
03916485	245	printf("tdc====================\n");
51346b82	246
03916485	247	Int_t besttimeright = fDigits->BestTimeA();
	248	Int_t besttimeleft = fDigits->BestTimeC();
	249	Int_t meantime = fDigits->MeanTime();
	250	Int_t timediff = fDigits->TimeDiff();
	251	Int_t summult = fDigits->SumMult();
	252
249bb876	253	printf("besttimeA = %3d\n",besttimeright);
	254	printf("besttimeC = %3d\n",besttimeleft);
	255	printf("meantime = %3d\n",meantime);
	256	printf("timediff = %3d\n",timediff);
	257	printf("summult = %3d\n",summult);
03916485	258
	259	printf(" idx=%d, amplitude=%d\n", idx, qb->fValue);
	260	}
	261	if (fSigType == 2) {
	262	printf("raw====================\n");
249bb876	263	printf("besttimeA = %3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
	264	printf("besttimeC = %3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
	265	printf("meantime = %3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
	266	printf("amplitude = %3d\n",fStart->GetData(idx+1,0));
51346b82	267
03916485	268	printf(" idx=%d, time %d\n", idx, qb->fValue);
	269	}
	270	if (fSigType == 3) {
	271	printf("raw====================\n");
249bb876	272	printf("besttimeA = %3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
	273	printf("besttimeC = %3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
	274	printf("meantime = %3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
	275	printf("amplitude = %3d\n",fStart->GetData(idx+13,0));
51346b82	276
03916485	277	printf(" idx=%d, time %d\n", idx, qb->fValue);
03916485	278	}
6c841fa2	279	if (fSigType == 5) {
cff55d04	280
	281	printf("vertex====================\n");
	282	printf(" idx=%d, zvertex pozition %d\n", idx, qb->fValue);
	283
	284	}
03916485	285	}