[u/mrichter/AliRoot.git] / MUON / AliMUONSegmentationV01.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 and Response classes version 01   //
/////////////////////////////////////////////////////

#include <TBox.h> 
#include <TTUBE.h>
#include <TBRIK.h>
#include <TNode.h>  
#include <TGeometry.h>  
#include <TF1.h> 
#include <TVector3.h> 
#include <TObjArray.h>

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


//___________________________________________
ClassImp(AliMUONSegmentationV01)

AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
  : AliMUONSegmentationV0(segmentation)
{
// Protected copy constructor

  AliFatal("Not implemented.");
}

AliMUONSegmentationV01::AliMUONSegmentationV01() 
  : AliMUONSegmentationV0()
{
// Default constructor
    fRSec = 0;
    fNDiv = 0;      
    fDpxD = 0;
    fCorrA = 0;
    fSector = -1;
}

AliMUONSegmentationV01::AliMUONSegmentationV01(Int_t nsec) 
  : AliMUONSegmentationV0()
{
//  Non default constructor

    fNsec = nsec;
    fRSec = new TArrayF(fNsec);
    fNDiv = new TArrayI(fNsec);      
    fDpxD = new TArrayF(fNsec);      


    (*fRSec)[0]=(*fRSec)[1]=(*fRSec)[2]=(*fRSec)[3]=0;     
    (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;     
    (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;     
    fCorrA = new TObjArray(3);
    fCorrA->AddAt(0,0);
    fCorrA->AddAt(0,1);
    fCorrA->AddAt(0,2);
    fOffsetY=0;
    fSector = -1;
} 

AliMUONSegmentationV01::~AliMUONSegmentationV01() 
{
// Destructor
    if (fRSec) delete fRSec;
    if (fNDiv) delete fNDiv;
    if (fDpxD) delete fDpxD;
    if (fCorrA) {
	fCorrA->Delete();
	delete fCorrA;
    }
} 


Float_t AliMUONSegmentationV01::Dpx(Int_t isec) const
{
//
// Returns x-pad size for given sector isec
   Float_t dpx = (*fDpxD)[isec];
   return dpx;
}

Float_t AliMUONSegmentationV01::Dpy(Int_t /*isec*/) const
{
//
// Returns y-pad size for given sector isec
   return fDpy;
}
    
void   AliMUONSegmentationV01::SetSegRadii(Float_t  r[4])
{
//
// Set the radii of the segmentation zones 
    for (Int_t i=0; i<4; i++) {
	(*fRSec)[i]=r[i];
    }
}


void AliMUONSegmentationV01::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 AliMUONSegmentationV01::Init(Int_t chamber)
{
//
//  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.
//  This version approximates concentric segmentation zones
//

    Int_t isec;
    //printf("\n Initialise Segmentation V01\n");


    fNpy=Int_t((*fRSec)[fNsec-1]/fDpy)+1;

    (*fDpxD)[fNsec-1]=fDpx;
    if (fNsec > 1) {
	for (Int_t i=fNsec-2; i>=0; i--){
	    (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
	}
    }
//
// fill the arrays defining the pad segmentation boundaries
    Float_t ry;
    Int_t   dnx;
    Int_t   add;
//
//  loop over sections
    for(isec=0; isec<fNsec; isec++) {
//  
//  loop over pads along the aode wires
	for (Int_t iy=1; iy<=fNpy; iy++) {
//
	    Float_t x=iy*fDpy-fDpy/2;
	    if (x > (*fRSec)[isec]) {
		fNpxS[isec][iy]=0;
		fCx[isec][iy]=0;
	    } else {
		ry=TMath::Sqrt((*fRSec)[isec]*(*fRSec)[isec]-x*x);
		if (isec > 1) {
		    dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
		    if (isec < fNsec-1) {
			if (TMath::Odd((Long_t)dnx)) dnx++;    		
		    }
                    fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
          	    fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
		} else if (isec == 1) {
		    dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
		    fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
                    add=4 - (fNpxS[isec][iy])%4;
                    if (add < 4) fNpxS[isec][iy]+=add; 
		    dnx=fNpxS[isec][iy]-fNpxS[isec-1][iy];
		    fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
		} else {
		    dnx=Int_t(ry/(*fDpxD)[isec]);
                    fNpxS[isec][iy]=dnx;
		    fCx[isec][iy]=dnx*(*fDpxD)[isec];
		}
	    }
	} // y-pad loop
    } // sector loop

// reference to chamber
    AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
    fChamber=&(pMUON->Chamber(chamber));
    fRmin=fChamber->RInner();
    fRmax=fChamber->ROuter();    
    fCorr=0;
    fZ = fChamber->Z();
    fId=chamber;
}

//______________________________________________________________________
Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
{
// Returns sector number for given pad position
//
    Int_t absix=TMath::Abs(ix);
    Int_t absiy=TMath::Abs(iy);
    Int_t isec=0;
    for (Int_t i=0; i<fNsec; i++) {
	if (absix<=fNpxS[i][absiy]){
	    isec=i;
	    break;
	}
    }
    return isec;
}

//______________________________________________________________________
void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
{
//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
//
    iy = (y-fOffsetY >0)? 
      Int_t((y-fOffsetY)/fDpy)+1 
      : 
      Int_t((y-fOffsetY)/fDpy)-1;
  
    if (iy >  fNpy) iy= fNpy;
    if (iy < -fNpy) iy=-fNpy;
//
//  Find sector isec
    Int_t isec=-1;
    Float_t absx=TMath::Abs(x);
    Int_t absiy=TMath::Abs(iy);
    for (Int_t i=0; i < fNsec; i++) {
	if (absx <= fCx[i][absiy]) {
	    isec=i;
	    break;
	}
    }
    if (isec>0) {
	ix= Int_t((absx-fCx[isec-1][absiy])/(*fDpxD)[isec])
	    +fNpxS[isec-1][absiy]+1;
    } else if (isec == 0) {
	ix= Int_t(absx/(*fDpxD)[isec])+1;
    } else {
	ix=fNpxS[fNsec-1][absiy]+1;	
    }
    ix = (x>0) ? ix:-ix;
}
//________________________________________________________________
void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy) 
{
  GetPadI(x, y, ix, iy);
}
//________________________________________________________________

void AliMUONSegmentationV01::
GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
{
//  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
//
    y = (iy>0) ?
      Float_t(iy*fDpy)-fDpy/2.+fOffsetY
      :
      Float_t(iy*fDpy)+fDpy/2.+fOffsetY; 

//
//  Find sector isec
    Int_t isec=AliMUONSegmentationV01::Sector(ix,iy);
//
    Int_t absix=TMath::Abs(ix);
    Int_t absiy=TMath::Abs(iy);
    if (isec) {
	x=fCx[isec-1][absiy]+(absix-fNpxS[isec-1][absiy])*(*fDpxD)[isec];
	x=(ix>0) ?  x-(*fDpxD)[isec]/2 : -x+(*fDpxD)[isec]/2;
    } else {
	x=y=0;
    }

}
//________________________________________________________________

void AliMUONSegmentationV01::
GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z)
{
//  Returns real coordinates (x,y,z) for given pad coordinates (ix,iy)
//
  GetPadC(ix,iy,x,y); 
    
  // To be properly interfaced with chamber geometry (AliMUONSt1GeometryBuilderV2) ???
  TVector3 scale[4];  
  scale[0] = TVector3( 1,  1,  1);  // quadrant I
  scale[1] = TVector3(-1,  1, -1);  // quadrant II
  scale[2] = TVector3(-1, -1,  1);  // quadrant III
  scale[3] = TVector3( 1, -1, -1);  // quadrant IV

  Int_t iQuadrant;
  
  if (ix > 0) {
    if (iy > 0) {
      iQuadrant = 0;
    } else {
      iQuadrant = 3;
    }
  } else {
    if (iy > 0) {
      iQuadrant = 1;
    } else {
      iQuadrant = 2;
    }
  }      
  if (TMath::Abs(fZ) <  600) {
    z = fZ + scale[iQuadrant].Z()*6.5/2.; // Station 1
  } else {
    z = fZ;  // Station 2
  }
}

void AliMUONSegmentationV01::
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 AliMUONSegmentationV01::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;
    //
    // find the pads over which the charge distributes

    GetPadI(x01,y01,fIxmin,fIymin);
    GetPadI(x02,y02,fIxmax,fIymax);
    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);

    // added 
    if (fSector == -1) {
      fSector=Sector(fIx,fIy);
    }
}


