[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)
  : TEveQuadSet(n), fSigType(sigType), fDigits(digits), fStart(start)
{
  //
  // Default constructor
  //
}

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

void AliEveT0Module::LoadRaw(TString fileName, Int_t ievt)
{
  // Load raw-data from file.

  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;
  TEveRGBAPalette* rawPalette  = new TEveRGBAPalette(0, 3000);
  rawPalette->SetLimits(1, 3000); // Set proper raw time range.
  TEveQuadSet* rawA = new AliEveT0Module("T0_RAW_A", 2, digits, start);
  rawA->SetPalette(rawPalette);
  rawA->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
  TEveQuadSet* rawC = new AliEveT0Module("T0_RAW_C", 3, digits, start);
  rawC->SetPalette(rawPalette);
  rawC->Reset(TEveQuadSet::kQT_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) {
        using namespace std;
        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);
    rawA->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
    rawA->QuadValue(start->GetData(i+37,0)-start->GetData(0,0));
    rawC->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
    rawC->QuadValue(start->GetData(i+25,0)-start->GetData(0,0));
  }

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

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

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

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

void AliEveT0Module::MakeModules(AliT0digit *digits)
{
  // Make modules for 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]);
  }

  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, 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();

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

}
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	/******************************************************************************/
d810d0de	38	AliEveT0Module::AliEveT0Module(const Text_t* n, Int_t sigType, AliT0digit digits, AliT0RawReader start)
84aff7a4	39	: TEveQuadSet(n), fSigType(sigType), fDigits(digits), fStart(start)
03916485	40	{
	41	//
	42	// Default constructor
	43	//
03916485	44	}
03916485	45
57ffa5fb	46	/******************************************************************************/
03916485	47
d810d0de	48	void AliEveT0Module::LoadRaw(TString fileName, Int_t ievt)
03916485	49	{
a15e6d7d	50	// Load raw-data from file.
a15e6d7d	51
03916485	52	AliT0digit *digits = 0;
	53	AliRawReader *reader = new AliRawReaderRoot(fileName,ievt);
	54	reader->LoadEquipmentIdsMap("T0map.txt");
	55	reader->RequireHeader(kTRUE);
	56	AliT0RawReader *start = new AliT0RawReader(reader);
	57	Int_t allData[110][5];
51346b82	58	TRandom r(0);
03916485	59	// cout<<ievt<<endl;
84aff7a4	60	TEveRGBAPalette* rawPalette = new TEveRGBAPalette(0, 3000);
03916485	61	rawPalette->SetLimits(1, 3000); // Set proper raw time range.
a15e6d7d	62	TEveQuadSet* rawA = new AliEveT0Module("T0_RAW_A", 2, digits, start);
	63	rawA->SetPalette(rawPalette);
	64	rawA->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	65	TEveQuadSet* rawC = new AliEveT0Module("T0_RAW_C", 3, digits, start);
	66	rawC->SetPalette(rawPalette);
	67	rawC->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
51346b82	68	Float_t angle = 2 * TMath::Pi() / 12;
03916485	69	start->Next();
	70	for (Int_t i=0; i<110; i++)
	71	{
51346b82	72	for (Int_t iHit=0; iHit<5; iHit++)
03916485	73	{
03916485	74	allData[i][iHit]= start->GetData(i,iHit);
a15e6d7d	75	if (allData[i][iHit] != 0) {
	76	using namespace std;
	77	cout <<"event"<< ievt <<" i "<< i <<" "<< allData[i][iHit] - allData[0][0] <<endl;
	78	}
03916485	79	}
	80	}
	81	for (Int_t i=0; i<12; i++)
	82	{
	83	Float_t x = 6.5 * TMath::Sin(i * angle);
	84	Float_t y = 6.5 * TMath::Cos(i * angle);
a15e6d7d	85	rawA->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
	86	rawA->QuadValue(start->GetData(i+37,0)-start->GetData(0,0));
	87	rawC->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
	88	rawC->QuadValue(start->GetData(i+25,0)-start->GetData(0,0));
03916485	89	}
03916485	90
a15e6d7d	91	rawA->RefitPlex();
a15e6d7d	92	rawC->RefitPlex();
03916485	93
a15e6d7d	94	TEveTrans& taA = rawA->RefMainTrans();
	95	taA.SetPos(0, 0, 373);
	96	TEveTrans& tcC = rawC->RefMainTrans();
	97	tcC.SetPos(0, 0, -69.7);
03916485	98
a15e6d7d	99	gEve->AddElement(rawA);
a15e6d7d	100	gEve->AddElement(rawC);
84aff7a4	101	gEve->Redraw3D();
03916485	102	}
03916485	103
57ffa5fb	104	/******************************************************************************/
a15e6d7d	105
d810d0de	106	void AliEveT0Module::MakeModules(AliT0digit *digits)
03916485	107	{
a15e6d7d	108	// Make modules for digits.
a15e6d7d	109
51346b82	110	TRandom r(0);
a15e6d7d	111	TArrayI adc(24);
a15e6d7d	112	TArrayI tdc(24);
51346b82	113
a15e6d7d	114	digits->GetQT1(adc);
a15e6d7d	115	digits->GetTimeCFD(tdc);
03916485	116	// printf("%3d\n",besttimeright);
03916485	117	for (Int_t i=0;i<24; i++){
a15e6d7d	118	printf("%3d %3d\n ",adc[i], tdc[i]);
03916485	119	}
03916485	120
84aff7a4	121	TEveRGBAPalette* adcPalette = new TEveRGBAPalette(5, 1024);
03916485	122	adcPalette->SetLimits(1, 1024); // Set proper ADC range.
84aff7a4	123	TEveRGBAPalette* tdcPalette = new TEveRGBAPalette(0, 9999);
03916485	124	tdcPalette->SetLimits(1, 9999); // Set proper TDC range.
03916485	125
d810d0de	126	TEveQuadSet* qa = new AliEveT0Module("T0A_ADC", 0, digits); qa->SetPalette(adcPalette);
	127	TEveQuadSet* qc = new AliEveT0Module("T0C_ADC", 0, digits); qc->SetPalette(adcPalette);
	128	TEveQuadSet* qat = new AliEveT0Module("T0A_TDC", 1, digits); qat->SetPalette(tdcPalette);
	129	TEveQuadSet* qct = new AliEveT0Module("T0C_TDC", 1, digits); qct->SetPalette(tdcPalette);
03916485	130
	131	Float_t angle = 2 * TMath::Pi() / 12;
	132
84aff7a4	133	qa->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	134	qc->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	135	qat->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
	136	qct->Reset(TEveQuadSet::kQT_HexagonXY, kFALSE, 32);
03916485	137
03916485	138	for (Int_t i=0; i<12; i++) {
	139	Float_t x = 6.5 * TMath::Sin(i * angle);
	140	Float_t y = 6.5 * TMath::Cos(i * angle);
	141
	142	qa->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
a15e6d7d	143	qa->QuadValue(adc[i+12]);
03916485	144	// qa->QuadId(new TNamed(Form("PMT with idx=%d", i), "PMT's aplitude in side A."));
	145
	146	qat->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
a15e6d7d	147	qat->QuadValue(tdc[i+12]);
03916485	148	// qat->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side A."));
51346b82	149
03916485	150	qc->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
a15e6d7d	151	qc->QuadValue(adc[i]);
03916485	152	// qc->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's amplitude in side C."));
	153
	154	qct->AddHexagon(x, y, r.Uniform(-0.1, 0.1), 1.0);
a15e6d7d	155	qct->QuadValue(tdc[i]);
03916485	156	// qct->QuadId(new TNamed(Form("Quad with idx=%d", i), "PMT's time in side C."));
	157	}
	158
	159	qa->RefitPlex();
	160	qc->RefitPlex();
	161	qat->RefitPlex();
	162	qct->RefitPlex();
	163
a15e6d7d	164	TEveTrans& ta = qa->RefMainTrans();
03916485	165	ta.SetPos(0, 0, 373);
a15e6d7d	166	TEveTrans& tc = qc->RefMainTrans();
03916485	167	tc.SetPos(0, 0, -69.7);
51346b82	168
a15e6d7d	169	TEveTrans& tat = qat->RefMainTrans();
03916485	170	tat.SetPos(0, 0, 373);
a15e6d7d	171	TEveTrans& tct = qct->RefMainTrans();
03916485	172	tct.SetPos(0, 0, -69.7);
51346b82	173
84aff7a4	174	gEve->AddElement(qa);
	175	gEve->AddElement(qc);
	176	gEve->AddElement(qat);
	177	gEve->AddElement(qct);
03916485	178
84aff7a4	179	gEve->Redraw3D();
03916485	180	}
03916485	181
57ffa5fb	182	/******************************************************************************/
03916485	183
d810d0de	184	void AliEveT0Module::DigitSelected(Int_t idx)
03916485	185	{
84aff7a4	186	// Override control-click from TEveQuadSet
03916485	187
84aff7a4	188	DigitBase_t* qb = GetDigit(idx);
03916485	189	if (fSigType == 0) { //ADC
	190	printf("adc====================\n");
	191	Int_t besttimeright = fDigits->BestTimeA();
	192	Int_t besttimeleft = fDigits->BestTimeC();
	193	Int_t meantime = fDigits->MeanTime();
	194	Int_t timediff = fDigits->TimeDiff();
	195	Int_t summult = fDigits->SumMult();
	196
	197	printf("besttimeA=%3d\n",besttimeright);
	198	printf("besttimeC=%3d\n",besttimeleft);
	199	printf("meantime=%3d\n",meantime);
	200	printf("timediff=%3d\n",timediff);
	201	printf("summult=%3d\n",summult);
	202
	203	printf(" idx=%d, amplitude=%d\n", idx, qb->fValue);
	204
51346b82	205	}
03916485	206	if (fSigType == 1) {
03916485	207	printf("tdc====================\n");
51346b82	208
03916485	209	Int_t besttimeright = fDigits->BestTimeA();
	210	Int_t besttimeleft = fDigits->BestTimeC();
	211	Int_t meantime = fDigits->MeanTime();
	212	Int_t timediff = fDigits->TimeDiff();
	213	Int_t summult = fDigits->SumMult();
	214
	215	printf("besttimeA=%3d\n",besttimeright);
	216	printf("besttimeC=%3d\n",besttimeleft);
	217	printf("meantime=%3d\n",meantime);
	218	printf("timediff=%3d\n",timediff);
	219	printf("summult=%3d\n",summult);
	220
	221	printf(" idx=%d, amplitude=%d\n", idx, qb->fValue);
	222	}
	223	if (fSigType == 2) {
	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+1,0));
51346b82	229
03916485	230	printf(" idx=%d, time %d\n", idx, qb->fValue);
	231	}
	232	if (fSigType == 3) {
	233	printf("raw====================\n");
	234	printf("besttimeA=%3d\n",fStart->GetData(51,0)-fStart->GetData(0,0));
	235	printf("besttimeC=%3d\n",fStart->GetData(52,0)-fStart->GetData(0,0));
	236	printf("meantime=%3d\n",fStart->GetData(49,0)-fStart->GetData(0,0));
	237	printf("amplitude= %3d\n",fStart->GetData(idx+13,0));
51346b82	238
03916485	239	printf(" idx=%d, time %d\n", idx, qb->fValue);
	240	}
	241
	242	}