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

#include "AliMUONSt345SlatSegmentationV2.h"
#include "AliMUONConstants.h"

#include "AliMpArea.h"
#include "AliMpSlat.h"
#include "AliMpSlatSegmentation.h"
#include "AliMpPCB.h" 
// FIXME: we should not need access to PCB at this level
// if the Dpx, Dpy, Sector interface would not be used.
// Investigate instead to direct use of AliMpVSegmentation and AliMpPad
// from the clusterFinder ? // :aphecetc:20050722 
// or, or ... have the AliMpSlat handles the notion of zone, finally
// (where "zone" in mapping is equivalent to "sector" here), and thus
// let AliMpSlat offer the interface to get information similar to what
// Dpx, Dpy, Sector offer now to the clustering. That indeed should be
// handled directly at the level of AliMpVSegmentation...
#include "AliMpVPadIterator.h"

#include "AliLog.h"

#include "Riostream.h"
#include "TClass.h"

ClassImp(AliMUONSt345SlatSegmentationV2)

namespace
{
  Int_t fgIntOffset = 1;
  Float_t FMAX(1E9);
}

//_____________________________________________________________________________
AliMUONSt345SlatSegmentationV2::AliMUONSt345SlatSegmentationV2()
: AliMUONVGeometryDESegmentation(),
fDetElemId(-1),
fPlaneType(kBendingPlane),
fSlat(0),
fSlatSegmentation(0),
fPadIterator(0),
fXhit(FMAX),
fYhit(FMAX)
{
	AliDebug(1,Form("this=%p default (empty) ctor",this));
}

//_____________________________________________________________________________
AliMUONSt345SlatSegmentationV2::AliMUONSt345SlatSegmentationV2(
                                   AliMpVSegmentation* segmentation,
                                   Int_t detElemId, AliMpPlaneType bendingOrNonBending)
: AliMUONVGeometryDESegmentation(),
fDetElemId(detElemId),
fPlaneType(bendingOrNonBending),
fSlat(0),
fSlatSegmentation(0),
fPadIterator(0),
fXhit(FMAX),
fYhit(FMAX)
{ 
  //
  // Normal ctor.
  //

  fSlatSegmentation = dynamic_cast<AliMpSlatSegmentation*>(segmentation);
  if (fSlatSegmentation)
    fSlat = fSlatSegmentation->Slat();
  else 
    AliFatal("Wrong mapping segmentation type");
		
  AliDebug(1,Form("this=%p detElemId=%3d %s fSlatSegmentation=%p",this,detElemId,
									( (bendingOrNonBending==kBendingPlane)?"Bending":"NonBending" ),
									fSlatSegmentation));
}

//_____________________________________________________________________________
AliMUONSt345SlatSegmentationV2::~AliMUONSt345SlatSegmentationV2()
{
	AliDebug(1,Form("dtor this=%p",this));
  delete fPadIterator;
}

//_____________________________________________________________________________
TF1*
AliMUONSt345SlatSegmentationV2::CorrFunc(Int_t) const
{
  AliFatal("Not Implemented");
  return 0x0;
}

