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

#include "MUONChamberData.h"

#include <AliMUONSegmentation.h>
#include <AliMUONConstants.h>
#include <AliMUONGeometryTransformer.h>
#include <AliMUONSegFactory.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>

///////////////////////////////////////////////////////////////////////////////
///
/// MUONChamberData: geometry and digits
///
///////////////////////////////////////////////////////////////////////////////

using namespace Reve;
using namespace Alieve;

ClassImp(MUONChamberData)

AliMUONSegmentation* MUONChamberData::fgSegmentation = 0;
AliMUONGeometryTransformer* MUONChamberData::fgTransformer = 0;

//______________________________________________________________________
MUONChamberData::MUONChamberData(Int_t chamber)
{
  //
  // constructor
  //

  fChamberID = chamber;
  fNDetElem  = 0;
  fNDigits   = 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 < 3; i++) {
    fChamberBox[i*2  ] = +9999;
    fChamberBox[i*2+1] = -9999;
  }

  if (fgSegmentation == 0) {
    AliMUONSegFactory segFactory("volpath.dat","transform.dat");
    fgSegmentation = segFactory.CreateSegmentation();
    fgTransformer = new AliMUONGeometryTransformer(true);
    fgTransformer->ReadGeometryData("volpaths.dat","transform.dat");
  }

  Init(chamber);

}

//______________________________________________________________________
MUONChamberData::~MUONChamberData()
{
  //
  // destructor
  //

}

//______________________________________________________________________
void MUONChamberData::DropData()
{
  //
  // release the chamber data
  //

  return;

}