void AliMUONSegmentationV01::NextPad()
{
// Stepper for the iteration over pads
//
// Step to next pad in the integration region
  // 
  // Step to next pad in integration region
    Float_t xc,yc;
    Int_t   iyc;
    
//  step from left to right    

    if (fX < fXmax && fX != 0) {
	if (fIx==-1) fIx++;
	fIx++;
//  step up 
    } else if (fIy != fIymax) {
	if (fIy==-1) fIy++;
	fIy++;
//      get y-position of next row (yc), xc not used here 	
	GetPadC(fIx,fIy,xc,yc);
//      get x-pad coordiante for first pad in row (fIx)
	GetPadI(fXmin,yc,fIx,iyc);
    } else {
	fIx=-1;
	fIy=-1;
    }
    GetPadC(fIx,fIy,fX,fY);
    fSector=Sector(fIx,fIy);
    if (MorePads() && 
	(fSector ==-1 || fSector==0)) 
	NextPad();
}

Int_t AliMUONSegmentationV01::MorePads()

{
// Stopping condition for the iterator over pads
//
// Are there more pads in the integration region
    return  (fIx != -1  || fIy != -1);
/*
    if ((fX >= fXmax  && fIy >= fIymax) || fY==0) {
	return 0;
    } else {
	return 1;
    }
*/
}
//______________________________________________________________________
void AliMUONSegmentationV01::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
{
  FirstPad(xhit, yhit, dx, dy);
}


void AliMUONSegmentationV01::
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);    
}

void AliMUONSegmentationV01::
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)
//
    const Float_t kEpsilon=fDpy/1000;
    
    Float_t x,y;
    Int_t   ixx, iyy, isec1;
//
    Int_t   isec0=AliMUONSegmentationV01::Sector(iX,iY);
    Int_t i=0;
//    
//  step right
    Xlist[i]=iX+1;
    if (Xlist[i]==0) Xlist[i]++;
    Ylist[i++]=iY;
//
//  step left    
    Xlist[i]=iX-1;
    if (Xlist[i]==0) Xlist[i]--;
    Ylist[i++]=iY;
//
//  step up 
    AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
    AliMUONSegmentationV01::GetPadI(x+kEpsilon,y+fDpy,ixx,iyy);
    Xlist[i]=ixx;
    Ylist[i++]=iyy;
    isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
    if (isec1==isec0) {
//
//  no sector boundary crossing
//	Xlist[i]=ixx+1;
//	Ylist[i++]=iY+1;
	
//	Xlist[i]=ixx-1;
//	Ylist[i++]=iY+1;
    } else if (isec1 < isec0) {
// finer segmentation
//	Xlist[i]=ixx+1;
//	Ylist[i++]=iY+1;
	
	Xlist[i]=ixx-1;
	Ylist[i++]=iyy;
	
//	Xlist[i]=ixx-2;
//	Ylist[i++]=iY+1;
    } else {
// coarser segmenation	
/*
	if (TMath::Odd(iX-fNpxS[isec1-1][iY+1])) {
	    Xlist[i]=ixx-1;
	    Ylist[i++]=iY+1;
	} else {
	    Xlist[i]=ixx+1;
	    Ylist[i++]=iY+1;
	}
*/
    }

