[u/mrichter/AliRoot.git] / MUON / mapping / AliMpFastSegmentation.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$

/// \class AliMpFastSegmentation
/// An implementation of AliMpVSegmentation, which uses
/// some internal maps to speed up the (Has)PadByIndices and PadByLocation
/// methods.
/// 
/// L. Aphecetche, Subatech
///

#include "AliMpFastSegmentation.h"

#include "AliCodeTimer.h"
#include "AliLog.h"
#include "AliMpConnection.h"
#include "AliMpConstants.h"
#include "AliMpMotifMap.h"
#include "AliMpMotifPosition.h"
#include "AliMpMotifType.h"
#include "AliMpPad.h"
#include "AliMpSector.h"
#include "AliMpSlat.h"
#include "AliMpVPadIterator.h"
#include "AliMpEncodePair.h"

#include <TArrayI.h>

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

//#define CHECK

#ifdef CHECK
#include <cassert>
#endif

namespace
{
  ///
  /// The values in Encode and Encode2 are not exactly random.
  /// They are the result of a few "try and see" efforts to optimize the
  /// timing of the TExMap::GetValue (you should note that the TExMap implementation
  /// speed depends on the "non-uniformity" of the keys).
  ///
  /// So don't change those values w/o at least testing a bit the implications...
  /// But feel free to experiment though, in order to optimizer further ;-)
  ///
  Int_t Encode(Int_t a, Int_t b)
  {
    return a*1009 + b;
  }

  Int_t Encode2(Int_t a)
  {
    /// Ideally this method should be different for sectors and slats, as we have
    /// much less manus per DE for slats, and hence the "non-uniformity" is less...
    return ( a ^ (1<<10) ) << 16 ;
  }
}

//_____________________________________________________________________________
AliMpFastSegmentation::AliMpFastSegmentation(AliMpVSegmentation* vseg)
: AliMpVSegmentation(),
fHelper(vseg),
fMotifPositions(),
fIxIy(),
fManuId(),
fPositionX(0.),
fPositionY(0.)
{
  /// Ctor. We adopt vseg.
  
  AliCodeTimerAuto(vseg->ClassName());
  
  if (!vseg) 
  {
    AliError("Will get a hard time working with a NULL vseg !");
    return;
  }
  
  fPositionX = vseg->GetPositionX();
  fPositionY = vseg->GetPositionY();
  
  TArrayI manus;
  
  vseg->GetAllElectronicCardIDs(manus);
  
  for ( Int_t i = 0; i < manus.GetSize(); ++i ) 
  {
    Int_t manuId = manus[i];
    
    AliMpMotifPosition* mp = vseg->MotifPosition(manuId);
    
    // Should never happen
    if ( ! mp ) {
      AliFatal("AliMpMotifPosition not found.");
    }  
    
    Int_t index = 1 + fMotifPositions.GetLast();

    fMotifPositions.AddLast(mp);

    fManuId.Add(Encode2(manuId),1+index);

    for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
    {
      if ( vseg->HasPadByLocation(manuId,manuChannel) )
      {
        AliMpPad pad = vseg->PadByLocation(manuId,manuChannel);
        
        fIxIy.Add(Encode(pad.GetIx(),pad.GetIy()),1+index);
      }
    }
  }
}

//_____________________________________________________________________________
AliMpFastSegmentation::~AliMpFastSegmentation()
{
  /// dtor
  delete fHelper;
}

//_____________________________________________________________________________
AliMpVPadIterator* 
AliMpFastSegmentation::CreateIterator(const AliMpArea& area) const
{
  /// Forward to our helper
  return fHelper->CreateIterator(area);
}

//_____________________________________________________________________________
AliMpVPadIterator* 
AliMpFastSegmentation::CreateIterator() const
{
  /// Forward to our helper
  return fHelper->CreateIterator();
}

