[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
{
  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)
{ 
  //
  // Normal ctor.
  //
	
	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+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 (10% bigger), in order to catch first neighbours.
//  AliMpArea area(pad.Position()+fSlat->Dimensions(),pad.Dimensions()*2.1); 
  AliMpArea area(pad.Position(),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 << " Npx,Npy=" << Npx() << "," << Npy() << " 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)
{
  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");
}

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