//
// step down 
    AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
    AliMUONSegmentationV01::GetPadI(x+kEpsilon,y-fDpy,ixx,iyy);
    Xlist[i]=ixx;
    Ylist[i++]=iyy;
    isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
    if (isec1==isec0) {
//
//  no sector boundary crossing
/*
    Xlist[i]=ixx+1;
    Ylist[i++]=iY-1;
	
    Xlist[i]=ixx-1;
    Ylist[i++]=iY-1;
*/
    } else if (isec1 < isec0) {
// finer segmentation
//	Xlist[i]=ixx+1;
//	Ylist[i++]=iY-1;
	
	Xlist[i]=ixx-1;
	Ylist[i++]=iyy;
	
//	Xlist[i]=ixx-2;
//	Ylist[i++]=iY-1;
    } else {
// coarser segmentation	
/*
	if (TMath::Odd(iX-fNpxS[isec1-1][iY-1])) {
	    Xlist[i]=ixx-1;
	    Ylist[i++]=iY-1;
	} else {
	    Xlist[i]=ixx+1;
	    Ylist[i++]=iY-1;
	}
*/
    }
    *Nlist=i;
}

void AliMUONSegmentationV01::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
{
// Returns test point on the pad plane.
// Used during determination of the segmoid correction of the COG-method

    n=3;
    x[0]=((*fRSec)[0]+(*fRSec)[1])/2/TMath::Sqrt(2.);
    y[0]=x[0];
    x[1]=((*fRSec)[1]+(*fRSec)[2])/2/TMath::Sqrt(2.);
    y[1]=x[1];
    x[2]=((*fRSec)[2]+(*fRSec)[3])/2/TMath::Sqrt(2.);
    y[2]=x[2];
}

void AliMUONSegmentationV01::Draw(const char* opt)
{
 
// Draws the segmentation zones
//
  if (!strcmp(opt,"eventdisplay")) { 
    const int kColorMUON  = kBlue;

    TRotMatrix* rot000 = new TRotMatrix("Rot000"," ", 90,  0, 90, 90, 0, 0);
    TRotMatrix* rot090 = new TRotMatrix("Rot090"," ", 90, 90, 90,180, 0, 0);
    TRotMatrix* rot180 = new TRotMatrix("Rot180"," ", 90,180, 90,270, 0, 0);
    TRotMatrix* rot270 = new TRotMatrix("Rot270"," ", 90,270, 90,  0, 0, 0);

    char nameChamber[9], nameSense[9], nameFrame[9], nameNode[9];
    char nameSense1[9], nameSense2[9];    
    TNode *node, *nodeF;
 
    sprintf(nameChamber,"C_MUON%d",fId+1);
    sprintf(nameSense,"S_MUON%d",fId+1);
    sprintf(nameSense1,"S1_MUON%d",fId+1);
    sprintf(nameSense2,"S2_MUON%d",fId+1);
    sprintf(nameFrame,"F_MUON%d",fId+1);	

    TNode* top=gAlice->GetGeometry()->GetNode("alice");

    Float_t rmin = (*fRSec)[0]-3;
    Float_t rmax = (*fRSec)[3]+3;
    new TTUBE(nameChamber,"Mother","void",rmin,rmax,0.25,1.);
    rmin = (*fRSec)[0];
    rmax = (*fRSec)[3];
    new TTUBE(nameSense,"Sens. region","void",rmin,rmax,0.25, 1.);
    Float_t dx=(rmax-rmin)/2;
    Float_t dy=3.;
    Float_t dz=0.25;
    TBRIK* frMUON = new TBRIK(nameFrame,"Frame","void",dx,dy,dz);
    top->cd();
    sprintf(nameNode,"MUON%d",100+fId+1);
    node = new TNode(nameNode,"ChamberNode",nameChamber,0,0,fChamber->Z(),"");
    node->SetLineColor(kColorMUON);
    AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
    (pMUON->Nodes())->Add(node);
    node->cd();
    sprintf(nameNode,"MUON%d",200+fId+1);
    node = new TNode(nameNode,"Sens. Region Node",nameSense,0,0,0,"");
    node->SetLineColor(kColorMUON);
    node->cd();
    Float_t dr=dx+rmin;
    sprintf(nameNode,"MUON%d",300+fId+1);
    nodeF = new TNode(nameNode,"Frame0",frMUON,dr, 0, 0,rot000,"");
    nodeF->SetLineColor(kColorMUON);
    node->cd();
    sprintf(nameNode,"MUON%d",400+fId+1);
    nodeF = new TNode(nameNode,"Frame1",frMUON,0 ,dr,0,rot090,"");
    nodeF->SetLineColor(kColorMUON);
    node->cd();
    sprintf(nameNode,"MUON%d",500+fId+1);
    nodeF = new TNode(nameNode,"Frame2",frMUON,-dr,0,0,rot180,"");
    nodeF->SetLineColor(kColorMUON);
    node  ->cd();
    sprintf(nameNode,"MUON%d",600+fId+1);   
    nodeF = new TNode(nameNode,"Frame3",frMUON,0,-dr,0,rot270,"");
    nodeF->SetLineColor(kColorMUON);   
  } else {
    TBox *box;
    
    Float_t dx=0.95/fCx[3][1]/2;
    Float_t dy=0.95/(Float_t(Npy()))/2;
    Float_t x0,y0,x1,y1;
    Float_t xc=0.5;
    Float_t yc=0.5;
    
    for (Int_t iy=1; iy<Npy(); iy++) {
      for (Int_t isec=0; isec<4; isec++) {
	if (isec==0) {
	  x0=0;
	  x1=fCx[isec][iy]*dx;
	} else {
	  x0=fCx[isec-1][iy]*dx;
	  x1=fCx[isec][iy]*dx;
	}
	y0=Float_t(iy-1)*dy;
	y1=y0+dy;
	box=new TBox(x0+xc,y0+yc,x1+xc,y1+yc);
	box->SetFillColor(isec+1);
	box->Draw();
	
	box=new TBox(-x1+xc,y0+yc,-x0+xc,y1+yc);
	box->SetFillColor(isec+1);
	box->Draw();
	
	box=new TBox(x0+xc,-y1+yc,x1+xc,-y0+yc);
	box->SetFillColor(isec+1);
	box->Draw();
	
	box=new TBox(-x1+xc,-y1+yc,-x0+xc,-y0+yc);
	box->SetFillColor(isec+1);
	box->Draw();
      }
    }
  }
}
void AliMUONSegmentationV01::SetCorrFunc(Int_t isec, TF1* func)
{
// Set the correction function
    fCorrA->AddAt(func,isec);
}

TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
{ 
// Get correction function
  //PH    return (TF1*) (*fCorrA)[isec];
    return (TF1*) fCorrA->At(isec);
}

AliMUONSegmentationV01& 
AliMUONSegmentationV01::operator =(const AliMUONSegmentationV01 & rhs)
{
// Protected assignement operator

  if (this == &rhs) return *this;

  AliFatal("Not implemented.");
    
  return *this;  
}
Commit	Line	Data
a9e2aefa	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
88cb7938	16	/* $Id$ */
a9e2aefa	17
	18	/////////////////////////////////////////////////////
	19	// Segmentation and Response classes version 01 //
	20	/////////////////////////////////////////////////////
	21
	22	#include <TBox.h>
aaf4addd	23	#include <TTUBE.h>
	24	#include <TBRIK.h>
	25	#include <TNode.h>
	26	#include <TGeometry.h>
a9e2aefa	27	#include <TF1.h>
3afc6e30	28	#include <TVector3.h>
a9e2aefa	29	#include <TObjArray.h>
a9e2aefa	30
	31	#include "AliMUONSegmentationV01.h"
	32	#include "AliMUON.h"
3e1872ed	33	#include "AliMUONChamber.h"
3e1872ed	34	#include "AliRun.h"
8c343c7c	35	#include "AliLog.h"
a9e2aefa	36
a9e2aefa	37
30178c30	38
a9e2aefa	39	//___________________________________________
	40	ClassImp(AliMUONSegmentationV01)
	41
30178c30	42	AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
30178c30	43	: AliMUONSegmentationV0(segmentation)
a9e2aefa	44	{
30178c30	45	// Protected copy constructor
30178c30	46
8c343c7c	47	AliFatal("Not implemented.");
a9e2aefa	48	}
e9e4cdf2	49
a9e2aefa	50	AliMUONSegmentationV01::AliMUONSegmentationV01()
30178c30	51	: AliMUONSegmentationV0()
a9e2aefa	52	{
a9e2aefa	53	// Default constructor
e9e4cdf2	54	fRSec = 0;
e9e4cdf2	55	fNDiv = 0;
a8a6107b	56	fDpxD = 0;
a8a6107b	57	fCorrA = 0;
0951fe3d	58	fSector = -1;
e9e4cdf2	59	}
	60
	61	AliMUONSegmentationV01::AliMUONSegmentationV01(Int_t nsec)
30178c30	62	: AliMUONSegmentationV0()
e9e4cdf2	63	{
	64	// Non default constructor
	65
	66	fNsec = nsec;
c3eff6ad	67	fRSec = new TArrayF(fNsec);
	68	fNDiv = new TArrayI(fNsec);
	69	fDpxD = new TArrayF(fNsec);
e9e4cdf2	70
e9e4cdf2	71
c3eff6ad	72	(fRSec)[0]=(fRSec)[1]=(fRSec)[2]=(fRSec)[3]=0;
	73	(fNDiv)[0]=(fNDiv)[1]=(fNDiv)[2]=(fNDiv)[3]=0;
	74	(fDpxD)[0]=(fDpxD)[1]=(fDpxD)[2]=(fDpxD)[3]=0;
bac96a1c	75	fCorrA = new TObjArray(3);
cd4df77b	76	fCorrA->AddAt(0,0);
	77	fCorrA->AddAt(0,1);
	78	fCorrA->AddAt(0,2);
e80ad807	79	fOffsetY=0;
0951fe3d	80	fSector = -1;
a9e2aefa	81	}
a9e2aefa	82
e9e4cdf2	83	AliMUONSegmentationV01::~AliMUONSegmentationV01()
	84	{
	85	// Destructor
	86	if (fRSec) delete fRSec;
	87	if (fNDiv) delete fNDiv;
	88	if (fDpxD) delete fDpxD;
	89	if (fCorrA) {
	90	fCorrA->Delete();
	91	delete fCorrA;
	92	}
	93	}
	94
	95
94de3818	96	Float_t AliMUONSegmentationV01::Dpx(Int_t isec) const
a9e2aefa	97	{
	98	//
	99	// Returns x-pad size for given sector isec
c3eff6ad	100	Float_t dpx = (*fDpxD)[isec];
c3eff6ad	101	return dpx;
a9e2aefa	102	}
a9e2aefa	103
b1ad38fa	104	Float_t AliMUONSegmentationV01::Dpy(Int_t /isec/) const
a9e2aefa	105	{
	106	//
	107	// Returns y-pad size for given sector isec
	108	return fDpy;
	109	}
	110
	111	void AliMUONSegmentationV01::SetSegRadii(Float_t r[4])
	112	{
	113	//
	114	// Set the radii of the segmentation zones
	115	for (Int_t i=0; i<4; i++) {
c3eff6ad	116	(*fRSec)[i]=r[i];
a9e2aefa	117	}
	118	}
	119
	120
	121	void AliMUONSegmentationV01::SetPadDivision(Int_t ndiv[4])
	122	{
	123	//
	124	// Defines the pad size perp. to the anode wire (y) for different sectors.
	125	// Pad sizes are defined as integral fractions ndiv of a basis pad size
	126	// fDpx
	127	//
	128	for (Int_t i=0; i<4; i++) {
c3eff6ad	129	(*fNDiv)[i]=ndiv[i];
a9e2aefa	130	}
	131	ndiv[0]=ndiv[1];
	132	}
	133
	134