//_____________________________________________________________________________
Int_t 
AliMpFastSegmentation::GetNeighbours(const AliMpPad& pad, TObjArray& neighbours,
                                     Bool_t includeSelf,
                                     Bool_t includeVoid) const
{
  /// Use default implementation
  return AliMpVSegmentation::GetNeighbours(pad,neighbours,includeSelf,includeVoid);
}

//_____________________________________________________________________________
AliMpPad 
AliMpFastSegmentation::PadByLocation(Int_t manuId, Int_t manuChannel, 
                                     Bool_t warning) const
{
  /// Get the pad by location, using the manuid map.
  
  Int_t index = fManuId.GetValue(Encode2(manuId));
  
  if (!index) 
  {
    if (warning)
    {
      AliWarning(Form("Manu ID %d not found",manuId));
      Print();
    }
    return AliMpPad::Invalid();
  }
  
  AliMpMotifPosition* motifPos = InternalMotifPosition(index);
  
  if (!motifPos)
  {
    AliError(Form("InternalMotifPosition(%d) failed",index));
    Print();
    return AliMpPad::Invalid();
  }
  
  AliMpVMotif* motif = motifPos->GetMotif();
  MpPair_t localIndices 
    =  motif->GetMotifType()->FindLocalIndicesByGassiNum(manuChannel);
	
  if ( localIndices < 0 ) 
  {
    if (warning) 
    {
      AliWarning(Form("The pad number %d doesn't exists", manuChannel));
      Print();
    }
    return AliMpPad::Invalid();
  }
	
#ifdef CHECK
  Double_t posx, posy;
  motif->PadPositionLocal(localIndices, posx, posy);
  posx += motifPos->GetPositionX() - fPositionX;
  posy += motifPos->GetPositionY() - fPositionY;

  Double_t dx, dy;
  motif->GetPadDimensionsByIndices(localIndices, dx, dy);
  
  AliMpPad pad1 = AliMpPad(manuId, manuChannel,
                           motifPos->GlobalIndices(localIndices),
                           posx, posy, dx, dy);

  AliMpPad pad2 = fHelper->PadByLocation(manuId, manuChannel,warning);
  if ( pad1 != pad2 ) 
  {
    Print();
    pad1.Print();
    pad2.Print();
    assert(pad1==pad2);
  }
#endif
  Double_t posx, posy;
  motif->PadPositionLocal(localIndices, posx, posy);
  posx += motifPos->GetPositionX() - fPositionX;
  posy += motifPos->GetPositionY() - fPositionY;

  Double_t dx, dy;
  motif->GetPadDimensionsByIndices(localIndices, dx, dy);

  return AliMpPad(manuId, manuChannel,
                  motifPos->GlobalIndices(localIndices),
                  posx, posy, dx, dy);
}

//_____________________________________________________________________________
AliMpMotifPosition*
AliMpFastSegmentation::InternalMotifPosition(Int_t index) const
{
  /// Get the internal manu from the index
  return static_cast<AliMpMotifPosition*>(fMotifPositions.UncheckedAt(index-1));
}

