[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveMUONChamberData.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.                                                 *
 **************************************************************************/

#include "AliEveMUONChamberData.h"

#include <AliMUONGeometryTransformer.h>
#include <mapping/AliMpDEIterator.h>
#include <mapping/AliMpSectorSegmentation.h>
#include <mapping/AliMpSector.h>
#include <mapping/AliMpPad.h>
#include <mapping/AliMpStationType.h>
#include <mapping/AliMpDEManager.h>
#include <mapping/AliMpSegmentation.h>

#include <TMath.h>
#include <TVector2.h>

#include <Riostream.h>

#include <EveBase/AliEveEventManager.h>

///////////////////////////////////////////////////////////////////////////////
///
/// AliEveMUONChamberData: geometry and digits
///
///////////////////////////////////////////////////////////////////////////////


ClassImp(AliEveMUONChamberData)

AliMUONGeometryTransformer* AliEveMUONChamberData::fgTransformer = 0;

//______________________________________________________________________________
AliEveMUONChamberData::AliEveMUONChamberData(Int_t chamber) :
  TObject(),
  fChamberID(0),           
  fNDetElem(0),            
  fNDigits(0),             
  fNClusters(0),           
  fNHits(0)
{
  //
  // constructor
  //

  AliEveEventManager *event = gEvent;

  TString dataPath = TString(event->GetTitle());
  dataPath.Append("/geometry.root");

  fChamberID = chamber;
  fNDetElem  = 0;
  fNDigits   = 0;
  fNClusters = 0;
  fNHits     = 0;

  for (Int_t i = 0; i < 26; i++) {
    for (Int_t j = 0; j < 4; j++) {
      fFrameCoord[i][j] = 0.0;
    }
  }
  for (Int_t i = 0; i < 7*4096; i++) {
    fDigitBuffer[i] = 0.0;
  }
  for (Int_t i = 0; i < 5*256; i++) {
    fClusterBuffer[i] = 0.0;
  }
  for (Int_t i = 0; i < 3*256; i++) {
    fHitBuffer[i] = 0.0;
  }

  for (Int_t i = 0; i < 3; i++) {
    fChamberBox[i*2  ] = +9999;
    fChamberBox[i*2+1] = -9999;
  }

  if (fgTransformer == 0) {
    fgTransformer = new AliMUONGeometryTransformer();
    fgTransformer->LoadGeometryData(dataPath.Data());
  }

  Init(chamber);

}

//______________________________________________________________________________
AliEveMUONChamberData::~AliEveMUONChamberData()
{
  //
  // destructor
  //

}

//______________________________________________________________________________
void AliEveMUONChamberData::DropData()
{
  //
  // release the chamber data
  //

  fNDigits   = 0;
  fNClusters = 0;
  fNHits     = 0;

  return;

}

//______________________________________________________________________________
void AliEveMUONChamberData::Init(Int_t chamber)
{
  //
  // initialize the drawing coordinates of the chamber
  //

  Float_t locP[3], gloP[3], locD[3], gloD[3];
  Float_t deltax, deltay;
  AliMpDEIterator it;
  const AliMpVSegmentation *vseg;
  const AliMpSectorSegmentation *sseg;
  const AliMpSector *sector;
  TVector2 position;
  TVector2 dimension;

  for ( it.First(chamber); ! it.IsDone(); it.Next() ) {

    Int_t detElemId = it.CurrentDEId();

    if (chamber < 4) {

      sseg = (AliMpSectorSegmentation*)
             AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
      sector = sseg->GetSector();

      position  = sector->Position();
      dimension = sector->Dimensions(); // half length

      locP[0] =  position.Px();
      locP[1] =  position.Py();
      locD[0] =  dimension.Px() * 2.;
      locD[1] =  dimension.Py() * 2.;

      locP[2] = 0.0;
      locD[2] = 0.0;

      fgTransformer->Local2Global(detElemId,
				  locP[0], locP[1], locP[2],
				  gloP[0], gloP[1], gloP[2]);

      fgTransformer->Local2Global(detElemId,
				  locD[0], locD[1], locD[2],
				  gloD[0], gloD[1], gloD[2]);

      fFrameCoord[fNDetElem][0] = gloP[0];
      fFrameCoord[fNDetElem][1] = gloP[1];
      fFrameCoord[fNDetElem][2] = gloD[0];
      fFrameCoord[fNDetElem][3] = gloD[1];
      fFrameCoord[fNDetElem][4] = gloP[2]; // Z position

      fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]-gloD[0]);
      fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]+gloD[0]);
      fChamberBox[2] = TMath::Min(fChamberBox[2],gloP[1]-gloD[1]);
      fChamberBox[3] = TMath::Max(fChamberBox[3],gloP[1]+gloD[1]);
      fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
      fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);

    } else {

//      if (!fgSegmentation->HasDE(detElemId)) {
//	printf("Segmentation has no %d detElemId! \n",detElemId);
//	continue;
//      }

      vseg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);

      if (vseg == 0) {
	printf("No MpVSegmentation for %d detElemId! \n",detElemId);
	continue;
      }

      deltax = vseg->Dimensions().X();
      deltay = vseg->Dimensions().Y();
      locP[0] =  -deltax;
      locP[1] =  -deltay;
      locD[0] =  +deltax;
      locD[1] =  +deltay;

      locP[2] = 0.0;
      locD[2] = 0.0;

      fgTransformer->Local2Global(detElemId,
				  locP[0], locP[1], locP[2],
				  gloP[0], gloP[1], gloP[2]);

      fgTransformer->Local2Global(detElemId,
				  locD[0], locD[1], locD[2],
				  gloD[0], gloD[1], gloD[2]);

      fFrameCoord[fNDetElem][0] = gloP[0];
      fFrameCoord[fNDetElem][1] = gloP[1];
      fFrameCoord[fNDetElem][2] = gloD[0];
      fFrameCoord[fNDetElem][3] = gloD[1];
      fFrameCoord[fNDetElem][4] = gloP[2]; // Z position

      fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]);
      fChamberBox[0] = TMath::Min(fChamberBox[0],gloD[0]);
      fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]);
      fChamberBox[1] = TMath::Max(fChamberBox[1],gloD[0]);
      fChamberBox[2] = TMath::Min(fChamberBox[0],gloP[1]);
      fChamberBox[2] = TMath::Min(fChamberBox[0],gloD[1]);
      fChamberBox[3] = TMath::Max(fChamberBox[1],gloP[1]);
      fChamberBox[3] = TMath::Max(fChamberBox[1],gloD[1]);
      fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
      fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);

    }

    fNDetElem++;

  }  // end detElemId loop

}

