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

// -------------------------------------
// Class AliMUONSt12QuadrantSegmentation
// -------------------------------------
// Segmentation for MUON quadrants of stations 1 and 2 using 
// the mapping package
// Author: Ivana Hrivnacova, IPN Orsay
 
#include <TError.h>
#include <TF1.h>
#include <TObjArray.h>
#include <TVector2.h>
#include <TSystem.h>

#include "AliLog.h"

#include "AliMpPad.h"
#include "AliMpArea.h"
#include "AliMpSectorReader.h"
#include "AliMpSector.h"
#include "AliMpVPadIterator.h"
#include "AliMpSectorSegmentation.h"
#include "AliMpFiles.h"
#include "AliMpNeighboursPadIterator.h"

#include "AliMUONSt12QuadrantSegmentation.h"
#include "AliMUONConstants.h"

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

//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(
                                       AliMpVSegmentation* segmentation,
                                       AliMpStationType stationType,
				       AliMpPlaneType planeType) 
: AliMUONVGeometryDESegmentation(),
  fStationType(stationType),
  fPlaneType(planeType),
  fSector(0),
  fSectorSegmentation(0),
  fSectorIterator(0),
  fWireD(0),
  fChamber(0),
  fId(0),
  fRmin(0.),
  fRmax(0.),
  fZ(0.),
  fIx(0),
  fIy(0),
  fX(0.),
  fY(0.),
  fZone(0),
  fXhit(0.),
  fYhit(0.),
  fIxt(0),
  fIyt(0),
  fIwt(0),
  fXt(0.),
  fYt(0.),
  fCorrA(0)
{
/// Standard constructor

  fSectorSegmentation = dynamic_cast<AliMpSectorSegmentation*>(segmentation);
  if (fSectorSegmentation)
    fSector = fSectorSegmentation->GetSector();
  else 
    AliFatal("Wrong mapping segmentation type");
    
  // Anod pitch
  if ( stationType == kStation1 )  
    fWireD = AliMUONConstants::PitchSt1();
  else if ( stationType == kStation2 )   
    fWireD = AliMUONConstants::Pitch();
  else  
    AliFatal("Wrong station type");

  fCorrA = new TObjArray(3);
  fCorrA->AddAt(0,0);
  fCorrA->AddAt(0,1);
  fCorrA->AddAt(0,2);

  AliDebug(1, Form("ctor this = %p", this) ); 
}

//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation() 
: AliMUONVGeometryDESegmentation(),
  fStationType(kStation1),
  fPlaneType(kBendingPlane),
  fSector(0),
  fSectorSegmentation(0),
  fSectorIterator(0),
  fWireD(0),
  fChamber(0),
  fId(0),
  fRmin(0.),
  fRmax(0.),
  fZ(0.),
  fIx(0),
  fIy(0),
  fX(0.),
  fY(0.),
  fZone(0),
  fXhit(0.),
  fYhit(0.),
  fIxt(0),
  fIyt(0),
  fIwt(0),
  fXt(0.),
  fYt(0.),
  fCorrA(0) 
{
/// Default Constructor

  AliDebug(1, Form("default (empty) ctor this = %p", this));
}

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

  AliDebug(1, Form("dtor this = %p", this));

  delete fSector;
  delete fSectorSegmentation;  
  delete fSectorIterator;  
} 

//
// private methods
//

//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::UpdateCurrentPadValues(const AliMpPad& pad)
{
/// Updates current pad values.

  fIx = pad.GetIndices().GetFirst();
  fIy = pad.GetIndices().GetSecond();
  fX = pad.Position().X();
  fY = pad.Position().Y();
  fZone = fSectorSegmentation->Zone(pad);
}  


//
// public methods
//

//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetPadSize(Float_t /*p1*/, Float_t /*p2*/)
{
/// Set pad size Dx*Dy 

  AliFatal("Not uniform pad size.");
}

//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetDAnod(Float_t d)
{
/// Set anod pitch

  fWireD = d;
}

#include "AliMpMotifMap.h"
//______________________________________________________________________________
Bool_t  AliMUONSt12QuadrantSegmentation::HasPad(Float_t x, Float_t y, Float_t /*z*/)
{ 
/// Returns true if a pad exists in the given position

  // fSector->GetMotifMap()->Print();

  AliMpPad pad = fSectorSegmentation
               ->PadByPosition(TVector2(x,y), false);

  return pad.IsValid();
}  


