[u/mrichter/AliRoot.git] / MUON / mapping / AliMpNeighboursPadIterator.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: AliMpNeighboursPadIterator.cxx,v 1.12 2006/05/24 13:58:46 ivana Exp $
// Category: sector
//
// Class AliMpNeighboursPadIterator
// --------------------------------
// Class, which defines an iterator over the pads surrounding a given pad
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay

#include "AliMpNeighboursPadIterator.h"
#include "AliMpIntPair.h"
#include "AliMpSectorSegmentation.h"
#include "AliMpRow.h"
#include "AliMpConstants.h"

#include "AliLog.h"

#include <TVector2.h>

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

const UInt_t AliMpNeighboursPadIterator::fgkInvalidIndex = 9999; 
                                                   //never so much neighbours...

//______________________________________________________________________________
AliMpNeighboursPadIterator::AliMpNeighboursPadIterator()
  : AliMpVPadIterator(),
    fkSegmentation(0),
    fCenterPad(AliMpPad::Invalid()),
    fPads(),
    fIndex(fgkInvalidIndex)
{
/// Default constructor, set the current position to "invalid"
}

//______________________________________________________________________________
AliMpNeighboursPadIterator::AliMpNeighboursPadIterator(
                                 const AliMpSectorSegmentation* segmentation,
                                 const AliMpPad& centerPad,
                                 Bool_t includeCenter)
  : AliMpVPadIterator(),
    fkSegmentation(segmentation),
    fCenterPad(centerPad),
    fPads(),
    fIndex(fgkInvalidIndex)
{
/// Standard constructor, set *this to invalid position

    FillPadsVector(includeCenter);
}

//______________________________________________________________________________
AliMpNeighboursPadIterator::AliMpNeighboursPadIterator(
                                 const AliMpNeighboursPadIterator& right)
  : AliMpVPadIterator(right),
    fkSegmentation(0),
    fCenterPad(AliMpPad::Invalid()),
    fPads(),
    fIndex(fgkInvalidIndex)
{
/// Copy constructor

  *this = right;
}

//______________________________________________________________________________
AliMpNeighboursPadIterator::~AliMpNeighboursPadIterator()
{
/// Destructor

#ifdef WITH_ROOT
  fPads.Delete();
#endif
}

// operators

//______________________________________________________________________________
AliMpNeighboursPadIterator& 
AliMpNeighboursPadIterator::operator = (const AliMpNeighboursPadIterator& right)
{
/// Assignment operator.                                                     \n
/// If the right hand iterator isn't of a good type
/// the current operator is invalidated                                      \n
/// Not provided for WITH_ROOT option.

  // check assignment to self
  if (this == &right) return *this;

  // base class assignment
  AliMpVPadIterator::operator=(right);

#ifdef WITH_STL
  fkSegmentation = right.fkSegmentation;
  fCenterPad     = right.fCenterPad;
  fPads          = right.fPads;
  fIndex         = right.fIndex;
#endif
#ifdef WITH_ROOT
  AliFatal("Not allowed assignment for TObjArray");
#endif

  return *this;
} 

//
// private methods
//

//______________________________________________________________________________
Bool_t AliMpNeighboursPadIterator::IsNeighbour(const AliMpPad& pad) const
{
/// Return true if the pad located by \a pad is a neighbour of those
/// located at a\ fCenterPad

    if ( !pad.IsValid() ) return kFALSE;    

    TVector2 relPos  = pad.Position()   - fCenterPad.Position();
    TVector2 bounds  = pad.Dimensions() + fCenterPad.Dimensions();
    return (TMath::Abs(relPos.X())- bounds.X()<AliMpConstants::LengthTolerance()) && 
           (TMath::Abs(relPos.Y())- bounds.Y()<AliMpConstants::LengthTolerance());

}

#ifdef WITH_STL
//______________________________________________________________________________
AliMpNeighboursPadIterator::PadVector 
AliMpNeighboursPadIterator::PadVectorLine(const AliMpPad& from,
                                          const AliMpIntPair& direction) const
{
/// Fill  a new vector with all pads which have common
/// parts with the pad located at \a fCenterPad, in a given line
/// starting from \a from and moving by \a direction

    AliMpPad current = from;
    PadVector ans;
    Bool_t cont=kTRUE;
    do {
        if (IsNeighbour(current))
            ans.push_back(current);
        else
            cont=kFALSE;
        TVector2 nextPos = current.Position() + TVector2(
          current.Dimensions().X()*(AliMpConstants::LengthStep()+1.)*direction.GetFirst(),
          current.Dimensions().Y()*(AliMpConstants::LengthStep()+1.)*direction.GetSecond());
        current = fkSegmentation->PadByPosition(nextPos, false);
    } while (cont);
    return ans;
}