//_____________________________________________________________________________
AliMpPad 
AliMpFastSegmentation::PadByIndices (Int_t ix, Int_t iy, Bool_t warning) const
{
  /// Get pad by indices
  
  Int_t index = fIxIy.GetValue(Encode(ix, iy));
  
  if ( !index )
  {
    if (warning)
    {
      AliWarning(Form("ManuID not found for pad indices (%d,%d)", ix, iy));	  
      Print();
    }
    return AliMpPad::Invalid();
  }
  
  AliMpMotifPosition* motifPos = InternalMotifPosition(index);

  if (!motifPos)
	{
    AliError(Form("InternalMotifPosition(%d) failed",index));
    Print();
		return AliMpPad::Invalid();
	}
	
  AliMpVMotif* motif = motifPos->GetMotif();
  AliMpMotifType* motifType = motif->GetMotifType();
  MpPair_t localIndices(AliMp::Pair(ix, iy) - motifPos->GetLowIndicesLimit());
  AliMpConnection* connection = motifType->FindConnectionByLocalIndices(localIndices);
  
  if (!connection)
  {
    if ( warning )
    {
      AliWarning(Form("No connection for pad indices (%d,%d)", ix, iy));
    }
    return AliMpPad::Invalid();
  }
	
#ifdef CHECK
  AliMpPad pad2 = fHelper->PadByIndices(ix, iy, warning);

  Double_t posx, posy;
  motif->PadPositionLocal(localIndices, posx, posy);
  posx += motifPos->GetPositionX() - fPositionX;
  posy += motifPos->GetPositionY() - fPositionY;

  Double_t dx, dy;
  motif->GetPadDimensionsByIndices(localIndices, dx, dy);

  AliMpPad pad1 = AliMpPad(motifPos->GetID(),connection->GetManuChannel(),
                          ix, iy, posx, posy, dx, dy);
  
  assert(pad1==pad2);
#endif
  Double_t posx, posy;
  motif->PadPositionLocal(localIndices, posx, posy);
  posx += motifPos->GetPositionX() - fPositionX;
  posy += motifPos->GetPositionY() - fPositionY;
 
  Double_t dx, dy;
  motif->GetPadDimensionsByIndices(localIndices, dx, dy);

  return AliMpPad(motifPos->GetID(),connection->GetManuChannel(),
                  ix, iy, posx, posy, dx, dy);
  
}

//_____________________________________________________________________________
AliMpPad 
AliMpFastSegmentation::PadByPosition(Double_t x, Double_t y, Bool_t warning ) const
{
  /// Forward to our helper
  return fHelper->PadByPosition(x, y, warning);
}

//_____________________________________________________________________________
Int_t 
AliMpFastSegmentation::MaxPadIndexX() const
{
  /// Forward to our helper
  return fHelper->MaxPadIndexX();
}

//_____________________________________________________________________________
Int_t  
AliMpFastSegmentation::MaxPadIndexY() const
{
  /// Forward to our helper
  return fHelper->MaxPadIndexY();
}

//_____________________________________________________________________________
Int_t  
AliMpFastSegmentation::NofPads() const
{
  /// Forward to our helper
  return fHelper->NofPads();
}

//_____________________________________________________________________________
Int_t
AliMpFastSegmentation::GetNofElectronicCards() const
{
  /// Forward to our helper
  return fHelper->GetNofElectronicCards();
}

//_____________________________________________________________________________
void
AliMpFastSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
{
  /// Forward to our helper
  fHelper->GetAllElectronicCardIDs(ecn);
}

//_____________________________________________________________________________
Bool_t 
AliMpFastSegmentation::HasPadByIndices(Int_t ix, Int_t iy) const
{
  /// Whether there is a pad at the given indices
  Int_t index = fIxIy.GetValue(Encode(ix, iy));
  
  if ( !index ) return kFALSE;
  
  AliMpMotifPosition* mp = InternalMotifPosition(index);
  
  Bool_t r1 = mp->HasPadByIndices(AliMp::Pair(ix, iy));
#ifdef CHECK
  Bool_t r2 = fHelper->HasPadByIndices(ix, iy);
  
  assert(r1==r2);
#endif
  return r1;
}

//_____________________________________________________________________________
Bool_t 
AliMpFastSegmentation::HasPadByLocation(Int_t manuId, Int_t manuChannel) const
{
  /// Whether there is a pad at the given location (de,manuid)
  
  Int_t index = fManuId.GetValue(Encode2(manuId));
  
  if (!index) return kFALSE;
  
  AliMpMotifPosition* mp = InternalMotifPosition(index);
  
  Bool_t r1 = mp->HasPadByManuChannel(manuChannel);
#ifdef CHECK
  Bool_t r2 = fHelper->HasPadByLocation(manuId, manuChannel);
  
  assert(r1==r2);
#endif
  return r1;
}

//_____________________________________________________________________________
void
AliMpFastSegmentation::Print(Option_t* opt) const
{
  /// Forward to our helper
  fHelper->Print(opt);
}