//______________________________________________________________________________
void AliEveMUONChamberData::RegisterDigit(Int_t detElemId, Int_t cathode, Int_t ix, Int_t iy, Int_t charge)
{
  //
  // add a digit to this chamber
  //

  if ((fNDigits/7) == (4096-1)) return;

  Float_t locP[3], gloP[3], locD[3], gloD[3];

  const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()
    ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));

  AliMpPad pad = vseg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);

  locP[0] = pad.Position().X();
  locP[1] = pad.Position().Y();
  locD[0] = pad.Dimensions().X();
  locD[1] = pad.Dimensions().Y();

  locP[2] = 0.0;
  locD[2] = 0.0;

  fgTransformer->Local2Global(detElemId,
			      locP[0], locP[1], locP[2],
			      gloP[0], gloP[1], gloP[2]);

  gloD[0] = locD[0];
  gloD[1] = locD[1];
  gloD[2] = gloP[2];

  if (cathode == 0) gloP[2] += 0.1;
  if (cathode == 1) gloP[2] -= 0.1;

  fDigitBuffer[fNDigits  ] = gloP[0];
  fDigitBuffer[fNDigits+1] = gloP[1];
  fDigitBuffer[fNDigits+2] = gloD[0];
  fDigitBuffer[fNDigits+3] = gloD[1];
  fDigitBuffer[fNDigits+4] = gloP[2];
  fDigitBuffer[fNDigits+5] = charge;
  fDigitBuffer[fNDigits+6] = cathode;

  fNDigits += 7;

}

//______________________________________________________________________________
void AliEveMUONChamberData::RegisterCluster(Int_t /*detElemId*/, Int_t cathode, Float_t clsX, Float_t clsY, Float_t clsZ, Float_t charge)
{
  //
  // add a reconstructed point (cluster) to this chamber
  //
  // identical clusters are registered for both cathode planes ...
  //

  if ((fNClusters/5) == (256-1)) return;

  fClusterBuffer[fNClusters  ] = clsX;
  fClusterBuffer[fNClusters+1] = clsY;
  fClusterBuffer[fNClusters+2] = clsZ;
  fClusterBuffer[fNClusters+3] = charge;
  fClusterBuffer[fNClusters+4] = cathode;

  fNClusters += 5;

}