d81db581	135	void AliMUONSegmentationV01::Init(Int_t chamber)
a9e2aefa	136	{
	137	//
	138	// Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
	139	// These arrays help in converting from real to pad co-ordinates and
	140	// vice versa.
	141	// This version approximates concentric segmentation zones
	142	//
c9d10ab5	143
a9e2aefa	144	Int_t isec;
9e1a0ddb	145	//printf("\n Initialise Segmentation V01\n");
e9e4cdf2	146
e9e4cdf2	147
c3eff6ad	148	fNpy=Int_t((*fRSec)[fNsec-1]/fDpy)+1;
a9e2aefa	149
c3eff6ad	150	(*fDpxD)[fNsec-1]=fDpx;
a9e2aefa	151	if (fNsec > 1) {
a9e2aefa	152	for (Int_t i=fNsec-2; i>=0; i--){
c3eff6ad	153	(fDpxD)[i]=(fDpxD)[fNsec-1]/(*fNDiv)[i];
a9e2aefa	154	}
	155	}
	156	//
	157	// fill the arrays defining the pad segmentation boundaries
	158	Float_t ry;
	159	Int_t dnx;
	160	Int_t add;
	161	//
	162	// loop over sections
	163	for(isec=0; isec<fNsec; isec++) {
	164	//
	165	// loop over pads along the aode wires
	166	for (Int_t iy=1; iy<=fNpy; iy++) {
	167	//
	168	Float_t x=iy*fDpy-fDpy/2;
c3eff6ad	169	if (x > (*fRSec)[isec]) {
a9e2aefa	170	fNpxS[isec][iy]=0;
	171	fCx[isec][iy]=0;
	172	} else {
c3eff6ad	173	ry=TMath::Sqrt((fRSec)[isec](fRSec)[isec]-xx);
a9e2aefa	174	if (isec > 1) {
c3eff6ad	175	dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
a9e2aefa	176	if (isec < fNsec-1) {
	177	if (TMath::Odd((Long_t)dnx)) dnx++;
	178	}
	179	fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
c3eff6ad	180	fCx[isec][iy]=fCx[isec-1][iy]+dnx(fDpxD)[isec];
a9e2aefa	181	} else if (isec == 1) {
c3eff6ad	182	dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
a9e2aefa	183	fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
	184	add=4 - (fNpxS[isec][iy])%4;
	185	if (add < 4) fNpxS[isec][iy]+=add;
	186	dnx=fNpxS[isec][iy]-fNpxS[isec-1][iy];
c3eff6ad	187	fCx[isec][iy]=fCx[isec-1][iy]+dnx(fDpxD)[isec];
a9e2aefa	188	} else {
c3eff6ad	189	dnx=Int_t(ry/(*fDpxD)[isec]);
a9e2aefa	190	fNpxS[isec][iy]=dnx;
c3eff6ad	191	fCx[isec][iy]=dnx(fDpxD)[isec];
a9e2aefa	192	}
	193	}
	194	} // y-pad loop
	195	} // sector loop
c9d10ab5	196
3e1872ed	197	// reference to chamber
	198	AliMUON pMUON = (AliMUON ) gAlice->GetModule("MUON");
	199	fChamber=&(pMUON->Chamber(chamber));
c9d10ab5	200	fRmin=fChamber->RInner();
	201	fRmax=fChamber->ROuter();
	202	fCorr=0;
3e1872ed	203	fZ = fChamber->Z();
aaf4addd	204	fId=chamber;
a9e2aefa	205	}
a9e2aefa	206
30178c30	207	//______________________________________________________________________
a9e2aefa	208	Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
	209	{
	210	// Returns sector number for given pad position
	211	//
	212	Int_t absix=TMath::Abs(ix);
	213	Int_t absiy=TMath::Abs(iy);
	214	Int_t isec=0;
	215	for (Int_t i=0; i<fNsec; i++) {
	216	if (absix<=fNpxS[i][absiy]){
	217	isec=i;
	218	break;
	219	}
	220	}
	221	return isec;
	222	}
30178c30	223
b1ad38fa	224	//______________________________________________________________________
b1ad38fa	225	void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
a9e2aefa	226	{
	227	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	228	//
e80ad807	229	iy = (y-fOffsetY >0)?
	230	Int_t((y-fOffsetY)/fDpy)+1
	231	:
	232	Int_t((y-fOffsetY)/fDpy)-1;
	233
a9e2aefa	234	if (iy > fNpy) iy= fNpy;
	235	if (iy < -fNpy) iy=-fNpy;
	236	//
	237	// Find sector isec
	238	Int_t isec=-1;
	239	Float_t absx=TMath::Abs(x);
	240	Int_t absiy=TMath::Abs(iy);
	241	for (Int_t i=0; i < fNsec; i++) {
	242	if (absx <= fCx[i][absiy]) {
	243	isec=i;
	244	break;
	245	}
	246	}
	247	if (isec>0) {
c3eff6ad	248	ix= Int_t((absx-fCx[isec-1][absiy])/(*fDpxD)[isec])
a9e2aefa	249	+fNpxS[isec-1][absiy]+1;
a9e2aefa	250	} else if (isec == 0) {
c3eff6ad	251	ix= Int_t(absx/(*fDpxD)[isec])+1;
a9e2aefa	252	} else {
	253	ix=fNpxS[fNsec-1][absiy]+1;
	254	}
	255	ix = (x>0) ? ix:-ix;
	256	}
b1ad38fa	257	//________________________________________________________________
	258	void AliMUONSegmentationV01::GetPadI(Float_t x, Float_t y , Float_t /z/, Int_t &ix, Int_t &iy)
	259	{
	260	GetPadI(x, y, ix, iy);
	261	}
	262	//________________________________________________________________