//_____________________________________________________________________________
AliMp::PlaneType
AliMpFastSegmentation::PlaneType() const
{
  /// Forward to our helper
  return fHelper->PlaneType();
}

//_____________________________________________________________________________
Double_t  
AliMpFastSegmentation::GetDimensionX() const
{
  /// Forward to our helper
  return fHelper->GetDimensionX();
}

//_____________________________________________________________________________
Double_t  
AliMpFastSegmentation::GetDimensionY() const
{
  /// Forward to our helper
  return fHelper->GetDimensionY();
}

//_____________________________________________________________________________
Double_t  
AliMpFastSegmentation::GetPositionX() const
{
  /// Forward to our helper
  return fHelper->GetPositionX();
}

//_____________________________________________________________________________
Double_t  
AliMpFastSegmentation::GetPositionY() const
{
  /// Forward to our helper
  return fHelper->GetPositionY();
}

//_____________________________________________________________________________
Bool_t
AliMpFastSegmentation::HasMotifPosition(Int_t manuId) const
{
  /// Whether or not we have a given manu
  return ( fManuId.GetValue(Encode2(manuId)) != 0);
}

//_____________________________________________________________________________
AliMpMotifPosition*
AliMpFastSegmentation::MotifPosition(Int_t manuId) const
{
  /// Get the motifPosition object of a given manu
  Int_t index = fManuId.GetValue(Encode2(manuId));

  if (!index) 
  {
    AliMpVPadIterator* it = CreateIterator();
    it->First();
    AliMpPad pad = it->CurrentItem();
    delete it;
    AliWarning(Form("DE %04d Manu ID %04d not found",pad.GetManuId(),manuId));
    return 0x0;
  }

  return InternalMotifPosition(index);
}
Commit	Line	Data
3dfcfe77	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
	18	/// \class AliMpFastSegmentation
	19	/// An implementation of AliMpVSegmentation, which uses
	20	/// some internal maps to speed up the (Has)PadByIndices and PadByLocation
	21	/// methods.
	22	///
	23	/// L. Aphecetche, Subatech
	24	///
	25
	26	#include "AliMpFastSegmentation.h"
	27
	28	#include "AliCodeTimer.h"
	29	#include "AliLog.h"
	30	#include "AliMpConnection.h"
	31	#include "AliMpConstants.h"
	32	#include "AliMpMotifMap.h"
	33	#include "AliMpMotifPosition.h"
	34	#include "AliMpMotifType.h"
	35	#include "AliMpPad.h"
	36	#include "AliMpSector.h"
	37	#include "AliMpSlat.h"
	38	#include "AliMpVPadIterator.h"
168e9c4d	39	#include "AliMpEncodePair.h"
168e9c4d	40
3dfcfe77	41	#include <TArrayI.h>
	42
	43	/// \cond CLASSIMP
	44	ClassImp(AliMpFastSegmentation)
	45	/// \endcond
	46
	47	//#define CHECK
	48
	49	#ifdef CHECK
	50	#include <cassert>
	51	#endif
	52
	53	namespace
	54	{
	55	///
	56	/// The values in Encode and Encode2 are not exactly random.
	57	/// They are the result of a few "try and see" efforts to optimize the
	58	/// timing of the TExMap::GetValue (you should note that the TExMap implementation
	59	/// speed depends on the "non-uniformity" of the keys).
	60	///
	61	/// So don't change those values w/o at least testing a bit the implications...
	62	/// But feel free to experiment though, in order to optimizer further ;-)
	63	///
	64	Int_t Encode(Int_t a, Int_t b)
	65	{
	66	return a*1009 + b;
	67	}
	68
	69	Int_t Encode2(Int_t a)
	70	{
	71	/// Ideally this method should be different for sectors and slats, as we have
	72	/// much less manus per DE for slats, and hence the "non-uniformity" is less...
	73	return ( a ^ (1<<10) ) << 16 ;
	74	}
	75	}
	76
	77	//_____________________________________________________________________________
	78	AliMpFastSegmentation::AliMpFastSegmentation(AliMpVSegmentation* vseg)
	79	: AliMpVSegmentation(),
	80	fHelper(vseg),
	81	fMotifPositions(),
	82	fIxIy(),
	83	fManuId(),