//______________________________________________________________________________
Bool_t  AliMUONSt12QuadrantSegmentation::HasPad(Int_t ix, Int_t iy)
{
/// Returns true if a pad with given indices exists

  AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), false);

  return pad.IsValid();
}  


//______________________________________________________________________________
AliMUONGeometryDirection  AliMUONSt12QuadrantSegmentation::GetDirection()
{
/// Returns the direction with a constant pad size  
/// (Direction or coordinate where the resolution is the best)

  switch ( fSector->GetDirection() ) {
    case kX: return kDirX;
    case kY: return kDirY;
    default: return kDirUndefined;
  }  
}  

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

  return fSectorSegmentation;
}  

//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::GetAnod(Float_t xhit) const
{
/// Anod wire coordinate closest to xhit
/// Returns for a hit position xhit the position of the nearest anode wire    
/// From AliMUONSegmentationV01.

  Float_t wire= (xhit>0) ? Int_t(xhit/fWireD) + 0.5
                         : Int_t(xhit/fWireD) - 0.5;
  return fWireD*wire;

}

//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y, Float_t /*z*/, 
                                      Int_t& ix, Int_t& iy)
{					
///  Returns pad coordinates (ix,iy) for given real coordinates (x,y)

  GetPadI(x, y, ix, iy);
}
		       
//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y,
                                      Int_t& ix, Int_t& iy)
{					
/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
/// If there is no pad, ix = 0, iy = 0 are returned.

  AliMpPad pad = fSectorSegmentation->PadByPosition(TVector2(x,y), true);

  ix = pad.GetIndices().GetFirst();
  iy = pad.GetIndices().GetSecond();
}
		       
//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy, 
                                      Float_t& x, Float_t& y, Float_t& z)
{					
/// Transform from pad to real coordinates

  z = fZ;
  GetPadC(ix, iy, x , y);
}

//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy, 
                                      Float_t& x, Float_t& y)
{					
/// Transform from pad to real coordinates
/// If there is no pad, x = 0., y = 0. are returned.

  AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), true);

  x = pad.Position().X();
  y = pad.Position().Y();
}


//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::Init(Int_t chamber)
{
/// Initialize segmentation

 // find Npx, Npy and save this info
  
  // reference to chamber
 fRmin=AliMUONConstants::Rmin(0);
 fRmax=AliMUONConstants::Rmax(0);  
 fZ = 0;
 fId=chamber;
}
 
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpx() const
{
/// Get pad size in x

  AliFatal( "Not uniform pad size.");
  return 0.;
}

//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpy() const
{
/// Get pad size in y

  AliFatal("Not uniform pad size.");
  return 0.;
}
 
//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpx(Int_t isector) const
{
/// Pad size in x by sector

  return fSectorSegmentation->PadDimensions(isector).X()*2.0;
} 

//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Dpy(Int_t isector) const
{
/// Pad size in x, y by Sector 

  return fSectorSegmentation->PadDimensions(isector).Y()*2.0;
}

//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Npx() const
{
/// Maximum number of Pads in x
/// hard coded for the time being

  return fSectorSegmentation->MaxPadIndexX();
}

//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Npy() const
{
/// Maximum number of Pads in y
/// hard coded for the time being

  return fSectorSegmentation->MaxPadIndexY();
}

//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::SetPad(Int_t ix, Int_t iy)
{
/// Set pad position.
/// Sets virtual pad coordinates, needed for evaluating pad response 
/// outside the tracking program.
/// From AliMUONSegmentationV01.

  GetPadC(ix, iy, fX, fY);
  fZone = Sector(ix, iy);
}

//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
{
/// Set hit position
/// Sets virtual hit position, needed for evaluating pad response 
/// outside the tracking program 
/// From AliMUONSegmentationV01.

  fXhit = xhit;
  fYhit = yhit;
}
    
//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, 
                                       Float_t dx, Float_t dy) 
{					 
/// Iterate over pads - initialiser

  // Sets the current pad to that located in the hit position
 
  SetHit(GetAnod(xhit), yhit, 0.); 
  
  // Enable iterating in one dimension
  if (dx == 0.)  dx = 0.01;
  if (dy == 0.)  dy = 0.01;
  
  // Delete previous iterator
  delete  fSectorIterator;
  
  fSectorIterator 
    = fSectorSegmentation
        ->CreateIterator(AliMpArea(TVector2(fXhit,fYhit),TVector2(dx,dy)));

  AliDebug(1,Form("CreateIterator area=%e,%e +- %e,%e %s",
                  fXhit,fYhit,dx,dy,PlaneTypeName(fPlaneType).Data()));
  
  fSectorIterator->First();		

  if (! fSectorIterator->IsDone())
    UpdateCurrentPadValues(fSectorIterator->CurrentItem());
}
 