a9e2aefa	263
a9e2aefa	264	void AliMUONSegmentationV01::
a30a000f	265	GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
a9e2aefa	266	{
	267	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
	268	//
bdf39337	269	y = (iy>0) ?
	270	Float_t(iy*fDpy)-fDpy/2.+fOffsetY
	271	:
	272	Float_t(iy*fDpy)+fDpy/2.+fOffsetY;
	273
a9e2aefa	274	//
	275	// Find sector isec
	276	Int_t isec=AliMUONSegmentationV01::Sector(ix,iy);
	277	//
	278	Int_t absix=TMath::Abs(ix);
	279	Int_t absiy=TMath::Abs(iy);
	280	if (isec) {
c3eff6ad	281	x=fCx[isec-1][absiy]+(absix-fNpxS[isec-1][absiy])(fDpxD)[isec];
c3eff6ad	282	x=(ix>0) ? x-(fDpxD)[isec]/2 : -x+(fDpxD)[isec]/2;
a9e2aefa	283	} else {
	284	x=y=0;
	285	}
3afc6e30	286
	287	}
	288	//________________________________________________________________
	289
	290	void AliMUONSegmentationV01::
	291	GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z)
	292	{
	293	// Returns real coordinates (x,y,z) for given pad coordinates (ix,iy)
	294	//
	295	GetPadC(ix,iy,x,y);
	296
	297	// To be properly interfaced with chamber geometry (AliMUONSt1GeometryBuilderV2) ???
	298	TVector3 scale[4];
	299	scale[0] = TVector3( 1, 1, 1); // quadrant I
	300	scale[1] = TVector3(-1, 1, -1); // quadrant II
	301	scale[2] = TVector3(-1, -1, 1); // quadrant III
	302	scale[3] = TVector3( 1, -1, -1); // quadrant IV
	303
	304	Int_t iQuadrant;
	305
	306	if (ix > 0) {
	307	if (iy > 0) {
	308	iQuadrant = 0;
	309	} else {
	310	iQuadrant = 3;
	311	}
	312	} else {
	313	if (iy > 0) {
	314	iQuadrant = 1;
	315	} else {
	316	iQuadrant = 2;
	317	}
	318	}
	319	if (TMath::Abs(fZ) < 600) {
	320	z = fZ + scale[iQuadrant].Z()*6.5/2.; // Station 1
	321	} else {
	322	z = fZ; // Station 2
	323	}
a9e2aefa	324	}
	325
	326	void AliMUONSegmentationV01::
	327	SetPad(Int_t ix, Int_t iy)
	328	{
	329	//
	330	// Sets virtual pad coordinates, needed for evaluating pad response
	331	// outside the tracking program
ecfa008b	332	GetPadC(ix,iy,fX,fY);
a9e2aefa	333	fSector=Sector(ix,iy);
	334	}
	335
b1ad38fa	336	//______________________________________________________________________
b1ad38fa	337	void AliMUONSegmentationV01::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
a9e2aefa	338	{
	339	// Initialises iteration over pads for charge distribution algorithm
	340	//
	341	//
	342	// Find the wire position (center of charge distribution)
	343	Float_t x0a=GetAnod(xhit);
ecfa008b	344	fXhit=x0a;
ecfa008b	345	fYhit=yhit;
a9e2aefa	346
	347	//
	348	// and take fNsigma*sigma around this center
	349	Float_t x01=x0a - dx;
	350	Float_t x02=x0a + dx;
	351	Float_t y01=yhit - dy;
	352	Float_t y02=yhit + dy;
	353	//
	354	// find the pads over which the charge distributes
c3eff6ad	355
ecfa008b	356	GetPadI(x01,y01,fIxmin,fIymin);
	357	GetPadI(x02,y02,fIxmax,fIymax);
	358	fXmin=x01;
	359	fXmax=x02;
	360	fYmin=y01;
	361	fYmax=y02;
a9e2aefa	362
	363	//
	364	// Set current pad to lower left corner
ecfa008b	365	if (fIxmax < fIxmin) fIxmax=fIxmin;
	366	if (fIymax < fIymin) fIymax=fIymin;
	367	fIx=fIxmin;
	368	fIy=fIymin;
	369	GetPadC(fIx,fIy,fX,fY);
30178c30	370
0951fe3d	371	// added
	372	if (fSector == -1) {
	373	fSector=Sector(fIx,fIy);
	374	}
a9e2aefa	375	}
	376
	377
	378	void AliMUONSegmentationV01::NextPad()
	379	{
	380	// Stepper for the iteration over pads
	381	//
	382	// Step to next pad in the integration region
	383	//
	384	// Step to next pad in integration region
	385	Float_t xc,yc;
	386	Int_t iyc;
	387
	388	// step from left to right
c3eff6ad	389
ecfa008b	390	if (fX < fXmax && fX != 0) {
	391	if (fIx==-1) fIx++;
	392	fIx++;
a9e2aefa	393	// step up
ecfa008b	394	} else if (fIy != fIymax) {
	395	if (fIy==-1) fIy++;
	396	fIy++;
a9e2aefa	397	// get y-position of next row (yc), xc not used here
ecfa008b	398	GetPadC(fIx,fIy,xc,yc);
	399	// get x-pad coordiante for first pad in row (fIx)
	400	GetPadI(fXmin,yc,fIx,iyc);
a9e2aefa	401	} else {
d7d176c9	402	fIx=-1;
d7d176c9	403	fIy=-1;
a9e2aefa	404	}
ecfa008b	405	GetPadC(fIx,fIy,fX,fY);
ecfa008b	406	fSector=Sector(fIx,fIy);
a9e2aefa	407	if (MorePads() &&
	408	(fSector ==-1 \|\| fSector==0))
	409	NextPad();
	410	}
	411
	412	Int_t AliMUONSegmentationV01::MorePads()