6e97fbb8	84	fPositionX(0.),
6e97fbb8	85	fPositionY(0.)
3dfcfe77	86	{
	87	/// Ctor. We adopt vseg.
	88
	89	AliCodeTimerAuto(vseg->ClassName());
	90
	91	if (!vseg)
	92	{
	93	AliError("Will get a hard time working with a NULL vseg !");
	94	return;
	95	}
	96
6e97fbb8	97	fPositionX = vseg->GetPositionX();
6e97fbb8	98	fPositionY = vseg->GetPositionY();
3dfcfe77	99
	100	TArrayI manus;
	101
	102	vseg->GetAllElectronicCardIDs(manus);
	103
	104	for ( Int_t i = 0; i < manus.GetSize(); ++i )
	105	{
	106	Int_t manuId = manus[i];
	107
	108	AliMpMotifPosition* mp = vseg->MotifPosition(manuId);
	109
	110	// Should never happen
	111	if ( ! mp ) {
	112	AliFatal("AliMpMotifPosition not found.");
	113	}
	114
	115	Int_t index = 1 + fMotifPositions.GetLast();
	116
	117	fMotifPositions.AddLast(mp);
	118
	119	fManuId.Add(Encode2(manuId),1+index);
	120
	121	for ( Int_t manuChannel = 0; manuChannel < AliMpConstants::ManuNofChannels(); ++manuChannel )
	122	{
168e9c4d	123	if ( vseg->HasPadByLocation(manuId,manuChannel) )
3dfcfe77	124	{
168e9c4d	125	AliMpPad pad = vseg->PadByLocation(manuId,manuChannel);
3dfcfe77	126
168e9c4d	127	fIxIy.Add(Encode(pad.GetIx(),pad.GetIy()),1+index);
3dfcfe77	128	}
	129	}
	130	}
	131	}
	132
	133	//_____________________________________________________________________________
	134	AliMpFastSegmentation::~AliMpFastSegmentation()
	135	{
	136	/// dtor
	137	delete fHelper;
	138	}
	139
	140	//_____________________________________________________________________________
	141	AliMpVPadIterator*
	142	AliMpFastSegmentation::CreateIterator(const AliMpArea& area) const
	143	{
	144	/// Forward to our helper
	145	return fHelper->CreateIterator(area);
	146	}
	147
	148	//_____________________________________________________________________________
	149	AliMpVPadIterator*
	150	AliMpFastSegmentation::CreateIterator() const
	151	{
	152	/// Forward to our helper
	153	return fHelper->CreateIterator();
	154	}
	155
	156	//_____________________________________________________________________________
	157	Int_t
	158	AliMpFastSegmentation::GetNeighbours(const AliMpPad& pad, TObjArray& neighbours,
	159	Bool_t includeSelf,
	160	Bool_t includeVoid) const
	161	{
	162	/// Use default implementation
	163	return AliMpVSegmentation::GetNeighbours(pad,neighbours,includeSelf,includeVoid);
	164	}
	165
	166	//_____________________________________________________________________________
	167	AliMpPad
