[u/mrichter/AliRoot.git] / EVE / Alieve / T0Module.cxx

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// The main AliEVE drawing module for the T0 detector                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
 
#include "EventAlieve.h"
#include "T0Module.h"
#include <TStyle.h>
#include <TMath.h>
#include <TRandom.h>
#include <Reve/ReveManager.h>
#include <AliT0digit.h>
#include "TArrayI.h"
#include <AliRawReader.h>
#include <AliRawReaderFile.h>
#include <AliRawReaderDate.h>
#include <AliRawReaderRoot.h>
#include "AliT0RawReader.h"
#include <AliCDBManager.h>
#include <AliCDBStorage.h> 


using namespace Reve;
using namespace Alieve;


ClassImp(T0Module)

/**************************************************************************/
T0Module::T0Module(const Text_t* n, Int_t sigType, AliT0digit *digits, AliT0RawReader *start)
  : QuadSet(n), fSigType(sigType), fDigits(digits), fStart(start)
{
  //
  // Default constructor
  //
 
}

/**************************************************************************/
T0Module::~T0Module()
{

}

void T0Module::LoadRaw(TString fileName, Int_t ievt)
{
  AliT0digit *digits = 0;
  AliRawReader *reader = new AliRawReaderRoot(fileName,ievt);
  reader->LoadEquipmentIdsMap("T0map.txt");
  reader->RequireHeader(kTRUE);
  AliT0RawReader *start = new AliT0RawReader(reader);
  Int_t allData[110][5];
  TRandom r(0); 
  //  cout<<ievt<<endl;
  Reve::RGBAPalette* rawPalette  = new RGBAPalette(0, 3000);
  rawPalette->SetLimits(1, 3000); // Set proper raw time range.
  Reve::QuadSet* raw_a = new T0Module("T0_RAW_A", 2,digits, start); raw_a->SetPalette(rawPalette);
  raw_a->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
  Reve::QuadSet* raw_c = new T0Module("T0_RAW_C", 3,digits, start); raw_c->SetPalette(rawPalette);
  raw_c->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
  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);
      if (allData[i][iHit] != 0)  cout<<"event"<<ievt<<" i "<< i<<" "<<allData[i][iHit] - allData[0][0]<<endl;
    }
  }
  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);
    raw_a->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
    raw_a->QuadValue(start->GetData(i+37,0)-start->GetData(0,0));
    raw_c->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
    raw_c->QuadValue(start->GetData(i+25,0)-start->GetData(0,0));
  }


  raw_a->RefitPlex();
  raw_c->RefitPlex();
  
  Reve::ZTrans& ta_a = raw_a->RefHMTrans();
  ta_a.SetPos(0, 0, 373);
  Reve::ZTrans& tc_c = raw_c->RefHMTrans();
  tc_c.SetPos(0, 0, -69.7);

  gReve->AddRenderElement(raw_a);
  gReve->AddRenderElement(raw_c);
  gReve->Redraw3D();
}

/**************************************************************************/
void T0Module::MakeModules(AliT0digit *digits)
{
  TRandom r(0); 
  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]);
  }

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

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

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

  qa->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
  qc->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
  qat->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
  qct->Reset(Reve::QuadSet::QT_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, r.Uniform(-0.1, 0.1), 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, r.Uniform(-0.1, 0.1), 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, r.Uniform(-0.1, 0.1), 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, r.Uniform(-0.1, 0.1), 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();

  Reve::ZTrans& ta = qa->RefHMTrans();
  ta.SetPos(0, 0, 373);
  Reve::ZTrans& tc = qc->RefHMTrans();
  tc.SetPos(0, 0, -69.7);
 
  Reve::ZTrans& tat = qat->RefHMTrans();
  tat.SetPos(0, 0, 373);
  Reve::ZTrans& tct = qct->RefHMTrans();
  tct.SetPos(0, 0, -69.7);
 
  gReve->AddRenderElement(qa);
  gReve->AddRenderElement(qc);
  gReve->AddRenderElement(qat);
  gReve->AddRenderElement(qct);

  gReve->Redraw3D();
}

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

void T0Module::DigitSelected(Int_t idx)
{
  // Override control-click from QuadSet

  DigitBase* 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);
  }

}
Commit	Line	Data
03916485	1	//////////////////////////////////////////////////////////////////////////
	2	// //
	3	// The main AliEVE drawing module for the T0 detector //
	4	// //
	5	//////////////////////////////////////////////////////////////////////////
	6
	7	#include "EventAlieve.h"
	8	#include "T0Module.h"
	9	#include <TStyle.h>
	10	#include <TMath.h>
	11	#include <TRandom.h>
