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

//*********************************************************
//  Segmentation classes for slat modules          
//  This class works with local coordinates
//  of the slats via the class AliMUONGeometrySegmentation
//  This class contains the size of the slats and the
//  and the differents PCB densities. 
//  (from old AliMUONSegmentationSlatModule)
//  Gines, Subatech, Nov04
//*********************************************************

#include <TArrayI.h>
#include <TArrayF.h>
#include "AliMUONSt345SlatSegmentation.h"
#include "AliLog.h"

ClassImp(AliMUONSt345SlatSegmentation)


AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation() 
  : AliMUONVGeometryDESegmentation(),
 	fBending(0),
 	fId(0),
        fNsec(0),
        fNDiv(0),
        fDpxD(0),
        fDpyD(0),
	fDpx(0),
	fDpy(0),
	fNpx(999999),
	fNpy(999999),
	fWireD(0.0),
	fXhit(0.),
	fYhit(0.),
	fIx(0),
	fIy(0),
	fX(0.),
	fY(0.),
	fIxmin(0),
	fIxmax(0),
	fIymin(0),
	fIymax(0)
{
  // default constructor

}

//___________________________________________
AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(Bool_t bending) 
  :     AliMUONVGeometryDESegmentation(),
 	fBending(bending),
 	fId(0),
        fNsec(0),
        fNDiv(0),
        fDpxD(0),
        fDpyD(0),
	fDpx(0),
	fDpy(0),
	fNpx(999999),
	fNpy(999999),
	fWireD(0.25),
	fXhit(0.),
	fYhit(0.),
	fIx(0),
	fIy(0),
	fX(0.),
	fY(0.),
	fIxmin(0),
	fIxmax(0),
	fIymin(0),
	fIymax(0)
{
  // Non default constructor
  fNsec = 4;  // 4 sector densities at most per slat 
  fNDiv = new TArrayI(fNsec);      
  fDpxD = new TArrayF(fNsec);      
  fDpyD = new TArrayF(fNsec);      
  (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;     
  (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;       
  (*fDpyD)[0]=(*fDpyD)[1]=(*fDpyD)[2]=(*fDpyD)[3]=0;       
}
//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs) 
:       AliMUONVGeometryDESegmentation(rhs),
	fBending(0),
 	fId(0),
	fDpx(0),
	fDpy(0),
	fNpx(999999),
	fNpy(999999),
	fWireD(0.25),
	fXhit(0.),
	fYhit(0.),
	fIx(0),
	fIy(0),
	fX(0.),
	fY(0.),
	fIxmin(0),
	fIxmax(0),
	fIymin(0),
	fIymax(0)
{
  // default constructor
}
//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation() 
{
  // Destructor
  if (fNDiv) delete fNDiv;
  if (fDpxD) delete fDpxD;
  if (fDpyD) delete fDpyD;
}
//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
{
  // Protected assignement operator
  if (this == &rhs) return *this;
  AliFatal("Not implemented.");
  return *this;  
}


//------------------------------------------------------------------------
Float_t AliMUONSt345SlatSegmentation::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
  Float_t x,y;
  GetPadC(iX,iY,x,y);
  return (x-X)*(x-X) + (y-Y)*(y-Y);
}
//____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
{
  // Return x-strip width
  return (*fDpxD)[isec];
} 

//____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t  isec) const
{
  // Return y-strip width
  return (*fDpyD)[isec];
}
//_____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
{
  // Returns for a hit position xhit the position of the nearest anode wire    
  Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
  return fWireD*wire;
}


//--------------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y) 
{
  if (ix<1 || ix>Npx() || iy<1 || iy>Npy() ){
    AliWarning(Form("ix %d or iy %d out of boundaries: Npx=%d and Npy=%d",ix, iy, Npx(), Npy()));
    x=-99999.; y=-99999.;
  }
  else { 
    //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
    //  Find sector isec
    Int_t isec = Sector(ix,iy);
    if (isec == -1) AliWarning(Form("isector = %d  with ix %d, iy %d", isec, ix, iy));
    if (iy > fNpyS[isec]) {
      x=-99999.; y=-99999.;
      return;
    }
    if (isec>0) {
      x = fCx[isec-1]+(ix-fNpxS[isec-1])*(*fDpxD)[isec];
      x = x-(*fDpxD)[isec]/2;
      y = Float_t(iy*(*fDpyD)[isec])-(*fDpyD)[isec]/2.- fCy;  // !!!  
    } else {
      x=y=0;
    }
  }
}


//_____________________________________________________________________________
void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy) 
{
//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)

  //  Find sector isec    
  Int_t isec=-1;
  for (Int_t i=fNsec-1; i > 0; i--) {
    if (x >= fCx[i-1]) {
      isec=i;
      if (fCx[isec] == fCx[isec-1]  && isec > 1) isec--;
      break;
    }
  }
  if (isec == -1) AliWarning(Form("isector equal to %d  with xl %f, yl %f", isec, x, y));
  if (isec>0) {
    ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
      +fNpxS[isec-1]+1;
    iy= Int_t((y+fCy)/(*fDpyD)[isec])+1;
  } else if (isec == 0) {
    ix= Int_t(x/(*fDpxD)[isec])+1;
    iy= Int_t((y+fCy)/(*fDpyD)[isec])+1;
  } else {
    ix=0;
    iy=0;
  }
}
//-------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
{
  GetPadI(x, y, ix, iy);
}
//_______________________________________________________________
void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
{
  // Defines the pad size perp. to the anode wire (y) for different sectors. 
  // Pad sizes are defined as integral fractions ndiv of a basis pad size
  // fDpx
  // 
  for (Int_t i=0; i<4; i++) {
    (*fNDiv)[i]=ndiv[i];
  }
  ndiv[0]=ndiv[1];
}
//____________________________________________________________________________
void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
{
  //  Sets the padsize 
  fDpx=p1;
  fDpy=p2;
}
//_______________________________________________________________          
void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
{
  //
  // Set PcbBoard segmentation zones for each density
  // n[0] PcbBoards for maximum density sector fNDiv[0]
  // n[1] PcbBoards for next density sector fNDiv[1] etc ...
  for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
}
//-------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
{
  //
  // Sets virtual pad coordinates, needed for evaluating pad response 
  // outside the tracking program 
  GetPadC(ix,iy,fX,fY);
  fSector=Sector(ix,iy);
}
//---------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
{
  // Set current hit 
  //
  fXhit = x;
  fYhit = y;
    
 //  if (x < 0) fXhit = 0;
//   if (y < 0) fYhit = 0;
    
//   if (x >= fCx[fNsec-1]) fXhit = fCx[fNsec-1];
//   if (y >= fDyPCB)       fYhit = fDyPCB;
    
}
//----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
{
  SetHit(xhit, yhit);
}

