[u/mrichter/AliRoot.git] / EVE / Alieve / 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 "Alieve/AliEveEventManager.h"

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


ClassImp(AliEveMUONChamberData)

AliMUONGeometryTransformer* AliEveMUONChamberData::fgTransformer = 0;

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