//_____________________________________________________________________________
Float_t 
AliMUONSt345SlatSegmentationV2::Distance2AndOffset(Int_t,Int_t,
																									 Float_t,Float_t,Int_t*)
{
  AliFatal("Not Implemented");
  return 0.0;
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::Draw(Option_t*)
{
  AliFatal("Not Implemented");
}

//_____________________________________________________________________________
Float_t
AliMUONSt345SlatSegmentationV2::Dpx() const
{
  AliFatal("Not Implemented");
  return 0.0;
}

//_____________________________________________________________________________
Float_t
AliMUONSt345SlatSegmentationV2::Dpy() const
{
  AliFatal("Not Implemented");
  return 0.0;
}

//_____________________________________________________________________________
Float_t
AliMUONSt345SlatSegmentationV2::Dpx(int ipcb) const
{
	AliMpPCB* pcb = fSlat->GetPCB(ipcb);
	if (!pcb) 
  {
    AliFatal("pcb is null!");
  }
	return pcb->PadSizeX();
}

//_____________________________________________________________________________
Float_t
AliMUONSt345SlatSegmentationV2::Dpy(int ipcb) const
{
	AliMpPCB* pcb = fSlat->GetPCB(ipcb);
	if (!pcb) 
  {
    AliFatal("pcb is null!");
  }
	return pcb->PadSizeY();
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::FirstPad(Float_t xhit, Float_t yhit, 
																				 Float_t /*zhit*/, 
																				 Float_t dx, Float_t dy)
{
  // OK. We will do it in 2 steps. First get the area over which to
  // iterate, based on hit coordinates and (dx,dy). This first step
  // has nothing to do with segmentation in the first place, but with
  // how we simulate the fact that at some point the charge is shared
  // amongst several pads.
  // The second step is the actual pad iteration and is handled by 
  // a specific class (which has to do only with iteration...)
  //
  // FIXME: this method should not be here in the first place, IMHO.
  //
	
  // Find the wire position (center of charge distribution)
  Float_t xwire = GetAnod(xhit);
  fXhit = xwire;
  fYhit = yhit;
	
  Double_t x01 = xwire - dx;
  Double_t x02 = xwire + dx;
  Double_t y01 = yhit - dy;
  Double_t y02 = yhit + dy;
	
  Double_t xext = x02 - x01;
  Double_t yext = y02 - y01;
	
  // we do not check area here, as we assume the iterator
  // will do it, and will possibly truncate it if needed.
  // Note that we convert the area position to a reference frame
  // located in the lower-left corner of the slat, instead of its
  // center.
//  AliMpArea area(TVector2((x01+x02)/2.0+fSlat->DX(),
//													(y01+y02)/2.0+fSlat->DY()),
//								 TVector2(xext/2.0,yext/2.0));
  AliMpArea area(TVector2((x01+x02)/2.0,(y01+y02)/2.0),
								 TVector2(xext/2.0,yext/2.0));
	
  delete fPadIterator;
	
  fPadIterator = fSlatSegmentation->CreateIterator(area);
	
  fPadIterator->First();
	
  fCurrentPad = fPadIterator->CurrentItem();
	
  if ( !fCurrentPad.IsValid() ) 
	{
		AliError(Form("Cannot get a valid pad for (xhit,yhit,dx,dy)=(%e,%e,%e,%e)",xhit,yhit,dx,dy));
	}
	
  AliDebug(4,Form("xhit,yhit,dx,dy=%e,%e,%e,%e ix,iy=%3d,%3d slat=%s",
									xhit,yhit,dx,dy,
									fCurrentPad.GetIndices().GetFirst()+1,
									fCurrentPad.GetIndices().GetSecond()+1,fSlat->GetID()));		  
}

//_____________________________________________________________________________
Float_t
AliMUONSt345SlatSegmentationV2::GetAnod(Float_t xhit) const
{
  // Gets the x-coordinate of the wire which is the closest to xhit.
	
  Int_t n = Int_t(xhit/AliMUONConstants::Pitch());
  Float_t wire = (xhit>0) ? n+0.5 : n-0.5;
  return AliMUONConstants::Pitch()*wire;
}

//_____________________________________________________________________________
AliMUONGeometryDirection
AliMUONSt345SlatSegmentationV2::GetDirection()
{
  //AliWarning("Not Implemented");
  return kDirUndefined;
}

//______________________________________________________________________________
const AliMpVSegmentation*  
AliMUONSt345SlatSegmentationV2::GetMpSegmentation() const
{
// Returns the mapping segmentation
// (provides access to electronics info)

  return fSlatSegmentation;
}  


//_____________________________________________________________________________
void 
AliMUONSt345SlatSegmentationV2::GetNParallelAndOffset(Int_t,Int_t,Int_t*,Int_t*)
{
  AliFatal("Not Implemented");
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy, 
																				Float_t& x, Float_t& y, Float_t& z)
{
  z = 0;
  GetPadC(ix,iy,x,y);
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy, 
																				Float_t& x, Float_t& y)
{
  AliMpPad pad = 
  fSlatSegmentation->PadByIndices(AliMpIntPair(ix-fgIntOffset,iy-fgIntOffset),
                                  kTRUE);
  x = pad.Position().X();
  y = pad.Position().Y();
}


//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y, Float_t /*z*/,
Int_t& ix, Int_t& iy)
{
  GetPadI(x,y,ix,iy);
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y,
																				Int_t& ix, Int_t& iy)
{
//  Double_t slatx = fSlat->DX();
//  Double_t slaty = fSlat->DY();
  AliMpPad pad = 
    fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
//  fSlatSegmentation->PadByPosition(TVector2(x+slatx,y+slaty), kTRUE);
	
  if ( pad != AliMpPad::Invalid() )
	{
		ix = pad.GetIndices().GetFirst() + fgIntOffset;
		iy = pad.GetIndices().GetSecond() + fgIntOffset;
	}
  else
	{
		ix = iy = -1;
	}
}

//_____________________________________________________________________________
void 
AliMUONSt345SlatSegmentationV2::GiveTestPoints(Int_t&,Float_t*,Float_t*) const
{
  AliFatal("Not Implemented");
}

//_____________________________________________________________________________
Bool_t
AliMUONSt345SlatSegmentationV2::HasPad(Float_t x, Float_t y, Float_t z)
{
  Int_t ix, iy;
  GetPadI(x,y,z,ix,iy);
  return HasPad(ix,iy);
}

//_____________________________________________________________________________
Bool_t
AliMUONSt345SlatSegmentationV2::HasPad(Int_t ix, Int_t iy)
{
  return fSlatSegmentation->HasPad(AliMpIntPair(ix-fgIntOffset,iy-fgIntOffset));
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::Init(int)
{
  AliWarning("Not Implemented because not needed ;-)");
}

//_____________________________________________________________________________
void  
AliMUONSt345SlatSegmentationV2::IntegrationLimits(Float_t& x1, Float_t& x2, 
																									Float_t& y1, Float_t& y2)
{
  //
  //  Returns integration limits for current pad
  //
	
	//   x1 = fXhit - fX - Dpx(fSector)/2.;
	//   x2 = x1 + Dpx(fSector);
	//   y1 = fYhit - fY - Dpy(fSector)/2.;
	//   y2 = y1 + Dpy(fSector);    
	
  Float_t x = fCurrentPad.Position().X();
  Float_t y = fCurrentPad.Position().Y();
	
  Float_t padsizex = fCurrentPad.Dimensions().X() * 2.0;
  Float_t padsizey = fCurrentPad.Dimensions().Y() * 2.0;
	
  x1 = fXhit - x - padsizex/2.0;
  x2 = x1 + padsizex;
  y1 = fYhit - y - padsizey/2.0;
  y2 = y1 + padsizey;
	
  AliDebug(4,Form("xhit,yhit=%e,%e x,y=%e,%e, x1,x2,y1,y2=%e,%e,%e,%e",fXhit,fYhit,x,y,x1,x2,y1,y2));
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::ISector()
{
  // FIXME: remove the usage of ISector from all the code.
  return -10;
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::Ix()
{
  if ( fPadIterator )
	{
		return fPadIterator->CurrentItem().GetIndices().GetFirst() + fgIntOffset;
	}
  else
	{
		return -1;
	}
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::Iy()
{
  if ( fPadIterator ) 
	{
		return fPadIterator->CurrentItem().GetIndices().GetSecond() + fgIntOffset;
	}
  else
	{
		return -1;
	}
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::MorePads()
{
  return (fPadIterator && !fPadIterator->IsDone());
}

//_____________________________________________________________________________
void 
AliMUONSt345SlatSegmentationV2::Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, 
																					 Int_t Xlist[10], Int_t Ylist[10])
{
  // Find pad at (ix,iy) for which we'll search neighbours.
  AliMpPad pad = 
	fSlatSegmentation->PadByIndices(AliMpIntPair(iX-fgIntOffset,iY-fgIntOffset),kTRUE);
	
  // Define the region to look into : a region slightly bigger
  // than the pad itself (5% bigger), in order to catch first neighbours.

  AliMpArea area(pad.Position(),pad.Dimensions()*1.05); 
		
  AliMpVPadIterator* it = fSlatSegmentation->CreateIterator(area);
  it->First();
  Int_t n = 0;
  while ( !it->IsDone() && n < 10 )
	{
		AliMpPad p = it->CurrentItem();
		if ( p != pad ) // skip self
		{
			Xlist[n] = p.GetIndices().GetFirst() + fgIntOffset;
			Ylist[n] = p.GetIndices().GetSecond() + fgIntOffset;
			++n;
		}
		it->Next();
	}
	delete it;
  *Nlist = n;
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::NextPad()
{
  if ( fPadIterator )
	{
		fPadIterator->Next();
		fCurrentPad = fPadIterator->CurrentItem();
	}
  else
	{
		AliError("PadIterator not initialized. Please use First() first ;-)");
	}
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::Npx() const
{
  return fSlatSegmentation->MaxPadIndexX()+1;
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::Npy() const
{
  return fSlatSegmentation->MaxPadIndexY()+1;
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::Print(Option_t*) const
{
  cout << "DetElemId=" << fDetElemId << " PlaneType=" 
  << fPlaneType << " Npx,Npy=" << Npx() << "," << Npy() << " fSlat=" << fSlat 
  << " fSlatSegmentation=" << fSlatSegmentation
  << " fSlatSegmentation->Slat()=" << fSlatSegmentation->Slat() << endl;
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::Sector(Int_t ix, Int_t)
{
  return fSlat->FindPCBIndex(ix - fgIntOffset);
}

//_____________________________________________________________________________
Int_t
AliMUONSt345SlatSegmentationV2::Sector(Float_t x, Float_t y)
{
  return fSlat->FindPCBIndex(x,y);
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::SetCorrFunc(Int_t,TF1*)
{
  AliFatal("Not Implemented");
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::SetDAnod(float)
{
  AliFatal("Not Implemented");
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
{
  fXhit = x;
  fYhit = y;
	
  //
  // insure we're within the slat limits. If not, issue an error and sets
  // the current hit to slat center.
  // FIXME: this should probably a) not happen at all b) be a fatal error
  //
  if ( fXhit < -fSlat->DX() || fXhit > fSlat->DX() ||
       fYhit < -fSlat->DY() || fYhit > fSlat->DY() )
	{
		AliError(Form("Hit outside slat %s limits (x,y)hit = (%e,%e)."
                  " Forcing to (0,0)",fSlat->GetID(),fXhit,fYhit));
		fXhit = 0.0;
		fYhit = 0.0;
	}
  
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::SetPad(Int_t ix, Int_t iy)
{
  fCurrentPad = 
	fSlatSegmentation->PadByIndices(AliMpIntPair(ix-fgIntOffset,iy-fgIntOffset),kTRUE);
  if ( !fCurrentPad.IsValid() )
	{
		AliError(Form("Setting current pad to invalid ! (ix,iy)=(%4d,%4d)",ix,iy));
	}
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::SetPadSize(float,float)
{
  AliFatal("Not Implemented");
}

//_____________________________________________________________________________
Int_t 
AliMUONSt345SlatSegmentationV2::SigGenCond(Float_t,Float_t,Float_t)
{
  AliFatal("Not Implemented");
  return 0;
}

//_____________________________________________________________________________
void 
AliMUONSt345SlatSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
{
  AliFatal("Not Implemented");
}
Commit	Line	Data
90e8f97c	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	#include "AliMUONSt345SlatSegmentationV2.h"
8fbf5237	19	#include "AliMUONConstants.h"
90e8f97c	20
90e8f97c	21	#include "AliMpArea.h"
	22	#include "AliMpSlat.h"
	23	#include "AliMpSlatSegmentation.h"
	24	#include "AliMpPCB.h"
	25	// FIXME: we should not need access to PCB at this level
	26	// if the Dpx, Dpy, Sector interface would not be used.
	27	// Investigate instead to direct use of AliMpVSegmentation and AliMpPad
	28	// from the clusterFinder ? // :aphecetc:20050722
	29	// or, or ... have the AliMpSlat handles the notion of zone, finally
	30	// (where "zone" in mapping is equivalent to "sector" here), and thus
	31	// let AliMpSlat offer the interface to get information similar to what
	32	// Dpx, Dpy, Sector offer now to the clustering. That indeed should be
	33	// handled directly at the level of AliMpVSegmentation...
	34	#include "AliMpVPadIterator.h"
90e8f97c	35
8fbf5237	36	#include "AliLog.h"
90e8f97c	37
8fbf5237	38	#include "Riostream.h"
90e8f97c	39	#include "TClass.h"
	40
	41	ClassImp(AliMUONSt345SlatSegmentationV2)
	42
	43	namespace
	44	{
90e8f97c	45	Int_t fgIntOffset = 1;
	46	Float_t FMAX(1E9);
	47	}
	48
	49	//_____________________________________________________________________________
	50	AliMUONSt345SlatSegmentationV2::AliMUONSt345SlatSegmentationV2()
	51	: AliMUONVGeometryDESegmentation(),
	52	fDetElemId(-1),
	53	fPlaneType(kBendingPlane),
	54	fSlat(0),
	55	fSlatSegmentation(0),
	56	fPadIterator(0),
	57	fXhit(FMAX),
	58	fYhit(FMAX)
	59	{
	60	AliDebug(1,Form("this=%p default (empty) ctor",this));
	61	}
	62
	63	//_____________________________________________________________________________
8fbf5237	64	AliMUONSt345SlatSegmentationV2::AliMUONSt345SlatSegmentationV2(
	65	AliMpVSegmentation* segmentation,
	66	Int_t detElemId, AliMpPlaneType bendingOrNonBending)
90e8f97c	67	: AliMUONVGeometryDESegmentation(),
	68	fDetElemId(detElemId),
	69	fPlaneType(bendingOrNonBending),
	70	fSlat(0),
	71	fSlatSegmentation(0),
	72	fPadIterator(0),
	73	fXhit(FMAX),
	74	fYhit(FMAX)
	75	{
df484e06	76	//
	77	// Normal ctor.
	78	//
8fbf5237	79
	80	fSlatSegmentation = dynamic_cast<AliMpSlatSegmentation*>(segmentation);
	81	if (fSlatSegmentation)
	82	fSlat = fSlatSegmentation->Slat();
	83	else
	84	AliFatal("Wrong mapping segmentation type");
90e8f97c	85
	86	AliDebug(1,Form("this=%p detElemId=%3d %s fSlatSegmentation=%p",this,detElemId,
	87	( (bendingOrNonBending==kBendingPlane)?"Bending":"NonBending" ),
	88	fSlatSegmentation));
	89	}
	90
	91	//_____________________________________________________________________________
	92	AliMUONSt345SlatSegmentationV2::~AliMUONSt345SlatSegmentationV2()
	93	{
	94	AliDebug(1,Form("dtor this=%p",this));
	95	delete fPadIterator;
	96	}
	97
	98	//_____________________________________________________________________________
	99	TF1*
	100	AliMUONSt345SlatSegmentationV2::CorrFunc(Int_t) const
	101	{
	102	AliFatal("Not Implemented");
	103	return 0x0;
	104	}
	105
	106	//_____________________________________________________________________________
	107	Float_t
	108	AliMUONSt345SlatSegmentationV2::Distance2AndOffset(Int_t,Int_t,
	109	Float_t,Float_t,Int_t*)
	110	{
	111	AliFatal("Not Implemented");
	112	return 0.0;
	113	}
	114
	115	//_____________________________________________________________________________
	116	void
	117	AliMUONSt345SlatSegmentationV2::Draw(Option_t*)
	118	{
	119	AliFatal("Not Implemented");
	120	}
	121
	122	//_____________________________________________________________________________
	123	Float_t
	124	AliMUONSt345SlatSegmentationV2::Dpx() const
	125	{
	126	AliFatal("Not Implemented");
	127	return 0.0;
	128	}
	129
	130	//_____________________________________________________________________________
	131	Float_t
	132	AliMUONSt345SlatSegmentationV2::Dpy() const
	133	{
	134	AliFatal("Not Implemented");
	135	return 0.0;
	136	}
	137
	138	//_____________________________________________________________________________
	139	Float_t
	140	AliMUONSt345SlatSegmentationV2::Dpx(int ipcb) const
	141	{
	142	AliMpPCB* pcb = fSlat->GetPCB(ipcb);
df484e06	143	if (!pcb)
	144	{
	145	AliFatal("pcb is null!");
	146	}
dfaf6b0d	147	return pcb->PadSizeX();
90e8f97c	148	}
	149
	150	//_____________________________________________________________________________
	151	Float_t
	152	AliMUONSt345SlatSegmentationV2::Dpy(int ipcb) const
	153	{
	154	AliMpPCB* pcb = fSlat->GetPCB(ipcb);
df484e06	155	if (!pcb)
	156	{
	157	AliFatal("pcb is null!");
	158	}
dfaf6b0d	159	return pcb->PadSizeY();
90e8f97c	160	}
	161
	162	//_____________________________________________________________________________
	163	void
	164	AliMUONSt345SlatSegmentationV2::FirstPad(Float_t xhit, Float_t yhit,
	165	Float_t /zhit/,
	166	Float_t dx, Float_t dy)
	167	{
	168	// OK. We will do it in 2 steps. First get the area over which to
	169	// iterate, based on hit coordinates and (dx,dy). This first step
	170	// has nothing to do with segmentation in the first place, but with
	171	// how we simulate the fact that at some point the charge is shared
	172	// amongst several pads.
	173	// The second step is the actual pad iteration and is handled by
	174	// a specific class (which has to do only with iteration...)
	175	//
	176	// FIXME: this method should not be here in the first place, IMHO.
	177	//
	178
	179	// Find the wire position (center of charge distribution)
	180	Float_t xwire = GetAnod(xhit);
	181	fXhit = xwire;
	182	fYhit = yhit;
	183
	184	Double_t x01 = xwire - dx;
	185	Double_t x02 = xwire + dx;
	186	Double_t y01 = yhit - dy;
	187	Double_t y02 = yhit + dy;
	188
	189	Double_t xext = x02 - x01;
	190	Double_t yext = y02 - y01;
	191
	192	// we do not check area here, as we assume the iterator
	193	// will do it, and will possibly truncate it if needed.
	194	// Note that we convert the area position to a reference frame
	195	// located in the lower-left corner of the slat, instead of its
	196	// center.
dfaf6b0d	197	// AliMpArea area(TVector2((x01+x02)/2.0+fSlat->DX(),
	198	// (y01+y02)/2.0+fSlat->DY()),
	199	// TVector2(xext/2.0,yext/2.0));
	200	AliMpArea area(TVector2((x01+x02)/2.0,(y01+y02)/2.0),
	201	TVector2(xext/2.0,yext/2.0));
90e8f97c	202
	203	delete fPadIterator;
	204
	205	fPadIterator = fSlatSegmentation->CreateIterator(area);
	206
	207	fPadIterator->First();
	208
	209	fCurrentPad = fPadIterator->CurrentItem();
	210
	211	if ( !fCurrentPad.IsValid() )
	212	{
	213	AliError(Form("Cannot get a valid pad for (xhit,yhit,dx,dy)=(%e,%e,%e,%e)",xhit,yhit,dx,dy));
	214	}
	215
	216	AliDebug(4,Form("xhit,yhit,dx,dy=%e,%e,%e,%e ix,iy=%3d,%3d slat=%s",
	217	xhit,yhit,dx,dy,
	218	fCurrentPad.GetIndices().GetFirst()+1,
	219	fCurrentPad.GetIndices().GetSecond()+1,fSlat->GetID()));
	220	}
	221
	222	//_____________________________________________________________________________
	223	Float_t
	224	AliMUONSt345SlatSegmentationV2::GetAnod(Float_t xhit) const
	225	{
	226	// Gets the x-coordinate of the wire which is the closest to xhit.
	227
	228	Int_t n = Int_t(xhit/AliMUONConstants::Pitch());
	229	Float_t wire = (xhit>0) ? n+0.5 : n-0.5;
	230	return AliMUONConstants::Pitch()*wire;
	231	}
	232
	233	//_____________________________________________________________________________
	234	AliMUONGeometryDirection
	235	AliMUONSt345SlatSegmentationV2::GetDirection()
	236	{
5289cf2f	237	//AliWarning("Not Implemented");
90e8f97c	238	return kDirUndefined;
	239	}
	240
b7ef3c96	241	//______________________________________________________________________________
	242	const AliMpVSegmentation*
	243	AliMUONSt345SlatSegmentationV2::GetMpSegmentation() const
	244	{
	245	// Returns the mapping segmentation
	246	// (provides access to electronics info)
	247
	248	return fSlatSegmentation;
	249	}
	250
	251
90e8f97c	252	//_____________________________________________________________________________
	253	void
	254	AliMUONSt345SlatSegmentationV2::GetNParallelAndOffset(Int_t,Int_t,Int_t,Int_t)
	255	{
	256	AliFatal("Not Implemented");
	257	}
	258
	259	//_____________________________________________________________________________
	260	void
	261	AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy,
	262	Float_t& x, Float_t& y, Float_t& z)
	263	{
	264	z = 0;
	265	GetPadC(ix,iy,x,y);
	266	}
	267
	268	//_____________________________________________________________________________
	269	void
	270	AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy,
	271	Float_t& x, Float_t& y)
	272	{
df484e06	273	AliMpPad pad =
	274	fSlatSegmentation->PadByIndices(AliMpIntPair(ix-fgIntOffset,iy-fgIntOffset),
	275	kTRUE);
dfaf6b0d	276	x = pad.Position().X();
dfaf6b0d	277	y = pad.Position().Y();
90e8f97c	278	}
90e8f97c	279
90e8f97c	280
	281	//_____________________________________________________________________________
	282	void
	283	AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y, Float_t /z/,
	284	Int_t& ix, Int_t& iy)
	285	{
	286	GetPadI(x,y,ix,iy);
	287	}
	288
	289	//_____________________________________________________________________________
	290	void
	291	AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y,
	292	Int_t& ix, Int_t& iy)
	293	{
dfaf6b0d	294	// Double_t slatx = fSlat->DX();
dfaf6b0d	295	// Double_t slaty = fSlat->DY();
90e8f97c	296	AliMpPad pad =
dfaf6b0d	297	fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
dfaf6b0d	298	// fSlatSegmentation->PadByPosition(TVector2(x+slatx,y+slaty), kTRUE);
90e8f97c	299
	300	if ( pad != AliMpPad::Invalid() )
	301	{
	302	ix = pad.GetIndices().GetFirst() + fgIntOffset;
	303	iy = pad.GetIndices().GetSecond() + fgIntOffset;
	304	}
	305	else
	306	{
	307	ix = iy = -1;
	308	}
	309	}
	310
	311	//_____________________________________________________________________________
	312	void
	313	AliMUONSt345SlatSegmentationV2::GiveTestPoints(Int_t&,Float_t,Float_t) const
	314	{
	315	AliFatal("Not Implemented");
	316	}
	317
	318	//_____________________________________________________________________________
	319	Bool_t
	320	AliMUONSt345SlatSegmentationV2::HasPad(Float_t x, Float_t y, Float_t z)
	321	{
	322	Int_t ix, iy;
	323	GetPadI(x,y,z,ix,iy);
	324	return HasPad(ix,iy);
	325	}
	326
	327	//_____________________________________________________________________________
	328	Bool_t
	329	AliMUONSt345SlatSegmentationV2::HasPad(Int_t ix, Int_t iy)
	330	{
	331	return fSlatSegmentation->HasPad(AliMpIntPair(ix-fgIntOffset,iy-fgIntOffset));
	332	}
	333
	334	//_____________________________________________________________________________
	335	void
	336	AliMUONSt345SlatSegmentationV2::Init(int)
	337	{
	338	AliWarning("Not Implemented because not needed ;-)");
	339	}
	340
	341	//_____________________________________________________________________________
	342	void
	343	AliMUONSt345SlatSegmentationV2::IntegrationLimits(Float_t& x1, Float_t& x2,
	344	Float_t& y1, Float_t& y2)
	345	{
	346	//
	347	// Returns integration limits for current pad
	348	//
	349
	350	// x1 = fXhit - fX - Dpx(fSector)/2.;
	351	// x2 = x1 + Dpx(fSector);
	352	// y1 = fYhit - fY - Dpy(fSector)/2.;
	353	// y2 = y1 + Dpy(fSector);
	354
dfaf6b0d	355	Float_t x = fCurrentPad.Position().X();
dfaf6b0d	356	Float_t y = fCurrentPad.Position().Y();
90e8f97c	357
dfaf6b0d	358	Float_t padsizex = fCurrentPad.Dimensions().X() * 2.0;
dfaf6b0d	359	Float_t padsizey = fCurrentPad.Dimensions().Y() * 2.0;
90e8f97c	360
	361	x1 = fXhit - x - padsizex/2.0;
	362	x2 = x1 + padsizex;
	363	y1 = fYhit - y - padsizey/2.0;
	364	y2 = y1 + padsizey;
	365
	366	AliDebug(4,Form("xhit,yhit=%e,%e x,y=%e,%e, x1,x2,y1,y2=%e,%e,%e,%e",fXhit,fYhit,x,y,x1,x2,y1,y2));
	367	}
	368
	369	//_____________________________________________________________________________
	370	Int_t
	371	AliMUONSt345SlatSegmentationV2::ISector()
	372	{
	373	// FIXME: remove the usage of ISector from all the code.
	374	return -10;
	375	}
	376
	377	//_____________________________________________________________________________
	378	Int_t
	379	AliMUONSt345SlatSegmentationV2::Ix()
	380	{
	381	if ( fPadIterator )
	382	{
	383	return fPadIterator->CurrentItem().GetIndices().GetFirst() + fgIntOffset;
	384	}
	385	else
	386	{
	387	return -1;
	388	}
	389	}
	390
	391	//_____________________________________________________________________________
	392	Int_t
	393	AliMUONSt345SlatSegmentationV2::Iy()
	394	{
	395	if ( fPadIterator )
	396	{
	397	return fPadIterator->CurrentItem().GetIndices().GetSecond() + fgIntOffset;
	398	}
	399	else
	400	{
	401	return -1;
	402	}
	403	}
	404
	405	//_____________________________________________________________________________
	406	Int_t
	407	AliMUONSt345SlatSegmentationV2::MorePads()
	408	{
	409	return (fPadIterator && !fPadIterator->IsDone());
	410	}
	411
	412	//_____________________________________________________________________________
	413	void
	414	AliMUONSt345SlatSegmentationV2::Neighbours(Int_t iX, Int_t iY, Int_t* Nlist,
	415	Int_t Xlist[10], Int_t Ylist[10])
	416	{
	417	// Find pad at (ix,iy) for which we'll search neighbours.
	418	AliMpPad pad =
	419	fSlatSegmentation->PadByIndices(AliMpIntPair(iX-fgIntOffset,iY-fgIntOffset),kTRUE);
	420
	421	// Define the region to look into : a region slightly bigger
e46a0808	422	// than the pad itself (5% bigger), in order to catch first neighbours.
	423
	424	AliMpArea area(pad.Position(),pad.Dimensions()*1.05);
90e8f97c	425
	426	AliMpVPadIterator* it = fSlatSegmentation->CreateIterator(area);
	427	it->First();
	428	Int_t n = 0;
	429	while ( !it->IsDone() && n < 10 )
	430	{
	431	AliMpPad p = it->CurrentItem();
	432	if ( p != pad ) // skip self
	433	{
	434	Xlist[n] = p.GetIndices().GetFirst() + fgIntOffset;
	435	Ylist[n] = p.GetIndices().GetSecond() + fgIntOffset;
	436	++n;
	437	}
	438	it->Next();
	439	}
	440	delete it;
	441	*Nlist = n;
	442	}
	443
	444	//_____________________________________________________________________________
	445	void
	446	AliMUONSt345SlatSegmentationV2::NextPad()
	447	{
	448	if ( fPadIterator )
	449	{
	450	fPadIterator->Next();
	451	fCurrentPad = fPadIterator->CurrentItem();
	452	}
	453	else
	454	{
	455	AliError("PadIterator not initialized. Please use First() first ;-)");
	456	}
	457	}
	458
	459	//_____________________________________________________________________________
	460	Int_t
	461	AliMUONSt345SlatSegmentationV2::Npx() const
	462	{
	463	return fSlatSegmentation->MaxPadIndexX()+1;
	464	}
	465
	466	//_____________________________________________________________________________
	467	Int_t
	468	AliMUONSt345SlatSegmentationV2::Npy() const
	469	{
	470	return fSlatSegmentation->MaxPadIndexY()+1;
	471	}
	472
	473	//_____________________________________________________________________________
	474	void
	475	AliMUONSt345SlatSegmentationV2::Print(Option_t*) const
	476	{
	477	cout << "DetElemId=" << fDetElemId << " PlaneType="
df484e06	478	<< fPlaneType << " Npx,Npy=" << Npx() << "," << Npy() << " fSlat=" << fSlat
90e8f97c	479	<< " fSlatSegmentation=" << fSlatSegmentation
	480	<< " fSlatSegmentation->Slat()=" << fSlatSegmentation->Slat() << endl;
	481	}
	482
90e8f97c	483	//_____________________________________________________________________________
90e8f97c	484	Int_t
df484e06	485	AliMUONSt345SlatSegmentationV2::Sector(Int_t ix, Int_t)
90e8f97c	486	{
df484e06	487	return fSlat->FindPCBIndex(ix - fgIntOffset);
90e8f97c	488	}
	489
	490	//_____________________________________________________________________________
	491	Int_t
	492	AliMUONSt345SlatSegmentationV2::Sector(Float_t x, Float_t y)
	493	{
	494	return fSlat->FindPCBIndex(x,y);
	495	}
	496
	497	//_____________________________________________________________________________
	498	void
	499	AliMUONSt345SlatSegmentationV2::SetCorrFunc(Int_t,TF1*)
	500	{
	501	AliFatal("Not Implemented");
	502	}
	503
	504	//_____________________________________________________________________________
	505	void
	506	AliMUONSt345SlatSegmentationV2::SetDAnod(float)
	507	{
	508	AliFatal("Not Implemented");
	509	}
	510
	511	//_____________________________________________________________________________
	512	void
	513	AliMUONSt345SlatSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
	514	{
	515	fXhit = x;
	516	fYhit = y;
	517
	518	//
	519	// insure we're within the slat limits. If not, issue an error and sets
	520	// the current hit to slat center.
	521	// FIXME: this should probably a) not happen at all b) be a fatal error
	522	//
	523	if ( fXhit < -fSlat->DX() \|\| fXhit > fSlat->DX() \|\|
	524	fYhit < -fSlat->DY() \|\| fYhit > fSlat->DY() )
	525	{
	526	AliError(Form("Hit outside slat %s limits (x,y)hit = (%e,%e)."
	527	" Forcing to (0,0)",fSlat->GetID(),fXhit,fYhit));
	528	fXhit = 0.0;
	529	fYhit = 0.0;
	530	}
	531
	532	}
	533
	534	//_____________________________________________________________________________
	535	void
	536	AliMUONSt345SlatSegmentationV2::SetPad(Int_t ix, Int_t iy)
	537	{
	538	fCurrentPad =
	539	fSlatSegmentation->PadByIndices(AliMpIntPair(ix-fgIntOffset,iy-fgIntOffset),kTRUE);
	540	if ( !fCurrentPad.IsValid() )
	541	{
	542	AliError(Form("Setting current pad to invalid ! (ix,iy)=(%4d,%4d)",ix,iy));
	543	}
	544	}
	545
	546	//_____________________________________________________________________________
	547	void
	548	AliMUONSt345SlatSegmentationV2::SetPadSize(float,float)
	549	{
	550	AliFatal("Not Implemented");
	551	}
552
553	//_____________________________________________________________________________
554	Int_t
555	AliMUONSt345SlatSegmentationV2::SigGenCond(Float_t,Float_t,Float_t)
556	{
557	AliFatal("Not Implemented");
558	return 0;
559	}
560
561	//_____________________________________________________________________________
562	void
563	AliMUONSt345SlatSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
564	{
565	AliFatal("Not Implemented");
566	}