//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::NextPad()
{
/// Iterate over pads - stepper

  fSectorIterator->Next();				

  if (! fSectorIterator->IsDone())
    UpdateCurrentPadValues(fSectorIterator->CurrentItem());
}

//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::MorePads()
{
/// Iterate over pads - condition

  if (fSectorIterator->IsDone())
    return 0;
  else
    return 1;  
}

//______________________________________________________________________________
Float_t AliMUONSt12QuadrantSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, 
						   Float_t x, Float_t y, Int_t* /*dummy*/)
{					   
/// Returns the square of the distance between 1 pad
/// labelled by its channel numbers and a coordinate

  AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX, iY));
  
  if (!pad.IsValid())
    AliFatal("Cannot locate pad.");

  return (pad.Position() - TVector2(x, y)).Mod2();
}

//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/,
						   Int_t* /*Nparallel*/, Int_t* /*Offset*/)
{					   
/// Number of pads read in parallel and offset to add to x 
/// (specific to LYON, but mandatory for display)

  AliFatal( "Not yet implemented.");
}


//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::Neighbours(Int_t iX, Int_t iY, 
                                        Int_t* Nlist, 
					Int_t Xlist[10], Int_t Ylist[10])
{					  
/// Get next neighbours 

  AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX,iY));
  Int_t &i = *Nlist;
  i=0;
  AliMpNeighboursPadIterator iter(fSectorSegmentation, pad, kFALSE);

  for( iter.First(); !iter.IsDone() && i<10; iter.Next()) {
    Xlist[i] = iter.CurrentItem().GetIndices().GetFirst();
    Ylist[i] = iter.CurrentItem().GetIndices().GetSecond();
    i++;
  }
}
 
//______________________________________________________________________________
Int_t  AliMUONSt12QuadrantSegmentation::Ix()
{
/// Current pad cursor during disintegration
/// x, y-coordinate

  return fSectorIterator->CurrentItem().GetIndices().GetFirst();
}

//______________________________________________________________________________
Int_t  AliMUONSt12QuadrantSegmentation::Iy()
{
/// Current pad cursor during disintegration
/// x, y-coordinate

  return fSectorIterator->CurrentItem().GetIndices().GetSecond();
}

//______________________________________________________________________________
Int_t  AliMUONSt12QuadrantSegmentation::ISector()
{
/// Current sector

  return fZone;
}

//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Sector(Int_t ix, Int_t iy)
{
/// Calculate sector from pad coordinates

  return fSectorSegmentation
           ->Zone(fSectorSegmentation->PadByIndices(AliMpIntPair(ix, iy)));
}

//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::Sector(Float_t x, Float_t y)
{
/// Calculate sector from pad coordinates

  return fSectorSegmentation
           ->Zone(fSectorSegmentation
	            ->PadByPosition(TVector2(x,y)));
}

//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::IntegrationLimits(Float_t& x1, Float_t& x2,
                                                Float_t& y1, Float_t& y2)
{						  
/// Current integration limits 
 
  x1 = fXhit - fX - Dpx(fZone)/2.;
  x2 = x1 + Dpx(fZone);

  y1 = fYhit - fY - Dpy(fZone)/2.;
  y2 = y1 + Dpy(fZone);    
}