168e9c4d	168	AliMpFastSegmentation::PadByLocation(Int_t manuId, Int_t manuChannel,
168e9c4d	169	Bool_t warning) const
3dfcfe77	170	{
	171	/// Get the pad by location, using the manuid map.
	172
168e9c4d	173	Int_t index = fManuId.GetValue(Encode2(manuId));
3dfcfe77	174
	175	if (!index)
	176	{
	177	if (warning)
168e9c4d	178	{
168e9c4d	179	AliWarning(Form("Manu ID %d not found",manuId));
3dfcfe77	180	Print();
	181	}
	182	return AliMpPad::Invalid();
	183	}
	184
	185	AliMpMotifPosition* motifPos = InternalMotifPosition(index);
	186
	187	if (!motifPos)
	188	{
	189	AliError(Form("InternalMotifPosition(%d) failed",index));
	190	Print();
	191	return AliMpPad::Invalid();
	192	}
	193
	194	AliMpVMotif* motif = motifPos->GetMotif();
168e9c4d	195	MpPair_t localIndices
168e9c4d	196	= motif->GetMotifType()->FindLocalIndicesByGassiNum(manuChannel);
3dfcfe77	197
168e9c4d	198	if ( localIndices < 0 )
	199	{
	200	if (warning)
	201	{
	202	AliWarning(Form("The pad number %d doesn't exists", manuChannel));
3dfcfe77	203	Print();
168e9c4d	204	}
	205	return AliMpPad::Invalid();
	206	}
3dfcfe77	207
3dfcfe77	208	#ifdef CHECK
6e97fbb8	209	Double_t posx, posy;
	210	motif->PadPositionLocal(localIndices, posx, posy);
	211	posx += motifPos->GetPositionX() - fPositionX;
	212	posy += motifPos->GetPositionY() - fPositionY;
	213
	214	Double_t dx, dy;
	215	motif->GetPadDimensionsByIndices(localIndices, dx, dy);
	216
168e9c4d	217	AliMpPad pad1 = AliMpPad(manuId, manuChannel,
3dfcfe77	218	motifPos->GlobalIndices(localIndices),
6e97fbb8	219	posx, posy, dx, dy);
6e97fbb8	220
168e9c4d	221	AliMpPad pad2 = fHelper->PadByLocation(manuId, manuChannel,warning);
3dfcfe77	222	if ( pad1 != pad2 )
	223	{
	224	Print();
	225	pad1.Print();
	226	pad2.Print();
	227	assert(pad1==pad2);
	228	}
	229	#endif
6e97fbb8	230	Double_t posx, posy;
	231	motif->PadPositionLocal(localIndices, posx, posy);
	232	posx += motifPos->GetPositionX() - fPositionX;
	233	posy += motifPos->GetPositionY() - fPositionY;
	234
	235	Double_t dx, dy;
	236	motif->GetPadDimensionsByIndices(localIndices, dx, dy);
	237
168e9c4d	238	return AliMpPad(manuId, manuChannel,
3dfcfe77	239	motifPos->GlobalIndices(localIndices),
6e97fbb8	240	posx, posy, dx, dy);
3dfcfe77	241	}
	242
	243	//_____________________________________________________________________________
	244	AliMpMotifPosition*
	245	AliMpFastSegmentation::InternalMotifPosition(Int_t index) const
	246	{
	247	/// Get the internal manu from the index
	248	return static_cast<AliMpMotifPosition*>(fMotifPositions.UncheckedAt(index-1));
	249	}
	250
	251	//_____________________________________________________________________________
	252	AliMpPad