//----------------------------------------------------------
void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
{
// Initialises iteration over pads for charge distribution algorithm
//
    //
    // Find the wire position (center of charge distribution)
    Float_t x0a=GetAnod(xhit);
    fXhit=x0a;
    fYhit=yhit;
    //
    // and take fNsigma*sigma around this center
    Float_t x01=x0a  - dx ;
    Float_t x02=x0a  + dx;
    Float_t y01=yhit - dy;
    Float_t y02=yhit + dy;
//     if (x01 < 0) x01 = 0;
//     if (y01 < 0) y01 = 0;

//     if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1];

   
    Int_t isec=-1;
    for (Int_t i=fNsec-1; i > 0; i--) {
	if (x02 >= fCx[i-1]) {
	    isec=i;
	    if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
	    break;
	}
    }
    y02 += Dpy(isec);
    if (y02 >= fDyPCB) y02 = fDyPCB;
   
    //
    // find the pads over which the charge distributes
    GetPadI(x01,y01,fIxmin,fIymin);
    GetPadI(x02,y02,fIxmax,fIymax);
    
    if (fIxmax > fNpx) fIxmax=fNpx;
    if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];    
    if (fIxmin < 1) fIxmin = 1;    // patch for the moment (Ch. Finck)
    if (fIymin < 1) fIymin = 1;    

    fXmin=x01;
    fXmax=x02;    
    fYmin=y01;
    fYmax=y02;    
  
    // 
    // Set current pad to lower left corner
    if (fIxmax < fIxmin) fIxmax=fIxmin;
    if (fIymax < fIymin) fIymax=fIymin;    
    fIx=fIxmin;
    fIy=fIymin;
    
    GetPadC(fIx,fIy,fX,fY);
    fSector=Sector(fIx,fIy);
