+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-#include <TArrayI.h>
-#include <TObjArray.h>
-#include <TMath.h>
-#include <TBRIK.h>
-#include <TNode.h>
-#include <TGeometry.h>
-
-#include "AliMUONSegmentationSlat.h"
-#include "AliMUONSegmentationSlatModule.h"
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliRun.h"
-#include "AliMUONConstants.h"
-#include "AliLog.h"
-//___________________________________________
-ClassImp(AliMUONSegmentationSlat)
-
-AliMUONSegmentationSlat::AliMUONSegmentationSlat()
- : AliSegmentation()
-{
-// Default constructor
- fChamber = 0;
- fNDiv = 0;
- fSlats = 0;
- fCurrentSlat = 0;
-}
-
-AliMUONSegmentationSlat::AliMUONSegmentationSlat(Int_t /*nsec*/)
- : AliSegmentation()
-{
-// Non default constructor
- fSlats=0;
- fNDiv = new TArrayI(4);
- fChamber = 0;
- fCurrentSlat = 0;
-}
-
-AliMUONSegmentationSlat::AliMUONSegmentationSlat(const AliMUONSegmentationSlat& rhs)
- : AliSegmentation(rhs)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-AliMUONSegmentationSlat::~AliMUONSegmentationSlat(){
- //PH Delete TObjArrays
- if (fSlats) {
- fSlats->Delete();
- delete fSlats;
- }
-
- if (fNDiv) {
- delete fNDiv;
- }
-
-}
-
-//----------------------------------------------------------------------
-AliMUONSegmentationSlat&
-AliMUONSegmentationSlat::operator=(const AliMUONSegmentationSlat& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
-//-----------------------------------------------------------
-void AliMUONSegmentationSlat::SetPadSize(Float_t p1, Float_t p2)
-{
-// Sets the pad (strip) size
-//
- fDpx=p1;
- fDpy=p2;
-}
-
-//-----------------------------------------------------------
-Float_t AliMUONSegmentationSlat::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 AliMUONSegmentationSlat::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t *Nparallel, Int_t *Offset)
-{
- *Nparallel = 1;
- *Offset = 0;
-}
-//-----------------------------------------------------------
-void AliMUONSegmentationSlat::GiveTestPoints(Int_t & /*n*/, Float_t */*x*/, Float_t */*y*/) const
-{;}
-
-//-----------------------------------------------------------
-Float_t AliMUONSegmentationSlat::Distance2AndOffset(Int_t /*iX*/, Int_t /*iY*/, Float_t /*X*/, Float_t /*Y*/, Int_t * /*dummy*/)
-{
- return 0.;
-}
-
-//-----------------------------------------------------------
-Float_t AliMUONSegmentationSlat::Dpx(Int_t isec) const
-{
-//
-// Returns x-pad size for given sector isec
-// isec = 100*islat+iregion
-//
- Int_t islat, iregion;
- islat = isec/100;
- iregion = isec%100;
- return Slat(islat)->Dpx(iregion);
-}
-
-Float_t AliMUONSegmentationSlat::Dpy(Int_t /*isec*/) const
-{
-//
-// Returns y-pad (strip) size for given sector isec
- return fDpy;
-}
-
-void AliMUONSegmentationSlat::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];
- }
-}
-
-void AliMUONSegmentationSlat::GlobalToLocal(
- Float_t x, Float_t y, Float_t z, Int_t &islat, Float_t &xlocal, Float_t &ylocal)
-{
-//
-// Perform local to global transformation for space coordinates
-//
- Float_t zlocal;
- Int_t i;
- Int_t index = -1;
- Float_t eps = 1.e-4;
-
-// Transform According to slat plane z-position: negative side is shifted down
-// positive side is shifted up
-// by half the overlap
- zlocal = z-fChamber->Z();
-
-// zlocal = (x>0) ? zlocal-2.*fDz : zlocal+2.*fDz;
-// zlocal = (x>0) ? zlocal+2.*fDz : zlocal-2.*fDz; //Change?
-
-
-
-
-// Set the signs for the symmetry transformation and transform to first quadrant
- SetSymmetry(x);
- Float_t xabs = TMath::Abs(x);
-
-
-// Find slat number
- for (i = 0; i < fNSlats; i++) { //Loop on all slats (longuer but more secure)
- index = i;
- if ((y >= fYPosition[i]-eps) && (y <= fYPosition[i]+fSlatY+eps)) break;
- }
-
-//
-// Transform to local coordinate system
-
-
- if (index >= fNSlats || index < 0 ) {
- islat = -1;
- xlocal = -1;
- ylocal = -1;
- } else {
- islat = index;
- xlocal = xabs - fXPosition[index];
- ylocal = y - fYPosition[index];
- }
-}
-//_________________________________________________
-void AliMUONSegmentationSlat::GlobalToLocal(
- Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal) const
-{
-//
-// Perform global to local transformation for pad coordinates
-//
- Int_t iytemp = iy;
- Int_t index = 0;
-
- iylocal = iytemp;
-
-//
-// Find slat number (index) and iylocal
- for (Int_t i=0; i<fNSlats; i++) {
- iytemp-=Slat(i)->Npy();
-
- if (iytemp <= 0) break;
- iylocal = iytemp;
- index=i+1;
- }
- ixlocal=TMath::Abs(ix);
- islat=index;
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::
-LocalToGlobal(Int_t islat, Float_t xlocal, Float_t ylocal, Float_t &x, Float_t &y, Float_t &z) const
-{
-// Transform from local to global space coordinates
-//
-// upper plane (y>0) even slat number is shifted down
-// upper plane (y>0) odd slat number is shifted up
-// lower plane (y<0) even slat number is shifted up
-// lower plane (y<0) odd slat number is shifted down
-//
-
- x = (xlocal + fXPosition[islat])*fSym;
- y = (ylocal + fYPosition[islat]);
-
-// z = (TMath::Even(islat)) ? fDz : -fDz ; //Change for new referential
-// z = (x>0) ? z+2.*fDz : z-2.*fDz ;
-// z+=fChamber->Z();
-
-// z-position
- z = (TMath::Even(islat)) ? -fDzSlat : fDzSlat ; //Change for new referential
- z = (x>0) ? -z + fDzCh : z - fDzCh;
- z += fChamber->Z();
-
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::LocalToGlobal (
- Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy) const
-{
-// Transform from local to global pad coordinates
-//
- Int_t i;
- iy=iylocal;
-
-//
-// Find slat number (index) and iylocal
- for (i=0; i<islat; i++) iy+=Slat(islat)->Npy();
-
- ix=ixlocal*fSym;
- iy=iy;
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetSymmetry(Int_t ix)
-{
-// Set set signs for symmetry transformation
- fSym = TMath::Sign(1,ix);
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetSymmetry(Float_t x)
-{
-// Set set signs for symmetry transformation
- fSym = Int_t (TMath::Sign((Float_t)1.,x));
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::
-GetPadI(Float_t x, Float_t y, Float_t z, Int_t &ix, Int_t &iy)
-{
-// Returns pad coordinates for given set of space coordinates
-
- Int_t islat, i;
- Float_t xlocal, ylocal;
-
- GlobalToLocal(x,y,z,islat,xlocal,ylocal);
- if (islat == -1) {
- ix = 0; iy = 0;
- return;
- }
-
- Slat(islat)->GetPadI(xlocal, ylocal, ix, iy);
- for (i = 0; i < islat; i++) iy += Slat(islat)->Npy();
-
- ix = ix*Int_t(TMath::Sign((Float_t)1.,x));
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::
-GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z)
-{
-// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
-//
- Int_t islat, ixlocal, iylocal;
-//
-// Delegation of transforamtion to slat
- GlobalToLocal(ix,iy,islat,ixlocal,iylocal);
- Slat(islat)->GetPadC(ixlocal, iylocal, x, y);
-// Slat offset
- x += fXPosition[islat];
- y += fYPosition[islat];
-
-// Symmetry transformation of half planes
- x = x * TMath::Sign(1,ix);
-
-// z-position
- z = (TMath::Even(islat)) ? -fDzSlat : fDzSlat ; //Change for new referential
- z = (x>0) ? -z + fDzCh : z - fDzCh;
- z += fChamber->Z();
-}
-
-//_________________________________________________
-Int_t AliMUONSegmentationSlat::ISector()
-{
-// Returns current sector during tracking
- Int_t iregion;
-
- iregion = fCurrentSlat->ISector();
- return 100*fSlatIndex+iregion;
-}
-
-//_________________________________________________
-Int_t AliMUONSegmentationSlat::Sector(Int_t ix, Int_t iy)
-{
-// Returns sector for pad coordiantes (ix,iy)
- Int_t ixlocal, iylocal, iregion, islat;
-
- GlobalToLocal(ix,iy,islat,ixlocal,iylocal);
-
- iregion = Slat(islat)->Sector(ixlocal, iylocal);
- return 100*islat+iregion;
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetPad(Int_t ix, Int_t iy)
-{
- //
- // Sets virtual pad coordinates, needed for evaluating pad response
- // outside the tracking program
- Int_t islat, ixlocal, iylocal;
-
- SetSymmetry(ix);
-
- GlobalToLocal(ix,iy,islat,ixlocal,iylocal);
- fSlatIndex=islat;
- fCurrentSlat=Slat(islat);
- fCurrentSlat->SetPad(ixlocal, iylocal);
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetHit(Float_t xhit, Float_t yhit, Float_t zhit)
-{ //
- // Sets current hit coordinates
-
- Float_t xlocal, ylocal;
- Int_t islat;
-
-
-
- GlobalToLocal(xhit,yhit,zhit,islat,xlocal,ylocal);
- fSlatIndex=islat;
- if (islat < 0) printf("\n SetHit: %d", islat);
-
- fCurrentSlat=Slat(islat);
- fCurrentSlat->SetHit(xlocal, ylocal);
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::
-FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy)
-{
-// Initialises iteration over pads for charge distribution algorithm
-//
-
-
- Int_t islat;
- Float_t xlocal, ylocal;
- GlobalToLocal(xhit, yhit, zhit, islat, xlocal, ylocal);
- fSlatIndex=islat;
- if (islat>-1) {
- fCurrentSlat=Slat(islat);
- fCurrentSlat->FirstPad(xlocal, ylocal, dx, dy);
- }
-
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::NextPad()
-{
-// Stepper for the iteration over pads
-//
- fCurrentSlat->NextPad();
-}
-
-//_________________________________________________
-Int_t AliMUONSegmentationSlat::MorePads()
-// Stopping condition for the iterator over pads
-//
-// Are there more pads in the integration region
-{
- return fCurrentSlat->MorePads();
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::
-IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
-{
-// Returns integration limits for current pad
-//
-
- fCurrentSlat->IntegrationLimits(x1, x2, y1, y2);
-
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::
-Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
-{
-// Returns list of neighbours of pad with coordinates iX, iY
-
- Int_t i, xListLocal[10], yListLocal[10], iXlocal, iYlocal, islat;
-
- SetSymmetry(iX);
-
- GlobalToLocal(iX, iY, islat, iXlocal, iYlocal);
-
- Slat(islat)->Neighbours(iXlocal, iYlocal, Nlist, xListLocal, yListLocal);
-
- for (i=0; i<*Nlist; i++) LocalToGlobal(islat, xListLocal[i], yListLocal[i], Xlist[i], Ylist[i]);
-
-}
-
-//_________________________________________________
-Int_t AliMUONSegmentationSlat::Ix()
-{
-// Return current pad coordinate ix during stepping
- Int_t ixl,iyl,ix,iy;
- ixl=fCurrentSlat->Ix();
- iyl=fCurrentSlat->Iy();
- LocalToGlobal(fSlatIndex, ixl, iyl, ix, iy);
-
- Int_t ixc, iyc, isc;
- Float_t xc, yc;
- GlobalToLocal(ix, iy, isc, ixc, iyc);
-
- Slat(isc)->GetPadC(ixc,iyc,xc,yc);
- return ix;
-}
-
-//_________________________________________________
-Int_t AliMUONSegmentationSlat::Iy()
-{
-// Return current pad coordinate iy during stepping
- Int_t ixl,iyl,ix,iy;
- ixl=fCurrentSlat->Ix();
- iyl=fCurrentSlat->Iy();
- LocalToGlobal(fSlatIndex, ixl, iyl, ix, iy);
- return iy;
-}
-
-//_________________________________________________
-Int_t AliMUONSegmentationSlat::SigGenCond(Float_t x, Float_t y, Float_t z)
-{
- // Signal Generation Condition during Stepping
-//
-// True if signal generation condition fullfilled
- Float_t xlocal, ylocal;
- Int_t islat;
- GlobalToLocal(x, y, z, islat, xlocal, ylocal);
- return Slat(islat)->SigGenCond(xlocal, ylocal, z);
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SigGenInit(Float_t x, Float_t y, Float_t z)
-{
-
-// Initialize the signal generation condition
-//
- Float_t xlocal, ylocal;
- Int_t islat;
-
- GlobalToLocal(x, y, z, islat, xlocal, ylocal);
- Slat(islat)->SigGenInit(xlocal, ylocal, z);
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::Init(Int_t chamber)
-{
-//
-// Initialize slat modules of quadrant +/+
-// The other three quadrants are handled through symmetry transformations
-//
- //printf("\n Initialise Segmentation Slat \n");
-//
-
-// Initialize Slat modules
- Int_t islat, i;
- Int_t ndiv[4];
-// Pad division
- for (i=0; i<4; i++) ndiv[i]=(*fNDiv)[i];
-
-// Slat height
- fSlatY=40.;
- for (i=0; i<15; i++) fSlatX[i]=0.;
-
-// shifts in z direction
- fDzSlat = AliMUONConstants::DzSlat();
- fDzCh = AliMUONConstants::DzCh();
-
-// Initialize array of slats
- fSlats = new TObjArray(fNSlats);
-// Maximum number of strips (pads) in x and y
- fNpy=0;
- fNpx=0;
-// for each slat in the quadrant (+,+)
- for (islat=0; islat<fNSlats; islat++) {
- fSlats->AddAt(CreateSlatModule(),islat);
-
- AliMUONSegmentationSlatModule *slat = Slat(islat);
- // Configure Slat
- slat->SetId(islat);
-
-// Foward pad size
- slat->SetPadSize(fDpx, fDpy);
-// Forward wire pitch
- slat->SetDAnod(fWireD);
-// Foward segmentation
- slat->SetPadDivision(ndiv);
- slat->SetPcbBoards(fPcb[islat]);
-// Initialize slat module
- slat->Init(chamber);
-// y-position of slat module relative to the first (closest to the beam)
-// fYPosition[islat]= fYPosOrigin+islat*(fSlatY-2.*fShift);
-//
- fNpy+=slat->Npy();
- if (slat->Npx() > fNpx) fNpx=slat->Npx();
- Int_t isec;
- for (isec=0; isec< 4; isec++)
- {
- fSlatX[islat]+=40.*fPcb[islat][isec];
- }
-
- }
-// Set parent chamber number
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- fChamber=&(pMUON->Chamber(chamber));
- fId=chamber;
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetNPCBperSector(Int_t *npcb)
-{
- // PCB distribution for station 4 (6 rows with 1+3 segmentation regions)
- for (Int_t islat=0; islat<fNSlats; islat++){
- fPcb[islat][0] = *(npcb + 4 * islat);
- fPcb[islat][1] = *(npcb + 4 * islat + 1);
- fPcb[islat][2] = *(npcb + 4 * islat + 2);
- fPcb[islat][3] = *(npcb + 4 * islat + 3);
- }
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetSlatXPositions(Float_t *xpos)
-{
-// Set x-positions of Slats
- for (Int_t islat=0; islat<fNSlats; islat++) fXPosition[islat]=xpos[islat];
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::SetSlatYPositions(Float_t *ypos)
-{
-// Set y-positions of Slats
- for (Int_t islat=0; islat<fNSlats; islat++) fYPosition[islat]=ypos[islat];
-}
-
-//_________________________________________________
-AliMUONSegmentationSlatModule* AliMUONSegmentationSlat::Slat(Int_t index) const
- //PH { return ((AliMUONSegmentationSlatModule*) (*fSlats)[index]);}
-{
- return ((AliMUONSegmentationSlatModule*) fSlats->At(index));
-}
-
-//_________________________________________________
-AliMUONSegmentationSlatModule* AliMUONSegmentationSlat::
-CreateSlatModule() const
-{
- // Factory method for slat module
- return new AliMUONSegmentationSlatModule(4);
-}
-
-//_________________________________________________
-void AliMUONSegmentationSlat::Draw(const char* opt)
-{
- // Draw method for event display
- //
- if (!strcmp(opt,"eventdisplay")) {
- const int kColorMUON1 = kYellow;
- const int kColorMUON2 = kBlue;
- //
- // Drawing Routines for example for Event Display
- Int_t i,j;
- Int_t npcb[15];
- char nameChamber[9], nameSlat[9], nameNode[9];
-
- //
- // Number of modules per slat
- for (i = 0; i < fNSlats; i++) {
- npcb[i] = 0;
- for (j = 0; j < 4; j++) npcb[i] += fPcb[i][j];
- }
- //
- TNode* top=gAlice->GetGeometry()->GetNode("alice");
- sprintf(nameChamber,"C_MUON%d",fId+1);
- new TBRIK(nameChamber,"Mother","void",340,340,5.);
- top->cd();
- sprintf(nameNode,"MUON%d",100+fId+1);
- TNode* node = new TNode(nameNode,"Chambernode",nameChamber,0,0,fChamber->Z(),"");
-
- node->SetLineColor(kBlack);
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- (pMUON->Nodes())->Add(node);
- TNode* nodeSlat;
- Int_t color;
-
- for (j = 0; j < fNSlats; j++) {
- sprintf(nameSlat,"SLAT%d",100*fId+1+j);
- Float_t dx = 20.*npcb[j];
- Float_t dy = 20;
- new TBRIK(nameSlat,"Slat Module","void",dx,20.,0.25);
- node->cd();
- color = TMath::Even(j) ? kColorMUON1 : kColorMUON2;
-
- sprintf(nameNode,"SLAT%d",100*fId+1+j);
- nodeSlat =
- new TNode(nameNode,"Slat Module",nameSlat, dx+fXPosition[j],fYPosition[j]+dy,0,"");
- nodeSlat->SetLineColor(color);
- node->cd();
- sprintf(nameNode,"SLAT%d",100*fId+1+j+fNSlats);
- nodeSlat =
- new TNode(nameNode,"Slat Module",nameSlat,-dx-fXPosition[j],fYPosition[j]+dy,0,"");
- nodeSlat->SetLineColor(color);
- }
- }
-}
-
-
-
+++ /dev/null
-/**************************************************************************
- * 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 //
-// to be used with AluMUONSegmentationSlat //
-/////////////////////////////////////////////////////
-
-#include <TArrayI.h>
-#include <TArrayF.h>
-
-#include "AliMUONSegmentationSlatModule.h"
-#include "AliLog.h"
-
-//___________________________________________
-ClassImp(AliMUONSegmentationSlatModule)
-
-AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule()
- : AliMUONSegmentationV0()
-{
-// Default constructor
- fNDiv = 0;
- fDpxD = 0;
-}
-
-AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule(Int_t nsec)
- : AliMUONSegmentationV0()
-{
-// Non default constructor
- fNsec = nsec;
- fNDiv = new TArrayI(fNsec);
- fDpxD = new TArrayF(fNsec);
- (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;
- (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;
-}
-
-//----------------------------------------------------------------------
-AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule(
- const AliMUONSegmentationSlatModule& rhs)
- : AliMUONSegmentationV0(rhs)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-
-AliMUONSegmentationSlatModule::~AliMUONSegmentationSlatModule()
-{
-// Destructor
- if (fNDiv) delete fNDiv;
- if (fDpxD) delete fDpxD;
-}
-
-//----------------------------------------------------------------------
-AliMUONSegmentationSlatModule&
-AliMUONSegmentationSlatModule::operator=(
- const AliMUONSegmentationSlatModule& rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
-
-void AliMUONSegmentationSlatModule::SetPcbBoards(Int_t n[4])
-{
-//
-// Set Pcb Board segmentation zones
- for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
-}
-
-
-void AliMUONSegmentationSlatModule::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];
-}
-
-Float_t AliMUONSegmentationSlatModule::Dpx(Int_t isec) const
-{
-// Return x-strip width
- return (*fDpxD)[isec];
-}
-
-
-Float_t AliMUONSegmentationSlatModule::Dpy(Int_t /*isec*/) const
-{
-// Return y-strip width
-
- return fDpy;
-}
-
-
-void AliMUONSegmentationSlatModule::
-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 = Int_t(y/fDpy)+1;
- if (iy > fNpy) iy= fNpy;
-//
-// 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>0) {
- ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
- +fNpxS[isec-1]+1;
- } else if (isec == 0) {
- ix= Int_t(x/(*fDpxD)[isec])+1;
- } else {
- ix=0;
- iy=0;
- }
-}
-
-void AliMUONSegmentationSlatModule::
-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 = Float_t(iy*fDpy)-fDpy/2.;
-//
-// Find sector isec
- Int_t isec=AliMUONSegmentationSlatModule::Sector(ix,iy);
- if (isec == -1) printf("\n PadC %d %d %d %d \n ", isec, fId, ix, iy);
-//
- if (isec>0) {
- x = fCx[isec-1]+(ix-fNpxS[isec-1])*(*fDpxD)[isec];
- x = x-(*fDpxD)[isec]/2;
- } else {
- x=y=0;
- }
-}
-//-------------------------------------------------------------------------
-void AliMUONSegmentationSlatModule::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
-{
- GetPadI(x, y, ix, iy);
-}
-//-------------------------------------------------------------------------
-void AliMUONSegmentationSlatModule::
-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 AliMUONSegmentationSlatModule::
-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 AliMUONSegmentationSlatModule::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
-{
- SetHit(xhit, yhit);
-}
-//----------------------------------------------------------
-void AliMUONSegmentationSlatModule::
-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];
-
- 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 AliMUONSegmentationSlatModule::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
-{
- FirstPad(xhit, yhit, dx, dy);
-}
-//----------------------------------------------------------------------
-void AliMUONSegmentationSlatModule::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=-1;
- fIy=-1;
- }
-// printf("\n Next Pad %d %d %f %f %d %d %d %d %d ",
-}
-
-
-Int_t AliMUONSegmentationSlatModule::MorePads()
-{
-// Stopping condition for the iterator over pads
-//
-// Are there more pads in the integration region
-
- return (fIx != -1 || fIy != -1);
-}
-
-
-Int_t AliMUONSegmentationSlatModule::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) printf("\n Sector: Attention isec ! %d %d %d %d \n",
- fId, ix, iy,fNpxS[3]);
-
- return isec;
-
-}
-
-void AliMUONSegmentationSlatModule::
-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 AliMUONSegmentationSlatModule::
-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;
- }
-
-//
-// step up
- if (iY+1 <= fNpy) {
- Xlist[i]=iX;
- Ylist[i++]=iY+1;
- }
-//
-// step down
- if (iY-1 > 0) {
- Xlist[i]=iX;
- Ylist[i++]=iY-1;
- }
-
- *Nlist=i;
-}
-
-
-void AliMUONSegmentationSlatModule::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
-//
-// Segmentation is defined by rectangular modules approximating
-// concentric circles as shown below
-//
-// PCB module size in cm
- // printf("\n Initialise Segmentation SlatModule \n");
-
- fDxPCB=40;
- fDyPCB=40;
-//
-// number of pad rows per PCB
-//
- Int_t nPyPCB=Int_t(fDyPCB/fDpy);
-//
-// maximum number of pad rows
- fNpy=nPyPCB;
-//
-// Calculate padsize along x
- (*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
-//
-//
-// Loop over sectors (isec=0 is the dead space surounding the beam pipe)
- for (Int_t isec=0; isec<4; isec++) {
- if (isec==0) {
- fNpxS[0] = 0;
- fNpyS[0] = 0;
- fCx[0] = 0;
- } else {
- fNpxS[isec]=fNpxS[isec-1] + fPcbBoards[isec]*Int_t(fDxPCB/(*fDpxD)[isec]);
- fNpyS[isec]=fNpy;
- fCx[isec]=fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
- }
- } // sectors
-// maximum number of pad rows
- fNpy=nPyPCB;
- fNpx=fNpxS[3];
-//
- fId = chamber;
-}
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * 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 //
-// to be used with AluMUONSegmentationSlat //
-/////////////////////////////////////////////////////
-
-
-#include <TArrayI.h>
-#include <TArrayF.h>
-
-#include "AliMUONSegmentationSlatModuleN.h"
-
-//___________________________________________
-ClassImp(AliMUONSegmentationSlatModuleN)
-
-AliMUONSegmentationSlatModuleN::AliMUONSegmentationSlatModuleN()
- : AliMUONSegmentationSlatModule()
-{
-// Default constructor
-}
-
-AliMUONSegmentationSlatModuleN::AliMUONSegmentationSlatModuleN(Int_t nsec)
- : AliMUONSegmentationSlatModule(nsec)
-{
-// Non default constructor
-}
-
-
-Float_t AliMUONSegmentationSlatModuleN::Dpx(Int_t /*isec*/) const
-{
-//
-// Returns x-pad size for given sector isec
- return fDpx;
-}
-
-Float_t AliMUONSegmentationSlatModuleN::Dpy(Int_t isec) const
-{
-//
-// Returns y-pad size for given sector isec
- return (*fDpxD)[isec];
-}
-
-
-void AliMUONSegmentationSlatModuleN::
-GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
-{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-//
- ix = Int_t(x/fDpx)+1;
- if (ix > fNpx) ix= fNpx;
-//
-// 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) {
- ix = 0;
- iy = 0;
- } else {
- iy = Int_t(y/(*fDpxD)[isec])+1;
- }
-}
-
-void AliMUONSegmentationSlatModuleN::
-GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
-{
-// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
-//
- x = Float_t(ix*fDpx)-fDpx/2.;
-//
-// Find sector isec
- Int_t isec=Sector(ix,iy);
- if (isec == -1) printf("\n gtpadc2 Warning isec !\n");
- y = iy*(*fDpxD)[isec]-(*fDpxD)[isec]/2.;
-}
-
-
-void AliMUONSegmentationSlatModuleN::NextPad()
-{
-// Stepper for the iteration over pads
-//
- Float_t xc,yc;
- Int_t ixc;
- // step up
- if ((fY + Dpy(fSector)) < fYmax) {
- fIy++;
- GetPadC(fIx,fIy,fX,fY);
-// step right
- } else if (fIx != fIxmax) {
- fIx++;
-// get y-position of next row (yc), xc not used here
- GetPadC(fIx,fIy,xc,yc);
-// get x-pad coordiante for 1 pad in row (fIx)
- GetPadI(xc,fYmin,ixc,fIy);
- GetPadC(fIx,fIy,fX,fY);
- fSector=Sector(fIx,fIy);
- } else {
- fIx=fIy=-1;
- }
-
- if (fIy > fNpyS[fSector]) printf("\n this pad %f %f %d %d \n",fX,fY,fIx,fIy);
- GetPadC(fIx, fIy, xc, yc);
-// printf("\n Next Pad (n)%d %d %f %f %d %f %d ", fIx,fIy,fX,fY,fSector, fYmax, fIxmax);
-}
-
-Int_t AliMUONSegmentationSlatModuleN::MorePads()
-{
-// Stopping condition for the iterator over pads
-//
-//
-// Are there more pads in the integration region
-
- if (fIy == -1) {
- return 0;
- } else {
- return 1;
- }
-}
-
-void AliMUONSegmentationSlatModuleN::
-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;
- Float_t x,y;
- Int_t ix,iy,isec1,isec2;
- Float_t kEpsil= 0.001;
-
-//
-// step up
- Int_t isec=Sector(iX, iY);
-
- if (iY+1 <= fNpyS[isec]) {
- Xlist[i]=iX;
- Ylist[i++]=iY+1;
- }
-//
-// step down
- if (iY-1 > 0) {
- Xlist[i]=iX;
- Ylist[i++]=iY-1;
- }
-//
-//
-// step right
-
- if (iX+1 <= fNpx) {
-
-
- GetPadC(iX, iY, x, y);
- GetPadI(x+fDpx, y, ix, iy);
- Xlist[i]=iX+1;
- Ylist[i++]=iy;
- }
-//
-// step left
- if (iX-1 > 0) {
- isec1=Sector(iX, iY);
- isec2=Sector(iX-1, iY);
- if (isec1==isec2) {
- Xlist[i]=iX-1;
- Ylist[i++]=iY;
- } else {
- GetPadC(iX, iY, x, y);
- GetPadI(x-fDpx, y+kEpsil, ix, iy);
- if (ix != -1) {
- Xlist[i]=iX-1;
- Ylist[i++]=iy;
- }
- GetPadI(x-fDpx, y-kEpsil, ix, iy);
- if (ix != -1) {
- Xlist[i]=iX-1;
- Ylist[i++]=iy;
- }
- }
- }
- *Nlist=i;
-}
-
-
-void AliMUONSegmentationSlatModuleN::Init(Int_t chamber)
-{
-//
-// Fill the arrays fCx (x-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 SlatModuleN \n");
-
-
- fDxPCB=40;
- fDyPCB=40;
-//
-// number of pad rows per PCB
-//
- fNpxPCB = Int_t(fDxPCB/fDpx) ;
-//
-// Calculate padsize along y
- (*fDpxD)[fNsec-1]=fDpy;
- 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
-//
-//
-// Loop over sectors (isec=0 is the dead space surounding the beam pipe)
-
- for (Int_t isec=0; isec<4; isec++) {
- if (isec==0) {
- fCx[0] = 0;
- fNpxS[0] = 0;
- fNpyS[0] = 0;
- } else {
- fNpxS[isec] = fNpxS[isec-1] + fPcbBoards[isec]*fNpxPCB;
- fNpyS[isec] = Int_t(fDyPCB/fDpy)*(*fNDiv)[isec];
- fCx[isec] = fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
- fNpx += fPcbBoards[isec] * fNpxPCB;
- }
- } // sectors
-
- fNpx=fNpxS[3];
- fNpy=Int_t(fDyPCB/fDpy)*(*fNDiv)[1];
-//
- fId = chamber;
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-#include <TArrayI.h>
-#include <TMath.h>
-
-#include "AliMUONSegmentationSlatN.h"
-#include "AliMUONSegmentationSlatModuleN.h"
-
-//___________________________________________
-ClassImp(AliMUONSegmentationSlatN)
-
-AliMUONSegmentationSlatN::AliMUONSegmentationSlatN()
- : AliMUONSegmentationSlat()
-{
-// Default constructor
-}
-
-
-AliMUONSegmentationSlatN::AliMUONSegmentationSlatN(Int_t nsec)
- : AliMUONSegmentationSlat(nsec)
-{
-// Non default constructor
-}
-
-
-Float_t AliMUONSegmentationSlatN::Dpx(Int_t /*isec*/) const
-{
-//
-// Returns y-pad size for given sector isec
- return fDpx;
-}
-
-Float_t AliMUONSegmentationSlatN::Dpy(Int_t isec) const
-{
-//
-// Returns x-pad size for given sector isec
-// isec = 100*islat+iregion
-//
- Int_t islat, iregion;
- islat = isec/100;
- iregion = isec%100;
- return Slat(islat)->Dpy(iregion);
-}
-
-
-
-void AliMUONSegmentationSlatN::GlobalToLocal(
- Int_t ix, Int_t iy, Int_t &islat, Int_t &ixlocal, Int_t &iylocal) const
-{
-//
-// Perform local to global transformation for pad coordinates
-//
- Int_t iytemp = iy;
- Int_t index = 0;
-
- iylocal = iytemp;
- ix=TMath::Abs(ix);
-
-//
-// Find slat number (index) and iylocal
- for (Int_t i=0; i<fNSlats; i++) {
- if (ix <= Slat(i)->Npx()) {
- Int_t isec=Slat(i)->Sector(ix,1);
- iytemp-=Slat(i)->Npy()*(*fNDiv)[isec]/(*fNDiv)[1];
- }
- if (iytemp <= 0) break;
- iylocal = iytemp;
- index=i+1;
- }
- ixlocal=ix;
- islat=index;
-}
-
-void AliMUONSegmentationSlatN::LocalToGlobal(
- Int_t islat, Int_t ixlocal, Int_t iylocal, Int_t &ix, Int_t &iy) const
-{
-// Local to global transformation for pad coordinates
-
- Int_t i;
- iy=iylocal;
-
-//
-// Find iy global by adding iy offset from slats below
- for (i=0; i<islat; i++) {
- if (ixlocal <= Slat(i)->Npx()) {
- Int_t isec=Slat(i)->Sector(ixlocal,1);
- iy+=Slat(i)->Npy()*(*fNDiv)[isec]/(*fNDiv)[1];
- }
- }
-//
-// Perform symmetry transformation
- ix=ixlocal*fSym;
-}
-
-
-void AliMUONSegmentationSlatN::
-GetPadI(Float_t x, Float_t y, Float_t z, Int_t &ix, Int_t &iy)
-{
-// Returns pad coordinates for given set of space coordinates
-
- Int_t islat, i;
- Float_t xlocal, ylocal;
-// Transform to local coordinates
- AliMUONSegmentationSlat::GlobalToLocal(x,y,z,islat,xlocal,ylocal);
- Slat(islat)->GetPadI(xlocal, ylocal, ix, iy);
-// add to local iy offfset from slats below
- for (i=0; i<islat; i++) {
- if (ix <= Slat(i)->Npx()) {
- Int_t isec=Slat(i)->Sector(ix,1);
- iy+=Slat(i)->Npy()*(*fNDiv)[isec]/(*fNDiv)[1];
- }
- }
-// Determine sign depending on quadrant
- ix=ix*Int_t(TMath::Sign((Float_t)1.,x));
-}
-
-AliMUONSegmentationSlatModule* AliMUONSegmentationSlatN::
-CreateSlatModule() const
-{
- // Factory method for slat module
- return new AliMUONSegmentationSlatModuleN(4);
-}
-
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-#include <TMath.h>
-//#include <TRandom.h>
-//#include <TArc.h>
-//#include <Riostream.h>
-
-#include "AliMUONSegmentationTrigger.h"
-#include "AliMUONTriggerConstants.h"
-#include "AliMUONConstants.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliLog.h"
-
-ClassImp(AliMUONSegmentationTrigger)
-
-//------------------------------------------------------------------
-AliMUONSegmentationTrigger::AliMUONSegmentationTrigger()
- : AliMUONSegmentationV0()
-{
-// Constructor
-
- fChamber=0;
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTrigger::Init(Int_t chamber)
-{
- // initialize Module geometry
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- AliMUONChamber* iChamber=&(pMUON->Chamber(chamber));
-
- AliDebug(2,"Initialize Trigger Chamber Module Geometry");
-
- Float_t zPos=iChamber->Z();
- Float_t z1Pos=AliMUONConstants::DefaultChamberZ(10); //cp changed
- fZscale = zPos/z1Pos;
-
- Float_t y1Cmin[126];
- Float_t y1Cmax[126];
-
- Float_t dz=7.2;
- Float_t z1PosPlus=z1Pos-dz/2.;
- Float_t z1PosMinus=z1Pos+dz/2.;
-
- Float_t z1pm=z1PosPlus/z1PosMinus;
- Float_t z1mp=z1PosMinus/z1PosPlus;
-
- AliDebug(2,Form("fZscale = %f ",fZscale));
-// calculate yCmin and fYcmax
- Int_t i;
- for (i=62; i>=0; i--) {
- Int_t j=ModuleNumber(-AliMUONTriggerConstants::ModuleId(i)); // i == right, j == left
- if (Int_t(AliMUONTriggerConstants::ModuleId(i)/10)==5) { // start with middle chamber
- if (AliMUONTriggerConstants::ModuleId(i)==51) { // special case (empty module)
- fYcmin[i]=fYcmax[i]=fYcmin[j]=fYcmax[j]=0.;
- } else {
- y1Cmin[i]=y1Cmin[j]=-34;
- y1Cmax[i]=y1Cmax[j]=34;
- fYcmin[i]=fYcmin[j]=-34.;
-
- fYcmax[i]=fYcmax[j]=34.;
- }
- } else if (Int_t(AliMUONTriggerConstants::ModuleId(i)/10)==4) { // up
- if (AliMUONTriggerConstants::ModuleId(i)!=41) {
- y1Cmin[i]=y1Cmax[i+7]*z1pm;
- y1Cmax[i]=y1Cmin[i]+68.;
- fYcmin[i]=y1Cmin[i];
- fYcmax[i]=fYcmin[i]+68.;
-
- y1Cmin[j]=y1Cmax[j+7]*z1mp;
- y1Cmax[j]=y1Cmin[j]+68.;
- fYcmin[j]=y1Cmin[j];
- fYcmax[j]=fYcmin[j]+68.;
- } else {
- y1Cmin[i]=y1Cmin[ModuleNumber(42)]+17;
- y1Cmax[i]=y1Cmin[i]+51.;
- fYcmin[i]=y1Cmin[i];
- fYcmax[i]=fYcmin[i]+51.;
-
- y1Cmin[j]=y1Cmin[ModuleNumber(-42)]+17;
- y1Cmax[j]=y1Cmin[j]+51.;
- fYcmin[j]=y1Cmin[j];
- fYcmax[j]=fYcmin[j]+51.;
- }
- } else if (Int_t(AliMUONTriggerConstants::ModuleId(i)/10)==3) {
- y1Cmin[i]=y1Cmax[i+7]*z1mp;
- y1Cmax[i]=y1Cmin[i]+68.;
- fYcmin[i]=y1Cmin[i];
- fYcmax[i]=fYcmin[i]+68.;
-
- y1Cmin[j]=y1Cmax[j+7]*z1pm;
- y1Cmax[j]=y1Cmin[j]+68.;
- fYcmin[j]=y1Cmin[j];
- fYcmax[j]=fYcmin[j]+68.;
- } else if (Int_t(AliMUONTriggerConstants::ModuleId(i)/10)==2) {
- y1Cmin[i]=y1Cmax[i+7]*z1pm;
- y1Cmax[i]=y1Cmin[i]+68.;
- fYcmin[i]=y1Cmin[i];
- fYcmax[i]=fYcmin[i]+68.;
-
- y1Cmin[j]=y1Cmax[j+7]*z1mp;
- y1Cmax[j]=y1Cmin[j]+68.;
- fYcmin[j]=y1Cmin[j];
- fYcmax[j]=fYcmin[j]+68.;
- } else if (Int_t(AliMUONTriggerConstants::ModuleId(i)/10)==1) {
- y1Cmin[i]=y1Cmax[i+7]*z1mp;
- y1Cmax[i]=y1Cmin[i]+68.;
- fYcmin[i]=y1Cmin[i];
- fYcmax[i]=fYcmin[i]+68.;
-
- y1Cmin[j]=y1Cmax[j+7]*z1pm;
- y1Cmax[j]=y1Cmin[j]+68.;
- fYcmin[j]=y1Cmin[j];
- fYcmax[j]=fYcmin[j]+68.;
- }
- }
-
- for (i=0; i<63; i++) { // second loop (fill lower part)
- Int_t j=ModuleNumber(-AliMUONTriggerConstants::ModuleId(i)); // i == right, j == left
- if (TMath::Abs(Int_t(AliMUONTriggerConstants::ModuleId(i)/10))==6) {
- fYcmin[i]=-fYcmax[i-14];
- fYcmax[i]=-fYcmin[i-14];
- fYcmin[j]=-fYcmax[j-14];
- fYcmax[j]=-fYcmin[j-14];
- } else if (TMath::Abs(Int_t(AliMUONTriggerConstants::ModuleId(i)/10))==7) {
- fYcmin[i]=-fYcmax[i-28];
- fYcmax[i]=-fYcmin[i-28];
- fYcmin[j]=-fYcmax[j-28];
- fYcmax[j]=-fYcmin[j-28];
- } else if (TMath::Abs(Int_t(AliMUONTriggerConstants::ModuleId(i)/10))==8) {
- fYcmin[i]=-fYcmax[i-42];
- fYcmax[i]=-fYcmin[i-42];
- fYcmin[j]=-fYcmax[j-42];
- fYcmax[j]=-fYcmin[j-42];
- } else if (TMath::Abs(Int_t(AliMUONTriggerConstants::ModuleId(i)/10))==9) {
- fYcmin[i]=-fYcmax[i-56];
- fYcmax[i]=-fYcmin[i-56];
- fYcmin[j]=-fYcmax[j-56];
- fYcmax[j]=-fYcmin[j-56];
- }
- }
-
- fNpx=124;
- fNpy=64;
-
-// Set parent chamber number
- fChamber=&(pMUON->Chamber(chamber));
- fId=chamber;
-}
-//------------------------------------------------------------------
-void AliMUONSegmentationTrigger::Draw(const char * /*opt*/) {}
-//------------------------------------------------------------------
-Int_t AliMUONSegmentationTrigger::ModuleNumber(Int_t imodule){
-// returns module number (from 0 to 126) corresponding to module imodule
- Int_t imod=0;
- for (Int_t i=0; i<AliMUONTriggerConstants::Nmodule(); i++) {
- if (AliMUONTriggerConstants::ModuleId(i)==imodule) {
- imod=i;
- break;
- }
- }
- return imod;
-}
-//------------------------------------------------------------------
-void AliMUONSegmentationTrigger::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
-{
- SetHit(xhit, yhit);
-}
-//------------------------------------------------------------------
-Float_t AliMUONSegmentationTrigger::StripSizeX(Int_t imodule){
-// Returns x-strip size for given module imodule
-
- Int_t absimodule=TMath::Abs(imodule);
- Int_t moduleNum=ModuleNumber(imodule);
- if (absimodule==51) {
- return 0.;
- } else {
- return TMath::Abs((fYcmax[moduleNum]-fYcmin[moduleNum])/
- AliMUONTriggerConstants::NstripX(moduleNum));
- }
-}
-
-//------------------------------------------------------------------
-Float_t AliMUONSegmentationTrigger::StripSizeY(Int_t imodule, Int_t istrip){
-// Returns y-strip size for given module imodule
-
- Int_t absimodule=TMath::Abs(imodule);
- Int_t moduleNum=ModuleNumber(imodule);
- if (absimodule==51) {
- return 0.;
- } else if (TMath::Abs(imodule-10*Int_t(imodule/10.))==7) {
- if (istrip<8) {
- return AliMUONTriggerConstants::StripWidth(2);
- }
- else if (istrip>7) {
- return AliMUONTriggerConstants::StripWidth(1);
- }
- else {
- return 0.;
- }
- } else {
- return TMath::Abs((AliMUONTriggerConstants::XcMax(moduleNum) -
- AliMUONTriggerConstants::XcMin(moduleNum)) /
- AliMUONTriggerConstants::NstripY(moduleNum));
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTrigger::SetHit(Float_t xhit, Float_t yhit)
-{
- // Sets virtual hit position, needed for evaluating pad response
- // outside the tracking program
-
- fXhit=xhit;
- fYhit=yhit;
-}
-
-
-
-
-
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-#include <TMath.h>
-#include <TBRIK.h>
-#include <TNode.h>
-#include <TGeometry.h>
-
-#include "AliMUON.h"
-#include "AliMUONSegmentationTriggerX.h"
-#include "AliMUONTriggerConstants.h"
-#include "AliMUONChamber.h"
-#include "AliRun.h" // gAlice
-#include "AliLog.h"
-
-ClassImp(AliMUONSegmentationTriggerX)
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::Init(Int_t chamber)
-{
-// intialize X segmentation
- AliDebug(2,"Initialize Trigger Chamber Geometry X");
- AliMUONSegmentationTrigger::Init(chamber);
-
-// calculate x & y position of X strips
- Int_t nModule=AliMUONTriggerConstants::Nmodule();
- for (Int_t imodule=0; imodule<nModule; imodule++) {
- Float_t width=StripSizeX(AliMUONTriggerConstants::ModuleId(imodule));
- Int_t nStrip=AliMUONTriggerConstants::NstripX(imodule);
- for (Int_t istrip=0; istrip<nStrip; istrip++){
- fXofxsmin[imodule][istrip] = AliMUONTriggerConstants::XcMin(imodule)*fZscale;
- fXofxsmax[imodule][istrip] = AliMUONTriggerConstants::XcMax(imodule)*fZscale;
-
- fYofxsmin[imodule][istrip] = (fYcmin[imodule]+width*(istrip))*fZscale;
- fYofxsmax[imodule][istrip] = (fYcmin[imodule]+width*(istrip+1))*fZscale;
-/*
- if (TMath::Abs(AliMUONTriggerConstants::ModuleId(imodule))==11) {
- printf("module Id istrip fXofxsmin fXofxsmax fYofxsmin fYofxsmax %d %d %f %f %f %f \n",
- AliMUONTriggerConstants::ModuleId(imodule),
- istrip,
- fXofxsmin[imodule][istrip],
- fXofxsmax[imodule][istrip],
- fYofxsmin[imodule][istrip],
- fYofxsmax[imodule][istrip]);
- }
-*/
- }
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy)
-{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-// x,y = real coordinates; ix = module number , iy = strip number
- ix = 0;
- iy = 0;
- Int_t nModule=AliMUONTriggerConstants::Nmodule();
- for (Int_t imodule=0; imodule<nModule; imodule++) {
- Int_t nStrip=AliMUONTriggerConstants::NstripX(imodule);
- for (Int_t istrip=0; istrip<nStrip; istrip++){
- if (x>fXofxsmin[imodule][istrip]&&x<fXofxsmax[imodule][istrip]&&
- y>fYofxsmin[imodule][istrip]&&y<fYofxsmax[imodule][istrip]){
- ix = AliMUONTriggerConstants::ModuleId(imodule);
- iy = istrip;
- }
- }
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
-{
-// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
-// ix = module number , iy = strip number; x,y = center of strip
- x = 0.;
- y = 0.;
- Int_t nModule=AliMUONTriggerConstants::Nmodule();
-
- for (Int_t imodule=0; imodule<nModule; imodule++) {
- if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
- x=fXofxsmin[imodule][iy]+(fXofxsmax[imodule][iy]-fXofxsmin[imodule][iy])/2.;
- y=fYofxsmin[imodule][iy]+(fYofxsmax[imodule][iy]-fYofxsmin[imodule][iy])/2.;
- }
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::SetPadSize(Float_t p1, Float_t p2)
-{
-// Sets the padsize
-//
- fDpx=p1;
- fDpy=p2;
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::
-Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]){
-// Returns list of 10 next neighbours for given X strip (ix, iy)
-// neighbour number 4 in the list -
-// neighbour number 3 in the list |
-// neighbour number 2 in the list |_ Upper part
-// neighbour number 1 in the list |
-// neighbour number 0 in the list -
-// X strip (ix, iy)
-// neighbour number 5 in the list -
-// neighbour number 6 in the list | _ Lower part
-// neighbour number 7 in the list |
-// neighbour number 8 in the list |
-// neighbour number 9 in the list -
-
- Int_t absiX = TMath::Abs(iX);
- Int_t numModule = ModuleNumber(absiX); // module number Id.
- Int_t nStrip = AliMUONTriggerConstants::NstripX(numModule); //numb of strips
- Int_t iCandidateUp, iCandidateDo;
- Int_t j;
-
- *Nlist = 10;
- for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;
-
- if (iY < nStrip) {
-
- for (Int_t i=0; i<5; i++) {
- j = i + 5;
- iCandidateUp = iY + (i + 1);
- iCandidateDo = iY - (i + 1);
- if (iCandidateUp < nStrip) {
- Xlist[i] = iX;
- Ylist[i] = iCandidateUp;
- }
- if (iCandidateDo >= 0) {
- Xlist[j] = iX;
- Ylist[j] = iCandidateDo;
- }
- }
-
- } // iY < nStrip
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::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);
- GetPadI(fX,fY,fIx,fIy);
- fSector=Sector(ix,iy);
-}
-
-//------------------------------------------------------------------
-Int_t AliMUONSegmentationTriggerX::ISector()
-{ return fSector;}
-
-//------------------------------------------------------------------
-Int_t AliMUONSegmentationTriggerX::Ix()
-{ return fIx;}
-
-//------------------------------------------------------------------
-
-Int_t AliMUONSegmentationTriggerX::Iy()
-{ return fIy;}
-
-//------------------------------------------------------------------
-Float_t AliMUONSegmentationTriggerX::Dpx(Int_t isec) const
-{
-// returns x size of x strips for sector isec
-
- if (isec==1) {
- return AliMUONTriggerConstants::StripLength(0)*fZscale;
- } else if (isec==2) {
- return AliMUONTriggerConstants::StripLength(1)*fZscale;
- } else if (isec==3) {
- return AliMUONTriggerConstants::StripLength(1)*fZscale;
- } else if (isec==4) {
- return AliMUONTriggerConstants::StripLength(1)*fZscale;
- } else if (isec==5) {
- return AliMUONTriggerConstants::StripLength(1)*fZscale;
- } else if (isec==6) {
- return AliMUONTriggerConstants::StripLength(2)*fZscale;
- } else {
- return 0.;
- }
-}
-
-//------------------------------------------------------------------
-Float_t AliMUONSegmentationTriggerX::Dpy(Int_t isec) const
-{
-// returns y size of x strips for sector isec
-
- if (isec==1) {
- return AliMUONTriggerConstants::StripWidth(0)*fZscale;
- } else if (isec==2) {
- return AliMUONTriggerConstants::StripWidth(0)*fZscale;
- } else if (isec==3) {
- return AliMUONTriggerConstants::StripWidth(0)*fZscale;
- } else if (isec==4) {
- return AliMUONTriggerConstants::StripWidth(1)*fZscale;
- } else if (isec==5) {
- return AliMUONTriggerConstants::StripWidth(2)*fZscale;
- } else if (isec==6) {
- return AliMUONTriggerConstants::StripWidth(2)*fZscale;
- } else {
- return 0.;
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::GetPadI(Float_t x, Float_t y, Float_t /*z*/, Int_t &ix, Int_t &iy)
-{
- GetPadI(x, y, ix, iy);
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::SetHit(Float_t xhit, Float_t yhit)
-{
-// set hit during disIntegration
-AliMUONSegmentationTrigger::SetHit(xhit,yhit);
-}
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
-{
- SetHit(xhit, yhit);
-}
-
-//------------------------------------------------------------------
-Int_t AliMUONSegmentationTriggerX::Sector(Int_t ix, Int_t /*iy*/)
-{
-// Returns sector number for given module
-//
-
- Int_t absix=TMath::Abs(ix);
- Int_t iwidth=Int_t(StripSizeX(absix));
-
- if (absix==52) {
- return 1;
- } else if (absix==41||absix==61) {
- return 2;
- } else if (iwidth==1) {
- return 3;
- } else if (iwidth==2) {
- return 4;
- } else if ((absix>=11&&absix<17)||(absix>=91&&absix<97)) {
- return 5;
- } else if (iwidth==4) {
- return 6;
- } else {
- return 0;
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::
-IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4)
-{
-// returns quantities needed to evaluate neighbour strip response
-
- Int_t ix,iy;
- Float_t xstrip,ystrip;
- GetPadI(fXhit,fYhit,ix,iy);
- GetPadC(ix,iy,xstrip,ystrip);
- x1=fYhit; // hit y position
- x2=ystrip; // y coordinate of the main strip
- x3=fY; // current strip real y coordinate
- // width=StripSizeX(ix); // width of the main strip
-
- // find the position of the 2 borders of the current strip
- Float_t ymin = fYofxsmin[ModuleNumber(fIx)][fIy];
- Float_t ymax = fYofxsmax[ModuleNumber(fIx)][fIy];
-
- // dist. between the hit and the closest border of the current strip
- x4 = (TMath::Abs(ymax-x1) > TMath::Abs(ymin-x1)) ?
- TMath::Abs(ymin-x1):TMath::Abs(ymax-x1);
-
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerX::Draw(const char* opt)
-{
-// Draw method for event display
- if (!strcmp(opt,"eventdisplay")) {
-
- TNode *node, *nodeS;
- char nameChamber[10], nameNode[12];
- char nameSense1[10], nameSense2[10], nameSense3[10], nameSense4[10];
-
- TNode* top=gAlice->GetGeometry()->GetNode("alice");
- sprintf(nameChamber,"C_MUON%d",fId+1);
- new TBRIK(nameChamber,"Mother","void",340.,340.,0.25);
- top->cd();
- sprintf(nameNode,"MUON%d",100+fId+1);
- node = new TNode(nameNode,"Chambernode",nameChamber,0,0,fChamber->Z(),"");
- node->SetLineColor(kBlack);
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- (pMUON->Nodes())->Add(node);
-
- sprintf(nameSense1,"S1_MUON%d",fId+1);
- sprintf(nameSense2,"S2_MUON%d",fId+1);
- sprintf(nameSense3,"S3_MUON%d",fId+1);
- sprintf(nameSense4,"S4_MUON%d",fId+1);
-
- for (Int_t imodule=0; imodule<AliMUONTriggerConstants::Nmodule(); imodule++) {
- Int_t idModule=AliMUONTriggerConstants::ModuleId(imodule);
-
- if (TMath::Abs(idModule)!=51) {
-
- Int_t nStripX=AliMUONTriggerConstants::NstripX(imodule);
- Float_t xmin=fXofxsmin[imodule][0];
- Float_t xmax=fXofxsmax[imodule][nStripX-1];
- Float_t ymin=fYofxsmin[imodule][0];
- Float_t ymax=fYofxsmax[imodule][nStripX-1];
- Float_t xpos=xmin+(xmax-xmin)/2.;
- Float_t ypos=ymin+(ymax-ymin)/2.;
- Float_t halfx=(xmax-xmin)/2.;
- Float_t halfy=(ymax-ymin)/2.;
-
- if (idModule==11)
- new TBRIK(nameSense1,"Module","void",halfx,halfy,0.25);
- if (idModule==17)
- new TBRIK(nameSense2,"Module","void",halfx,halfy,0.25);
- if (idModule==41)
- new TBRIK(nameSense3,"Module","void",halfx,halfy,0.25);
- if (idModule==52)
- new TBRIK(nameSense4,"Module","void",halfx,halfy,0.25);
- node->cd();
- sprintf(nameNode,"S_MUON%d",1000*fId+1+imodule);
-
- if (TMath::Abs(idModule)==41||TMath::Abs(idModule)==61) {
- nodeS = new TNode(nameNode,"Module",nameSense3,xpos,ypos,0,"");
- } else if (TMath::Abs(idModule)==52) {
- nodeS = new TNode(nameNode,"Module",nameSense4,xpos,ypos,0,"");
- } else if (TMath::Abs((idModule-Int_t(idModule/10)*10.))!=7) {
- nodeS = new TNode(nameNode,"Module",nameSense1,xpos,ypos,0,"");
- } else {
- // } else if (TMath::Abs((idModule-Int_t(idModule/10)*10.))==7) {
- nodeS = new TNode(nameNode,"Module",nameSense2,xpos,ypos,0,"");
- }
- nodeS->SetLineColor(kBlue);
- node->cd();
- }
- }
- }
-}
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-#include <TMath.h>
-
-#include "AliMUONSegmentationTriggerY.h"
-#include "AliMUONTriggerConstants.h"
-#include "AliMUON.h"
-#include "AliRun.h"
-#include "AliLog.h"
-
-ClassImp(AliMUONSegmentationTriggerY)
-
-//------------------------------------------------------------------
-AliMUONSegmentationTriggerY::AliMUONSegmentationTriggerY()
- : AliMUONSegmentationTrigger()
-{
-// Constructor
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::Init(Int_t chamber)
-{
-// intialize Y segmentation
- AliDebug(2,"Initialize Trigger Chamber Geometry Y");
- AliMUONSegmentationTrigger::Init(chamber);
-
-// calculate x & y position of Y strips
- Int_t nModule=AliMUONTriggerConstants::Nmodule();
- for (Int_t imodule=0; imodule<nModule; imodule++) {
- Int_t moduleId=AliMUONTriggerConstants::ModuleId(imodule);
- Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);
- for (Int_t istrip=0; istrip<nStrip; istrip++){
- Float_t width=StripSizeY(moduleId,istrip);
-
- if (imodule<63) {
- if (moduleId-10*Int_t(moduleId/10.)==7&&istrip>7) {
- fXofysmin[imodule][istrip]=
- ( AliMUONTriggerConstants::XcMin(imodule)+
- (width*2.)*8 + width*(istrip-8) )*fZscale;
- fXofysmax[imodule][istrip]=
- ( AliMUONTriggerConstants::XcMin(imodule)+
- (width*2.)*8 + width*(istrip-7) )*fZscale;
- } else {
- fXofysmin[imodule][istrip]=
- (AliMUONTriggerConstants::XcMin(imodule)
- +width*(istrip))*fZscale;
- fXofysmax[imodule][istrip]=
- (AliMUONTriggerConstants::XcMin(imodule)
- +width*(istrip+1))*fZscale;
-
- }
-
- } else {
- fXofysmin[imodule][istrip]=-1.*fXofysmax[imodule-63][istrip];
- fXofysmax[imodule][istrip]=-1.*fXofysmin[imodule-63][istrip];
- }
- fYofysmin[imodule][istrip] = fYcmin[imodule]*fZscale;
- fYofysmax[imodule][istrip] = fYcmax[imodule]*fZscale;
- }
- }
-/*
- if (TMath::Abs(AliMUONTriggerConstants::ModuleId(imodule))==11) {
- printf("module Id istrip fXofxsmin fXofxsmax fYofxsmin fYofxsmax %d %d %f %f %f %f \n",
- AliMUONTriggerConstants::ModuleId(imodule),
- istrip,
- fXofysmin[imodule][istrip],
- fXofysmax[imodule][istrip],
- fYofysmin[imodule][istrip],
- fYofysmax[imodule][istrip]);
- }
-*/
-
-}
-
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy)
-{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-// x,y = real coordinates; ix = module number , iy = strip number
-
- ix = 0;
- iy = 0;
- Int_t nModule=AliMUONTriggerConstants::Nmodule();
- for (Int_t imodule=0; imodule<nModule; imodule++) {
- Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);
- for (Int_t istrip=0; istrip<nStrip; istrip++){
- if (x>fXofysmin[imodule][istrip]&&x<fXofysmax[imodule][istrip]&&
- y>fYofysmin[imodule][istrip]&&y<fYofysmax[imodule][istrip]){
- ix = AliMUONTriggerConstants::ModuleId(imodule);
- iy = istrip;
- }
- }
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
-{
-// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
-// ix = module number , iy = strip number; x,y = center of strip
- x = 0.;
- y = 0.;
- Int_t nModule=AliMUONTriggerConstants::Nmodule();
- for (Int_t imodule=0; imodule<nModule; imodule++) {
- if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
- x=fXofysmin[imodule][iy]+(fXofysmax[imodule][iy]-fXofysmin[imodule][iy])/2.;
- y=fYofysmin[imodule][iy]+(fYofysmax[imodule][iy]-fYofysmin[imodule][iy])/2.;
- }
- }
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::SetPadSize(Float_t p1, Float_t p2)
-{
-// Sets the padsize
-//
- fDpx=p1;
- fDpy=p2;
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::
-Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]){
-// Returns list of 10 next neighbours for given Y strip (ix, iy)
-// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
-// \_______/ \_______/
-// left right
-// Note : should not be used to return a list of neighbours larger than 16 !
-
- Int_t absiX = TMath::Abs(iX);
- Int_t numModule = ModuleNumber(absiX); // module number Id.
- Int_t nStrip = AliMUONTriggerConstants::NstripY(numModule); //numb of strips
- Int_t iCandidateLeft, iCandidateRight;
- Int_t iNewCandidateRight=0;
- Int_t iNewCandidateLeft=0;
-// first strip number on the right of the left module
- if ( (absiX-(Int_t(absiX/10))*10)!=1 && absiX!=52 )
- iNewCandidateLeft =
- AliMUONTriggerConstants::NstripY(ModuleNumber(absiX-1))-1;
- Int_t j;
-
- *Nlist = 10;
- for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;
-
- if (iY < nStrip) {
-
- for (Int_t i=0; i<5; i++) {
- j = i + 5;
- iCandidateRight = iY + (i + 1);
- iCandidateLeft = iY - (i + 1);
- if (iCandidateRight < nStrip) { // strip in same module
- Xlist[i] = absiX;
- Ylist[i] = iCandidateRight;
- } else if ((absiX+1)%10!=8) { // need to scan the module on the right
- Xlist[i] = absiX+1;
- Ylist[i] = iNewCandidateRight;
- iNewCandidateRight++;
- }
-
- if (iCandidateLeft >=0 ) { // strip in same module
- Xlist[j] = absiX;
- Ylist[j] = iCandidateLeft;
- } else if ( iNewCandidateLeft !=0) {
- Xlist[j] = absiX-1;
- Ylist[j] = iNewCandidateLeft;
- iNewCandidateLeft--;
- }
- }
-
- if (iX<0) { // left side of chamber
- for (Int_t i=0; i<10; i++) {
- if (Xlist[i]!=0) Xlist[i]=-Xlist[i];
- }
- }
-
- } // iY < nStrip
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::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);
- GetPadI(fX,fY,fIx,fIy);
- fSector=Sector(ix,iy);
-}
-
-//------------------------------------------------------------------
-Int_t AliMUONSegmentationTriggerY::ISector()
-{ return fSector;}
-
-//------------------------------------------------------------------
-
-Int_t AliMUONSegmentationTriggerY::Ix()
-{ return fIx;}
-
-//------------------------------------------------------------------
-
-Int_t AliMUONSegmentationTriggerY::Iy()
-{ return fIy;}
-
-//------------------------------------------------------------------
-Float_t AliMUONSegmentationTriggerY::Dpx(Int_t isec) const
-{
-// returns x size of y strips for sector isec
- if (isec==1) {
- return AliMUONTriggerConstants::StripWidth(1)*fZscale;
- } else if (isec==2) {
- return AliMUONTriggerConstants::StripWidth(1)*fZscale;
- } else if (isec==3) {
- return AliMUONTriggerConstants::StripWidth(1)*fZscale;
- } else if (isec==4) {
- return AliMUONTriggerConstants::StripWidth(2)*fZscale;
- } else {
- return 0.;
- }
-}
-
-//------------------------------------------------------------------
-Float_t AliMUONSegmentationTriggerY::Dpy(Int_t isec) const
-{
-// returns y size of y strips for sector isec
- if (isec==1) {
- return AliMUONTriggerConstants::StripLength(3)*fZscale;
- } else if (isec==2) {
- return AliMUONTriggerConstants::StripLength(2)*fZscale;
- } else if (isec==3) {
- return AliMUONTriggerConstants::StripLength(3)*fZscale;
- } else if (isec==4) {
- return AliMUONTriggerConstants::StripLength(3)*fZscale;
- } else if (isec==5) {
- return AliMUONTriggerConstants::StripLength(3)*fZscale;
- } else {
- return 0.;
- }
-}
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::GetPadI(Float_t x, Float_t y, Float_t /*z*/, Int_t &ix, Int_t &iy)
-{
- GetPadI(x, y, ix, iy);
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::SetHit(Float_t xhit, Float_t yhit)
-{
-// set hits during diintegration
- AliMUONSegmentationTrigger::SetHit(xhit,yhit);
-}
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
-{
- SetHit(xhit, yhit);
-}
-//------------------------------------------------------------------
-Int_t AliMUONSegmentationTriggerY::Sector(Int_t ix, Int_t iy)
-{
-// Returns sector number for given module
-//
- Int_t absix=TMath::Abs(ix);
- Int_t iwidth=Int_t(StripSizeY(absix,iy));
-
- if (absix==52) {
- return 1;
- } else if (absix==41||absix==61) {
- return 2;
- } else if (iwidth==2) {
- return 3;
- } else if (iwidth==4) {
- return 4;
- } else {
- return 0;
- }
-
-}
-
-//------------------------------------------------------------------
-void AliMUONSegmentationTriggerY::
-IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4)
-{
-// returns quantities needed to evaluate neighbour strip response
- Int_t ix,iy;
- Float_t xstrip,ystrip;
- GetPadI(fXhit,fYhit,ix,iy);
- GetPadC(ix,iy,xstrip,ystrip);
- x1=fXhit; // hit x position
- x2=xstrip; // x coordinate of the main strip
- x3=fX; // current strip real x coordinate
- // width=StripSizeY(ix); // width of the main strip
-
- // find the position of the 2 borders of the current strip
- Float_t xmin = fXofysmin[ModuleNumber(fIx)][fIy];
- Float_t xmax = fXofysmax[ModuleNumber(fIx)][fIy];
-
- // dist. between the hit and the closest border of the current strip
- x4 = (TMath::Abs(xmax-x1) > TMath::Abs(xmin-x1)) ?
- TMath::Abs(xmin-x1):TMath::Abs(xmax-x1);
-
-}
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/* $Id$ */
-
-#include <TArc.h>
-#include <TMath.h>
-
-#include "AliMUONSegmentationV0.h"
-#include "AliMUONChamber.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-#include "AliLog.h"
-
-ClassImp(AliMUONSegmentationV0)
-
-AliMUONSegmentationV0::AliMUONSegmentationV0()
- : AliSegmentation()
-{
- fCorr=0;
- fChamber=0;
-}
-
-AliMUONSegmentationV0::AliMUONSegmentationV0(const AliMUONSegmentationV0& segmentation)
- : AliSegmentation(segmentation)
-{
-// Protected copy constructor
-
- AliFatal("Not implemented.");
-}
-
-
-/*
-// Commented out - not used
-
-void AliMUONSegmentationV0::Init(Int_t chamber)
-{
-// Initialises member data of the segmentation from geometry data
-// owned by Chamber
-//
-
- AliMUON *pMUON = (AliMUON *) gAlice->GetModule("MUON");
- fChamber=&(pMUON->Chamber(chamber));
-
-// Initialise maximum number of pads in x ans y
- fNpx=(Int_t) (fChamber->ROuter()/fDpx+1);
- fNpy=(Int_t) (fChamber->ROuter()/fDpy+1);
-// Initialize inner and outer radius of the sensitive region
- fRmin=fChamber->RInner();
- fRmax=fChamber->ROuter();
- fCorr=0;
- fZ=fChamber->Z();
- fId=chamber;
-}
-*/
-
-Float_t AliMUONSegmentationV0::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 AliMUONSegmentationV0::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t *Nparallel, Int_t *Offset)
-{
- *Nparallel=1;
- *Offset=0;
-}
-
-
-//____________________________________________________________________________
-void AliMUONSegmentationV0::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
-{
- GetPadI(x, y, ix, iy);
-}
-//____________________________________________________________________________
-void AliMUONSegmentationV0::SetCorrFunc(Int_t /*dum*/, TF1* func)
-{
- fCorr=func;
-}
-//____________________________________________________________________________
-Int_t AliMUONSegmentationV0::Sector(Int_t /*ix*/, Int_t /*iy*/)
-{
- return 1;
-}
-//____________________________________________________________________________
-Int_t AliMUONSegmentationV0::Sector(Float_t /*x*/, Float_t /*y*/)
-{
- return 1;
-}
-//____________________________________________________________________________
-void AliMUONSegmentationV0::SetPadSize(Float_t p1, Float_t p2)
-{
-// Sets the padsize
-//
- fDpx=p1;
- fDpy=p2;
-}
-
-void AliMUONSegmentationV0::
- GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
-{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-//
- ix = (x>0)? Int_t(x/fDpx)+1 : Int_t(x/fDpx)-1;
- iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy)-1;
- if (iy > fNpy) iy= fNpy;
- if (iy < -fNpy) iy=-fNpy;
- if (ix > fNpx) ix= fNpx;
- if (ix < -fNpx) ix=-fNpx;
-}
-
-void AliMUONSegmentationV0::
-GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
-{
-// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
-//
-// Comments and Critics:
-
-// The Pad(0,0) does not exist, this causes in the present version errors
-// during iteration when used with hits close to zero.
-// Since we have frame crosses at x=0 or y=0 this does not cause any problems
-// Nevertheless, should be corrected in the next version !!
-// The name fRmin is misleading although we use this version with
-// a circular chamber geometry.
-
- x = (ix>0) ? Float_t(ix*fDpx)-fDpx/2. : Float_t(ix*fDpx)+fDpx/2.;
- y = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)+fDpy/2.;
-}
-//______________________________________________________________________
-void AliMUONSegmentationV0::SetHit(Float_t xhit, Float_t yhit)
-{
- //
- // Sets virtual hit position, needed for evaluating pad response
- // outside the tracking program
- fXhit=xhit;
- fYhit=yhit;
-}
-//_______________________________________________________________________
-void AliMUONSegmentationV0::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
-{
- SetHit(xhit, yhit);
-}
-//_______________________________________________________________________
-
-
-void AliMUONSegmentationV0::
-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);
-}
-//____________________________________________________________________________________
-void AliMUONSegmentationV0::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);
- //
- // Set current pad to lower left corner
- fIx=fIxmin;
- fIy=fIymin;
- GetPadC(fIx,fIy,fX,fY);
-}
-//________________________________________________________________________
-void AliMUONSegmentationV0::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
- {FirstPad(xhit, yhit, dx, dy);}
-
-
-void AliMUONSegmentationV0::NextPad()
-{
- // Stepper for the iteration over pads
- //
- // Comments and Critics:
- // Boundary crossing at x=0 or y=0 not correctly handled !
- // Step to next pad in the integration region
- if (fIx != fIxmax) {
- if (fIx==-1) fIx++;
- fIx++;
- } else if (fIy != fIymax) {
- fIx=fIxmin;
- if (fIy==-1) fIy++;
- fIy++;
- } else {
- printf("\n Error: Stepping outside integration region\n ");
- }
- GetPadC(fIx,fIy,fX,fY);
-}
-
-Int_t AliMUONSegmentationV0::MorePads()
-{
-// Stopping condition for the iterator over pads
-//
-// Are there more pads in the integration region ?
-
- if (fIx == fIxmax && fIy == fIymax) {
- return 0;
- } else {
- return 1;
-
- }
-}
-
-void AliMUONSegmentationV0::SigGenInit(Float_t x,Float_t y,Float_t /*z*/)
-{
-//
-// Initialises pad and wire position during stepping
- fXt =x;
- fYt =y;
- GetPadI(x,y,fIxt,fIyt);
- fIwt= (x>0) ? Int_t(x/fWireD)+1 : Int_t(x/fWireD)-1 ;
-}
-
-Int_t AliMUONSegmentationV0::SigGenCond(Float_t x,Float_t y,Float_t /*z*/)
-{
-// Signal generation condition during stepping
-// 0: don't generate signal
-// 1: generate signal
-// Comments and critics:
-
-// 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.
- 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 AliMUONSegmentationV0::
-IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
-{
-// Returns integration limits for current pad
-//
- x1=fXhit-fX-fDpx/2.;
- x2=x1+fDpx;
- y1=fYhit-fY-fDpy/2.;
- y2=y1+fDpy;
-}
-
-void AliMUONSegmentationV0::
-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)
-//
-// Comments and critics
-// "Diagonal" neighbours are not passed
-// Is this ok when we search for local maxima ??
-// No test whether neighbours have valid indices id performed
- *Nlist=4;
- Xlist[0]=Xlist[1]=iX;
- Xlist[2]=iX-1;
- Xlist[3]=iX+1;
- Ylist[0]=iY-1;
- Ylist[1]=iY+1;
- Ylist[2]=Ylist[3]=iY;
-}
-
-Float_t AliMUONSegmentationV0::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);
-}
-
-
-void AliMUONSegmentationV0::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=1;
- x[0]=(fRmax+fRmin)/2/TMath::Sqrt(2.);
- y[0]=x[0];
-}
-
-/*
-// Commented out - not used
-
-void AliMUONSegmentationV0::Draw(const char *)
-{
-// Draws the segmentation zones
-//
- TArc *circle;
- Float_t scale=0.95/fRmax/2.;
-
-
- circle = new TArc(0.5,0.5,fRmax*scale,0.,360.);
- circle->SetFillColor(2);
- circle->Draw();
-
- circle = new TArc(0.5,0.5,fRmin*scale,0.,360.);
- circle->SetFillColor(1);
- circle->Draw();
-}
-*/
-
-AliMUONSegmentationV0&
-AliMUONSegmentationV0::operator =(const AliMUONSegmentationV0 & rhs)
-{
-// Protected assignement operator
-
- if (this == &rhs) return *this;
-
- AliFatal("Not implemented.");
-
- return *this;
-}
+++ /dev/null
-/**************************************************************************
- * 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;
-}
-
+++ /dev/null
-/**************************************************************************
- * 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 02 //
-/////////////////////////////////////////////////////
-
-#include <TArrayF.h>
-
-#include "AliMUONSegmentationV02.h"
-
-//___________________________________________
-ClassImp(AliMUONSegmentationV02)
-
-
-AliMUONSegmentationV02::AliMUONSegmentationV02()
- : AliMUONSegmentationV01()
-{
-// Default constructor
-}
-
-AliMUONSegmentationV02::AliMUONSegmentationV02(Int_t nsec)
- : AliMUONSegmentationV01(nsec)
-{
-// Non default constructor
-}
-
-void AliMUONSegmentationV02::SetPadSize(Float_t p1, Float_t p2)
-{
-// Sets the padsize
-//
- fDpy=p1;
- fDpx=p2;
-}
-
-Int_t AliMUONSegmentationV02::Npx() const
-// Returns maximum number if pads in x
-{return AliMUONSegmentationV01::Npy();}
-
-Int_t AliMUONSegmentationV02::Npy() const
-// Returns maximum number if pads in y
-{return AliMUONSegmentationV01::Npx();}
-
-
-Float_t AliMUONSegmentationV02::Dpx(Int_t /*isec*/) const
-// Returns pad-size in x
-{return fDpy;}
-
-Float_t AliMUONSegmentationV02::Dpy(Int_t isec) const
-// Returns pad-size in y
-{return (*fDpxD)[isec];}
-
-void AliMUONSegmentationV02::Draw(const char * /*opt*/) const
-{}
-
-Int_t AliMUONSegmentationV02::Sector(Int_t ix, Int_t iy)
-// Returns sector number for given pad position
-//
-{return AliMUONSegmentationV01::Sector(iy, ix);}
-
-void AliMUONSegmentationV02::
-GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-//
-{
-AliMUONSegmentationV01::GetPadI(y, x, iy, ix);
-// printf("\n x,y,ix,iy %f %f %d %d", x,y,ix,iy);
-}
-
-void AliMUONSegmentationV02::GetPad(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
-{
- GetPadI(x, y, ix, iy);
-}
-
-void AliMUONSegmentationV02::
-GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
-{
-// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
-//
-
- AliMUONSegmentationV01::GetPadC(iy, ix, y, x);
-}
-void AliMUONSegmentationV02::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 AliMUONSegmentationV02::NextPad()
-{
-// Stepper for the iteration over pads
-//
- //
- // Step to next pad in integration region
- Float_t xc,yc;
- Int_t ixc;
-
-// step up
- if (fY < fYmax && fY != 0) {
- if (fIy==-1) fIy++;
- fIy++;
-// step right
- } else if (fIx != fIxmax) {
- if (fIx==-1) fIx++;
- fIx++;
-// get y-position of next row (yc), xc not used here
- GetPadC(fIx,fIy,xc,yc);
-// get x-pad coordiante for 1 pad in row (fIx)
- GetPadI(xc,fYmin,ixc,fIy);
- } else {
- fIx=fIy=-1;
- }
- GetPadC(fIx,fIy,fX,fY);
- fSector=Sector(fIx,fIy);
- if (MorePads() &&
- (fSector ==-1 || fSector==0 ))
- NextPad();
-// printf("\n this pad %f %f %d %d \n",fX,fY,fIx,fIy);
-
-}
-
-Int_t AliMUONSegmentationV02::MorePads()
-{
-// Stopping condition for the iterator over pads
-//
-//
-// Are there more pads in the integration region
-
- return (fIx != -1 || fIy != -1);
-/*
- if ((fY >= fYmax && fIx >= fIxmax) || fX==0) {
- return 0;
- } else {
- return 1;
- }
-*/
-}
-
-void AliMUONSegmentationV02::
-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 n;
- AliMUONSegmentationV01::Neighbours(iY, iX, &n, Ylist, Xlist);
- *Nlist=n;
-}
-
-
-
-
+++ /dev/null
-/**************************************************************************
- * 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$ */
-
-// Authors: David Guez, Ivana Hrivnacova, Marion MacCormick; IPN Orsay
-//
-// Class AliMUONSt1Segmentation
-// ------------------------------
-// Segmentation for MUON station 1 using the external
-// mapping package
-// Included in AliRoot 2003/01/28
-
-#include <TError.h>
-#include <TF1.h>
-#include <TObjArray.h>
-#include <TVector2.h>
-
-#include "AliMpPad.h"
-#include "AliMpPlane.h"
-#include "AliMpPlaneAreaPadIterator.h"
-#include "AliMpPlaneSegmentation.h"
-
-#include "AliMUONSt1Segmentation.h"
-#include "AliRun.h"
-#include "AliMUON.h"
-#include "AliMUONChamber.h"
-#include "AliLog.h"
-
-ClassImp(AliMUONSt1Segmentation)
-
-const Float_t AliMUONSt1Segmentation::fgkWireD = 0.20;
-const Float_t AliMUONSt1Segmentation::fgkLengthUnit = 0.1;
-
-//______________________________________________________________________________
-AliMUONSt1Segmentation::AliMUONSt1Segmentation(const AliMpPlaneType planeType)
-: AliSegmentation(),
- fPlane(0),
- fPlaneSegmentation(0),
- fPlaneIterator(0),
- fWireD(fgkWireD),
- fChamber(0),
- fId(0),
- fRmin(0.),
- fRmax(0.),
- fZ(0.),
- fIx(0),
- fIy(0),
- fX(0.),
- fY(0.),
- fSector(0),
- fXhit(0.),
- fYhit(0.),
- fIxt(0),
- fIyt(0),
- fIwt(0),
- fXt(0.),
- fYt(0.),
- fCorrA(0)
-{
-// Normal constructor
- fPlane = AliMpPlane::Create(kStation1, planeType);
- fPlaneSegmentation = new AliMpPlaneSegmentation(fPlane);
-
- fCorrA = new TObjArray(3);
- fCorrA->AddAt(0,0);
- fCorrA->AddAt(0,1);
- fCorrA->AddAt(0,2);
-}
-
-//______________________________________________________________________________
-AliMUONSt1Segmentation::AliMUONSt1Segmentation()
-: AliSegmentation(),
- fPlane(0),
- fPlaneSegmentation(0),
- fPlaneIterator(0),
- fWireD(fgkWireD),
- fChamber(0),
- fId(0),
- fRmin(0.),
- fRmax(0.),
- fZ(0.),
- fIx(0),
- fIy(0),
- fX(0.),
- fY(0.),
- fSector(0),
- fXhit(0.),
- fYhit(0.),
- fIxt(0),
- fIyt(0),
- fIwt(0),
- fXt(0.),
- fYt(0.),
- fCorrA(0) {
-// Default Constructor
-}
-
-//______________________________________________________________________________
-AliMUONSt1Segmentation::AliMUONSt1Segmentation(const AliMUONSt1Segmentation& rhs)
- : AliSegmentation(rhs)
-{
-// Copy constructor
- AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
-AliMUONSt1Segmentation::~AliMUONSt1Segmentation() {
-// Destructor
-
- delete fPlane;
- delete fPlaneSegmentation;
- delete fPlaneIterator;
-}
-
-//
-// operators
-//
-
-//______________________________________________________________________________
-AliMUONSt1Segmentation&
-AliMUONSt1Segmentation::operator=(const AliMUONSt1Segmentation& rhs)
-{
-// Copy operator
-
- // check assignement to self
- if (this == &rhs) return *this;
-
- AliFatal("Assignment operator is not implemented.");
-
- return *this;
-}
-
-//
-// private methods
-//
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::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;
- fSector = fPlaneSegmentation->Zone(pad);
-}
-
-//
-// public methods
-//
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::SetPadSize(Float_t /*p1*/, Float_t /*p2*/)
-{
-// Set pad size Dx*Dy
-// ---
-
- AliFatal("Not uniform pad size.");
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::SetDAnod(Float_t d)
-{
-// Set anod pitch
-// ---
-
- fWireD = d;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::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 = fPlaneSegmentation
- ->PadByPosition(TVector2(x/fgkLengthUnit, y/fgkLengthUnit), false);
-
- ix = pad.GetIndices().GetFirst();
- iy = pad.GetIndices().GetSecond();
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::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 = fPlaneSegmentation->PadByIndices(AliMpIntPair(ix,iy));
-
- x = pad.Position().X() * fgkLengthUnit;
- y = pad.Position().Y() * fgkLengthUnit;
-}
-
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::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 = fChamber->Z();
- fId=chamber;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONSt1Segmentation::Dpx() const
-{
-// Get pad size in x
-// ---
-
- AliFatal( "Not uniform pad size.");
- return 0.;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONSt1Segmentation::Dpy() const
-{
-// Get pad size in y
-// ---
-
- AliFatal("Not uniform pad size.");
- return 0.;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONSt1Segmentation::Dpx(Int_t isector) const
-{
-// Pad size in x by sector
-// ---
-
- return fPlaneSegmentation->PadDimensions(isector).X()*2.*fgkLengthUnit;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONSt1Segmentation::Dpy(Int_t isector) const
-{
-// Pad size in x, y by Sector
-// ---
-
- return fPlaneSegmentation->PadDimensions(isector).Y()*2.*fgkLengthUnit;
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::Npx() const
-{
-// Maximum number of Pads in x
-// ---
-
- //Fatal("Npx", "Not yet implemented.");
- return 142; //hard coded for the time being
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::Npy() const
-{
-// Maximum number of Pads in y
-// ---
-
- //Fatal("Npy", "Not yet implemented.");
- return 213; //hard coded for the time being
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::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);
- fSector = Sector(ix, iy);
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::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;
-
- fPlaneIterator
- = fPlaneSegmentation
- ->CreateIterator(AliMpArea(TVector2(fXhit/fgkLengthUnit, fYhit/fgkLengthUnit),
- TVector2(dx/fgkLengthUnit, dy/fgkLengthUnit)));
-
- fPlaneIterator->First();
-
- if (! fPlaneIterator->IsDone())
- UpdateCurrentPadValues(fPlaneIterator->CurrentItem());
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::NextPad()
-{
-// Iterate over pads - stepper
-// ---
-
- fPlaneIterator->Next();
-
- if (! fPlaneIterator->IsDone())
- UpdateCurrentPadValues(fPlaneIterator->CurrentItem());
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::MorePads()
-{
-// Iterate over pads - condition
-// ---
-
- if (fPlaneIterator->IsDone())
- return 0;
- else
- return 1;
-}
-
-//______________________________________________________________________________
-Float_t AliMUONSt1Segmentation::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 = fPlaneSegmentation->PadByIndices(AliMpIntPair(iX, iY));
-
- if (!pad.IsValid())
- AliFatal("Cannot locate pad.");
-
- return (pad.Position()*fgkLengthUnit - TVector2(x, y)).Mod2();
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::Neighbours(Int_t iX, Int_t iY,
- Int_t* Nlist,
- Int_t Xlist[10], Int_t Ylist[10])
-{
-// Get next neighbours
-// ---
-
- AliMpPad pad = fPlaneSegmentation->PadByIndices(AliMpIntPair(iX,iY));
- Int_t &i = *Nlist;
- i=0;
- AliMpVPadIterator* iter
- = fPlaneSegmentation
- ->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 AliMUONSt1Segmentation::Ix()
-{
-// Current pad cursor during disintegration
-// x, y-coordinate
-// ---
-
- return fPlaneIterator->CurrentItem().GetIndices().GetFirst();
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::Iy()
-{
-// Current pad cursor during disintegration
-// x, y-coordinate
-// ---
-
- return fPlaneIterator->CurrentItem().GetIndices().GetSecond();
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::ISector()
-{
-// Current sector
-// ---
-
- return fSector;
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::Sector(Int_t ix, Int_t iy)
-{
-// Calculate sector from pad coordinates
-// ---
-
- return fPlaneSegmentation
- ->Zone(fPlaneSegmentation->PadByIndices(AliMpIntPair(ix, iy)));
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::Sector(Float_t x, Float_t y)
-{
-// Calculate sector from pad coordinates
-// ---
-
- return fPlaneSegmentation
- ->Zone(fPlaneSegmentation
- ->PadByPosition(TVector2(x/fgkLengthUnit, y/fgkLengthUnit)));
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::IntegrationLimits(Float_t& x1, Float_t& x2,
- Float_t& y1, Float_t& y2)
-{
-// Current integration limits
-// ---
-
- x1 = fXhit - fX - Dpx(fSector)/2.;
- x2 = x1 + Dpx(fSector);
-
- y1 = fYhit - fY - Dpy(fSector)/2.;
- y2 = y1 + Dpy(fSector);
-}
-
-//______________________________________________________________________________
-Int_t AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::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 AliMUONSt1Segmentation::Draw(const char * /*opt*/)
-{
-// Draw the segmentation zones.
-// (Called from AliMUON::BuildGeometry)
-// ---
-
- AliWarning("Not yet implemented.");
-}
-
-//______________________________________________________________________________
-void AliMUONSt1Segmentation::SetCorrFunc(Int_t isec, TF1* func)
-{
-// Set the correction function.
-// From AliMUONSegmentationV01
-// ---
-
- fCorrA->AddAt(func, isec);
-}
-
-//______________________________________________________________________________
-TF1* AliMUONSt1Segmentation::CorrFunc(Int_t isec) const
-{
-// Get the correction Function.
-// From AliMUONSegmentationV01
-// ---
-
- return (TF1*) fCorrA->At(isec);
-}
-
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff