[u/mrichter/AliRoot.git] / MUON / mapping / AliMpSlat.cxx

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/

// $Id$
// $MpId: AliMpSlat.cxx,v 1.2 2005/09/19 19:01:31 ivana Exp $

#include "AliMpSlat.h"

#include "AliLog.h"
#include "AliMpConnection.h"
#include "AliMpMotif.h"
#include "AliMpMotifPosition.h"
#include "AliMpMotifType.h"
#include "AliMpPCB.h"
#include "AliMpSlatPadIterator.h"

#include "Riostream.h"

#include "TArrayI.h"

ClassImp(AliMpSlat)

//_____________________________________________________________________________
AliMpSlat::AliMpSlat() 
: TObject(), 
  fId(""), 
  fDX(0), 
  fDY(0),
  fNofPadsX(0), 
  fMaxNofPadsY(0)
{
    //
    // Empty ctor.
    //
  AliDebug(1,Form("this=%p Empty ctor",this));
}

//_____________________________________________________________________________
AliMpSlat::AliMpSlat(const char* id)
: TObject(), 
  fId(id), 
  fDX(0), 
  fDY(0),
  fNofPadsX(0), 
  fMaxNofPadsY(0)
{
    //
    // Normal ctor
    //
	AliDebug(1,Form("this=%p id=%s",this,id));			
}

//_____________________________________________________________________________
AliMpSlat::~AliMpSlat()
{
  //
  // Dtor.
  //
		AliDebug(1,Form("this=%p fId=%s",this,fId.Data()));			
}

//_____________________________________________________________________________
void
AliMpSlat::Add(AliMpPCB* pcbType, const TArrayI& manuList) 
{
  //
  // Adds a PCB to this slat. The manuList speficy the ids of the manu
  // that compose the PCB. The manuList ordering is important, as the 
  // assumption is that it's ordered counter-clockwise, starting from
  // the lower-left of the PCB.
  //
  Int_t ixOffset = 0;
  if ( GetSize() )
	{
		ixOffset = GetPCB(GetSize()-1)->Ixmax()+1;
	}
  Double_t xOffset = DX()*2;
  AliMpPCB* pcb = pcbType->Clone(manuList,ixOffset,xOffset);
#ifdef WITH_ROOT
  fPCBs.AddLast(pcb);
#else
  fPCBs.push_back(pcb);
#endif  
  fDY = pcb->DY();
  fDX += pcb->DX();
  fNofPadsX += pcb->GetNofPadsX();
  fMaxNofPadsY = std::max(fMaxNofPadsY,pcb->GetNofPadsY());
  for ( AliMpPCB::Size_t i = 0; i < pcb->GetSize(); ++i )
	{
		AliMpMotifPosition* mp = pcb->GetMotifPosition(i);
		Int_t manuID = mp->GetID();
    // Before inserting a new key, check if it's already there
#ifdef WITH_ROOT
    Long_t there = fManuMap.GetValue((Long_t)manuID);
    if ( there == 0 )
    {
      fManuMap.Add((Long_t)manuID,(Long_t)mp);
    }
    else
    {
      AliError(Form("ManuID %d is duplicated for PCB %s",manuID,pcbType->GetID()));      
    }
#else
  fManuMap[manuID] = mp;
#endif  
	}
}

//_____________________________________________________________________________
TVector2
AliMpSlat::Dimensions() const
{
  //
  // Returns the half-sizes of the slat.
  //
  return TVector2(DX(),DY());
}

//_____________________________________________________________________________
Double_t
AliMpSlat::DX() const
{
  //
  // Returns the x-half-size of the slat.
  //
  return fDX;
}

//_____________________________________________________________________________
Double_t
AliMpSlat::DY() const
{
  //
  // Returns the y-half-size of the slat.
  //
  return fDY;
}