/*
    printf("\n \n First Pad: %d %d %f %f %d %d %d %f" , 
	   fIxmin, fIxmax, fXmin, fXmax, fNpx, fId, isec, Dpy(isec));    
    printf("\n \n First Pad: %d %d %f %f %d %d %d %f",
	   fIymin, fIymax, fYmin, fYmax,  fNpyS[isec], fId, isec, Dpy(isec));
*/
}


//----------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
{
  FirstPad(xhit, yhit, dx, dy);
}
//----------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::NextPad()
{
  // Stepper for the iteration over pads
  //
  // Step to next pad in the integration region
  //  step from left to right    
  if (fIx != fIxmax) {
    fIx++;
    GetPadC(fIx,fIy,fX,fY);
    fSector=Sector(fIx,fIy);
    //  step up 
  } else if (fIy != fIymax) {
    fIx=fIxmin;
    fIy++;
    GetPadC(fIx,fIy,fX,fY);
    fSector=Sector(fIx,fIy);

  } else {
    fIx=-999;
    fIy=-999;
  }
}
//-------------------------------------------------------------------------
Int_t AliMUONSt345SlatSegmentation::MorePads()
{
  // Stopping condition for the iterator over pads
  //
  // Are there more pads in the integration region
    
  return  (fIx != -999  || fIy != -999);
}
//--------------------------------------------------------------------------
Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy) 
{
  //
  // Determine segmentation zone from pad coordinates
  //
  Int_t isec=-1;
  for (Int_t i=0; i < fNsec; i++) {
    if (ix <= fNpxS[i]) {
      isec=i;
      break;
    }
  }
  if (isec == -1) AliWarning(Form("Sector = %d  with ix %d and iy %d, max padx %d",
				  isec, ix, iy,fNpxS[3]));

  return isec;

}
//-----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::
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);    
  //  printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));

}
//-----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::
Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]) 
{
  // Returns list of next neighbours for given Pad (iX, iY)
  Int_t i=0;
  //  step right
  if (iX+1 <= fNpx) {
    Xlist[i]=iX+1;
    Ylist[i++]=iY;
  }
  //  step left    
  if (iX-1 > 0) {
    Xlist[i]=iX-1;
    Ylist[i++]=iY;
  } 
  Int_t sector = Sector(iX,iY);
  //  step up
  if (iY+1 <= fNpyS[sector]) {
    Xlist[i]=iX;
    Ylist[i++]=iY+1;
  }
  //  step down    
  if (iY-1 > 0) {
    Xlist[i]=iX;
    Ylist[i++]=iY-1;
  }
  *Nlist=i;
}