//______________________________________________________________________________
Int_t AliMUONSt12QuadrantSegmentation::SigGenCond(Float_t x, Float_t y, Float_t /*z*/)
{
/// Signal Generation Condition during Stepping
/// -  0: don't generate signal
/// -  1: generate signal 
///
///  Comments:                                                                  \n 
///
///  Crossing of pad boundary and mid plane between neighbouring wires is checked.
///  To correctly simulate the dependence of the spatial resolution on the angle 
///  of incidence signal must be generated for constant steps on 
///  the projection of the trajectory along the anode wire.
///
///  Signal will be generated if particle crosses pad boundary or
///  boundary between two wires. 
///
/// From AliMUONSegmentationV01

  Int_t ixt, iyt;
  GetPadI(x, y, ixt, iyt);
  Int_t iwt=(x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1;
  
  if ((ixt != fIxt) || (iyt !=fIyt) || (iwt != fIwt)) {
    return 1;
  } 
  else {
    return 0;
  }
}

//______________________________________________________________________________
void  AliMUONSt12QuadrantSegmentation::SigGenInit(Float_t x, Float_t y, Float_t /*z*/)
{
/// Initialise signal generation at coord (x,y,z)
/// Initialises pad and wire position during stepping.
/// From AliMUONSegmentationV01

  fXt = x;
  fYt = y;
  GetPadI(x, y, fIxt, fIyt);
  fIwt = (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
}		    
    
//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const
{					      
/// Test points for auto calibration
/// Returns test point on the pad plane.
/// Used during determination of the segmoid correction of the COG-method
/// From AliMUONSegmentationV01

  n=1;
  x[0] = (fRmax+fRmin)/2/TMath::Sqrt(2.);
  y[0] = x[0];
}

//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::Draw(const char * /*opt*/)
{
/// Draw the segmentation zones.
/// (Called from AliMUON::BuildGeometry)

  AliWarning("Not yet implemented.");
}

//______________________________________________________________________________
void AliMUONSt12QuadrantSegmentation::SetCorrFunc(Int_t isec, TF1* func)
{
/// Set the correction function.
/// From AliMUONSegmentationV01

  fCorrA->AddAt(func, isec);
}

//______________________________________________________________________________
TF1* AliMUONSt12QuadrantSegmentation::CorrFunc(Int_t isec) const
{
/// Get the correction Function.
/// From AliMUONSegmentationV01

  return (TF1*) fCorrA->At(isec);
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	// -------------------------------------
	19	// Class AliMUONSt12QuadrantSegmentation
	20	// -------------------------------------
	21	// Segmentation for MUON quadrants of stations 1 and 2 using
	22	// the mapping package
	23	// Author: Ivana Hrivnacova, IPN Orsay
	24
	25	#include <TError.h>
	26	#include <TF1.h>
	27	#include <TObjArray.h>
	28	#include <TVector2.h>
	29	#include <TSystem.h>
	30
	31	#include "AliLog.h"
	32
	33	#include "AliMpPad.h"
	34	#include "AliMpArea.h"
	35	#include "AliMpSectorReader.h"
	36	#include "AliMpSector.h"
	37	#include "AliMpVPadIterator.h"
	38	#include "AliMpSectorSegmentation.h"
	39	#include "AliMpFiles.h"
	40	#include "AliMpNeighboursPadIterator.h"
	41
	42	#include "AliMUONSt12QuadrantSegmentation.h"
	43	#include "AliMUONConstants.h"
	44
	45	/// \cond CLASSIMP
	46	ClassImp(AliMUONSt12QuadrantSegmentation)
	47	/// \endcond
	48
	49	//______________________________________________________________________________
	50	AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(
	51	AliMpVSegmentation* segmentation,
	52	AliMpStationType stationType,
	53	AliMpPlaneType planeType)
	54	: AliMUONVGeometryDESegmentation(),
	55	fStationType(stationType),
	56	fPlaneType(planeType),
	57	fSector(0),
	58	fSectorSegmentation(0),
	59	fSectorIterator(0),
	60	fWireD(0),
	61	fChamber(0),
	62	fId(0),
	63	fRmin(0.),
	64	fRmax(0.),
	65	fZ(0.),
	66	fIx(0),
	67	fIy(0),
	68	fX(0.),
	69	fY(0.),
	70	fZone(0),
	71	fXhit(0.),
	72	fYhit(0.),
	73	fIxt(0),
	74	fIyt(0),
	75	fIwt(0),
	76	fXt(0.),
	77	fYt(0.),
	78	fCorrA(0)
	79	{
	80	/// Standard constructor
	81
	82	fSectorSegmentation = dynamic_cast<AliMpSectorSegmentation*>(segmentation);
	83	if (fSectorSegmentation)
	84	fSector = fSectorSegmentation->GetSector();
	85	else
	86	AliFatal("Wrong mapping segmentation type");
	87
	88	// Anod pitch
	89	if ( stationType == kStation1 )
	90	fWireD = AliMUONConstants::PitchSt1();
	91	else if ( stationType == kStation2 )
	92	fWireD = AliMUONConstants::Pitch();
	93	else
	94	AliFatal("Wrong station type");
	95
	96	fCorrA = new TObjArray(3);
	97	fCorrA->AddAt(0,0);
	98	fCorrA->AddAt(0,1);
	99	fCorrA->AddAt(0,2);
	100
	101	AliDebug(1, Form("ctor this = %p", this) );
	102	}
	103
	104	//______________________________________________________________________________
	105	AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation()
	106	: AliMUONVGeometryDESegmentation(),
	107	fStationType(kStation1),
	108	fPlaneType(kBendingPlane),
	109	fSector(0),
	110	fSectorSegmentation(0),
	111	fSectorIterator(0),
	112	fWireD(0),
	113	fChamber(0),
	114	fId(0),
	115	fRmin(0.),
	116	fRmax(0.),
	117	fZ(0.),
	118	fIx(0),
	119	fIy(0),
	120	fX(0.),
	121	fY(0.),
	122	fZone(0),
	123	fXhit(0.),
	124	fYhit(0.),
	125	fIxt(0),
	126	fIyt(0),
	127	fIwt(0),
	128	fXt(0.),
	129	fYt(0.),
	130	fCorrA(0)
	131	{
	132	/// Default Constructor
	133
	134	AliDebug(1, Form("default (empty) ctor this = %p", this));
	135	}
	136
	137	//______________________________________________________________________________
	138	AliMUONSt12QuadrantSegmentation::~AliMUONSt12QuadrantSegmentation()
	139	{
	140	/// Destructor
	141
	142	AliDebug(1, Form("dtor this = %p", this));
	143
	144	delete fSector;
	145	delete fSectorSegmentation;
	146	delete fSectorIterator;
	147	}
	148
	149	//
	150	// private methods
	151	//
	152
	153	//______________________________________________________________________________
	154	void AliMUONSt12QuadrantSegmentation::UpdateCurrentPadValues(const AliMpPad& pad)
	155	{
	156	/// Updates current pad values.
	157
	158	fIx = pad.GetIndices().GetFirst();
	159	fIy = pad.GetIndices().GetSecond();
	160	fX = pad.Position().X();
	161	fY = pad.Position().Y();
	162	fZone = fSectorSegmentation->Zone(pad);
	163	}
	164
	165
	166	//
	167	// public methods
	168	//
	169
	170	//______________________________________________________________________________
	171	void AliMUONSt12QuadrantSegmentation::SetPadSize(Float_t /p1/, Float_t /p2/)
	172	{
	173	/// Set pad size Dx*Dy
	174
	175	AliFatal("Not uniform pad size.");
	176	}
	177
	178	//______________________________________________________________________________
	179	void AliMUONSt12QuadrantSegmentation::SetDAnod(Float_t d)
	180	{
	181	/// Set anod pitch
	182
	183	fWireD = d;
	184	}
	185
	186	#include "AliMpMotifMap.h"
	187	//______________________________________________________________________________
	188	Bool_t AliMUONSt12QuadrantSegmentation::HasPad(Float_t x, Float_t y, Float_t /z/)
	189	{
	190	/// Returns true if a pad exists in the given position
	191
	192	// fSector->GetMotifMap()->Print();
	193
	194	AliMpPad pad = fSectorSegmentation
	195	->PadByPosition(TVector2(x,y), false);
	196
	197	return pad.IsValid();
	198	}
	199
	200
	201	//______________________________________________________________________________
	202	Bool_t AliMUONSt12QuadrantSegmentation::HasPad(Int_t ix, Int_t iy)
	203	{
	204	/// Returns true if a pad with given indices exists
	205
	206	AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), false);
	207
	208	return pad.IsValid();
	209	}
	210
	211
	212	//______________________________________________________________________________
	213	AliMUONGeometryDirection AliMUONSt12QuadrantSegmentation::GetDirection()
	214	{
	215	/// Returns the direction with a constant pad size
	216	/// (Direction or coordinate where the resolution is the best)
	217
	218	switch ( fSector->GetDirection() ) {
	219	case kX: return kDirX;
	220	case kY: return kDirY;
	221	default: return kDirUndefined;
	222	}
	223	}
	224
	225	//______________________________________________________________________________
	226	const AliMpVSegmentation*
	227	AliMUONSt12QuadrantSegmentation::GetMpSegmentation() const
	228	{
	229	/// Returns the mapping segmentation
	230	/// (provides access to electronics info)
	231
	232	return fSectorSegmentation;
	233	}
	234
	235	//______________________________________________________________________________
	236	Float_t AliMUONSt12QuadrantSegmentation::GetAnod(Float_t xhit) const
	237	{
	238	/// Anod wire coordinate closest to xhit
	239	/// Returns for a hit position xhit the position of the nearest anode wire
	240	/// From AliMUONSegmentationV01.
	241
	242	Float_t wire= (xhit>0) ? Int_t(xhit/fWireD) + 0.5
	243	: Int_t(xhit/fWireD) - 0.5;
	244	return fWireD*wire;
	245
	246	}
	247
	248	//______________________________________________________________________________
	249	void AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y, Float_t /z/,
	250	Int_t& ix, Int_t& iy)
	251	{
	252	/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	253
	254	GetPadI(x, y, ix, iy);
	255	}
	256
	257	//______________________________________________________________________________
	258	void AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y,
	259	Int_t& ix, Int_t& iy)
	260	{
	261	/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	262	/// If there is no pad, ix = 0, iy = 0 are returned.
	263
	264	AliMpPad pad = fSectorSegmentation->PadByPosition(TVector2(x,y), true);
	265
	266	ix = pad.GetIndices().GetFirst();
	267	iy = pad.GetIndices().GetSecond();
	268	}
	269
	270	//______________________________________________________________________________
	271	void AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy,
	272	Float_t& x, Float_t& y, Float_t& z)
	273	{
	274	/// Transform from pad to real coordinates
	275
	276	z = fZ;
	277	GetPadC(ix, iy, x , y);
	278	}
	279
	280	//______________________________________________________________________________
	281	void AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy,
	282	Float_t& x, Float_t& y)
	283	{
	284	/// Transform from pad to real coordinates
	285	/// If there is no pad, x = 0., y = 0. are returned.
	286
	287	AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), true);
	288
	289	x = pad.Position().X();
	290	y = pad.Position().Y();
	291	}
	292
	293
	294	//______________________________________________________________________________
	295	void AliMUONSt12QuadrantSegmentation::Init(Int_t chamber)
	296	{
	297	/// Initialize segmentation
	298
	299	// find Npx, Npy and save this info
	300
	301	// reference to chamber
	302	fRmin=AliMUONConstants::Rmin(0);
	303	fRmax=AliMUONConstants::Rmax(0);
	304	fZ = 0;
	305	fId=chamber;
	306	}
	307
	308	//______________________________________________________________________________
	309	Float_t AliMUONSt12QuadrantSegmentation::Dpx() const
	310	{
	311	/// Get pad size in x
	312
	313	AliFatal( "Not uniform pad size.");
	314	return 0.;
	315	}
	316
	317	//______________________________________________________________________________
	318	Float_t AliMUONSt12QuadrantSegmentation::Dpy() const
	319	{
	320	/// Get pad size in y
	321
	322	AliFatal("Not uniform pad size.");
	323	return 0.;
	324	}
	325
	326	//______________________________________________________________________________
	327	Float_t AliMUONSt12QuadrantSegmentation::Dpx(Int_t isector) const
	328	{
	329	/// Pad size in x by sector
	330
	331	return fSectorSegmentation->PadDimensions(isector).X()*2.0;
	332	}
	333
	334	//______________________________________________________________________________
	335	Float_t AliMUONSt12QuadrantSegmentation::Dpy(Int_t isector) const
	336	{
	337	/// Pad size in x, y by Sector
	338
	339	return fSectorSegmentation->PadDimensions(isector).Y()*2.0;
	340	}
	341
	342	//______________________________________________________________________________
	343	Int_t AliMUONSt12QuadrantSegmentation::Npx() const
	344	{
	345	/// Maximum number of Pads in x
	346	/// hard coded for the time being
	347
	348	return fSectorSegmentation->MaxPadIndexX();
	349	}
	350
	351	//______________________________________________________________________________
	352	Int_t AliMUONSt12QuadrantSegmentation::Npy() const
	353	{
	354	/// Maximum number of Pads in y
	355	/// hard coded for the time being
	356
	357	return fSectorSegmentation->MaxPadIndexY();
	358	}
	359
	360	//______________________________________________________________________________
	361	void AliMUONSt12QuadrantSegmentation::SetPad(Int_t ix, Int_t iy)
	362	{
	363	/// Set pad position.
	364	/// Sets virtual pad coordinates, needed for evaluating pad response
	365	/// outside the tracking program.
	366	/// From AliMUONSegmentationV01.
	367
	368	GetPadC(ix, iy, fX, fY);
	369	fZone = Sector(ix, iy);
	370	}
	371
	372	//______________________________________________________________________________
	373	void AliMUONSt12QuadrantSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /zhit/)
	374	{
	375	/// Set hit position
	376	/// Sets virtual hit position, needed for evaluating pad response
	377	/// outside the tracking program
	378	/// From AliMUONSegmentationV01.
	379
	380	fXhit = xhit;
	381	fYhit = yhit;
	382	}
	383
	384	//______________________________________________________________________________
	385	void AliMUONSt12QuadrantSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /zhit/,
	386	Float_t dx, Float_t dy)
	387	{
	388	/// Iterate over pads - initialiser
	389
	390	// Sets the current pad to that located in the hit position
	391
	392	SetHit(GetAnod(xhit), yhit, 0.);
	393
	394	// Enable iterating in one dimension
	395	if (dx == 0.) dx = 0.01;
	396	if (dy == 0.) dy = 0.01;
	397
	398	// Delete previous iterator
	399	delete fSectorIterator;
	400
	401	fSectorIterator
	402	= fSectorSegmentation
	403	->CreateIterator(AliMpArea(TVector2(fXhit,fYhit),TVector2(dx,dy)));
	404
	405	AliDebug(1,Form("CreateIterator area=%e,%e +- %e,%e %s",
	406	fXhit,fYhit,dx,dy,PlaneTypeName(fPlaneType).Data()));
	407
	408	fSectorIterator->First();
	409
	410	if (! fSectorIterator->IsDone())
	411	UpdateCurrentPadValues(fSectorIterator->CurrentItem());
	412	}
	413
	414	//______________________________________________________________________________
	415	void AliMUONSt12QuadrantSegmentation::NextPad()
	416	{
	417	/// Iterate over pads - stepper
	418
	419	fSectorIterator->Next();
	420
	421	if (! fSectorIterator->IsDone())
	422	UpdateCurrentPadValues(fSectorIterator->CurrentItem());
	423	}
	424
	425	//______________________________________________________________________________
	426	Int_t AliMUONSt12QuadrantSegmentation::MorePads()
	427	{
	428	/// Iterate over pads - condition
	429
	430	if (fSectorIterator->IsDone())
	431	return 0;
	432	else
	433	return 1;
	434	}
	435
	436	//______________________________________________________________________________
	437	Float_t AliMUONSt12QuadrantSegmentation::Distance2AndOffset(Int_t iX, Int_t iY,
	438	Float_t x, Float_t y, Int_t* /dummy/)
	439	{
	440	/// Returns the square of the distance between 1 pad
	441	/// labelled by its channel numbers and a coordinate
	442
	443	AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX, iY));
	444
	445	if (!pad.IsValid())
	446	AliFatal("Cannot locate pad.");
	447
	448	return (pad.Position() - TVector2(x, y)).Mod2();
	449	}
	450
	451	//______________________________________________________________________________
	452	void AliMUONSt12QuadrantSegmentation::GetNParallelAndOffset(Int_t /iX/, Int_t /iY/,
	453	Int_t* /Nparallel/, Int_t* /Offset/)
	454	{
	455	/// Number of pads read in parallel and offset to add to x
	456	/// (specific to LYON, but mandatory for display)
	457
	458	AliFatal( "Not yet implemented.");
	459	}
	460
	461
	462	//______________________________________________________________________________
	463	void AliMUONSt12QuadrantSegmentation::Neighbours(Int_t iX, Int_t iY,
	464	Int_t* Nlist,
	465	Int_t Xlist[10], Int_t Ylist[10])
	466	{
	467	/// Get next neighbours
	468
	469	AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX,iY));
	470	Int_t &i = *Nlist;
	471	i=0;
	472	AliMpNeighboursPadIterator iter(fSectorSegmentation, pad, kFALSE);
	473
	474	for( iter.First(); !iter.IsDone() && i<10; iter.Next()) {
	475	Xlist[i] = iter.CurrentItem().GetIndices().GetFirst();
	476	Ylist[i] = iter.CurrentItem().GetIndices().GetSecond();
	477	i++;
	478	}
	479	}
	480
	481	//______________________________________________________________________________
	482	Int_t AliMUONSt12QuadrantSegmentation::Ix()
	483	{
	484	/// Current pad cursor during disintegration
	485	/// x, y-coordinate
	486
	487	return fSectorIterator->CurrentItem().GetIndices().GetFirst();
	488	}
	489
	490	//______________________________________________________________________________
	491	Int_t AliMUONSt12QuadrantSegmentation::Iy()
	492	{
	493	/// Current pad cursor during disintegration
	494	/// x, y-coordinate
	495
	496	return fSectorIterator->CurrentItem().GetIndices().GetSecond();
	497	}
	498
	499	//______________________________________________________________________________
	500	Int_t AliMUONSt12QuadrantSegmentation::ISector()
	501	{
	502	/// Current sector
	503
	504	return fZone;
	505	}
	506
	507	//______________________________________________________________________________
	508	Int_t AliMUONSt12QuadrantSegmentation::Sector(Int_t ix, Int_t iy)
	509	{
	510	/// Calculate sector from pad coordinates
	511
	512	return fSectorSegmentation
	513	->Zone(fSectorSegmentation->PadByIndices(AliMpIntPair(ix, iy)));
	514	}
	515
	516	//______________________________________________________________________________
	517	Int_t AliMUONSt12QuadrantSegmentation::Sector(Float_t x, Float_t y)
	518	{
	519	/// Calculate sector from pad coordinates
	520
	521	return fSectorSegmentation
	522	->Zone(fSectorSegmentation
	523	->PadByPosition(TVector2(x,y)));
	524	}
	525
	526	//______________________________________________________________________________
	527	void AliMUONSt12QuadrantSegmentation::IntegrationLimits(Float_t& x1, Float_t& x2,
	528	Float_t& y1, Float_t& y2)
	529	{
	530	/// Current integration limits
	531
	532	x1 = fXhit - fX - Dpx(fZone)/2.;
	533	x2 = x1 + Dpx(fZone);
	534
	535	y1 = fYhit - fY - Dpy(fZone)/2.;
	536	y2 = y1 + Dpy(fZone);
	537	}
	538
	539	//______________________________________________________________________________
	540	Int_t AliMUONSt12QuadrantSegmentation::SigGenCond(Float_t x, Float_t y, Float_t /z/)
	541	{
	542	/// Signal Generation Condition during Stepping
	543	/// - 0: don't generate signal
	544	/// - 1: generate signal
	545	///
	546	/// Comments: \n
	547	///
	548	/// Crossing of pad boundary and mid plane between neighbouring wires is checked.
	549	/// To correctly simulate the dependence of the spatial resolution on the angle
	550	/// of incidence signal must be generated for constant steps on
	551	/// the projection of the trajectory along the anode wire.
	552	///
	553	/// Signal will be generated if particle crosses pad boundary or
	554	/// boundary between two wires.
	555	///
	556	/// From AliMUONSegmentationV01
	557
	558	Int_t ixt, iyt;
	559	GetPadI(x, y, ixt, iyt);
	560	Int_t iwt=(x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1;
	561
	562	if ((ixt != fIxt) \|\| (iyt !=fIyt) \|\| (iwt != fIwt)) {
	563	return 1;
	564	}
	565	else {
	566	return 0;
	567	}
	568	}
	569
	570	//______________________________________________________________________________
	571	void AliMUONSt12QuadrantSegmentation::SigGenInit(Float_t x, Float_t y, Float_t /z/)
	572	{
	573	/// Initialise signal generation at coord (x,y,z)
	574	/// Initialises pad and wire position during stepping.
	575	/// From AliMUONSegmentationV01
	576
	577	fXt = x;
	578	fYt = y;
	579	GetPadI(x, y, fIxt, fIyt);
	580	fIwt = (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
	581	}
	582
	583	//______________________________________________________________________________
	584	void AliMUONSt12QuadrantSegmentation::GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const
	585	{
	586	/// Test points for auto calibration
	587	/// Returns test point on the pad plane.
	588	/// Used during determination of the segmoid correction of the COG-method
	589	/// From AliMUONSegmentationV01
	590
	591	n=1;
	592	x[0] = (fRmax+fRmin)/2/TMath::Sqrt(2.);
	593	y[0] = x[0];
	594	}
	595
	596	//______________________________________________________________________________
	597	void AliMUONSt12QuadrantSegmentation::Draw(const char * /opt/)
	598	{
	599	/// Draw the segmentation zones.
	600	/// (Called from AliMUON::BuildGeometry)
	601
	602	AliWarning("Not yet implemented.");
	603	}
	604
	605	//______________________________________________________________________________
	606	void AliMUONSt12QuadrantSegmentation::SetCorrFunc(Int_t isec, TF1* func)
	607	{
	608	/// Set the correction function.
	609	/// From AliMUONSegmentationV01
	610
	611	fCorrA->AddAt(func, isec);
	612	}
	613
	614	//______________________________________________________________________________
	615	TF1* AliMUONSt12QuadrantSegmentation::CorrFunc(Int_t isec) const
	616	{
	617	/// Get the correction Function.
	618	/// From AliMUONSegmentationV01
	619
	620	return (TF1*) fCorrA->At(isec);
	621	}