//______________________________________________________________________________
void AliEveMUONChamberData::RegisterHit(Int_t /*detElemId*/, Float_t hitX, Float_t hitY, Float_t hitZ)
{
  //
  // add a simulation hit to this chamber
  //

  if ((fNHits/3) == (256-1)) return;

  fHitBuffer[fNHits  ] = hitX;
  fHitBuffer[fNHits+1] = hitY;
  fHitBuffer[fNHits+2] = hitZ;

  fNHits += 3;

}
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	**************************************************************************/
cb4245bb	9
d810d0de	10	#include "AliEveMUONChamberData.h"
3626c858	11
3626c858	12	#include <AliMUONGeometryTransformer.h>
3626c858	13	#include <mapping/AliMpDEIterator.h>
	14	#include <mapping/AliMpSectorSegmentation.h>
	15	#include <mapping/AliMpSector.h>
	16	#include <mapping/AliMpPad.h>
	17	#include <mapping/AliMpStationType.h>
	18	#include <mapping/AliMpDEManager.h>
	19	#include <mapping/AliMpSegmentation.h>
	20
	21	#include <TMath.h>
	22	#include <TVector2.h>
	23
eadce74d	24	#include <Riostream.h>
eadce74d	25
707b281a	26	#include <EveBase/AliEveEventManager.h>
2674c15a	27
3626c858	28	///////////////////////////////////////////////////////////////////////////////
3626c858	29	///
d810d0de	30	/// AliEveMUONChamberData: geometry and digits
3626c858	31	///
3626c858	32	///////////////////////////////////////////////////////////////////////////////
3626c858	33
3626c858	34
d810d0de	35	ClassImp(AliEveMUONChamberData)
	36
	37	AliMUONGeometryTransformer* AliEveMUONChamberData::fgTransformer = 0;
3626c858	38
57ffa5fb	39	//______________________________________________________________________________
fd31e9de	40	AliEveMUONChamberData::AliEveMUONChamberData(Int_t chamber) :
	41	TObject(),
	42	fChamberID(0),
	43	fNDetElem(0),
	44	fNDigits(0),
	45	fNClusters(0),
	46	fNHits(0)
3626c858	47	{
	48	//
	49	// constructor
	50	//
	51
d810d0de	52	AliEveEventManager *event = gEvent;
2674c15a	53
	54	TString dataPath = TString(event->GetTitle());
	55	dataPath.Append("/geometry.root");
	56
3626c858	57	fChamberID = chamber;
	58	fNDetElem = 0;
	59	fNDigits = 0;
eadce74d	60	fNClusters = 0;
	61	fNHits = 0;
	62
3626c858	63	for (Int_t i = 0; i < 26; i++) {
	64	for (Int_t j = 0; j < 4; j++) {
	65	fFrameCoord[i][j] = 0.0;
	66	}
	67	}
	68	for (Int_t i = 0; i < 7*4096; i++) {
	69	fDigitBuffer[i] = 0.0;
	70	}
cef26510	71	for (Int_t i = 0; i < 5*256; i++) {
eadce74d	72	fClusterBuffer[i] = 0.0;
eadce74d	73	}
cef26510	74	for (Int_t i = 0; i < 3*256; i++) {
eadce74d	75	fHitBuffer[i] = 0.0;
eadce74d	76	}
3626c858	77
	78	for (Int_t i = 0; i < 3; i++) {
	79	fChamberBox[i*2 ] = +9999;
	80	fChamberBox[i*2+1] = -9999;
	81	}
	82
8d33d1c2	83	if (fgTransformer == 0) {
66e5f12c	84	fgTransformer = new AliMUONGeometryTransformer();
66e5f12c	85	fgTransformer->LoadGeometryData(dataPath.Data());
3626c858	86	}
	87
	88	Init(chamber);
	89
	90	}
	91
57ffa5fb	92	//______________________________________________________________________________
d810d0de	93	AliEveMUONChamberData::~AliEveMUONChamberData()
3626c858	94	{
	95	//
	96	// destructor
	97	//
	98
	99	}
	100
57ffa5fb	101	//______________________________________________________________________________
d810d0de	102	void AliEveMUONChamberData::DropData()
3626c858	103	{
	104	//
	105	// release the chamber data
	106	//
	107
eadce74d	108	fNDigits = 0;
	109	fNClusters = 0;
	110	fNHits = 0;
	111
3626c858	112	return;
	113
	114	}
	115
57ffa5fb	116	//______________________________________________________________________________
d810d0de	117	void AliEveMUONChamberData::Init(Int_t chamber)
3626c858	118	{
	119	//
	120	// initialize the drawing coordinates of the chamber
	121	//
	122
	123	Float_t locP[3], gloP[3], locD[3], gloD[3];
	124	Float_t deltax, deltay;
	125	AliMpDEIterator it;
	126	const AliMpVSegmentation *vseg;
	127	const AliMpSectorSegmentation *sseg;
	128	const AliMpSector *sector;
	129	TVector2 position;
	130	TVector2 dimension;
	131
	132	for ( it.First(chamber); ! it.IsDone(); it.Next() ) {
	133
361fa326	134	Int_t detElemId = it.CurrentDEId();
3626c858	135
	136	if (chamber < 4) {
	137
361fa326	138	sseg = (AliMpSectorSegmentation*)
361fa326	139	AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
3626c858	140	sector = sseg->GetSector();
51346b82	141
51346b82	142	position = sector->Position();
3626c858	143	dimension = sector->Dimensions(); // half length
51346b82	144
3626c858	145	locP[0] = position.Px();
	146	locP[1] = position.Py();
	147	locD[0] = dimension.Px() * 2.;
	148	locD[1] = dimension.Py() * 2.;
51346b82	149
3626c858	150	locP[2] = 0.0;
	151	locD[2] = 0.0;
	152
51346b82	153	fgTransformer->Local2Global(detElemId,
51346b82	154	locP[0], locP[1], locP[2],
3626c858	155	gloP[0], gloP[1], gloP[2]);
51346b82	156
3626c858	157	fgTransformer->Local2Global(detElemId,
51346b82	158	locD[0], locD[1], locD[2],
3626c858	159	gloD[0], gloD[1], gloD[2]);
51346b82	160
	161	fFrameCoord[fNDetElem][0] = gloP[0];
	162	fFrameCoord[fNDetElem][1] = gloP[1];
	163	fFrameCoord[fNDetElem][2] = gloD[0];
	164	fFrameCoord[fNDetElem][3] = gloD[1];
3626c858	165	fFrameCoord[fNDetElem][4] = gloP[2]; // Z position
	166
	167	fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]-gloD[0]);
	168	fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]+gloD[0]);
	169	fChamberBox[2] = TMath::Min(fChamberBox[2],gloP[1]-gloD[1]);
	170	fChamberBox[3] = TMath::Max(fChamberBox[3],gloP[1]+gloD[1]);
	171	fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
	172	fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);
51346b82	173
3626c858	174	} else {
3626c858	175
8d33d1c2	176	// if (!fgSegmentation->HasDE(detElemId)) {
	177	// printf("Segmentation has no %d detElemId! \n",detElemId);
	178	// continue;
	179	// }
3626c858	180
361fa326	181	vseg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath0);
3626c858	182
	183	if (vseg == 0) {
	184	printf("No MpVSegmentation for %d detElemId! \n",detElemId);
	185	continue;
	186	}
	187
	188	deltax = vseg->Dimensions().X();
	189	deltay = vseg->Dimensions().Y();
	190	locP[0] = -deltax;
	191	locP[1] = -deltay;
	192	locD[0] = +deltax;
	193	locD[1] = +deltay;
	194
	195	locP[2] = 0.0;
	196	locD[2] = 0.0;
	197
51346b82	198	fgTransformer->Local2Global(detElemId,
51346b82	199	locP[0], locP[1], locP[2],
3626c858	200	gloP[0], gloP[1], gloP[2]);
51346b82	201
3626c858	202	fgTransformer->Local2Global(detElemId,
51346b82	203	locD[0], locD[1], locD[2],
3626c858	204	gloD[0], gloD[1], gloD[2]);
51346b82	205
	206	fFrameCoord[fNDetElem][0] = gloP[0];
	207	fFrameCoord[fNDetElem][1] = gloP[1];
	208	fFrameCoord[fNDetElem][2] = gloD[0];
	209	fFrameCoord[fNDetElem][3] = gloD[1];
3626c858	210	fFrameCoord[fNDetElem][4] = gloP[2]; // Z position
	211
	212	fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]);
	213	fChamberBox[0] = TMath::Min(fChamberBox[0],gloD[0]);
	214	fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]);
	215	fChamberBox[1] = TMath::Max(fChamberBox[1],gloD[0]);
	216	fChamberBox[2] = TMath::Min(fChamberBox[0],gloP[1]);
	217	fChamberBox[2] = TMath::Min(fChamberBox[0],gloD[1]);
	218	fChamberBox[3] = TMath::Max(fChamberBox[1],gloP[1]);
	219	fChamberBox[3] = TMath::Max(fChamberBox[1],gloD[1]);
	220	fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
	221	fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);
51346b82	222
3626c858	223	}
	224
	225	fNDetElem++;
	226
	227	} // end detElemId loop
	228
3626c858	229	}
3626c858	230
57ffa5fb	231	//______________________________________________________________________________
d810d0de	232	void AliEveMUONChamberData::RegisterDigit(Int_t detElemId, Int_t cathode, Int_t ix, Int_t iy, Int_t charge)
3626c858	233	{
	234	//
	235	// add a digit to this chamber
	236	//
	237
cef26510	238	if ((fNDigits/7) == (4096-1)) return;
cef26510	239
3626c858	240	Float_t locP[3], gloP[3], locD[3], gloD[3];
3626c858	241
361fa326	242	const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()
361fa326	243	->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
3626c858	244
3626c858	245	AliMpPad pad = vseg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
51346b82	246
3626c858	247	locP[0] = pad.Position().X();
	248	locP[1] = pad.Position().Y();
	249	locD[0] = pad.Dimensions().X();
	250	locD[1] = pad.Dimensions().Y();
51346b82	251
3626c858	252	locP[2] = 0.0;
	253	locD[2] = 0.0;
	254
51346b82	255	fgTransformer->Local2Global(detElemId,
51346b82	256	locP[0], locP[1], locP[2],
3626c858	257	gloP[0], gloP[1], gloP[2]);
51346b82	258
3626c858	259	gloD[0] = locD[0];
	260	gloD[1] = locD[1];
	261	gloD[2] = gloP[2];
	262
3626c858	263	if (cathode == 0) gloP[2] += 0.1;
	264	if (cathode == 1) gloP[2] -= 0.1;
	265
	266	fDigitBuffer[fNDigits ] = gloP[0];
	267	fDigitBuffer[fNDigits+1] = gloP[1];
	268	fDigitBuffer[fNDigits+2] = gloD[0];
	269	fDigitBuffer[fNDigits+3] = gloD[1];
	270	fDigitBuffer[fNDigits+4] = gloP[2];
	271	fDigitBuffer[fNDigits+5] = charge;
	272	fDigitBuffer[fNDigits+6] = cathode;
	273
	274	fNDigits += 7;
cef26510	275
eadce74d	276	}
eadce74d	277
57ffa5fb	278	//______________________________________________________________________________
d810d0de	279	void AliEveMUONChamberData::RegisterCluster(Int_t /detElemId/, Int_t cathode, Float_t clsX, Float_t clsY, Float_t clsZ, Float_t charge)
eadce74d	280	{
	281	//
	282	// add a reconstructed point (cluster) to this chamber
	283	//
	284	// identical clusters are registered for both cathode planes ...
	285	//
	286
cef26510	287	if ((fNClusters/5) == (256-1)) return;
cef26510	288
eadce74d	289	fClusterBuffer[fNClusters ] = clsX;
	290	fClusterBuffer[fNClusters+1] = clsY;
	291	fClusterBuffer[fNClusters+2] = clsZ;
	292	fClusterBuffer[fNClusters+3] = charge;
	293	fClusterBuffer[fNClusters+4] = cathode;
	294
	295	fNClusters += 5;
	296
eadce74d	297	}
eadce74d	298
57ffa5fb	299	//______________________________________________________________________________
d810d0de	300	void AliEveMUONChamberData::RegisterHit(Int_t /detElemId/, Float_t hitX, Float_t hitY, Float_t hitZ)
eadce74d	301	{
	302	//
	303	// add a simulation hit to this chamber
	304	//
	305
cef26510	306	if ((fNHits/3) == (256-1)) return;
cef26510	307
eadce74d	308	fHitBuffer[fNHits ] = hitX;
	309	fHitBuffer[fNHits+1] = hitY;
	310	fHitBuffer[fNHits+2] = hitZ;
	311
eadce74d	312	fNHits += 3;
3626c858	313
3626c858	314	}