//--------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
{
  //
  //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
  //  These arrays help in converting from real to pad co-ordinates and
  //  vice versa
  //   
  //  Segmentation is defined by rectangular modules approximating
  //  concentric circles as shown below
  //
  //  PCB module size in cm
  //  printf("\n Initialise Segmentation SlatModule \n");

  
  //  printf(" fBending: %d \n",fBending);

  fDxPCB=40;
  fDyPCB=40;

  //  Calculate padsize along x
  (*fDpxD)[fNsec-1]=fDpx;
  (*fDpyD)[fNsec-1]=fDpy;
  if (fNsec > 1) {
    for (Int_t i=fNsec-1; i>=0; i--){ // fNsec-2
      if (!fBending) {
	(*fDpxD)[i]=fDpx;
	(*fDpyD)[i]=(*fDpyD)[fNsec-1]/(*fNDiv)[i];
      } else {
	(*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
	(*fDpyD)[i]=fDpy;
      }
    }
  }
  //
  // fill the arrays defining the pad segmentation boundaries
  //
  //  
  //  Loop over sectors (isec=0 for secto close to the beam pipe)
  Float_t totalLength = 0;
  for (Int_t isec=0; isec<4; isec++) totalLength += fPcbBoards[isec]*fDxPCB;  // !!!!

  fNpy = 0;   // maximum number of pads in y
  for (Int_t isec=0; isec<4; isec++) {
    if (isec==0) {
      fNpxS[0] = 0;
      fNpyS[0] = 0;
      fCx[0]   = -totalLength/2;
    } else {
      fNpxS[isec] = fNpxS[isec-1] + fPcbBoards[isec]*Int_t(fDxPCB/(*fDpxD)[isec]); 
      fNpyS[isec] = Int_t(fDyPCB/(*fDpyD)[isec]);
      if (fNpyS[isec] >= fNpy) fNpy = fNpyS[isec]; 
      fCx[isec]= fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
    }
  } // sectors

  fNpx = fNpxS[3];  // maximum number of pads in x
  fCy = fDyPCB/2.;
  //
  fId = detectionElementId;
}
Commit	Line	Data
cc4dcfb0	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	// Segmentation classes for slat modules
	20	// This class works with local coordinates
	21	// of the slats via the class AliMUONGeometrySegmentation
	22	// This class contains the size of the slats and the
	23	// and the differents PCB densities.
	24	// (from old AliMUONSegmentationSlatModule)
	25	// Gines, Subatech, Nov04
	26	//*********************************************************
	27
	28	#include <TArrayI.h>
	29	#include <TArrayF.h>
	30	#include "AliMUONSt345SlatSegmentation.h"
	31	#include "AliLog.h"
	32
cc4dcfb0	33	ClassImp(AliMUONSt345SlatSegmentation)
	34
	35
a713db22	36	AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation()
	37	: AliMUONVGeometryDESegmentation(),
	38	fBending(0),
	39	fId(0),
6b9de626	40	fNsec(0),
	41	fNDiv(0),
	42	fDpxD(0),
	43	fDpyD(0),
a713db22	44	fDpx(0),
	45	fDpy(0),
	46	fNpx(999999),
	47	fNpy(999999),
	48	fWireD(0.0),
	49	fXhit(0.),
	50	fYhit(0.),
	51	fIx(0),
	52	fIy(0),
	53	fX(0.),
	54	fY(0.),
	55	fIxmin(0),
	56	fIxmax(0),
	57	fIymin(0),
	58	fIymax(0)
	59	{
	60	// default constructor
	61
	62	}
	63
	64	//___________________________________________
f48459ab	65	AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(Bool_t bending)
fed772f3	66	: AliMUONVGeometryDESegmentation(),
f48459ab	67	fBending(bending),
f48459ab	68	fId(0),
6b9de626	69	fNsec(0),
	70	fNDiv(0),
	71	fDpxD(0),
	72	fDpyD(0),
f48459ab	73	fDpx(0),
	74	fDpy(0),
	75	fNpx(999999),
	76	fNpy(999999),
	77	fWireD(0.25),
	78	fXhit(0.),
	79	fYhit(0.),
	80	fIx(0),
	81	fIy(0),
	82	fX(0.),
	83	fY(0.),
	84	fIxmin(0),
	85	fIxmax(0),
	86	fIymin(0),
	87	fIymax(0)
cc4dcfb0	88	{
f48459ab	89	// Non default constructor
cc4dcfb0	90	fNsec = 4; // 4 sector densities at most per slat
	91	fNDiv = new TArrayI(fNsec);
	92	fDpxD = new TArrayF(fNsec);
f48459ab	93	fDpyD = new TArrayF(fNsec);
cc4dcfb0	94	(fNDiv)[0]=(fNDiv)[1]=(fNDiv)[2]=(fNDiv)[3]=0;
cc4dcfb0	95	(fDpxD)[0]=(fDpxD)[1]=(fDpxD)[2]=(fDpxD)[3]=0;
f48459ab	96	(fDpyD)[0]=(fDpyD)[1]=(fDpyD)[2]=(fDpyD)[3]=0;
cc4dcfb0	97	}
cc4dcfb0	98	//----------------------------------------------------------------------
fed772f3	99	AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs)
	100	: AliMUONVGeometryDESegmentation(rhs),
	101	fBending(0),
	102	fId(0),
	103	fDpx(0),
	104	fDpy(0),
	105	fNpx(999999),
	106	fNpy(999999),
	107	fWireD(0.25),
	108	fXhit(0.),
	109	fYhit(0.),
	110	fIx(0),
	111	fIy(0),
	112	fX(0.),
	113	fY(0.),
	114	fIxmin(0),
	115	fIxmax(0),
	116	fIymin(0),
	117	fIymax(0)