32e219c2	12	#include <Reve/ReveManager.h>
03916485	13	#include <AliT0digit.h>
	14	#include "TArrayI.h"
	15	#include <AliRawReader.h>
	16	#include <AliRawReaderFile.h>
	17	#include <AliRawReaderDate.h>
	18	#include <AliRawReaderRoot.h>
	19	#include "AliT0RawReader.h"
	20	#include <AliCDBManager.h>
	21	#include <AliCDBStorage.h>
	22
	23
	24	using namespace Reve;
	25	using namespace Alieve;
	26
	27
	28	ClassImp(T0Module)
	29
	30	/**************************************************************************/
	31	T0Module::T0Module(const Text_t* n, Int_t sigType, AliT0digit digits, AliT0RawReader start)
	32	: QuadSet(n), fSigType(sigType), fDigits(digits), fStart(start)
	33	{
	34	//
	35	// Default constructor
	36	//
	37
	38	}
	39
	40	/**************************************************************************/
	41	T0Module::~T0Module()
	42	{
	43
	44	}
	45
	46	void T0Module::LoadRaw(TString fileName, Int_t ievt)
	47	{
	48	AliT0digit *digits = 0;
	49	AliRawReader *reader = new AliRawReaderRoot(fileName,ievt);
	50	reader->LoadEquipmentIdsMap("T0map.txt");
	51	reader->RequireHeader(kTRUE);
	52	AliT0RawReader *start = new AliT0RawReader(reader);
	53	Int_t allData[110][5];
	54	TRandom r(0);
	55	// cout<<ievt<<endl;
	56	Reve::RGBAPalette* rawPalette = new RGBAPalette(0, 3000);
	57	rawPalette->SetLimits(1, 3000); // Set proper raw time range.
	58	Reve::QuadSet* raw_a = new T0Module("T0_RAW_A", 2,digits, start); raw_a->SetPalette(rawPalette);
	59	raw_a->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
	60	Reve::QuadSet* raw_c = new T0Module("T0_RAW_C", 3,digits, start); raw_c->SetPalette(rawPalette);
	61	raw_c->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
	62	Float_t angle = 2 * TMath::Pi() / 12;
	63	start->Next();
	64	for (Int_t i=0; i<110; i++)
	65	{
	66	for (Int_t iHit=0; iHit<5; iHit++)
	67	{
	68	allData[i][iHit]= start->GetData(i,iHit);
	69	if (allData[i][iHit] != 0) cout<<"event"<<ievt<<" i "<< i<<" "<<allData[i][iHit] - allData[0][0]<<endl;
	70	}
	71	}
	72	for (Int_t i=0; i<12; i++)
	73	{
	74	Float_t x = 6.5 * TMath::Sin(i * angle);
	75	Float_t y = 6.5 * TMath::Cos(i * angle);
	76	raw_a->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
77	raw_a->QuadValue(start->GetData(i+37,0)-start->GetData(0,0));
78	raw_c->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
79	raw_c->QuadValue(start->GetData(i+25,0)-start->GetData(0,0));
80	}
81
82
83	raw_a->RefitPlex();
84	raw_c->RefitPlex();
85
86	Reve::ZTrans& ta_a = raw_a->RefHMTrans();
87	ta_a.SetPos(0, 0, 373);
88	Reve::ZTrans& tc_c = raw_c->RefHMTrans();
89	tc_c.SetPos(0, 0, -69.7);
90
91	gReve->AddRenderElement(raw_a);
92	gReve->AddRenderElement(raw_c);
93	gReve->Redraw3D();
94	}
95
96	/**************************************************************************/
97	void T0Module::MakeModules(AliT0digit *digits)
98	{
99	TRandom r(0);
100	TArrayI ADC(24);
101	TArrayI TDC(24);
102
103	digits->GetQT1(ADC);
104	digits->GetTimeCFD(TDC);
105	// printf("%3d\n",besttimeright);
106	for (Int_t i=0;i<24; i++){
107	printf("%3d %3d\n ",ADC[i], TDC[i]);
108	}
109
110	Reve::RGBAPalette* adcPalette = new RGBAPalette(5, 1024);
111	adcPalette->SetLimits(1, 1024); // Set proper ADC range.
112	Reve::RGBAPalette* tdcPalette = new RGBAPalette(0, 9999);
113	tdcPalette->SetLimits(1, 9999); // Set proper TDC range.
114
115	Reve::QuadSet* qa = new T0Module("T0A_ADC", 0, digits); qa->SetPalette(adcPalette);
116	Reve::QuadSet* qc = new T0Module("T0C_ADC", 0, digits); qc->SetPalette(adcPalette);
117	Reve::QuadSet* qat = new T0Module("T0A_TDC", 1, digits); qat->SetPalette(tdcPalette);
118	Reve::QuadSet* qct = new T0Module("T0C_TDC", 1, digits); qct->SetPalette(tdcPalette);
119
120	Float_t angle = 2 * TMath::Pi() / 12;
121
122	qa->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
123	qc->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
124	qat->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
125	qct->Reset(Reve::QuadSet::QT_HexagonXY, kFALSE, 32);
126
127
128
129	for (Int_t i=0; i<12; i++) {
130	Float_t x = 6.5 * TMath::Sin(i * angle);
131	Float_t y = 6.5 * TMath::Cos(i * angle);
132
133	qa->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
134	qa->QuadValue(ADC[i+12]);
135	// qa->QuadId(new TNamed(Form("PMT with idx=%d", i), "PMT's aplitude in side A."));
136
137	qat->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
138	qat->QuadValue(TDC[i+12]);
139	// qat->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side A."));
140
141	qc->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
142	qc->QuadValue(ADC[i]);
143	// qc->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's amplitude in side C."));
144
145	qct->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
146	qct->QuadValue(TDC[i]);
147	// qct->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side C."));
148	}
149
150	qa->RefitPlex();
151	qc->RefitPlex();
152	qat->RefitPlex();
153	qct->RefitPlex();
154
155	Reve::ZTrans& ta = qa->RefHMTrans();
156	ta.SetPos(0, 0, 373);
157	Reve::ZTrans& tc = qc->RefHMTrans();
158	tc.SetPos(0, 0, -69.7);
159
160	Reve::ZTrans& tat = qat->RefHMTrans();
161	tat.SetPos(0, 0, 373);
162	Reve::ZTrans& tct = qct->RefHMTrans();
163	tct.SetPos(0, 0, -69.7);
164
165	gReve->AddRenderElement(qa);
166	gReve->AddRenderElement(qc);
167	gReve->AddRenderElement(qat);
168	gReve->AddRenderElement(qct);
169
170	gReve->Redraw3D();
171	}
172
173	/**************************************************************************/
174
32e219c2	175	void T0Module::DigitSelected(Int_t idx)
03916485	176	{
	177	// Override control-click from QuadSet
	178
32e219c2	179	DigitBase* qb = GetDigit(idx);
03916485	180	if (fSigType == 0) { //ADC
	181	printf("adc====================\n");
	182	Int_t besttimeright = fDigits->BestTimeA();
	183	Int_t besttimeleft = fDigits->BestTimeC();
	184	Int_t meantime = fDigits->MeanTime();
	185	Int_t timediff = fDigits->TimeDiff();
	186	Int_t summult = fDigits->SumMult();
	187
	188	printf("besttimeA=%3d\n",besttimeright);
	189	printf("besttimeC=%3d\n",besttimeleft);
	190	printf("meantime=%3d\n",meantime);
	191	printf("timediff=%3d\n",timediff);
	192	printf("summult=%3d\n",summult);
	193
	194	printf(" idx=%d, amplitude=%d\n", idx, qb->fValue);
	195
	196	}
	197	if (fSigType == 1) {
	198	printf("tdc====================\n");
	199
	200	Int_t besttimeright = fDigits->BestTimeA();
	201	Int_t besttimeleft = fDigits->BestTimeC();
	202	Int_t meantime = fDigits->MeanTime();
	203	Int_t timediff = fDigits->TimeDiff();
	204	Int_t summult = fDigits->SumMult();
	205
	206	printf("besttimeA=%3d\n",besttimeright);
	207	printf("besttimeC=%3d\n",besttimeleft);
	208	printf("meantime=%3d\n",meantime);
	209	printf("timediff=%3d\n",timediff);
	210	printf("summult=%3d\n",summult);
	211
	212	printf(" idx=%d, amplitude=%d\n", idx, qb->fValue);
	213	}
	214	if (fSigType == 2) {
	215	printf("raw====================\n");
	216	printf("besttimeA=%3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
	217	printf("besttimeC=%3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
	218	printf("meantime=%3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
	219	printf("amplitude= %3d\n",fStart->GetData(idx+1,0));
	220
	221	printf(" idx=%d, time %d\n", idx, qb->fValue);
	222	}
	223	if (fSigType == 3) {
	224	printf("raw====================\n");
	225	printf("besttimeA=%3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
	226	printf("besttimeC=%3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
	227	printf("meantime=%3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
	228	printf("amplitude= %3d\n",fStart->GetData(idx+13,0));
	229
	230	printf(" idx=%d, time %d\n", idx, qb->fValue);
	231	}
	232
	233	}