de05461e	413
de05461e	414	{
a9e2aefa	415	// Stopping condition for the iterator over pads
	416	//
	417	// Are there more pads in the integration region
d7d176c9	418	return (fIx != -1 \|\| fIy != -1);
d7d176c9	419	/*
ecfa008b	420	if ((fX >= fXmax && fIy >= fIymax) \|\| fY==0) {
a9e2aefa	421	return 0;
	422	} else {
	423	return 1;
	424	}
d7d176c9	425	*/
a9e2aefa	426	}
b1ad38fa	427	//______________________________________________________________________
	428	void AliMUONSegmentationV01::FirstPad(Float_t xhit, Float_t yhit, Float_t /zhit/, Float_t dx, Float_t dy)
	429	{
	430	FirstPad(xhit, yhit, dx, dy);
	431	}
	432
a9e2aefa	433
	434	void AliMUONSegmentationV01::
	435	IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
	436	{
	437	// Returns integration limits for current pad
	438	//
ecfa008b	439	x1=fXhit-fX-Dpx(fSector)/2.;
a9e2aefa	440	x2=x1+Dpx(fSector);
ecfa008b	441	y1=fYhit-fY-Dpy(fSector)/2.;
a9e2aefa	442	y2=y1+Dpy(fSector);
	443	}
	444
	445	void AliMUONSegmentationV01::
	446	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
	447	{
	448	// Returns list of next neighbours for given Pad (iX, iY)
	449	//
	450	const Float_t kEpsilon=fDpy/1000;
	451
	452	Float_t x,y;
	453	Int_t ixx, iyy, isec1;
	454	//
	455	Int_t isec0=AliMUONSegmentationV01::Sector(iX,iY);
	456	Int_t i=0;
	457	//
	458	// step right
	459	Xlist[i]=iX+1;
	460	if (Xlist[i]==0) Xlist[i]++;
	461	Ylist[i++]=iY;
	462	//
	463	// step left
	464	Xlist[i]=iX-1;
	465	if (Xlist[i]==0) Xlist[i]--;
	466	Ylist[i++]=iY;
	467	//
	468	// step up
a30a000f	469	AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
a30a000f	470	AliMUONSegmentationV01::GetPadI(x+kEpsilon,y+fDpy,ixx,iyy);
a9e2aefa	471	Xlist[i]=ixx;
	472	Ylist[i++]=iyy;
	473	isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
	474	if (isec1==isec0) {
	475	//
	476	// no sector boundary crossing
	477	// Xlist[i]=ixx+1;
	478	// Ylist[i++]=iY+1;
	479
	480	// Xlist[i]=ixx-1;
	481	// Ylist[i++]=iY+1;
	482	} else if (isec1 < isec0) {
	483	// finer segmentation
	484	// Xlist[i]=ixx+1;
	485	// Ylist[i++]=iY+1;
	486
	487	Xlist[i]=ixx-1;
	488	Ylist[i++]=iyy;
	489
	490	// Xlist[i]=ixx-2;
	491	// Ylist[i++]=iY+1;
	492	} else {
	493	// coarser segmenation
	494	/*
	495	if (TMath::Odd(iX-fNpxS[isec1-1][iY+1])) {
	496	Xlist[i]=ixx-1;
	497	Ylist[i++]=iY+1;
	498	} else {
	499	Xlist[i]=ixx+1;
	500	Ylist[i++]=iY+1;
	501	}
	502	*/
	503	}
	504
	505	//
	506	// step down
a30a000f	507	AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
a30a000f	508	AliMUONSegmentationV01::GetPadI(x+kEpsilon,y-fDpy,ixx,iyy);
a9e2aefa	509	Xlist[i]=ixx;
	510	Ylist[i++]=iyy;
	511	isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
	512	if (isec1==isec0) {
	513	//
	514	// no sector boundary crossing
	515	/*
	516	Xlist[i]=ixx+1;
	517	Ylist[i++]=iY-1;
	518
	519	Xlist[i]=ixx-1;
	520	Ylist[i++]=iY-1;
	521	*/
	522	} else if (isec1 < isec0) {
	523	// finer segmentation
	524	// Xlist[i]=ixx+1;
	525	// Ylist[i++]=iY-1;
	526
	527	Xlist[i]=ixx-1;
	528	Ylist[i++]=iyy;
	529
	530	// Xlist[i]=ixx-2;
	531	// Ylist[i++]=iY-1;
	532	} else {
	533	// coarser segmentation
	534	/*
	535	if (TMath::Odd(iX-fNpxS[isec1-1][iY-1])) {
	536	Xlist[i]=ixx-1;
	537	Ylist[i++]=iY-1;
	538	} else {
	539	Xlist[i]=ixx+1;
	540	Ylist[i++]=iY-1;
	541	}
	542	*/
	543	}
	544	*Nlist=i;
	545	}
	546
c3eff6ad	547	void AliMUONSegmentationV01::GiveTestPoints(Int_t &n, Float_t x, Float_t y) const
a9e2aefa	548	{
	549	// Returns test point on the pad plane.
	550	// Used during determination of the segmoid correction of the COG-method
	551
	552	n=3;
c3eff6ad	553	x[0]=((fRSec)[0]+(fRSec)[1])/2/TMath::Sqrt(2.);
a9e2aefa	554	y[0]=x[0];
c3eff6ad	555	x[1]=((fRSec)[1]+(fRSec)[2])/2/TMath::Sqrt(2.);
a9e2aefa	556	y[1]=x[1];
c3eff6ad	557	x[2]=((fRSec)[2]+(fRSec)[3])/2/TMath::Sqrt(2.);
a9e2aefa	558	y[2]=x[2];
	559	}
	560