//______________________________________________________________________________
void  AliMpNeighboursPadIterator::UpdateTotalSet(PadSet& setTotal, 
                                                 const PadVector& from) const
{
/// Add pads from pad vector to the total set 
/// only if they are not yet included

    setTotal.insert(from.begin(),from.end());
}    

#endif
#ifdef WITH_ROOT
//______________________________________________________________________________
AliMpNeighboursPadIterator::PadVector* 
AliMpNeighboursPadIterator::PadVectorLine(const AliMpPad& from,
                                          const AliMpIntPair& direction) const
{
/// Fill  a new vector with all pads which have common
/// parts with the pad located at \a fCenterPad, in a given line
/// starting from \a from and moving by \a direction

    AliMpPad current = from;
    PadVector* ans = new PadVector();
    Bool_t cont=kTRUE;
    do {
        if (IsNeighbour(current))
            ans->Add(new AliMpPad(current));
        else
            cont=kFALSE;
        TVector2 nextPos = current.Position() + TVector2(
          current.Dimensions().X()*(AliMpConstants::LengthStep()+1.)*direction.GetFirst(),
          current.Dimensions().Y()*(AliMpConstants::LengthStep()+1.)*direction.GetSecond());
        current = fkSegmentation->PadByPosition(nextPos, false);
    } while (cont);
    return ans;
}

//______________________________________________________________________________
void  AliMpNeighboursPadIterator::UpdateTotalSet(PadSet& setTotal, 
                                                 PadVector* from) const
{
/// Add pads from pad vector to the total set 
/// only if they are not yet included and deletes the pad vector

    for (Int_t i=0; i<from->GetEntriesFast(); i++) {
      AliMpPad* candidate = (AliMpPad*)from->At(i);
      
      Bool_t isInSetTotal = false;
      for (Int_t j=0; j<setTotal.GetEntriesFast(); j++) {
         AliMpPad* pad = (AliMpPad*)setTotal.At(j);
	 
	 if (pad->GetIndices() == candidate->GetIndices()) {
	   isInSetTotal = true;
	   break;
	 }       
      }
      if (!isInSetTotal) 
        setTotal.Add(candidate);
      else
        delete candidate;	
    }
    delete from;
} 

#endif

//______________________________________________________________________________
void AliMpNeighboursPadIterator::FillPadsVector(Bool_t includeCenter)
{
/// Fill the indices vector with all indices of pads which have common
/// parts with the pad located at \a fCenterPad

    if (!fkSegmentation || !fCenterPad.IsValid()) return;
    
    
    AliMpPad from;
    AliMpIntPair direction;
#ifdef WITH_STL
    PadVector found;
#endif
#ifdef WITH_ROOT
    PadVector* found;
#endif
    
    // repare a unique simple associative container
    // --> no doublons, rapid insersion
    PadSet setTotal;

  /////////////  Left side
  
  ////////////////// up direction
    
    from = fkSegmentation->PadsLeft(fCenterPad).GetFirst();
    direction = AliMpIntPair(0,1);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);

  ////////////////// down direction

    from = fkSegmentation->PadsDown(from).GetFirst(); // the Pad down is already added
    direction = AliMpIntPair(0,-1);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);
    
  /////////////  Up side
  
  ////////////////// right direction

    from = fkSegmentation->PadsUp(fCenterPad).GetFirst();
    direction = AliMpIntPair(1,0);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);
    
  ////////////////// left direction

    from = fkSegmentation->PadsLeft(from).GetFirst(); // the pad up is already added
    direction = AliMpIntPair(-1,0);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);
    
  /////////////  Right side
  
  ////////////////// Up direction
    
    from = fkSegmentation->PadsRight(fCenterPad).GetFirst();
    direction = AliMpIntPair(0,1);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);
    
  ////////////////// down direction

    from = fkSegmentation->PadsDown(from).GetFirst(); // the pad right is already added
    direction = AliMpIntPair(0,-1);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);
    
  /////////////  Down side
  
  ////////////////// Right direction

    from = fkSegmentation->PadsDown(fCenterPad).GetFirst();
    direction = AliMpIntPair(1,0);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);
    
  ////////////////// left direction
    
    from = fkSegmentation->PadsLeft(from).GetFirst(); // the pad down is already added
    direction = AliMpIntPair(-1,0);
    found = PadVectorLine(from,direction);
    UpdateTotalSet(setTotal, found);

    // fill the fIndices vector with the set (-->pass from a rapid insertion,
    // to rapid and indexed access, for the rest of the job)