cc4dcfb0	118	{
fed772f3	119	// default constructor
cc4dcfb0	120	}
	121	//----------------------------------------------------------------------
	122	AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation()
	123	{
f48459ab	124	// Destructor
	125	if (fNDiv) delete fNDiv;
	126	if (fDpxD) delete fDpxD;
	127	if (fDpyD) delete fDpyD;
cc4dcfb0	128	}
	129	//----------------------------------------------------------------------
	130	AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
	131	{
f48459ab	132	// Protected assignement operator
cc4dcfb0	133	if (this == &rhs) return *this;
	134	AliFatal("Not implemented.");
	135	return *this;
	136	}
	137
	138
	139	//------------------------------------------------------------------------
	140	Float_t AliMUONSt345SlatSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * /dummy/)
	141	{
f48459ab	142	// Returns the square of the distance between 1 pad
f48459ab	143	// labelled by its Channel numbers and a coordinate
cc4dcfb0	144	Float_t x,y;
	145	GetPadC(iX,iY,x,y);
	146	return (x-X)(x-X) + (y-Y)(y-Y);
	147	}
	148	//____________________________________________________________________________
	149	Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
	150	{
f48459ab	151	// Return x-strip width
f48459ab	152	return (*fDpxD)[isec];
cc4dcfb0	153	}
	154
	155	//____________________________________________________________________________
f48459ab	156	Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t isec) const
cc4dcfb0	157	{
cc4dcfb0	158	// Return y-strip width
f48459ab	159	return (*fDpyD)[isec];
cc4dcfb0	160	}
	161	//_____________________________________________________________________________
	162	Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
	163	{
f48459ab	164	// Returns for a hit position xhit the position of the nearest anode wire
	165	Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
	166	return fWireD*wire;
cc4dcfb0	167	}
cc4dcfb0	168
cc4dcfb0	169
f48459ab	170
cc4dcfb0	171	//--------------------------------------------------------------------------------
	172	void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
	173	{
	174	if (ix<1 \|\| ix>Npx() \|\| iy<1 \|\| iy>Npy() ){
f7db2071	175	AliWarning(Form("ix %d or iy %d out of boundaries: Npx=%d and Npy=%d",ix, iy, Npx(), Npy()));
cc4dcfb0	176	x=-99999.; y=-99999.;
	177	}
	178	else {
	179	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
cc4dcfb0	180	// Find sector isec
cc4dcfb0	181	Int_t isec = Sector(ix,iy);
76fa1113	182	if (isec == -1) AliWarning(Form("isector = %d with ix %d, iy %d", isec, ix, iy));
f48459ab	183	if (iy > fNpyS[isec]) {
	184	x=-99999.; y=-99999.;
	185	return;
	186	}
cc4dcfb0	187	if (isec>0) {
	188	x = fCx[isec-1]+(ix-fNpxS[isec-1])(fDpxD)[isec];
	189	x = x-(*fDpxD)[isec]/2;
f48459ab	190	y = Float_t(iy(fDpyD)[isec])-(*fDpyD)[isec]/2.- fCy; // !!!
cc4dcfb0	191	} else {
	192	x=y=0;
	193	}
	194	}
	195	}