c9d10ab5	561	void AliMUONSegmentationV01::Draw(const char* opt)
a9e2aefa	562	{
aaf4addd	563
a9e2aefa	564	// Draws the segmentation zones
a9e2aefa	565	//
aaf4addd	566	if (!strcmp(opt,"eventdisplay")) {
	567	const int kColorMUON = kBlue;
	568
	569	TRotMatrix* rot000 = new TRotMatrix("Rot000"," ", 90, 0, 90, 90, 0, 0);
	570	TRotMatrix* rot090 = new TRotMatrix("Rot090"," ", 90, 90, 90,180, 0, 0);
	571	TRotMatrix* rot180 = new TRotMatrix("Rot180"," ", 90,180, 90,270, 0, 0);
	572	TRotMatrix* rot270 = new TRotMatrix("Rot270"," ", 90,270, 90, 0, 0, 0);
	573
	574	char nameChamber[9], nameSense[9], nameFrame[9], nameNode[9];
	575	char nameSense1[9], nameSense2[9];
	576	TNode node, nodeF;
	577
	578	sprintf(nameChamber,"C_MUON%d",fId+1);
	579	sprintf(nameSense,"S_MUON%d",fId+1);
	580	sprintf(nameSense1,"S1_MUON%d",fId+1);
	581	sprintf(nameSense2,"S2_MUON%d",fId+1);
	582	sprintf(nameFrame,"F_MUON%d",fId+1);
	583
	584	TNode* top=gAlice->GetGeometry()->GetNode("alice");
	585
	586	Float_t rmin = (*fRSec)[0]-3;
	587	Float_t rmax = (*fRSec)[3]+3;
	588	new TTUBE(nameChamber,"Mother","void",rmin,rmax,0.25,1.);
	589	rmin = (*fRSec)[0];
	590	rmax = (*fRSec)[3];
	591	new TTUBE(nameSense,"Sens. region","void",rmin,rmax,0.25, 1.);
	592	Float_t dx=(rmax-rmin)/2;
	593	Float_t dy=3.;
	594	Float_t dz=0.25;
	595	TBRIK* frMUON = new TBRIK(nameFrame,"Frame","void",dx,dy,dz);
	596	top->cd();
	597	sprintf(nameNode,"MUON%d",100+fId+1);
	598	node = new TNode(nameNode,"ChamberNode",nameChamber,0,0,fChamber->Z(),"");
	599	node->SetLineColor(kColorMUON);
	600	AliMUON pMUON = (AliMUON ) gAlice->GetModule("MUON");
	601	(pMUON->Nodes())->Add(node);
	602	node->cd();
	603	sprintf(nameNode,"MUON%d",200+fId+1);
	604	node = new TNode(nameNode,"Sens. Region Node",nameSense,0,0,0,"");
	605	node->SetLineColor(kColorMUON);
	606	node->cd();
	607	Float_t dr=dx+rmin;
	608	sprintf(nameNode,"MUON%d",300+fId+1);
	609	nodeF = new TNode(nameNode,"Frame0",frMUON,dr, 0, 0,rot000,"");
	610	nodeF->SetLineColor(kColorMUON);
	611	node->cd();
	612	sprintf(nameNode,"MUON%d",400+fId+1);
	613	nodeF = new TNode(nameNode,"Frame1",frMUON,0 ,dr,0,rot090,"");
	614	nodeF->SetLineColor(kColorMUON);
	615	node->cd();
	616	sprintf(nameNode,"MUON%d",500+fId+1);
	617	nodeF = new TNode(nameNode,"Frame2",frMUON,-dr,0,0,rot180,"");
	618	nodeF->SetLineColor(kColorMUON);
	619	node ->cd();
	620	sprintf(nameNode,"MUON%d",600+fId+1);
	621	nodeF = new TNode(nameNode,"Frame3",frMUON,0,-dr,0,rot270,"");
	622	nodeF->SetLineColor(kColorMUON);
	623	} else {
a9e2aefa	624	TBox *box;
	625
	626	Float_t dx=0.95/fCx[3][1]/2;
	627	Float_t dy=0.95/(Float_t(Npy()))/2;
	628	Float_t x0,y0,x1,y1;
	629	Float_t xc=0.5;
	630	Float_t yc=0.5;
	631
aaf4addd	632	for (Int_t iy=1; iy<Npy(); iy++) {
	633	for (Int_t isec=0; isec<4; isec++) {
	634	if (isec==0) {
	635	x0=0;
	636	x1=fCx[isec][iy]*dx;
	637	} else {
	638	x0=fCx[isec-1][iy]*dx;
	639	x1=fCx[isec][iy]*dx;
a9e2aefa	640	}
aaf4addd	641	y0=Float_t(iy-1)*dy;
	642	y1=y0+dy;
	643	box=new TBox(x0+xc,y0+yc,x1+xc,y1+yc);
	644	box->SetFillColor(isec+1);
	645	box->Draw();
	646
	647	box=new TBox(-x1+xc,y0+yc,-x0+xc,y1+yc);
	648	box->SetFillColor(isec+1);
	649	box->Draw();
	650
	651	box=new TBox(x0+xc,-y1+yc,x1+xc,-y0+yc);
	652	box->SetFillColor(isec+1);
	653	box->Draw();
	654
	655	box=new TBox(-x1+xc,-y1+yc,-x0+xc,-y0+yc);
	656	box->SetFillColor(isec+1);
	657	box->Draw();
	658	}
a9e2aefa	659	}
aaf4addd	660	}
a9e2aefa	661	}
	662	void AliMUONSegmentationV01::SetCorrFunc(Int_t isec, TF1* func)
	663	{
de05461e	664	// Set the correction function
cd4df77b	665	fCorrA->AddAt(func,isec);
a9e2aefa	666	}
a9e2aefa	667
c3eff6ad	668	TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
a9e2aefa	669	{
de05461e	670	// Get correction function
2682e810	671	//PH return (TF1) (fCorrA)[isec];
2682e810	672	return (TF1*) fCorrA->At(isec);
a9e2aefa	673	}
a9e2aefa	674
30178c30	675	AliMUONSegmentationV01&
30178c30	676	AliMUONSegmentationV01::operator =(const AliMUONSegmentationV01 & rhs)
a9e2aefa	677	{
30178c30	678	// Protected assignement operator
	679
	680	if (this == &rhs) return *this;
	681
8c343c7c	682	AliFatal("Not implemented.");
30178c30	683
30178c30	684	return *this;
a9e2aefa	685	}
de05461e	686