#ifdef WITH_STL
    fPads.clear();
    // include the center pad if requiered
    if (includeCenter) fPads.push_back(fCenterPad);
    //fPads.insert(fPads.end(),setTotal.begin(),setTotal.end());
    
    PadSetCIterator it;
    for (it = setTotal.begin(); it != setTotal.end(); it++)
      fPads.push_back((*it));
#endif

#ifdef WITH_ROOT
    fPads.Delete();
    // include the center pad if requiered
    if (includeCenter) fPads.Add(new AliMpPad(fCenterPad));

    for (Int_t i = 0; i<setTotal.GetEntriesFast(); i++)
      fPads.Add(setTotal.At(i));
#endif
}

//______________________________________________________________________________
Bool_t AliMpNeighboursPadIterator::IsValid() const
{
/// Is the iterator in a valid position?

    return (fkSegmentation!=0 && fIndex!=fgkInvalidIndex);
} 

//public methods

//______________________________________________________________________________
void AliMpNeighboursPadIterator::First()
{
/// Reset the iterator, so that it points to the first available
/// pad in the sector

#ifdef WITH_STL
    if ((fkSegmentation != 0) && (fPads.size() != 0)) 
#endif
#ifdef WITH_ROOT
    if ((fkSegmentation != 0) && (fPads.GetEntriesFast() != 0)) 
#endif
      fIndex=0; 
    else 
      fIndex=fgkInvalidIndex;

}

//______________________________________________________________________________
void AliMpNeighboursPadIterator::Next()
{
/// Pre-increment operator. Should be used by default for iterating over
/// pads


  if (!IsValid()) return;
  
#ifdef WITH_STL
  if (fIndex < fPads.size()-1) 
#endif
#ifdef WITH_ROOT
  if (Int_t(fIndex) < fPads.GetEntriesFast()-1) 
#endif
    fIndex++; 
  else 
    Invalidate();
}

//______________________________________________________________________________
Bool_t AliMpNeighboursPadIterator::IsDone() const
{
/// Is the iterator in the end?
 
  return !IsValid();
}

//______________________________________________________________________________
AliMpPad AliMpNeighboursPadIterator::CurrentItem() const 
{
/// Dereferencement function

  if (!IsValid())
    return AliMpPad::Invalid();
  else
#ifdef WITH_STL
    return fPads[fIndex];
#endif
#ifdef WITH_ROOT
    return *((AliMpPad*)fPads[fIndex]);
#endif
}