//_____________________________________________________________________________
AliMpMotifPosition*
AliMpSlat::FindMotifPosition(Int_t manuID) const
{
  //
  // Returns the motifPosition referenced by it manuID
  //
#ifdef WITH_ROOT
  Long_t rv = fManuMap.GetValue((Long_t)manuID);
  if ( rv )
  {
    return (AliMpMotifPosition*)(rv);
  }
  else
  {
    return 0;
  }
#else
  std::map<int,AliMpMotifPosition*>::const_iterator it = fManuMap.find(manuID);
  if ( it != fManuMap.end() )
      {
	      return it->second;
      }
  else
  {
    return 0;
  }
#endif      
}

//_____________________________________________________________________________
AliMpMotifPosition*
AliMpSlat::FindMotifPosition(Int_t ix, Int_t iy) const
{
  //
  // 1. Find the PCB containing ix (iy not needed for this)
  // 2. Forward the request to the PCB, using pcb local indices.
	//
  const AliMpPCB* pcb = FindPCB(ix);
  if ( pcb )
	{
		return pcb->FindMotifPosition(ix,iy);
	}
  else
	{
		return 0;
	}
}

//_____________________________________________________________________________
AliMpMotifPosition*
AliMpSlat::FindMotifPosition(Double_t x, Double_t y) const
{
  //
  // Returns the motifPosition containing position (x,y)
  //
  const AliMpPCB* pcb = FindPCB(x,y);
  if (pcb)
	{
		return pcb->FindMotifPosition(x,y);
	}
  else
	{
		return 0;
	}
}

//_____________________________________________________________________________
AliMpPCB*
AliMpSlat::FindPCB(Int_t ix) const
{
  //
  // Returns the PCB containing x-integer-position ix
  //
  for ( Size_t i = 0; i < GetSize(); ++i ) 
	{
		AliMpPCB* pcb = GetPCB(i);
		if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
		{
			return pcb;
		}
	}
  return 0;
}

//_____________________________________________________________________________
Int_t
AliMpSlat::FindPCBIndex(Int_t ix) const
{
  //
  // Returns the index of the PCB containing x-integer-position ix.
  //
  for ( Size_t i = 0; i < GetSize(); ++i ) 
	{
		AliMpPCB* pcb = GetPCB(i);
		if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
		{
			return i;
		}
	}
  return -1;
}

//_____________________________________________________________________________
AliMpPCB*
AliMpSlat::FindPCB(Double_t x, Double_t y) const
{
  //
  // Returns the PCB containing position (x,y)
  //
  for ( Size_t i = 0; i < GetSize(); ++i ) 
	{
		AliMpPCB* pcb = GetPCB(i);
		if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
				 y >= pcb->Ymin() && y < pcb->Ymax() )
		{
			return pcb;
		}
	}
  return 0;
}

//_____________________________________________________________________________
Int_t
AliMpSlat::FindPCBIndex(Double_t x, Double_t y) const
{
  //
  // Returns the index of the PCB containing position (x,y)
  //
  for ( Size_t i = 0; i < GetSize(); ++i ) 
	{
		AliMpPCB* pcb = GetPCB(i);
		if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
				 y >= pcb->Ymin() && y < pcb->Ymax() )
		{
			return i;
		}
	}
  return -1;
}

//_____________________________________________________________________________
const char*
AliMpSlat::GetID() const
{
  //
  // Returns the name of this slat.
  //
  return fId.Data();
}

//_____________________________________________________________________________
Int_t 
AliMpSlat::GetMaxNofPadsY() const
{
  //
  // Returns the maximum number of pads to be found in this slat y-direction.
  // 
  return fMaxNofPadsY;
}

//_____________________________________________________________________________
Int_t
AliMpSlat::GetNofPadsX() const
{
  //
  // Returns the number of pad in x-direction.
  //
  return fNofPadsX;
}

