[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.6 2006/05/24 13:58:50 ivana Exp $

#include "AliMpSlat.h"

#include "AliLog.h"
#include "AliMpMotifPosition.h"
#include "AliMpPCB.h"

#include "Riostream.h"

#include "TArrayI.h"

//-----------------------------------------------------------------------------
/// Representation of a slat cathode (bending or non-bending).
///
/// A slat can be viewed as a "collection" of PCBs of various densities
/// (the density is defined by the size of the pads composing the PCB).
///
/// All the PCBs have a least the same height, if not the same width. In most
/// of the case, height=width=40 cm, at least for St345 (for trigger,
/// width varies)
// 
/// \author Laurent Aphecetche
//-----------------------------------------------------------------------------

/// \cond CLASSIMP
ClassImp(AliMpSlat)
/// \endcond

//_____________________________________________________________________________
AliMpSlat::AliMpSlat() 
: TObject(), 
  fId(""), 
  fPlaneType(AliMp::kNonBendingPlane),
  fDX(0), 
  fDY(0),
  fNofPadsX(0), 
  fMaxNofPadsY(0),
  fManuMap(),
  fPCBs(),
  fPosition(),
  fNofPads(0)
{
    ///
    /// Empty ctor.
    ///
  AliDebug(1,Form("this=%p Empty ctor",this));
#ifdef WITH_ROOT    
    fPCBs.SetOwner(kTRUE);
#endif    
    fManuMap.SetOwner(kFALSE);
}

//_____________________________________________________________________________
AliMpSlat::AliMpSlat(const char* id, AliMp::PlaneType bendingOrNonBending)
: TObject(), 
  fId(id), 
  fPlaneType(bendingOrNonBending),
  fDX(0), 
  fDY(0),
  fNofPadsX(0), 
  fMaxNofPadsY(0),
  fManuMap(kTRUE),
  fPCBs(),
  fPosition(),
  fNofPads(0)
{
    ///
    /// Normal ctor
    ///
  AliDebug(1,Form("this=%p id=%s",this,id));			
#ifdef WITH_ROOT    
    fPCBs.SetOwner(kTRUE);
#endif    
    fManuMap.SetOwner(kFALSE);
}

//_____________________________________________________________________________
AliMpSlat::~AliMpSlat()
{
  ///
  /// Dtor.
  ///
  AliDebug(1,Form("this=%p fId=%s",this,fId.Data()));			
#ifdef WITH_ROOT    
  fPCBs.Delete();
#else
  for ( size_t i = 0; i < fPCBs.size(); ++i )
  {
    delete fPCBs[i];
  }
#endif    
}

//_____________________________________________________________________________
void
AliMpSlat::Add(const AliMpPCB& pcbType, const TArrayI& manuList) 
{
  ///
  /// Adds a PCB to this slat. The manuList specifies 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;
	}
  else
  {
    ixOffset = pcbType.Ixmin();
  }
  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 = TMath::Max(pcb->DY(),fDY);
  fDX += pcb->DX();
  fNofPadsX += pcb->GetNofPadsX();
  fMaxNofPadsY = TMath::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
    TObject* there = fManuMap.GetValue(manuID);
    if ( there == 0 )
    {
      fManuMap.Add(manuID,(TObject*)mp);
    }
    else
    {
      AliError(Form("ManuID %d is duplicated for PCB %s",manuID,pcbType.GetID()));      
    }
//#else
//  fManuMap[manuID] = mp;
//#endif  
	}
  fPosition.Set(DX(),DY());
  fNofPads += pcb->NofPads();
}

//_____________________________________________________________________________
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
  return static_cast<AliMpMotifPosition*>(fManuMap.GetValue(manuID));
//#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;
//		}
    if ( x < pcb->Xmin() || x >= pcb->Xmax() ||
         y < pcb->Ymin() || y >= pcb->Ymax() )
    {
      continue;
    }
    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;
}

//_____________________________________________________________________________
void
AliMpSlat::ForcePosition(const TVector2& pos)
{
  ///
  /// Force the position to be different from (DX(),DY()).
  /// Normally only used by triggerSlats (for layers).
  /// Beware that this method must be called once all PCB have been added,
  /// as the Add() method resets the position.
  ///
  fPosition = pos;
}

//_____________________________________________________________________________
void
AliMpSlat::GetAllMotifPositionsIDs(TArrayI& ecn) const
{
  ///
  /// Return all the manuIds (=MotifPositionIDs) of this slat
  ///
  ecn.Set(GetNofElectronicCards());
//#ifdef WITH_ROOT
  TExMapIter it(fManuMap.GetIterator());
  Long_t key;
  Long_t value;
  Int_t n(0);
  while ( it.Next(key,value) == kTRUE )
  {
    ecn.AddAt((Int_t)(key),n);
    ++n;
  }
//#else
  // missing here
//#endif      
}