//______________________________________________________________________
void MUONChamberData::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.CurrentDE();

    if (chamber < 4) {

      sseg = (AliMpSectorSegmentation*)AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,0);
      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 {

      //AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);

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

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

      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

  //printf("ChamberBox %d \n",chamber);
  //printf("%f %f \n",fChamberBox[0],fChamberBox[1]);
  //printf("%f %f \n",fChamberBox[2],fChamberBox[3]);
  //printf("%f %f \n",fChamberBox[4],fChamberBox[5]);

}

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

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

  const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,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];

  //printf("DigitP %f %f %f \n",gloP[0],gloP[1],gloP[2]);
  //printf("DigitD %f %f \n",gloD[0],gloD[1]);

  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;

}
Commit	Line	Data
3626c858	1	#include "MUONChamberData.h"
	2
	3	#include <AliMUONSegmentation.h>
	4	#include <AliMUONConstants.h>
	5	#include <AliMUONGeometryTransformer.h>
	6	#include <AliMUONSegFactory.h>
	7	#include <mapping/AliMpDEIterator.h>
	8	#include <mapping/AliMpSectorSegmentation.h>
	9	#include <mapping/AliMpSector.h>
	10	#include <mapping/AliMpPad.h>
	11	#include <mapping/AliMpStationType.h>
	12	#include <mapping/AliMpDEManager.h>
	13	#include <mapping/AliMpSegmentation.h>
	14
	15	#include <TMath.h>
	16	#include <TVector2.h>
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	///
	20	/// MUONChamberData: geometry and digits
	21	///
	22	///////////////////////////////////////////////////////////////////////////////
	23
	24	using namespace Reve;
	25	using namespace Alieve;
	26
	27	ClassImp(MUONChamberData)
	28
	29	AliMUONSegmentation* MUONChamberData::fgSegmentation = 0;
	30	AliMUONGeometryTransformer* MUONChamberData::fgTransformer = 0;
	31
	32	//______________________________________________________________________
	33	MUONChamberData::MUONChamberData(Int_t chamber)
	34	{
	35	//
	36	// constructor
	37	//
	38
	39	fChamberID = chamber;
	40	fNDetElem = 0;
	41	fNDigits = 0;
	42	for (Int_t i = 0; i < 26; i++) {
	43	for (Int_t j = 0; j < 4; j++) {
	44	fFrameCoord[i][j] = 0.0;
	45	}
	46	}
	47	for (Int_t i = 0; i < 7*4096; i++) {
	48	fDigitBuffer[i] = 0.0;
	49	}
	50
	51	for (Int_t i = 0; i < 3; i++) {
	52	fChamberBox[i*2 ] = +9999;
	53	fChamberBox[i*2+1] = -9999;
	54	}
	55
	56	if (fgSegmentation == 0) {
	57	AliMUONSegFactory segFactory("volpath.dat","transform.dat");
8fa29787	58	fgSegmentation = segFactory.CreateSegmentation();
3626c858	59	fgTransformer = new AliMUONGeometryTransformer(true);
	60	fgTransformer->ReadGeometryData("volpaths.dat","transform.dat");
	61	}
	62
	63	Init(chamber);
	64
	65	}
	66
	67	//______________________________________________________________________
	68	MUONChamberData::~MUONChamberData()
	69	{
	70	//
	71	// destructor
	72	//
	73
	74	}
	75
	76	//______________________________________________________________________
	77	void MUONChamberData::DropData()
	78	{
	79	//
	80	// release the chamber data
	81	//
	82
	83	return;
	84
	85	}
	86
	87	//______________________________________________________________________
	88	void MUONChamberData::Init(Int_t chamber)
	89	{
	90	//
	91	// initialize the drawing coordinates of the chamber
	92	//
	93
	94	Float_t locP[3], gloP[3], locD[3], gloD[3];
	95	Float_t deltax, deltay;
	96	AliMpDEIterator it;
	97	const AliMpVSegmentation *vseg;
	98	const AliMpSectorSegmentation *sseg;
	99	const AliMpSector *sector;
	100	TVector2 position;
	101	TVector2 dimension;
	102
	103	for ( it.First(chamber); ! it.IsDone(); it.Next() ) {
	104
	105	Int_t detElemId = it.CurrentDE();
	106
	107	if (chamber < 4) {
	108
	109	sseg = (AliMpSectorSegmentation*)AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,0);
	110	sector = sseg->GetSector();
	111
	112	position = sector->Position();
	113	dimension = sector->Dimensions(); // half length
	114
	115	locP[0] = position.Px();
	116	locP[1] = position.Py();
	117	locD[0] = dimension.Px() * 2.;
	118	locD[1] = dimension.Py() * 2.;
	119
	120	locP[2] = 0.0;
	121	locD[2] = 0.0;
	122
123	fgTransformer->Local2Global(detElemId,
124	locP[0], locP[1], locP[2],
125	gloP[0], gloP[1], gloP[2]);
126
127	fgTransformer->Local2Global(detElemId,
128	locD[0], locD[1], locD[2],
129	gloD[0], gloD[1], gloD[2]);
130
131	fFrameCoord[fNDetElem][0] = gloP[0];
132	fFrameCoord[fNDetElem][1] = gloP[1];
133	fFrameCoord[fNDetElem][2] = gloD[0];
134	fFrameCoord[fNDetElem][3] = gloD[1];
135	fFrameCoord[fNDetElem][4] = gloP[2]; // Z position
136
137	fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]-gloD[0]);
138	fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]+gloD[0]);
139	fChamberBox[2] = TMath::Min(fChamberBox[2],gloP[1]-gloD[1]);
140	fChamberBox[3] = TMath::Max(fChamberBox[3],gloP[1]+gloD[1]);
141	fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
142	fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);
143
144	} else {
145
146	//AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);
147
148	if (!fgSegmentation->HasDE(detElemId)) {
149	printf("Segmentation has no %d detElemId! \n",detElemId);
150	continue;
151	}
152
153	vseg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,0);
154
155	if (vseg == 0) {
156	printf("No MpVSegmentation for %d detElemId! \n",detElemId);
157	continue;
158	}
159
160	deltax = vseg->Dimensions().X();
161	deltay = vseg->Dimensions().Y();
162	locP[0] = -deltax;
163	locP[1] = -deltay;
164	locD[0] = +deltax;
165	locD[1] = +deltay;
166
167	locP[2] = 0.0;
168	locD[2] = 0.0;
169
170	fgTransformer->Local2Global(detElemId,
171	locP[0], locP[1], locP[2],
172	gloP[0], gloP[1], gloP[2]);
173
174	fgTransformer->Local2Global(detElemId,
175	locD[0], locD[1], locD[2],
176	gloD[0], gloD[1], gloD[2]);
177
178	fFrameCoord[fNDetElem][0] = gloP[0];
179	fFrameCoord[fNDetElem][1] = gloP[1];
180	fFrameCoord[fNDetElem][2] = gloD[0];
181	fFrameCoord[fNDetElem][3] = gloD[1];
182	fFrameCoord[fNDetElem][4] = gloP[2]; // Z position
183
184	fChamberBox[0] = TMath::Min(fChamberBox[0],gloP[0]);
185	fChamberBox[0] = TMath::Min(fChamberBox[0],gloD[0]);
186	fChamberBox[1] = TMath::Max(fChamberBox[1],gloP[0]);
187	fChamberBox[1] = TMath::Max(fChamberBox[1],gloD[0]);
188	fChamberBox[2] = TMath::Min(fChamberBox[0],gloP[1]);
189	fChamberBox[2] = TMath::Min(fChamberBox[0],gloD[1]);
190	fChamberBox[3] = TMath::Max(fChamberBox[1],gloP[1]);
191	fChamberBox[3] = TMath::Max(fChamberBox[1],gloD[1]);
192	fChamberBox[4] = TMath::Min(fChamberBox[4],gloP[2]);
193	fChamberBox[5] = TMath::Max(fChamberBox[5],gloP[2]);
194
195	}
196
197	fNDetElem++;
198
199	} // end detElemId loop
200
201	//printf("ChamberBox %d \n",chamber);
202	//printf("%f %f \n",fChamberBox[0],fChamberBox[1]);
203	//printf("%f %f \n",fChamberBox[2],fChamberBox[3]);
204	//printf("%f %f \n",fChamberBox[4],fChamberBox[5]);
205
206	}
207
208	//______________________________________________________________________
209	void MUONChamberData::RegisterDigit(Int_t detElemId, Int_t cathode, Int_t ix, Int_t iy, Int_t charge)
210	{
211	//
212	// add a digit to this chamber
213	//
214
215	Float_t locP[3], gloP[3], locD[3], gloD[3];
216
217	const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,cathode);
218
219	AliMpPad pad = vseg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
220
221	locP[0] = pad.Position().X();
222	locP[1] = pad.Position().Y();
223	locD[0] = pad.Dimensions().X();
224	locD[1] = pad.Dimensions().Y();
225
226	locP[2] = 0.0;
227	locD[2] = 0.0;
228
229	fgTransformer->Local2Global(detElemId,
230	locP[0], locP[1], locP[2],
231	gloP[0], gloP[1], gloP[2]);
232
233	gloD[0] = locD[0];
234	gloD[1] = locD[1];
235	gloD[2] = gloP[2];
236
237	//printf("DigitP %f %f %f \n",gloP[0],gloP[1],gloP[2]);
238	//printf("DigitD %f %f \n",gloD[0],gloD[1]);
239
240	if (cathode == 0) gloP[2] += 0.1;
241	if (cathode == 1) gloP[2] -= 0.1;
242
243	fDigitBuffer[fNDigits ] = gloP[0];
244	fDigitBuffer[fNDigits+1] = gloP[1];
245	fDigitBuffer[fNDigits+2] = gloD[0];
246	fDigitBuffer[fNDigits+3] = gloD[1];
247	fDigitBuffer[fNDigits+4] = gloP[2];
248	fDigitBuffer[fNDigits+5] = charge;
249	fDigitBuffer[fNDigits+6] = cathode;
250
251	fNDigits += 7;
252
253	}