f48459ab	196
	197
	198	//_____________________________________________________________________________
	199	void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
	200	{
	201	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
76fa1113	202
f48459ab	203	// Find sector isec
	204	Int_t isec=-1;
	205	for (Int_t i=fNsec-1; i > 0; i--) {
	206	if (x >= fCx[i-1]) {
	207	isec=i;
	208	if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
	209	break;
	210	}
	211	}
f7db2071	212	if (isec == -1) AliWarning(Form("isector equal to %d with xl %f, yl %f", isec, x, y));
f48459ab	213	if (isec>0) {
	214	ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
	215	+fNpxS[isec-1]+1;
	216	iy= Int_t((y+fCy)/(*fDpyD)[isec])+1;
	217	} else if (isec == 0) {
	218	ix= Int_t(x/(*fDpxD)[isec])+1;
	219	iy= Int_t((y+fCy)/(*fDpyD)[isec])+1;
	220	} else {
	221	ix=0;
	222	iy=0;
	223	}
	224	}
cc4dcfb0	225	//-------------------------------------------------------------------------
	226	void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /z/, Int_t &ix, Int_t &iy)
	227	{
	228	GetPadI(x, y, ix, iy);
	229	}
	230	//_______________________________________________________________
	231	void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
	232	{
f48459ab	233	// Defines the pad size perp. to the anode wire (y) for different sectors.
	234	// Pad sizes are defined as integral fractions ndiv of a basis pad size
	235	// fDpx
	236	//
	237	for (Int_t i=0; i<4; i++) {
	238	(*fNDiv)[i]=ndiv[i];
	239	}
	240	ndiv[0]=ndiv[1];
cc4dcfb0	241	}
	242	//____________________________________________________________________________
	243	void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
	244	{
f48459ab	245	// Sets the padsize
	246	fDpx=p1;
	247	fDpy=p2;
cc4dcfb0	248	}
	249	//_______________________________________________________________
	250	void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
	251	{
f48459ab	252	//
	253	// Set PcbBoard segmentation zones for each density
	254	// n[0] PcbBoards for maximum density sector fNDiv[0]
	255	// n[1] PcbBoards for next density sector fNDiv[1] etc ...
	256	for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
cc4dcfb0	257	}
	258	//-------------------------------------------------------------------------
	259	void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
	260	{
f48459ab	261	//
	262	// Sets virtual pad coordinates, needed for evaluating pad response
	263	// outside the tracking program
	264	GetPadC(ix,iy,fX,fY);
	265	fSector=Sector(ix,iy);
cc4dcfb0	266	}
	267	//---------------------------------------------------------------------------
	268	void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
	269	{
f48459ab	270	// Set current hit
	271	//
	272	fXhit = x;
	273	fYhit = y;
cc4dcfb0	274
f7db2071	275	// if (x < 0) fXhit = 0;
f7db2071	276	// if (y < 0) fYhit = 0;
cc4dcfb0	277
f7db2071	278	// if (x >= fCx[fNsec-1]) fXhit = fCx[fNsec-1];
f7db2071	279	// if (y >= fDyPCB) fYhit = fDyPCB;
cc4dcfb0	280
	281	}
	282	//----------------------------------------------------------------------------
	283	void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /zhit/)
	284	{
	285	SetHit(xhit, yhit);
	286	}
f48459ab	287
cc4dcfb0	288	//----------------------------------------------------------
	289	void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
	290	{
	291	// Initialises iteration over pads for charge distribution algorithm
	292	//
	293	//
	294	// Find the wire position (center of charge distribution)
	295	Float_t x0a=GetAnod(xhit);
	296	fXhit=x0a;
	297	fYhit=yhit;
	298	//
	299	// and take fNsigma*sigma around this center
76fa1113	300	Float_t x01=x0a - dx ;
cc4dcfb0	301	Float_t x02=x0a + dx;
	302	Float_t y01=yhit - dy;
	303	Float_t y02=yhit + dy;
f7db2071	304	// if (x01 < 0) x01 = 0;
76fa1113	305	// if (y01 < 0) y01 = 0;
cc4dcfb0	306
76fa1113	307	// if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1];
cc4dcfb0	308
	309
	310	Int_t isec=-1;
	311	for (Int_t i=fNsec-1; i > 0; i--) {
	312	if (x02 >= fCx[i-1]) {
	313	isec=i;
	314	if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
	315	break;
	316	}
	317	}
	318	y02 += Dpy(isec);
	319	if (y02 >= fDyPCB) y02 = fDyPCB;
	320
	321	//
	322	// find the pads over which the charge distributes
	323	GetPadI(x01,y01,fIxmin,fIymin);
	324	GetPadI(x02,y02,fIxmax,fIymax);
	325
	326	if (fIxmax > fNpx) fIxmax=fNpx;
	327	if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];