//______________________________________________________________________________
void AliMpNeighboursPadIterator::Invalidate()
{
/// Let the iterator point to the invalid position

    fIndex=fgkInvalidIndex;
}
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: AliMpNeighboursPadIterator.cxx,v 1.12 2006/05/24 13:58:46 ivana Exp $
	18	// Category: sector
	19	//
	20	// Class AliMpNeighboursPadIterator
	21	// --------------------------------
	22	// Class, which defines an iterator over the pads surrounding a given pad
	23	// Included in AliRoot: 2003/05/02
	24	// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
	25
	26	#include "AliMpNeighboursPadIterator.h"
	27	#include "AliMpIntPair.h"
	28	#include "AliMpSectorSegmentation.h"
	29	#include "AliMpRow.h"
	30	#include "AliMpConstants.h"
	31
	32	#include "AliLog.h"
	33
	34	#include <TVector2.h>
	35
	36	/// \cond CLASSIMP
	37	ClassImp(AliMpNeighboursPadIterator)
	38	/// \endcond
	39
	40	const UInt_t AliMpNeighboursPadIterator::fgkInvalidIndex = 9999;
	41	//never so much neighbours...
	42
	43	//______________________________________________________________________________
	44	AliMpNeighboursPadIterator::AliMpNeighboursPadIterator()
	45	: AliMpVPadIterator(),
	46	fkSegmentation(0),
	47	fCenterPad(AliMpPad::Invalid()),
	48	fPads(),
	49	fIndex(fgkInvalidIndex)
	50	{
	51	/// Default constructor, set the current position to "invalid"
	52	}
	53
	54	//______________________________________________________________________________
	55	AliMpNeighboursPadIterator::AliMpNeighboursPadIterator(
	56	const AliMpSectorSegmentation* segmentation,
	57	const AliMpPad& centerPad,
	58	Bool_t includeCenter)
	59	: AliMpVPadIterator(),
	60	fkSegmentation(segmentation),
	61	fCenterPad(centerPad),
	62	fPads(),
	63	fIndex(fgkInvalidIndex)
	64	{
	65	/// Standard constructor, set *this to invalid position
	66
	67	FillPadsVector(includeCenter);
	68	}
	69
	70	//______________________________________________________________________________
	71	AliMpNeighboursPadIterator::AliMpNeighboursPadIterator(
	72	const AliMpNeighboursPadIterator& right)
	73	: AliMpVPadIterator(right),
	74	fkSegmentation(0),
	75	fCenterPad(AliMpPad::Invalid()),
	76	fPads(),
	77	fIndex(fgkInvalidIndex)
	78	{
	79	/// Copy constructor
	80
	81	*this = right;
	82	}
	83
	84	//______________________________________________________________________________
	85	AliMpNeighboursPadIterator::~AliMpNeighboursPadIterator()
	86	{
	87	/// Destructor
	88
	89	#ifdef WITH_ROOT
	90	fPads.Delete();
	91	#endif
	92	}
	93
	94	// operators
	95
	96	//______________________________________________________________________________
	97	AliMpNeighboursPadIterator&
	98	AliMpNeighboursPadIterator::operator = (const AliMpNeighboursPadIterator& right)
	99	{
	100	/// Assignment operator. \n
	101	/// If the right hand iterator isn't of a good type
	102	/// the current operator is invalidated \n
	103	/// Not provided for WITH_ROOT option.
	104
	105	// check assignment to self
	106	if (this == &right) return *this;
	107
	108	// base class assignment
	109	AliMpVPadIterator::operator=(right);
	110
	111	#ifdef WITH_STL
	112	fkSegmentation = right.fkSegmentation;
	113	fCenterPad = right.fCenterPad;
	114	fPads = right.fPads;
	115	fIndex = right.fIndex;
	116	#endif
	117	#ifdef WITH_ROOT
	118	AliFatal("Not allowed assignment for TObjArray");
	119	#endif
	120
	121	return *this;
	122	}
	123
	124	//
	125	// private methods
	126	//
	127
	128	//______________________________________________________________________________
	129	Bool_t AliMpNeighboursPadIterator::IsNeighbour(const AliMpPad& pad) const
	130	{
	131	/// Return true if the pad located by \a pad is a neighbour of those
	132	/// located at a\ fCenterPad
	133
	134	if ( !pad.IsValid() ) return kFALSE;
	135
	136	TVector2 relPos = pad.Position() - fCenterPad.Position();
	137	TVector2 bounds = pad.Dimensions() + fCenterPad.Dimensions();
	138	return (TMath::Abs(relPos.X())- bounds.X()<AliMpConstants::LengthTolerance()) &&
	139	(TMath::Abs(relPos.Y())- bounds.Y()<AliMpConstants::LengthTolerance());
	140
	141	}
	142
	143	#ifdef WITH_STL
	144	//______________________________________________________________________________
	145	AliMpNeighboursPadIterator::PadVector
	146	AliMpNeighboursPadIterator::PadVectorLine(const AliMpPad& from,
	147	const AliMpIntPair& direction) const
	148	{
	149	/// Fill a new vector with all pads which have common
	150	/// parts with the pad located at \a fCenterPad, in a given line
	151	/// starting from \a from and moving by \a direction
	152
	153	AliMpPad current = from;
	154	PadVector ans;
	155	Bool_t cont=kTRUE;
	156	do {
	157	if (IsNeighbour(current))
	158	ans.push_back(current);
	159	else
	160	cont=kFALSE;
	161	TVector2 nextPos = current.Position() + TVector2(
	162	current.Dimensions().X()(AliMpConstants::LengthStep()+1.)direction.GetFirst(),
	163	current.Dimensions().Y()(AliMpConstants::LengthStep()+1.)direction.GetSecond());
	164	current = fkSegmentation->PadByPosition(nextPos, false);
	165	} while (cont);
	166	return ans;
	167	}
	168
	169	//______________________________________________________________________________
	170	void AliMpNeighboursPadIterator::UpdateTotalSet(PadSet& setTotal,
	171	const PadVector& from) const
	172	{
	173	/// Add pads from pad vector to the total set
	174	/// only if they are not yet included
	175
	176	setTotal.insert(from.begin(),from.end());
	177	}
	178
	179	#endif
	180	#ifdef WITH_ROOT
	181	//______________________________________________________________________________
	182	AliMpNeighboursPadIterator::PadVector*
	183	AliMpNeighboursPadIterator::PadVectorLine(const AliMpPad& from,
	184	const AliMpIntPair& direction) const
	185	{
	186	/// Fill a new vector with all pads which have common
	187	/// parts with the pad located at \a fCenterPad, in a given line
	188	/// starting from \a from and moving by \a direction
	189
	190	AliMpPad current = from;
	191	PadVector* ans = new PadVector();
	192	Bool_t cont=kTRUE;
	193	do {
	194	if (IsNeighbour(current))
	195	ans->Add(new AliMpPad(current));
	196	else
	197	cont=kFALSE;
	198	TVector2 nextPos = current.Position() + TVector2(
	199	current.Dimensions().X()(AliMpConstants::LengthStep()+1.)direction.GetFirst(),
	200	current.Dimensions().Y()(AliMpConstants::LengthStep()+1.)direction.GetSecond());
	201	current = fkSegmentation->PadByPosition(nextPos, false);
	202	} while (cont);
	203	return ans;
	204	}
	205
	206	//______________________________________________________________________________
	207	void AliMpNeighboursPadIterator::UpdateTotalSet(PadSet& setTotal,
	208	PadVector* from) const
	209	{
	210	/// Add pads from pad vector to the total set
	211	/// only if they are not yet included and deletes the pad vector
	212
	213	for (Int_t i=0; i<from->GetEntriesFast(); i++) {
	214	AliMpPad* candidate = (AliMpPad*)from->At(i);
	215
	216	Bool_t isInSetTotal = false;
	217	for (Int_t j=0; j<setTotal.GetEntriesFast(); j++) {
	218	AliMpPad* pad = (AliMpPad*)setTotal.At(j);
	219
	220	if (pad->GetIndices() == candidate->GetIndices()) {
	221	isInSetTotal = true;
	222	break;
	223	}
	224	}
	225	if (!isInSetTotal)
	226	setTotal.Add(candidate);
	227	else
	228	delete candidate;
	229	}
	230	delete from;
	231	}
	232
	233	#endif
	234
	235	//______________________________________________________________________________
	236	void AliMpNeighboursPadIterator::FillPadsVector(Bool_t includeCenter)
	237	{
	238	/// Fill the indices vector with all indices of pads which have common
	239	/// parts with the pad located at \a fCenterPad
	240
	241	if (!fkSegmentation \|\| !fCenterPad.IsValid()) return;
	242
	243
	244	AliMpPad from;
	245	AliMpIntPair direction;
	246	#ifdef WITH_STL
	247	PadVector found;
	248	#endif
	249	#ifdef WITH_ROOT
	250	PadVector* found;
	251	#endif
	252
	253	// repare a unique simple associative container
	254	// --> no doublons, rapid insersion
	255	PadSet setTotal;
	256
	257	///////////// Left side
	258
	259	////////////////// up direction
	260
	261	from = fkSegmentation->PadsLeft(fCenterPad).GetFirst();
	262	direction = AliMpIntPair(0,1);
	263	found = PadVectorLine(from,direction);
	264	UpdateTotalSet(setTotal, found);
	265
	266	////////////////// down direction
	267
	268	from = fkSegmentation->PadsDown(from).GetFirst(); // the Pad down is already added
	269	direction = AliMpIntPair(0,-1);
	270	found = PadVectorLine(from,direction);
	271	UpdateTotalSet(setTotal, found);
	272
	273	///////////// Up side
	274
	275	////////////////// right direction
	276
	277	from = fkSegmentation->PadsUp(fCenterPad).GetFirst();
	278	direction = AliMpIntPair(1,0);
	279	found = PadVectorLine(from,direction);
	280	UpdateTotalSet(setTotal, found);
	281
	282	////////////////// left direction
	283
	284	from = fkSegmentation->PadsLeft(from).GetFirst(); // the pad up is already added
	285	direction = AliMpIntPair(-1,0);
	286	found = PadVectorLine(from,direction);
	287	UpdateTotalSet(setTotal, found);
	288
	289	///////////// Right side
	290
	291	////////////////// Up direction
	292
	293	from = fkSegmentation->PadsRight(fCenterPad).GetFirst();
	294	direction = AliMpIntPair(0,1);
	295	found = PadVectorLine(from,direction);
	296	UpdateTotalSet(setTotal, found);
	297
	298	////////////////// down direction
	299
	300	from = fkSegmentation->PadsDown(from).GetFirst(); // the pad right is already added
	301	direction = AliMpIntPair(0,-1);
	302	found = PadVectorLine(from,direction);
	303	UpdateTotalSet(setTotal, found);
	304
	305	///////////// Down side
	306
	307	////////////////// Right direction
	308
	309	from = fkSegmentation->PadsDown(fCenterPad).GetFirst();
	310	direction = AliMpIntPair(1,0);
	311	found = PadVectorLine(from,direction);
	312	UpdateTotalSet(setTotal, found);
	313
	314	////////////////// left direction
	315
	316	from = fkSegmentation->PadsLeft(from).GetFirst(); // the pad down is already added
	317	direction = AliMpIntPair(-1,0);
	318	found = PadVectorLine(from,direction);
	319	UpdateTotalSet(setTotal, found);
	320
	321	// fill the fIndices vector with the set (-->pass from a rapid insertion,
	322	// to rapid and indexed access, for the rest of the job)
	323
	324	#ifdef WITH_STL
	325	fPads.clear();
	326	// include the center pad if requiered
	327	if (includeCenter) fPads.push_back(fCenterPad);
	328	//fPads.insert(fPads.end(),setTotal.begin(),setTotal.end());
	329
	330	PadSetCIterator it;
	331	for (it = setTotal.begin(); it != setTotal.end(); it++)
	332	fPads.push_back((*it));
	333	#endif
	334
	335	#ifdef WITH_ROOT
	336	fPads.Delete();
	337	// include the center pad if requiered
	338	if (includeCenter) fPads.Add(new AliMpPad(fCenterPad));
	339
	340	for (Int_t i = 0; i<setTotal.GetEntriesFast(); i++)
	341	fPads.Add(setTotal.At(i));
	342	#endif
	343	}
	344
	345	//______________________________________________________________________________
	346	Bool_t AliMpNeighboursPadIterator::IsValid() const
	347	{
	348	/// Is the iterator in a valid position?
	349
	350	return (fkSegmentation!=0 && fIndex!=fgkInvalidIndex);
	351	}
	352
	353	//public methods
	354
	355	//______________________________________________________________________________
	356	void AliMpNeighboursPadIterator::First()
	357	{
	358	/// Reset the iterator, so that it points to the first available
	359	/// pad in the sector
	360
	361	#ifdef WITH_STL
	362	if ((fkSegmentation != 0) && (fPads.size() != 0))
	363	#endif
	364	#ifdef WITH_ROOT
	365	if ((fkSegmentation != 0) && (fPads.GetEntriesFast() != 0))
	366	#endif
	367	fIndex=0;
	368	else
	369	fIndex=fgkInvalidIndex;
	370
	371	}
	372
	373	//______________________________________________________________________________
	374	void AliMpNeighboursPadIterator::Next()
	375	{
	376	/// Pre-increment operator. Should be used by default for iterating over
	377	/// pads
	378
	379
	380	if (!IsValid()) return;
	381
	382	#ifdef WITH_STL
	383	if (fIndex < fPads.size()-1)
	384	#endif
	385	#ifdef WITH_ROOT
	386	if (Int_t(fIndex) < fPads.GetEntriesFast()-1)
	387	#endif
	388	fIndex++;
	389	else
	390	Invalidate();
	391	}
	392
	393	//______________________________________________________________________________
	394	Bool_t AliMpNeighboursPadIterator::IsDone() const
	395	{
	396	/// Is the iterator in the end?
	397
	398	return !IsValid();
	399	}
	400
	401	//______________________________________________________________________________
	402	AliMpPad AliMpNeighboursPadIterator::CurrentItem() const
	403	{
	404	/// Dereferencement function
	405
	406	if (!IsValid())
	407	return AliMpPad::Invalid();
	408	else
	409	#ifdef WITH_STL
	410	return fPads[fIndex];
	411	#endif
	412	#ifdef WITH_ROOT
	413	return ((AliMpPad)fPads[fIndex]);
	414	#endif
	415	}
	416
	417	//______________________________________________________________________________
	418	void AliMpNeighboursPadIterator::Invalidate()
	419	{
	420	/// Let the iterator point to the invalid position
	421
	422	fIndex=fgkInvalidIndex;
	423	}
	424