[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 "AliMpPad.h"
#include "AliMpArea.h"
#include "AliMpReader.h"
#include "AliMpSector.h"
#include "AliMpVPadIterator.h"
#include "AliMpSectorSegmentation.h"

#include "AliMUONSt12QuadrantSegmentation.h"
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONChamber.h"
#include "AliLog.h"

ClassImp(AliMUONSt12QuadrantSegmentation)

const Float_t  AliMUONSt12QuadrantSegmentation::fgkWireD = 0.20; 
const Float_t  AliMUONSt12QuadrantSegmentation::fgkLengthUnit = 0.1; 

//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(
                                       AliMpStationType stationType,
				       AliMpPlaneType planeType) 
: AliMUONVGeometryDESegmentation(),
  fSector(0),
  fSectorSegmentation(0),
  fSectorIterator(0),
  fWireD(fgkWireD),
  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)
{
// Normal constructor
  
  AliMpReader r(stationType, planeType);
  fSector = r.BuildSector();
  fSectorSegmentation = new AliMpSectorSegmentation(fSector);

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

//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation() 
: AliMUONVGeometryDESegmentation(),
  fSector(0),
  fSectorSegmentation(0),
  fSectorIterator(0),
  fWireD(fgkWireD),
  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
}

//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs) 
  : AliMUONVGeometryDESegmentation(rhs)
{
// Copy constructor
  AliFatal("Copy constructor is not implemented.");
}

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

  delete fSector;
  delete fSectorSegmentation;  
  delete fSectorIterator;  
} 

//
// operators
//

//______________________________________________________________________________
AliMUONSt12QuadrantSegmentation& 
AliMUONSt12QuadrantSegmentation::operator=(const AliMUONSt12QuadrantSegmentation& rhs)
{
// Copy operator 

  // check assignement to self
  if (this == &rhs) return *this;

  AliFatal("Assignment operator is not implemented.");
    
  return *this;  
}

//
// private methods
//

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

  fIx = pad.GetIndices().GetFirst();
  fIy = pad.GetIndices().GetSecond();
  fX = pad.Position().X() * fgkLengthUnit;
  fY = pad.Position().Y() * fgkLengthUnit;
  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;
}

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

  AliMpPad pad = fSectorSegmentation
               ->PadByPosition(TVector2(x/fgkLengthUnit, y/fgkLengthUnit), 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;
  }  
}  

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


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

  // find Npx, Npy and save this info
  
  // reference to chamber
 AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
 fChamber = &(pMUON->Chamber(chamber));
 fRmin=fChamber->RInner();
 fRmax=fChamber->ROuter();  
 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.*fgkLengthUnit;
} 

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

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

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

  //Fatal("Npx", "Not yet implemented.");
  switch (fSector->GetDirection()) {
    case kX:
      return 142;
    case kY:
      return 108;
    default:
      AliError("Unknown sector direction");
      return 0;  
  }      
}

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

  //Fatal("Npy", "Not yet implemented.");
  switch (fSector->GetDirection()) {
    case kX:
      return 160;
    case kY:
      return 213;
    default:
      AliError("Unknown sector direction");
      return 0;  
  }    
}

//______________________________________________________________________________
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;
  
  fSectorIterator 
    = fSectorSegmentation
        ->CreateIterator(AliMpArea(TVector2(fXhit/fgkLengthUnit, fYhit/fgkLengthUnit), 
	                           TVector2(dx/fgkLengthUnit, dy/fgkLengthUnit)));

  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()*fgkLengthUnit - 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;
  AliMpVPadIterator* iter
    = fSectorSegmentation
      ->CreateIterator(AliMpArea(pad.Position(),2.*pad.Dimensions()*1.1));

  for( iter->First(); !iter->IsDone() && i<10; iter->Next()) {
    Xlist[i] = iter->CurrentItem().GetIndices().GetFirst();
    Ylist[i] = iter->CurrentItem().GetIndices().GetSecond();
    i++;
  }
  
  delete iter;
}

//______________________________________________________________________________
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/fgkLengthUnit, y/fgkLengthUnit)));
}

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