[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)
{ 
  //
  // 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() * fgkLengthUnit;
}

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

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