//_____________________________________________________________________________
AliMpPCB*
AliMpSlat::GetPCB(AliMpSlat::Size_t i) const
{
  //
  // Returns the i-th PCB of this slat.
  //
#ifdef WITH_ROOT
  if ( i >= fPCBs.GetEntriesFast() ) return 0;
  return (AliMpPCB*)fPCBs[i];
#else
  if ( i >= fPCBs.size() ) return 0;
  return fPCBs[i];
#endif  
}

//_____________________________________________________________________________
AliMpSlat::Size_t
AliMpSlat::GetSize() const
{
  //
  // Returns the number of PCB in this slat.
  //
#ifdef WITH_ROOT
  return fPCBs.GetEntriesFast();
#else
  return fPCBs.size();
#endif  
}

//_____________________________________________________________________________
void
AliMpSlat::Print(Option_t* option) const
{
  //
  // Prints the slat characteristics.
  //
  cout << "SLAT " << GetID() <<  " 1/2 DIM = (" << DX() << "," << DY() << ")"
	<< " NPADSX = " << GetNofPadsX() << " NPCBs=" << GetSize() << endl;
  
  if ( option && option[0] == 'P' )
	{
    for ( Size_t i = 0; i < GetSize() ; ++i )
		{
      cout << "    ";
			if ( option )
	    {
				fPCBs[i]->Print(option+1);
	    }
			else
	    {
	      fPCBs[i]->Print();
	    }
		}
	}
}
Commit	Line	Data
dee1d5f1	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	// $Id$
	17	// $MpId: AliMpSlat.cxx,v 1.2 2005/09/19 19:01:31 ivana Exp $
	18
	19	#include "AliMpSlat.h"
	20
	21	#include "AliLog.h"
	22	#include "AliMpConnection.h"
	23	#include "AliMpMotif.h"
	24	#include "AliMpMotifPosition.h"
	25	#include "AliMpMotifType.h"
	26	#include "AliMpPCB.h"
	27	#include "AliMpSlatPadIterator.h"
	28
	29	#include "Riostream.h"
	30
	31	#include "TArrayI.h"
	32
	33	ClassImp(AliMpSlat)
	34
	35	//_____________________________________________________________________________
	36	AliMpSlat::AliMpSlat()
	37	: TObject(),
	38	fId(""),
	39	fDX(0),
	40	fDY(0),
	41	fNofPadsX(0),
	42	fMaxNofPadsY(0)
	43	{
	44	//
	45	// Empty ctor.
	46	//
	47	AliDebug(1,Form("this=%p Empty ctor",this));
	48	}
	49
	50	//_____________________________________________________________________________
	51	AliMpSlat::AliMpSlat(const char* id)
	52	: TObject(),
	53	fId(id),
	54	fDX(0),
	55	fDY(0),
	56	fNofPadsX(0),
	57	fMaxNofPadsY(0)
	58	{
	59	//
	60	// Normal ctor
	61	//
	62	AliDebug(1,Form("this=%p id=%s",this,id));
	63	}
	64