f7db2071	328	if (fIxmin < 1) fIxmin = 1; // patch for the moment (Ch. Finck)
f7db2071	329	if (fIymin < 1) fIymin = 1;
cc4dcfb0	330
	331	fXmin=x01;
	332	fXmax=x02;
	333	fYmin=y01;
	334	fYmax=y02;
	335
	336	//
	337	// Set current pad to lower left corner
	338	if (fIxmax < fIxmin) fIxmax=fIxmin;
	339	if (fIymax < fIymin) fIymax=fIymin;
	340	fIx=fIxmin;
	341	fIy=fIymin;
	342
	343	GetPadC(fIx,fIy,fX,fY);
	344	fSector=Sector(fIx,fIy);
	345	/*
	346	printf("\n \n First Pad: %d %d %f %f %d %d %d %f" ,
	347	fIxmin, fIxmax, fXmin, fXmax, fNpx, fId, isec, Dpy(isec));
	348	printf("\n \n First Pad: %d %d %f %f %d %d %d %f",
	349	fIymin, fIymax, fYmin, fYmax, fNpyS[isec], fId, isec, Dpy(isec));
	350	*/
	351	}
f48459ab	352
	353
	354
cc4dcfb0	355	//----------------------------------------------------------------------
	356	void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /zhit/, Float_t dx, Float_t dy)
	357	{
	358	FirstPad(xhit, yhit, dx, dy);
	359	}
	360	//----------------------------------------------------------------------
	361	void AliMUONSt345SlatSegmentation::NextPad()
	362	{
f48459ab	363	// Stepper for the iteration over pads
	364	//
	365	// Step to next pad in the integration region
	366	// step from left to right
	367	if (fIx != fIxmax) {
	368	fIx++;
	369	GetPadC(fIx,fIy,fX,fY);
	370	fSector=Sector(fIx,fIy);
	371	// step up
	372	} else if (fIy != fIymax) {
	373	fIx=fIxmin;
	374	fIy++;
	375	GetPadC(fIx,fIy,fX,fY);
	376	fSector=Sector(fIx,fIy);
cc4dcfb0	377
f48459ab	378	} else {
f7db2071	379	fIx=-999;
f7db2071	380	fIy=-999;
f48459ab	381	}
cc4dcfb0	382	}
	383	//-------------------------------------------------------------------------
	384	Int_t AliMUONSt345SlatSegmentation::MorePads()
	385	{
f48459ab	386	// Stopping condition for the iterator over pads
	387	//
	388	// Are there more pads in the integration region
cc4dcfb0	389
f7db2071	390	return (fIx != -999 \|\| fIy != -999);
cc4dcfb0	391	}
	392	//--------------------------------------------------------------------------
	393	Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy)
	394	{
f48459ab	395	//
	396	// Determine segmentation zone from pad coordinates
	397	//
	398	Int_t isec=-1;
	399	for (Int_t i=0; i < fNsec; i++) {
	400	if (ix <= fNpxS[i]) {
	401	isec=i;
	402	break;
cc4dcfb0	403	}
f48459ab	404	}
f7db2071	405	if (isec == -1) AliWarning(Form("Sector = %d with ix %d and iy %d, max padx %d",
f7db2071	406	isec, ix, iy,fNpxS[3]));
cc4dcfb0	407
f48459ab	408	return isec;
cc4dcfb0	409
	410	}
	411	//-----------------------------------------------------------------------------
	412	void AliMUONSt345SlatSegmentation::
	413	IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
	414	{
f48459ab	415	// Returns integration limits for current pad
	416	//
	417	x1=fXhit-fX-Dpx(fSector)/2.;
	418	x2=x1+Dpx(fSector);
	419	y1=fYhit-fY-Dpy(fSector)/2.;
	420	y2=y1+Dpy(fSector);
76fa1113	421	// printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
cc4dcfb0	422
	423	}
	424	//-----------------------------------------------------------------------------
	425	void AliMUONSt345SlatSegmentation::
	426	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
	427	{
f48459ab	428	// Returns list of next neighbours for given Pad (iX, iY)
	429	Int_t i=0;
	430	// step right
	431	if (iX+1 <= fNpx) {
	432	Xlist[i]=iX+1;
	433	Ylist[i++]=iY;
	434	}
	435	// step left
	436	if (iX-1 > 0) {
	437	Xlist[i]=iX-1;
	438	Ylist[i++]=iY;
	439	}
	440	Int_t sector = Sector(iX,iY);
	441	// step up
	442	if (iY+1 <= fNpyS[sector]) {
	443	Xlist[i]=iX;
	444	Ylist[i++]=iY+1;
	445	}
	446	// step down
	447	if (iY-1 > 0) {
	448	Xlist[i]=iX;
	449	Ylist[i++]=iY-1;
	450	}
	451	*Nlist=i;
cc4dcfb0	452	}
f48459ab	453
cc4dcfb0	454	//--------------------------------------------------------------------------
	455	void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
	456	{
f48459ab	457	//
	458	// Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
	459	// These arrays help in converting from real to pad co-ordinates and
	460	// vice versa
	461	//
	462	// Segmentation is defined by rectangular modules approximating
	463	// concentric circles as shown below
	464	//
	465	// PCB module size in cm
	466	// printf("\n Initialise Segmentation SlatModule \n");
cc4dcfb0	467
f48459ab	468
a713db22	469	// printf(" fBending: %d \n",fBending);
f48459ab	470
	471	fDxPCB=40;
	472	fDyPCB=40;
	473
	474	// Calculate padsize along x
	475	(*fDpxD)[fNsec-1]=fDpx;
	476	(*fDpyD)[fNsec-1]=fDpy;
	477	if (fNsec > 1) {
	478	for (Int_t i=fNsec-1; i>=0; i--){ // fNsec-2
	479	if (!fBending) {
	480	(*fDpxD)[i]=fDpx;
	481	(fDpyD)[i]=(fDpyD)[fNsec-1]/(*fNDiv)[i];
	482	} else {
cc4dcfb0	483	(fDpxD)[i]=(fDpxD)[fNsec-1]/(*fNDiv)[i];
f48459ab	484	(*fDpyD)[i]=fDpy;
cc4dcfb0	485	}
cc4dcfb0	486	}
f48459ab	487	}
	488	//
	489	// fill the arrays defining the pad segmentation boundaries
	490	//
	491	//
	492	// Loop over sectors (isec=0 for secto close to the beam pipe)
	493	Float_t totalLength = 0;
	494	for (Int_t isec=0; isec<4; isec++) totalLength += fPcbBoards[isec]*fDxPCB; // !!!!
	495
	496	fNpy = 0; // maximum number of pads in y
	497	for (Int_t isec=0; isec<4; isec++) {
	498	if (isec==0) {
	499	fNpxS[0] = 0;
	500	fNpyS[0] = 0;
	501	fCx[0] = -totalLength/2;
	502	} else {
	503	fNpxS[isec] = fNpxS[isec-1] + fPcbBoards[isec]Int_t(fDxPCB/(fDpxD)[isec]);
	504	fNpyS[isec] = Int_t(fDyPCB/(*fDpyD)[isec]);
	505	if (fNpyS[isec] >= fNpy) fNpy = fNpyS[isec];
	506	fCx[isec]= fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
	507	}
	508	} // sectors
cc4dcfb0	509
f48459ab	510	fNpx = fNpxS[3]; // maximum number of pads in x
	511	fCy = fDyPCB/2.;
	512	//
	513	fId = detectionElementId;
	514	}
cc4dcfb0	515
	516
	517
	518
	519
	520
	521
	522
	523
	524
	525