[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 "AliLog.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 "AliMUONSegmentationManager.h"
#include "AliMUONConstants.h"

#include "Riostream.h"

#include "TClass.h"

ClassImp(AliMUONSt345SlatSegmentationV2)

namespace
{
  Double_t fgkLengthUnit = 0.1; // This class expects centimeters, while
																// AliMpSlat works with milimeters.
  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(Int_t detElemId, AliMpPlaneType bendingOrNonBending)
: AliMUONVGeometryDESegmentation(),
fDetElemId(detElemId),
fPlaneType(bendingOrNonBending),
fSlat(0),
fSlatSegmentation(0),
fPadIterator(0),
fXhit(FMAX),
fYhit(FMAX)
{ 
  // slatType is the description of the PCBs of that slat,
  // e.g. 122200N, 112200SR2, 112233NR3, etc...
  // The actual filename used is dealt with by the AliMpSt345Reader class.
  // Same thing for the path if that file, by the way.
	
	ReadMappingData();
		
  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/fgkLengthUnit+fSlat->DX(),
													(y01+y02)/2.0/fgkLengthUnit+fSlat->DY()),
								 TVector2(xext/2.0/fgkLengthUnit,yext/2.0/fgkLengthUnit));
	
  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()
{
  AliFatal("Not Implemented");
  return kDirUndefined;
}

//_____________________________________________________________________________
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),true);
  x = pad.Position().X() * fgkLengthUnit;
  y = pad.Position().Y() * fgkLengthUnit;
}


//_____________________________________________________________________________
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/fgkLengthUnit+slatx, 
																	y/fgkLengthUnit+slaty), true);
	
  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() * fgkLengthUnit;
  Float_t y = fCurrentPad.Position().Y() * fgkLengthUnit;
	
  Float_t padsizex = fCurrentPad.Dimensions().X() * 2.0 * fgkLengthUnit;
  Float_t padsizey = fCurrentPad.Dimensions().Y() * 2.0 * fgkLengthUnit;
	
  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 (10% bigger), in order to catch first neighbours.
  AliMpArea area(pad.Position()+fSlat->Dimensions(),pad.Dimensions()*2.1); 
		
  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 << " fSlat=" << fSlat 
  << " fSlatSegmentation=" << fSlatSegmentation
  << " fSlatSegmentation->Slat()=" << fSlatSegmentation->Slat() << endl;
}

//_____________________________________________________________________________
void
AliMUONSt345SlatSegmentationV2::ReadMappingData()
{
	fSlatSegmentation = dynamic_cast<AliMpSlatSegmentation*>(AliMUONSegmentationManager::Segmentation(fDetElemId,fPlaneType));
	if (!fSlatSegmentation)
	{
		AliFatal("Wrong segmentation type encountered");
	}
  fSlat = fSlatSegmentation->Slat();
}

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

//_____________________________________________________________________________
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");
}

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