//_____________________________________________________________________________
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::GetMaxPadIndexX() const
{
  ///
  /// Returns the max ix that is valid for this slat.
  ///
  AliMpPCB* last = GetPCB(GetSize()-1);
  if (last)
  {
    return last->Ixmax();
  }
  return 0;
}

//_____________________________________________________________________________
const char*
AliMpSlat::GetName() const
{
  ///
  /// Returns the name of this slat, which is composed of its ID with
  /// the plane type as a suffix.
  ///
  TString name(GetID());
  if ( fPlaneType == AliMp::kBendingPlane )
  {
    name += ".Bending";
  }
  else if ( fPlaneType == AliMp::kNonBendingPlane )
  {
    name += ".NonBending";
  }
  else
  {
    name += ".Invalid";
  }
  return name.Data();  
}

//_____________________________________________________________________________
Int_t
AliMpSlat::GetNofElectronicCards() const
{
  ///
  /// Returns the number of manus that compose the readout of this slat.
  ///
  return fManuMap.GetSize();
}

//_____________________________________________________________________________
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() << ")"
  << " POS = " << Position().X() << "," << Position().Y()
	<< " NPADSX = " << GetNofPadsX() 
  << " MAXNPADSY = " << GetMaxNofPadsY()
  << " NPCBs=" << GetSize() << endl;
  
  TString soption(option);
  
  if ( soption.Contains("P") )
	{
    for ( Size_t i = 0; i < GetSize() ; ++i )
		{
      cout << "    ";
			if ( option )
	    {
				fPCBs[i]->Print(option+1);
	    }
			else
	    {
	      fPCBs[i]->Print();
	    }
		}
	}
  
  if ( soption.Contains("M") || soption.Contains("L") )
  {
    cout << fManuMap.GetSize() << " ";
    cout << "Electronic card (manu or local board) Ids : ";
    
    TExMapIter iter(fManuMap.GetIterator());
    Long_t key, value;
    while ( iter.Next(key,value) )
    {
      cout << key << " ";
    }
    cout << endl;
  }
}
Commit	Line	Data
	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.6 2006/05/24 13:58:50 ivana Exp $
	18
	19	#include "AliMpSlat.h"
	20
	21	#include "AliLog.h"
	22	#include "AliMpMotifPosition.h"
	23	#include "AliMpPCB.h"
	24
	25	#include "Riostream.h"
	26
	27	#include "TArrayI.h"
	28
	29	//-----------------------------------------------------------------------------
	30	/// Representation of a slat cathode (bending or non-bending).
	31	///
	32	/// A slat can be viewed as a "collection" of PCBs of various densities
	33	/// (the density is defined by the size of the pads composing the PCB).
	34	///
	35	/// All the PCBs have a least the same height, if not the same width. In most
	36	/// of the case, height=width=40 cm, at least for St345 (for trigger,
	37	/// width varies)
	38	//
	39	/// \author Laurent Aphecetche
	40	//-----------------------------------------------------------------------------
	41
	42	/// \cond CLASSIMP
	43	ClassImp(AliMpSlat)
	44	/// \endcond
	45
	46	//_____________________________________________________________________________
	47	AliMpSlat::AliMpSlat()
	48	: TObject(),
	49	fId(""),
	50	fPlaneType(AliMp::kNonBendingPlane),
	51	fDX(0),
	52	fDY(0),
	53	fNofPadsX(0),
	54	fMaxNofPadsY(0),
	55	fManuMap(),
	56	fPCBs(),
	57	fPosition(),
	58	fNofPads(0)
	59	{
	60	///
	61	/// Empty ctor.
	62	///
	63	AliDebug(1,Form("this=%p Empty ctor",this));
	64	#ifdef WITH_ROOT
	65	fPCBs.SetOwner(kTRUE);
	66	#endif
	67	fManuMap.SetOwner(kFALSE);
	68	}
	69
	70	//_____________________________________________________________________________
	71	AliMpSlat::AliMpSlat(const char* id, AliMp::PlaneType bendingOrNonBending)
	72	: TObject(),
	73	fId(id),
	74	fPlaneType(bendingOrNonBending),
	75	fDX(0),
	76	fDY(0),
	77	fNofPadsX(0),
	78	fMaxNofPadsY(0),
	79	fManuMap(kTRUE),
	80	fPCBs(),
	81	fPosition(),
	82	fNofPads(0)
	83	{
	84	///
	85	/// Normal ctor
	86	///
	87	AliDebug(1,Form("this=%p id=%s",this,id));
	88	#ifdef WITH_ROOT
	89	fPCBs.SetOwner(kTRUE);
	90	#endif
	91	fManuMap.SetOwner(kFALSE);
	92	}
	93
	94	//_____________________________________________________________________________
	95	AliMpSlat::~AliMpSlat()
	96	{
	97	///
	98	/// Dtor.
	99	///
	100	AliDebug(1,Form("this=%p fId=%s",this,fId.Data()));
	101	#ifdef WITH_ROOT
	102	fPCBs.Delete();
	103	#else
	104	for ( size_t i = 0; i < fPCBs.size(); ++i )
	105	{
	106	delete fPCBs[i];
	107	}
	108	#endif
	109	}
	110
	111	//_____________________________________________________________________________
	112	void
	113	AliMpSlat::Add(const AliMpPCB& pcbType, const TArrayI& manuList)
	114	{
	115	///
	116	/// Adds a PCB to this slat. The manuList specifies the ids of the manu
	117	/// that compose the PCB. The manuList ordering is important, as the
	118	/// assumption is that it's ordered counter-clockwise, starting from
	119	/// the lower-left of the PCB.
	120	///
	121	Int_t ixOffset = 0;
	122	if ( GetSize() )
	123	{
	124	ixOffset = GetPCB(GetSize()-1)->Ixmax()+1;
	125	}
	126	else
	127	{
	128	ixOffset = pcbType.Ixmin();
	129	}
	130	Double_t xOffset = DX()*2;
	131	AliMpPCB* pcb = pcbType.Clone(manuList,ixOffset,xOffset);
	132	#ifdef WITH_ROOT
	133	fPCBs.AddLast(pcb);
	134	#else
	135	fPCBs.push_back(pcb);
	136	#endif
	137	fDY = TMath::Max(pcb->DY(),fDY);
	138	fDX += pcb->DX();
	139	fNofPadsX += pcb->GetNofPadsX();
	140	fMaxNofPadsY = TMath::Max(fMaxNofPadsY,pcb->GetNofPadsY());
	141	for ( AliMpPCB::Size_t i = 0; i < pcb->GetSize(); ++i )
	142	{
	143	AliMpMotifPosition* mp = pcb->GetMotifPosition(i);
	144	Int_t manuID = mp->GetID();
	145	// Before inserting a new key, check if it's already there
	146	//#ifdef WITH_ROOT
	147	TObject* there = fManuMap.GetValue(manuID);
	148	if ( there == 0 )
	149	{
	150	fManuMap.Add(manuID,(TObject*)mp);
	151	}
	152	else
	153	{
	154	AliError(Form("ManuID %d is duplicated for PCB %s",manuID,pcbType.GetID()));
	155	}
	156	//#else
	157	// fManuMap[manuID] = mp;
	158	//#endif
	159	}
	160	fPosition.Set(DX(),DY());
	161	fNofPads += pcb->NofPads();
	162	}
	163
	164	//_____________________________________________________________________________
	165	TVector2
	166	AliMpSlat::Dimensions() const
	167	{
	168	///
	169	/// Returns the half-sizes of the slat.
	170	///
	171	return TVector2(DX(),DY());
	172	}
	173
	174	//_____________________________________________________________________________
	175	Double_t
	176	AliMpSlat::DX() const
	177	{
	178	///
	179	/// Returns the x-half-size of the slat.
	180	///
	181	return fDX;
	182	}
	183
	184	//_____________________________________________________________________________
	185	Double_t
	186	AliMpSlat::DY() const
	187	{
	188	///
	189	/// Returns the y-half-size of the slat.
	190	///
	191	return fDY;
	192	}
	193
	194	//_____________________________________________________________________________
	195	AliMpMotifPosition*
	196	AliMpSlat::FindMotifPosition(Int_t manuID) const
	197	{
	198	///
	199	/// Returns the motifPosition referenced by it manuID
	200	///
	201	//#ifdef WITH_ROOT
	202	return static_cast<AliMpMotifPosition*>(fManuMap.GetValue(manuID));
	203	//#else
	204	// std::map<int,AliMpMotifPosition*>::const_iterator it = fManuMap.find(manuID);
	205	// if ( it != fManuMap.end() )
	206	// {
	207	// return it->second;
	208	// }
	209	// else
	210	// {
	211	// return 0;
	212	// }
	213	//#endif
	214	}
	215
	216	//_____________________________________________________________________________
	217	AliMpMotifPosition*
	218	AliMpSlat::FindMotifPosition(Int_t ix, Int_t iy) const
	219	{
	220	///
	221	/// - 1. Find the PCB containing ix (iy not needed for this)
	222	/// - 2. Forward the request to the PCB, using pcb local indices.
	223	//
	224	const AliMpPCB* pcb = FindPCB(ix);
	225	if ( pcb )
	226	{
	227	return pcb->FindMotifPosition(ix,iy);
	228	}
	229	else
	230	{
	231	return 0;
	232	}
	233	}
	234
	235	//_____________________________________________________________________________
	236	AliMpMotifPosition*
	237	AliMpSlat::FindMotifPosition(Double_t x, Double_t y) const
	238	{
	239	///
	240	/// Returns the motifPosition containing position (x,y)
	241	///
	242	const AliMpPCB* pcb = FindPCB(x,y);
	243	if (pcb)
	244	{
	245	return pcb->FindMotifPosition(x,y);
	246	}
	247	else
	248	{
	249	return 0;
	250	}
	251	}
	252
	253	//_____________________________________________________________________________
	254	AliMpPCB*
	255	AliMpSlat::FindPCB(Int_t ix) const
	256	{
	257	///
	258	/// Returns the PCB containing x-integer-position ix
	259	///
	260	for ( Size_t i = 0; i < GetSize(); ++i )
	261	{
	262	AliMpPCB* pcb = GetPCB(i);
	263	if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
	264	{
	265	return pcb;
	266	}
	267	}
	268	return 0;
	269	}
	270
	271	//_____________________________________________________________________________
	272	Int_t
	273	AliMpSlat::FindPCBIndex(Int_t ix) const
	274	{
	275	///
	276	/// Returns the index of the PCB containing x-integer-position ix.
	277	///
	278	for ( Size_t i = 0; i < GetSize(); ++i )
	279	{
	280	AliMpPCB* pcb = GetPCB(i);
	281	if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
	282	{
	283	return i;
	284	}
	285	}
	286	return -1;
	287	}
	288
	289	//_____________________________________________________________________________
	290	AliMpPCB*
	291	AliMpSlat::FindPCB(Double_t x, Double_t y) const
	292	{
	293	///
	294	/// Returns the PCB containing position (x,y)
	295	///
	296	for ( Size_t i = 0; i < GetSize(); ++i )
	297	{
	298	AliMpPCB* pcb = GetPCB(i);
	299	// if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
	300	// y >= pcb->Ymin() && y < pcb->Ymax() )
	301	// {
	302	// return pcb;
	303	// }
	304	if ( x < pcb->Xmin() \|\| x >= pcb->Xmax() \|\|
	305	y < pcb->Ymin() \|\| y >= pcb->Ymax() )
	306	{
	307	continue;
	308	}
	309	return pcb;
	310	}
	311	return 0;
	312	}
	313
	314	//_____________________________________________________________________________
	315	Int_t
	316	AliMpSlat::FindPCBIndex(Double_t x, Double_t y) const
	317	{
	318	///
	319	/// Returns the index of the PCB containing position (x,y)
	320	///
	321	for ( Size_t i = 0; i < GetSize(); ++i )
	322	{
	323	AliMpPCB* pcb = GetPCB(i);
	324	if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
	325	y >= pcb->Ymin() && y < pcb->Ymax() )
	326	{
	327	return i;
	328	}
	329	}
	330	return -1;
	331	}
	332
	333	//_____________________________________________________________________________
	334	void
	335	AliMpSlat::ForcePosition(const TVector2& pos)
	336	{
	337	///
	338	/// Force the position to be different from (DX(),DY()).
	339	/// Normally only used by triggerSlats (for layers).
	340	/// Beware that this method must be called once all PCB have been added,
	341	/// as the Add() method resets the position.
	342	///
	343	fPosition = pos;
	344	}
	345
	346	//_____________________________________________________________________________
	347	void
	348	AliMpSlat::GetAllMotifPositionsIDs(TArrayI& ecn) const
	349	{
	350	///
	351	/// Return all the manuIds (=MotifPositionIDs) of this slat
	352	///
	353	ecn.Set(GetNofElectronicCards());
	354	//#ifdef WITH_ROOT
	355	TExMapIter it(fManuMap.GetIterator());
	356	Long_t key;
	357	Long_t value;
	358	Int_t n(0);
	359	while ( it.Next(key,value) == kTRUE )
	360	{
	361	ecn.AddAt((Int_t)(key),n);
	362	++n;
	363	}
	364	//#else
	365	// missing here
	366	//#endif
	367	}
	368
	369	//_____________________________________________________________________________
	370	const char*
	371	AliMpSlat::GetID() const
	372	{
	373	///
	374	/// Returns the name of this slat.
	375	///
	376	return fId.Data();
	377	}
	378
	379	//_____________________________________________________________________________
	380	Int_t
	381	AliMpSlat::GetMaxNofPadsY() const
	382	{
	383	///
	384	/// Returns the maximum number of pads to be found in this slat y-direction.
	385	///
	386	return fMaxNofPadsY;
	387	}
	388
	389	//_____________________________________________________________________________
	390	Int_t
	391	AliMpSlat::GetMaxPadIndexX() const
	392	{
	393	///
	394	/// Returns the max ix that is valid for this slat.
	395	///
	396	AliMpPCB* last = GetPCB(GetSize()-1);
	397	if (last)
	398	{
	399	return last->Ixmax();
	400	}
	401	return 0;
	402	}
	403
	404	//_____________________________________________________________________________
	405	const char*
	406	AliMpSlat::GetName() const
	407	{
	408	///
	409	/// Returns the name of this slat, which is composed of its ID with
	410	/// the plane type as a suffix.
	411	///
	412	TString name(GetID());
	413	if ( fPlaneType == AliMp::kBendingPlane )
	414	{
	415	name += ".Bending";
	416	}
	417	else if ( fPlaneType == AliMp::kNonBendingPlane )
	418	{
	419	name += ".NonBending";
	420	}
	421	else
	422	{
	423	name += ".Invalid";
	424	}
	425	return name.Data();
	426	}
	427
	428	//_____________________________________________________________________________
	429	Int_t
	430	AliMpSlat::GetNofElectronicCards() const
	431	{
	432	///
	433	/// Returns the number of manus that compose the readout of this slat.
	434	///
	435	return fManuMap.GetSize();
	436	}
	437
	438	//_____________________________________________________________________________
	439	Int_t
	440	AliMpSlat::GetNofPadsX() const
	441	{
	442	///
	443	/// Returns the number of pad in x-direction.
	444	///
	445	return fNofPadsX;
	446	}
	447
	448	//_____________________________________________________________________________
	449	AliMpPCB*
	450	AliMpSlat::GetPCB(AliMpSlat::Size_t i) const
	451	{
	452	///
	453	/// Returns the i-th PCB of this slat.
	454	///
	455	#ifdef WITH_ROOT
	456	if ( i >= fPCBs.GetEntriesFast() ) return 0;
	457	return (AliMpPCB*)fPCBs[i];
	458	#else
	459	if ( i >= fPCBs.size() ) return 0;
	460	return fPCBs[i];
	461	#endif
	462	}
	463
	464	//_____________________________________________________________________________
	465	AliMpSlat::Size_t
	466	AliMpSlat::GetSize() const
	467	{
	468	///
	469	/// Returns the number of PCB in this slat.
	470	///
	471	#ifdef WITH_ROOT
	472	return fPCBs.GetEntriesFast();
	473	#else
	474	return fPCBs.size();
	475	#endif
	476	}
	477
	478	//_____________________________________________________________________________
	479	void
	480	AliMpSlat::Print(Option_t* option) const
	481	{
	482	///
	483	/// Prints the slat characteristics.
	484	///
	485	cout << "SLAT " << GetID() << " 1/2 DIM = (" << DX() << "," << DY() << ")"
	486	<< " POS = " << Position().X() << "," << Position().Y()
	487	<< " NPADSX = " << GetNofPadsX()
	488	<< " MAXNPADSY = " << GetMaxNofPadsY()
	489	<< " NPCBs=" << GetSize() << endl;
	490
	491	TString soption(option);
	492
	493	if ( soption.Contains("P") )
	494	{
	495	for ( Size_t i = 0; i < GetSize() ; ++i )
	496	{
	497	cout << " ";
	498	if ( option )
	499	{
	500	fPCBs[i]->Print(option+1);
	501	}
	502	else
	503	{
	504	fPCBs[i]->Print();
	505	}
	506	}
	507	}
	508
	509	if ( soption.Contains("M") \|\| soption.Contains("L") )
	510	{
	511	cout << fManuMap.GetSize() << " ";
	512	cout << "Electronic card (manu or local board) Ids : ";
	513
	514	TExMapIter iter(fManuMap.GetIterator());
	515	Long_t key, value;
	516	while ( iter.Next(key,value) )
	517	{
	518	cout << key << " ";
	519	}
	520	cout << endl;
	521	}
	522	}