168e9c4d	253	AliMpFastSegmentation::PadByIndices (Int_t ix, Int_t iy, Bool_t warning) const
3dfcfe77	254	{
	255	/// Get pad by indices
	256
168e9c4d	257	Int_t index = fIxIy.GetValue(Encode(ix, iy));
3dfcfe77	258
	259	if ( !index )
	260	{
	261	if (warning)
	262	{
168e9c4d	263	AliWarning(Form("ManuID not found for pad indices (%d,%d)", ix, iy));
3dfcfe77	264	Print();
	265	}
	266	return AliMpPad::Invalid();
	267	}
	268
	269	AliMpMotifPosition* motifPos = InternalMotifPosition(index);
	270
	271	if (!motifPos)
	272	{
	273	AliError(Form("InternalMotifPosition(%d) failed",index));
	274	Print();
	275	return AliMpPad::Invalid();
	276	}
	277
	278	AliMpVMotif* motif = motifPos->GetMotif();
	279	AliMpMotifType* motifType = motif->GetMotifType();
168e9c4d	280	MpPair_t localIndices(AliMp::Pair(ix, iy) - motifPos->GetLowIndicesLimit());
3dfcfe77	281	AliMpConnection* connection = motifType->FindConnectionByLocalIndices(localIndices);
	282
	283	if (!connection)
168e9c4d	284	{
	285	if ( warning )
	286	{
	287	AliWarning(Form("No connection for pad indices (%d,%d)", ix, iy));
3dfcfe77	288	}
3dfcfe77	289	return AliMpPad::Invalid();
168e9c4d	290	}
3dfcfe77	291
3dfcfe77	292	#ifdef CHECK
168e9c4d	293	AliMpPad pad2 = fHelper->PadByIndices(ix, iy, warning);
6e97fbb8	294
	295	Double_t posx, posy;
	296	motif->PadPositionLocal(localIndices, posx, posy);
	297	posx += motifPos->GetPositionX() - fPositionX;
	298	posy += motifPos->GetPositionY() - fPositionY;
	299
	300	Double_t dx, dy;
	301	motif->GetPadDimensionsByIndices(localIndices, dx, dy);
	302
168e9c4d	303	AliMpPad pad1 = AliMpPad(motifPos->GetID(),connection->GetManuChannel(),
6e97fbb8	304	ix, iy, posx, posy, dx, dy);
3dfcfe77	305
	306	assert(pad1==pad2);
	307	#endif
6e97fbb8	308	Double_t posx, posy;
	309	motif->PadPositionLocal(localIndices, posx, posy);
	310	posx += motifPos->GetPositionX() - fPositionX;
	311	posy += motifPos->GetPositionY() - fPositionY;
	312
	313	Double_t dx, dy;
	314	motif->GetPadDimensionsByIndices(localIndices, dx, dy);
	315
168e9c4d	316	return AliMpPad(motifPos->GetID(),connection->GetManuChannel(),
6e97fbb8	317	ix, iy, posx, posy, dx, dy);
3dfcfe77	318
	319	}
	320
	321	//_____________________________________________________________________________
	322	AliMpPad
6e97fbb8	323	AliMpFastSegmentation::PadByPosition(Double_t x, Double_t y, Bool_t warning ) const
3dfcfe77	324	{
3dfcfe77	325	/// Forward to our helper
6e97fbb8	326	return fHelper->PadByPosition(x, y, warning);
3dfcfe77	327	}
	328
	329	//_____________________________________________________________________________
	330	Int_t
	331	AliMpFastSegmentation::MaxPadIndexX() const
	332	{
	333	/// Forward to our helper
	334	return fHelper->MaxPadIndexX();
	335	}
	336
	337	//_____________________________________________________________________________
	338	Int_t
	339	AliMpFastSegmentation::MaxPadIndexY() const
	340	{
	341	/// Forward to our helper
	342	return fHelper->MaxPadIndexY();
	343	}
	344
	345	//_____________________________________________________________________________
	346	Int_t
	347	AliMpFastSegmentation::NofPads() const
	348	{
	349	/// Forward to our helper
	350	return fHelper->NofPads();
	351	}
	352
	353	//_____________________________________________________________________________
	354	Int_t
	355	AliMpFastSegmentation::GetNofElectronicCards() const
	356	{
	357	/// Forward to our helper
	358	return fHelper->GetNofElectronicCards();
	359	}
	360
	361	//_____________________________________________________________________________
	362	void
	363	AliMpFastSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
	364	{
	365	/// Forward to our helper
	366	fHelper->GetAllElectronicCardIDs(ecn);
	367	}
	368
	369	//_____________________________________________________________________________
	370	Bool_t