65	//_____________________________________________________________________________
66	AliMpSlat::~AliMpSlat()
67	{
68	//
69	// Dtor.
70	//
71	AliDebug(1,Form("this=%p fId=%s",this,fId.Data()));
72	}
73
74	//_____________________________________________________________________________
75	void
76	AliMpSlat::Add(AliMpPCB* pcbType, const TArrayI& manuList)
77	{
78	//
79	// Adds a PCB to this slat. The manuList speficy the ids of the manu
80	// that compose the PCB. The manuList ordering is important, as the
81	// assumption is that it's ordered counter-clockwise, starting from
82	// the lower-left of the PCB.
83	//
84	Int_t ixOffset = 0;
85	if ( GetSize() )
86	{
87	ixOffset = GetPCB(GetSize()-1)->Ixmax()+1;
88	}
89	Double_t xOffset = DX()*2;
90	AliMpPCB* pcb = pcbType->Clone(manuList,ixOffset,xOffset);
91	#ifdef WITH_ROOT
92	fPCBs.AddLast(pcb);
93	#else
94	fPCBs.push_back(pcb);
95	#endif
96	fDY = pcb->DY();
97	fDX += pcb->DX();
98	fNofPadsX += pcb->GetNofPadsX();
99	fMaxNofPadsY = std::max(fMaxNofPadsY,pcb->GetNofPadsY());
100	for ( AliMpPCB::Size_t i = 0; i < pcb->GetSize(); ++i )
101	{
102	AliMpMotifPosition* mp = pcb->GetMotifPosition(i);
103	Int_t manuID = mp->GetID();
104	// Before inserting a new key, check if it's already there
105	#ifdef WITH_ROOT
106	Long_t there = fManuMap.GetValue((Long_t)manuID);
107	if ( there == 0 )
108	{
109	fManuMap.Add((Long_t)manuID,(Long_t)mp);
110	}
111	else
112	{
113	AliError(Form("ManuID %d is duplicated for PCB %s",manuID,pcbType->GetID()));
114	}
115	#else
116	fManuMap[manuID] = mp;
117	#endif
118	}
119	}
120
121	//_____________________________________________________________________________
122	TVector2
123	AliMpSlat::Dimensions() const
124	{
125	//
126	// Returns the half-sizes of the slat.
127	//
128	return TVector2(DX(),DY());
129	}
130
131	//_____________________________________________________________________________
132	Double_t
133	AliMpSlat::DX() const
134	{
135	//
136	// Returns the x-half-size of the slat.
137	//
138	return fDX;
139	}
140
141	//_____________________________________________________________________________
142	Double_t
143	AliMpSlat::DY() const
144	{
145	//
146	// Returns the y-half-size of the slat.
147	//
148	return fDY;
149	}
150
151	//_____________________________________________________________________________
152	AliMpMotifPosition*
153	AliMpSlat::FindMotifPosition(Int_t manuID) const
154	{
155	//
156	// Returns the motifPosition referenced by it manuID
157	//
158	#ifdef WITH_ROOT
159	Long_t rv = fManuMap.GetValue((Long_t)manuID);
160	if ( rv )
161	{
162	return (AliMpMotifPosition*)(rv);
163	}
164	else
165	{
166	return 0;
167	}
168	#else
169	std::map<int,AliMpMotifPosition*>::const_iterator it = fManuMap.find(manuID);
170	if ( it != fManuMap.end() )
171	{
172	return it->second;
173	}
174	else
175	{
176	return 0;
177	}
178	#endif
179	}
180
181	//_____________________________________________________________________________
182	AliMpMotifPosition*
183	AliMpSlat::FindMotifPosition(Int_t ix, Int_t iy) const
184	{
185	//
186	// 1. Find the PCB containing ix (iy not needed for this)
187	// 2. Forward the request to the PCB, using pcb local indices.
188	//
189	const AliMpPCB* pcb = FindPCB(ix);
190	if ( pcb )
191	{
192	return pcb->FindMotifPosition(ix,iy);
193	}
194	else
195	{
196	return 0;
197	}
198	}
199
200	//_____________________________________________________________________________
201	AliMpMotifPosition*
202	AliMpSlat::FindMotifPosition(Double_t x, Double_t y) const
203	{
204	//
205	// Returns the motifPosition containing position (x,y)
206	//
207	const AliMpPCB* pcb = FindPCB(x,y);
208	if (pcb)
209	{
210	return pcb->FindMotifPosition(x,y);
211	}
212	else
213	{
214	return 0;
215	}
216	}
217
218	//_____________________________________________________________________________
219	AliMpPCB*
220	AliMpSlat::FindPCB(Int_t ix) const
221	{
222	//
223	// Returns the PCB containing x-integer-position ix
224	//
225	for ( Size_t i = 0; i < GetSize(); ++i )
226	{
227	AliMpPCB* pcb = GetPCB(i);
228	if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
229	{
230	return pcb;
231	}
232	}
233	return 0;
234	}
235
236	//_____________________________________________________________________________
237	Int_t
238	AliMpSlat::FindPCBIndex(Int_t ix) const
239	{
240	//
241	// Returns the index of the PCB containing x-integer-position ix.
242	//
243	for ( Size_t i = 0; i < GetSize(); ++i )
244	{
245	AliMpPCB* pcb = GetPCB(i);
246	if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
247	{
248	return i;
249	}
250	}
251	return -1;
252	}
253
254	//_____________________________________________________________________________
255	AliMpPCB*
256	AliMpSlat::FindPCB(Double_t x, Double_t y) const
257	{
258	//
259	// Returns the PCB containing position (x,y)
260	//
261	for ( Size_t i = 0; i < GetSize(); ++i )
262	{
263	AliMpPCB* pcb = GetPCB(i);
264	if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
265	y >= pcb->Ymin() && y < pcb->Ymax() )
266	{
267	return pcb;
268	}
269	}
270	return 0;
271	}
272
273	//_____________________________________________________________________________
274	Int_t
275	AliMpSlat::FindPCBIndex(Double_t x, Double_t y) const
276	{
277	//
278	// Returns the index of the PCB containing position (x,y)
279	//
280	for ( Size_t i = 0; i < GetSize(); ++i )
281	{
282	AliMpPCB* pcb = GetPCB(i);
283	if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
284	y >= pcb->Ymin() && y < pcb->Ymax() )
285	{
286	return i;
287	}
288	}
289	return -1;
290	}
291
292	//_____________________________________________________________________________
293	const char*
294	AliMpSlat::GetID() const
295	{
296	//
297	// Returns the name of this slat.
298	//
299	return fId.Data();
300	}
301
302	//_____________________________________________________________________________
303	Int_t
304	AliMpSlat::GetMaxNofPadsY() const
305	{
306	//
307	// Returns the maximum number of pads to be found in this slat y-direction.
308	//
309	return fMaxNofPadsY;
310	}
311
312	//_____________________________________________________________________________
313	Int_t
314	AliMpSlat::GetNofPadsX() const
315	{
316	//
317	// Returns the number of pad in x-direction.
318	//
319	return fNofPadsX;
320	}
321
322	//_____________________________________________________________________________
323	AliMpPCB*
324	AliMpSlat::GetPCB(AliMpSlat::Size_t i) const
325	{
326	//
327	// Returns the i-th PCB of this slat.
328	//
329	#ifdef WITH_ROOT
330	if ( i >= fPCBs.GetEntriesFast() ) return 0;
331	return (AliMpPCB*)fPCBs[i];
332	#else
333	if ( i >= fPCBs.size() ) return 0;
334	return fPCBs[i];
335	#endif
336	}
337
338	//_____________________________________________________________________________
339	AliMpSlat::Size_t
340	AliMpSlat::GetSize() const
341	{
342	//
343	// Returns the number of PCB in this slat.
344	//
345	#ifdef WITH_ROOT
346	return fPCBs.GetEntriesFast();
347	#else
348	return fPCBs.size();
349	#endif
350	}
351
352	//_____________________________________________________________________________
353	void
354	AliMpSlat::Print(Option_t* option) const
355	{
356	//
357	// Prints the slat characteristics.
358	//
359	cout << "SLAT " << GetID() << " 1/2 DIM = (" << DX() << "," << DY() << ")"
360	<< " NPADSX = " << GetNofPadsX() << " NPCBs=" << GetSize() << endl;
361
362	if ( option && option[0] == 'P' )
363	{
364	for ( Size_t i = 0; i < GetSize() ; ++i )
365	{
366	cout << " ";
367	if ( option )
368	{
369	fPCBs[i]->Print(option+1);
370	}
371	else
372	{
373	fPCBs[i]->Print();
374	}
375	}
376	}
377	}