168e9c4d	371	AliMpFastSegmentation::HasPadByIndices(Int_t ix, Int_t iy) const
3dfcfe77	372	{
3dfcfe77	373	/// Whether there is a pad at the given indices
168e9c4d	374	Int_t index = fIxIy.GetValue(Encode(ix, iy));
3dfcfe77	375
	376	if ( !index ) return kFALSE;
	377
	378	AliMpMotifPosition* mp = InternalMotifPosition(index);
	379
168e9c4d	380	Bool_t r1 = mp->HasPadByIndices(AliMp::Pair(ix, iy));
3dfcfe77	381	#ifdef CHECK
168e9c4d	382	Bool_t r2 = fHelper->HasPadByIndices(ix, iy);
3dfcfe77	383
	384	assert(r1==r2);
	385	#endif
	386	return r1;
	387	}
	388
	389	//_____________________________________________________________________________
	390	Bool_t
168e9c4d	391	AliMpFastSegmentation::HasPadByLocation(Int_t manuId, Int_t manuChannel) const
3dfcfe77	392	{
	393	/// Whether there is a pad at the given location (de,manuid)
	394
168e9c4d	395	Int_t index = fManuId.GetValue(Encode2(manuId));
3dfcfe77	396
	397	if (!index) return kFALSE;
	398
	399	AliMpMotifPosition* mp = InternalMotifPosition(index);
	400
168e9c4d	401	Bool_t r1 = mp->HasPadByManuChannel(manuChannel);
3dfcfe77	402	#ifdef CHECK
168e9c4d	403	Bool_t r2 = fHelper->HasPadByLocation(manuId, manuChannel);
3dfcfe77	404
	405	assert(r1==r2);
	406	#endif
	407	return r1;
	408	}
	409
	410	//_____________________________________________________________________________
	411	void
	412	AliMpFastSegmentation::Print(Option_t* opt) const
	413	{
	414	/// Forward to our helper
	415	fHelper->Print(opt);
	416	}
	417
	418	//_____________________________________________________________________________
	419	AliMp::PlaneType
	420	AliMpFastSegmentation::PlaneType() const
	421	{
	422	/// Forward to our helper
	423	return fHelper->PlaneType();
	424	}
	425
	426	//_____________________________________________________________________________
6e97fbb8	427	Double_t
	428	AliMpFastSegmentation::GetDimensionX() const
	429	{
	430	/// Forward to our helper
	431	return fHelper->GetDimensionX();
	432	}
	433
	434	//_____________________________________________________________________________
	435	Double_t
	436	AliMpFastSegmentation::GetDimensionY() const
	437	{
	438	/// Forward to our helper
	439	return fHelper->GetDimensionY();
	440	}
	441
	442	//_____________________________________________________________________________
	443	Double_t
	444	AliMpFastSegmentation::GetPositionX() const
3dfcfe77	445	{
3dfcfe77	446	/// Forward to our helper
6e97fbb8	447	return fHelper->GetPositionX();
3dfcfe77	448	}
	449
	450	//_____________________________________________________________________________
6e97fbb8	451	Double_t
6e97fbb8	452	AliMpFastSegmentation::GetPositionY() const
3dfcfe77	453	{
3dfcfe77	454	/// Forward to our helper
6e97fbb8	455	return fHelper->GetPositionY();
3dfcfe77	456	}
	457
	458	//_____________________________________________________________________________
	459	Bool_t
	460	AliMpFastSegmentation::HasMotifPosition(Int_t manuId) const
	461	{
	462	/// Whether or not we have a given manu
	463	return ( fManuId.GetValue(Encode2(manuId)) != 0);
	464	}
	465
	466	//_____________________________________________________________________________
	467	AliMpMotifPosition*
	468	AliMpFastSegmentation::MotifPosition(Int_t manuId) const
	469	{
	470	/// Get the motifPosition object of a given manu
	471	Int_t index = fManuId.GetValue(Encode2(manuId));
	472
	473	if (!index)
	474	{
	475	AliMpVPadIterator* it = CreateIterator();
	476	it->First();
	477	AliMpPad pad = it->CurrentItem();
	478	delete it;
168e9c4d	479	AliWarning(Form("DE %04d Manu ID %04d not found",pad.GetManuId(),manuId));
3dfcfe77	480	return 0x0;
	481	}
	482
	483	return InternalMotifPosition(index);
	484	}
	485