[u/mrichter/AliRoot.git] / FMD / AliFMDRing.cxx

/**************************************************************************
 * Copyright(c) 2004, 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$ */
/** @file    AliFMDRing.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:47:43 2006
    @brief   FMD ring geometry parameters 
*/
//__________________________________________________________________
//
// Utility class to help implement collection of FMD modules into
// rings.  This is used by AliFMDDetector and AliFMDGeometry.
// The AliFMDGeometry object owns the AliFMDRing objects, and the
// AliFMDDetector objects reference these.  That is, the AliFMDRing
// objects are share amoung the AliFMDDetector objects.
//
// Latest changes by Christian Holm Christensen
//

#include <TMath.h>		// ROOT_TMath
#include <TVector2.h>		// ROOT_TVector2

// #include <AliLog.h>		// ALILOG_H
#include "AliFMDRing.h"		// ALIFMDRING_H

//====================================================================
ClassImp(AliFMDRing)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliFMDRing::AliFMDRing(Char_t id) 
  : TNamed(Form("FMD%c", id), "Forward multiplicity ring"), 
    fId(id), 
    fBondingWidth(0),
    fWaferRadius(0),
    fSiThickness(0),
    fLowR(0),
    fHighR(0),
    fMinR(0),
    fMaxR(0),
    fTheta(0),
    fNStrips(0),
    fRingDepth(0),
    fLegRadius(0),
    fLegLength(0),
    fLegOffset(0),
    fModuleSpacing(0),
    fPrintboardThickness(0),
    fCopperThickness(0),
    fChipThickness(0),
    fSpacing(0),
    fHoneycombThickness(0.),
    fAlThickness(0.),
    fVerticies(0), 
    fSensorVerticies(0),
    fHybridVerticies(0),
    fFeetPositions(0)
{
  // CTOR
  SetBondingWidth();
  SetWaferRadius();
  SetSiThickness();
  SetLegRadius();
  SetLegLength();
  SetLegOffset();
  SetModuleSpacing();
  SetPrintboardThickness();
  SetCopperThickness();
  SetChipThickness();
  SetSpacing();
  SetHoneycombThickness();
  SetAlThickness();
  
  if (fId == 'I' || fId == 'i') {
    SetLowR(4.3);
    SetHighR(17.2);
    SetTheta(36/2);
    SetNStrips(512);
    Double_t base = 0; // 4.1915;
    fFeetPositions.Add(new TVector2( 0.0551687, 8.0534-base));
    fFeetPositions.Add(new TVector2( 2.9993,   12.9457-base));
    fFeetPositions.Add(new TVector2(-2.9062,   12.9508-base));
    
    fHybridVerticies.Add(new TVector2(0.0000,  4.1700));
    fHybridVerticies.Add(new TVector2(1.0574,  4.1700));
    fHybridVerticies.Add(new TVector2(4.6614, 15.2622));
    fHybridVerticies.Add(new TVector2(0.9643, 17.4000));
    fHybridVerticies.Add(new TVector2(0.0000, 17.4000));

    fSensorVerticies.Add(new TVector2(0.0000,  4.1915));
    fSensorVerticies.Add(new TVector2(1.5793,  4.1915));
    fSensorVerticies.Add(new TVector2(5.2293, 15.4251));
    fSensorVerticies.Add(new TVector2(1.9807, 17.3035));
    fSensorVerticies.Add(new TVector2(0.0000, 17.3035));

    fVerticies.Add(new TVector2(0.0000,  4.3000));
    fVerticies.Add(new TVector2(1.3972,  4.3000));
    fVerticies.Add(new TVector2(4.9895, 15.3560));
    fVerticies.Add(new TVector2(1.8007, 17.2000));
    fVerticies.Add(new TVector2(0.0000, 17.2000));
  }
  else if (fId == 'O' || fId == 'o') {
    SetLowR(15.6);
    SetHighR(28.0);
    SetTheta(18/2);
    SetNStrips(256);
    Double_t base = 0; // 14.9104;
    fFeetPositions.Add(new TVector2(-1.72540000, 20.6267-base));
    fFeetPositions.Add(new TVector2( 1.72900000, 20.6267-base));
    fFeetPositions.Add(new TVector2( 0.00177616, 26.6007-base));

    fHybridVerticies.Add(new TVector2(0.0000, 14.9104));
    fHybridVerticies.Add(new TVector2(2.0783, 14.9104));
    fHybridVerticies.Add(new TVector2(3.9202, 26.5395));
    fHybridVerticies.Add(new TVector2(0.6784, 28.2500));
    fHybridVerticies.Add(new TVector2(0.0000, 28.2500));

    fSensorVerticies.Add(new TVector2(0.0000, 15.0104));
    fSensorVerticies.Add(new TVector2(2.5799, 15.0104));
    fSensorVerticies.Add(new TVector2(4.4439, 26.7766));
    fSensorVerticies.Add(new TVector2(1.8350, 28.1500));
    fSensorVerticies.Add(new TVector2(0.0000, 28.1500));

    fVerticies.Add(new TVector2(0.0000, 15.2104));
    fVerticies.Add(new TVector2(2.4091, 15.2104));
    fVerticies.Add(new TVector2(4.2231, 26.6638));
    fVerticies.Add(new TVector2(1.8357, 27.9500));
    fVerticies.Add(new TVector2(0.0000, 27.9500));
  }
}

//____________________________________________________________________
void
AliFMDRing::Init()
{
  // Initialize 
#if 0
  Double_t tanTheta  = TMath::Tan(fTheta * TMath::Pi() / 180.);
  Double_t tanTheta2 = TMath::Power(tanTheta,2);
  Double_t r2        = TMath::Power(fWaferRadius,2);
  Double_t yA        = tanTheta * fLowR;
  Double_t lr2       = TMath::Power(fLowR, 2);
  Double_t hr2       = TMath::Power(fHighR,2);
  Double_t xD        = fLowR + TMath::Sqrt(r2 - tanTheta2 * lr2);
  Double_t xD2       = TMath::Power(xD,2);
  Double_t yB        = TMath::Sqrt(r2 - hr2 + 2 * fHighR * xD - xD2);
  Double_t xC        = ((xD + TMath::Sqrt(-tanTheta2 * xD2 + r2
					  + r2 * tanTheta2)) 
			/ (1 + tanTheta2));
  Double_t yC        = tanTheta * xC;
  
  fVerticies.Expand(6);
  fVerticies.AddAt(new TVector2(fLowR,  -yA), 0);
  fVerticies.AddAt(new TVector2(xC,     -yC), 1);
  fVerticies.AddAt(new TVector2(fHighR, -yB), 2);
  fVerticies.AddAt(new TVector2(fHighR,  yB), 3);
  fVerticies.AddAt(new TVector2(xC,      yC), 4);
  fVerticies.AddAt(new TVector2(fLowR,   yA), 5);  
#endif

  // A's length. Corresponds to distance from nominal beam line to the
  // cornor of the active silicon element. 
  fMinR = GetVertex(1)->Mod(); // GetVertex(5)->Mod();
  // A's length. Corresponds to distance from nominal beam line to the
  // cornor of the active silicon element. 
  fMaxR = fHighR;

  fRingDepth = (fSiThickness + fPrintboardThickness 
		+ fCopperThickness + fChipThickness 
		+ fLegLength + fModuleSpacing + fSpacing);
}

//____________________________________________________________________
TVector2*
AliFMDRing::GetVertex(Int_t i) const
{
  // Get the i'th vertex of polygon shape
  return static_cast<TVector2*>(fVerticies.At(i));
}

//____________________________________________________________________
TVector2*
AliFMDRing::GetSensorVertex(Int_t i) const
{
  // Get the i'th vertex of polygon shape
  return static_cast<TVector2*>(fSensorVerticies.At(i));
}

//____________________________________________________________________
TVector2*
AliFMDRing::GetHybridVertex(Int_t i) const
{
  // Get the i'th vertex of polygon shape
  return static_cast<TVector2*>(fHybridVerticies.At(i));
}

//____________________________________________________________________
TVector2*
AliFMDRing::GetFootPosition(Int_t i) const
{
  // Get the i'th vertex of polygon shape
  return static_cast<TVector2*>(fFeetPositions.At(i));
}

//____________________________________________________________________
Double_t
AliFMDRing::GetStripRadius(UShort_t strip) const
{
  // Return the nominal strip radius 
  Double_t rmax     = GetMaxR();
  Double_t stripoff = GetMinR();
  Double_t dstrip   = (rmax - stripoff) / GetNStrips();
  return (strip + .5) * dstrip + stripoff; // fLowR
}
 
//____________________________________________________________________
Double_t
AliFMDRing::GetModuleDepth() const
{
  return (GetSiThickness() 
	  + GetSpacing() 
	  + GetPrintboardThickness()
	  + GetCopperThickness()
	  + GetChipThickness()
	  + GetLegLength());
  
}

//____________________________________________________________________
Double_t
AliFMDRing::GetFullDepth() const
{
  return (GetModuleDepth() 
	  + GetModuleSpacing()
	  + GetHoneycombThickness()
	  + GetFMDDPrintboardThickness()
	  + GetFMDDCopperThickness()
	  + GetFMDDChipThickness() 
	  + 0.5);
}

//____________________________________________________________________
void
AliFMDRing::Detector2XYZ(UShort_t sector,
			 UShort_t strip, 
			 Double_t& x, 
			 Double_t& y, 
			 Double_t& z) const
{
  // Translate detector coordinates (this,sector,strip) to global
  // coordinates (x,y,z)
  if (sector >= GetNSectors()) {
    Error("Detector2XYZ", "Invalid sector number %d (>=%d) in ring %c", 
	  sector, GetNSectors(), fId);
    return;
  }
  if (strip >= GetNStrips()) {
    Error("Detector2XYZ", "Invalid strip number %d (>=%d)", 
	  strip, GetNStrips(), fId);
    return;
  }
  Double_t phi = Float_t(sector + .5) / GetNSectors() * 2 * TMath::Pi();
  Double_t r   = Float_t(strip + .5) / GetNStrips() * (fHighR - fLowR) + fLowR;
  x = r * TMath::Cos(phi);
  y = r * TMath::Sin(phi);
  if (((sector / 2) % 2) == 1) 
    z += TMath::Sign(fModuleSpacing, z);
}

//____________________________________________________________________
Bool_t
AliFMDRing::XYZ2Detector(Double_t  x, 
			 Double_t  y, 
			 Double_t  z,
			 UShort_t& sector,
			 UShort_t& strip) const
{
  // Translate global coordinates (x,y,z) to detector coordinates
  // (this,sector,strip)
  sector = strip = 0;
  Double_t r = TMath::Sqrt(x * x + y * y);
  Int_t str = Int_t((r - fMinR) / GetPitch());
  if (str < 0 || str >= GetNStrips()) return kFALSE;

  Double_t phi = TMath::ATan2(y, x) * 180. / TMath::Pi();
  if (phi < 0) phi = 360. + phi;
  Int_t sec = Int_t(phi / fTheta);
  if (sec < 0 || sec >= GetNSectors()) return kFALSE;
  if ((sec / 2) % 2 == 1) {
    if (TMath::Abs(z - TMath::Sign(fModuleSpacing, z)) >= 0.01)
      return kFALSE;
  }
  else if (TMath::Abs(z) >= 0.01) return kFALSE;

  strip  = str;
  sector = sec;
  return kTRUE;
}
//____________________________________________________________________
Float_t 
AliFMDRing::GetStripLength(UShort_t strip) const 
{
  if(strip >= GetNStrips())
    Error("GetStripLength", "Invalid strip number %d (>=%d)", 
	  strip, GetNStrips(), fId);
  
  Float_t rad        = GetMaxR()-GetMinR();
  
  Float_t segment    = rad / GetNStrips();
  
  TVector2* corner1  = GetVertex(2);  
  TVector2* corner2  = GetVertex(3);
  
  Float_t slope      = (corner1->Y() - corner2->Y()) / (corner1->X() - corner2->X());
  Float_t constant   = (corner2->Y()*corner1->X()-(corner2->X()*corner1->Y())) / (corner1->X() - corner2->X());
  Float_t radius     = GetMinR() + strip*segment;
  
  Float_t d          = TMath::Power(TMath::Abs(radius*slope),2) + TMath::Power(radius,2) - TMath::Power(constant,2);
  
  Float_t arclength  = GetBaseStripLength(strip);
  if(d>0) {
    
    Float_t x        = (-1*TMath::Sqrt(d) -slope*constant) / (1+TMath::Power(slope,2));
    Float_t y        = slope*x + constant;
    Float_t theta    = TMath::ATan2(x,y);
    
    if(x < corner1->X() && y > corner1->Y()) {
      arclength = radius*theta;                        //One sector since theta is by definition half-hybrid
      
    }
    
  }
  
  return arclength;
  
  
}
//____________________________________________________________________
Float_t 
AliFMDRing::GetBaseStripLength(UShort_t strip) const 
{  
  Float_t rad             = GetMaxR()-GetMinR();
  Float_t segment         = rad / GetNStrips();
  Float_t basearc         = 2*TMath::Pi() / (0.5*GetNSectors()); // One hybrid: 36 degrees inner, 18 outer
  Float_t radius          = GetMinR() + strip*segment;
  Float_t basearclength   = 0.5*basearc * radius;                // One sector   
  
  return basearclength;
}
//
// EOF
//
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	/* $Id$ */
	16	/** @file AliFMDRing.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Mon Mar 27 12:47:43 2006
	19	@brief FMD ring geometry parameters
	20	*/
	21	//__________________________________________________________________
	22	//
	23	// Utility class to help implement collection of FMD modules into
	24	// rings. This is used by AliFMDDetector and AliFMDGeometry.
	25	// The AliFMDGeometry object owns the AliFMDRing objects, and the
	26	// AliFMDDetector objects reference these. That is, the AliFMDRing
	27	// objects are share amoung the AliFMDDetector objects.
	28	//
	29	// Latest changes by Christian Holm Christensen
	30	//
	31
	32	#include <TMath.h> // ROOT_TMath
	33	#include <TVector2.h> // ROOT_TVector2
	34
	35	// #include <AliLog.h> // ALILOG_H
	36	#include "AliFMDRing.h" // ALIFMDRING_H
	37
	38	//====================================================================
	39	ClassImp(AliFMDRing)
	40	#if 0
	41	; // This is here to keep Emacs for indenting the next line
	42	#endif
	43
	44	//____________________________________________________________________
	45	AliFMDRing::AliFMDRing(Char_t id)
	46	: TNamed(Form("FMD%c", id), "Forward multiplicity ring"),
	47	fId(id),
	48	fBondingWidth(0),
	49	fWaferRadius(0),
	50	fSiThickness(0),
	51	fLowR(0),
	52	fHighR(0),
	53	fMinR(0),
	54	fMaxR(0),
	55	fTheta(0),
	56	fNStrips(0),
	57	fRingDepth(0),
	58	fLegRadius(0),
	59	fLegLength(0),
	60	fLegOffset(0),
	61	fModuleSpacing(0),
	62	fPrintboardThickness(0),
	63	fCopperThickness(0),
	64	fChipThickness(0),
	65	fSpacing(0),
	66	fHoneycombThickness(0.),
	67	fAlThickness(0.),
	68	fVerticies(0),
	69	fSensorVerticies(0),
	70	fHybridVerticies(0),
	71	fFeetPositions(0)
	72	{
	73	// CTOR
	74	SetBondingWidth();
	75	SetWaferRadius();
	76	SetSiThickness();
	77	SetLegRadius();
	78	SetLegLength();
	79	SetLegOffset();
	80	SetModuleSpacing();
	81	SetPrintboardThickness();
	82	SetCopperThickness();
	83	SetChipThickness();
	84	SetSpacing();
	85	SetHoneycombThickness();
	86	SetAlThickness();
	87
	88	if (fId == 'I' \|\| fId == 'i') {
	89	SetLowR(4.3);
	90	SetHighR(17.2);
	91	SetTheta(36/2);
	92	SetNStrips(512);
	93	Double_t base = 0; // 4.1915;
	94	fFeetPositions.Add(new TVector2( 0.0551687, 8.0534-base));
	95	fFeetPositions.Add(new TVector2( 2.9993, 12.9457-base));
	96	fFeetPositions.Add(new TVector2(-2.9062, 12.9508-base));
	97
	98	fHybridVerticies.Add(new TVector2(0.0000, 4.1700));
	99	fHybridVerticies.Add(new TVector2(1.0574, 4.1700));
	100	fHybridVerticies.Add(new TVector2(4.6614, 15.2622));
	101	fHybridVerticies.Add(new TVector2(0.9643, 17.4000));
	102	fHybridVerticies.Add(new TVector2(0.0000, 17.4000));
	103
	104	fSensorVerticies.Add(new TVector2(0.0000, 4.1915));
	105	fSensorVerticies.Add(new TVector2(1.5793, 4.1915));
	106	fSensorVerticies.Add(new TVector2(5.2293, 15.4251));
	107	fSensorVerticies.Add(new TVector2(1.9807, 17.3035));
	108	fSensorVerticies.Add(new TVector2(0.0000, 17.3035));
	109
	110	fVerticies.Add(new TVector2(0.0000, 4.3000));
	111	fVerticies.Add(new TVector2(1.3972, 4.3000));
	112	fVerticies.Add(new TVector2(4.9895, 15.3560));
	113	fVerticies.Add(new TVector2(1.8007, 17.2000));
	114	fVerticies.Add(new TVector2(0.0000, 17.2000));
	115	}
	116	else if (fId == 'O' \|\| fId == 'o') {
	117	SetLowR(15.6);
	118	SetHighR(28.0);
	119	SetTheta(18/2);
	120	SetNStrips(256);
	121	Double_t base = 0; // 14.9104;
	122	fFeetPositions.Add(new TVector2(-1.72540000, 20.6267-base));
	123	fFeetPositions.Add(new TVector2( 1.72900000, 20.6267-base));
	124	fFeetPositions.Add(new TVector2( 0.00177616, 26.6007-base));
	125
	126	fHybridVerticies.Add(new TVector2(0.0000, 14.9104));
	127	fHybridVerticies.Add(new TVector2(2.0783, 14.9104));
	128	fHybridVerticies.Add(new TVector2(3.9202, 26.5395));
	129	fHybridVerticies.Add(new TVector2(0.6784, 28.2500));
	130	fHybridVerticies.Add(new TVector2(0.0000, 28.2500));
	131
	132	fSensorVerticies.Add(new TVector2(0.0000, 15.0104));
	133	fSensorVerticies.Add(new TVector2(2.5799, 15.0104));
	134	fSensorVerticies.Add(new TVector2(4.4439, 26.7766));
	135	fSensorVerticies.Add(new TVector2(1.8350, 28.1500));
	136	fSensorVerticies.Add(new TVector2(0.0000, 28.1500));
	137
	138	fVerticies.Add(new TVector2(0.0000, 15.2104));
	139	fVerticies.Add(new TVector2(2.4091, 15.2104));
	140	fVerticies.Add(new TVector2(4.2231, 26.6638));
	141	fVerticies.Add(new TVector2(1.8357, 27.9500));
	142	fVerticies.Add(new TVector2(0.0000, 27.9500));
	143	}
	144	}
	145
	146	//____________________________________________________________________
	147	void
	148	AliFMDRing::Init()
	149	{
	150	// Initialize
	151	#if 0
	152	Double_t tanTheta = TMath::Tan(fTheta * TMath::Pi() / 180.);
	153	Double_t tanTheta2 = TMath::Power(tanTheta,2);
	154	Double_t r2 = TMath::Power(fWaferRadius,2);
	155	Double_t yA = tanTheta * fLowR;
	156	Double_t lr2 = TMath::Power(fLowR, 2);
	157	Double_t hr2 = TMath::Power(fHighR,2);
	158	Double_t xD = fLowR + TMath::Sqrt(r2 - tanTheta2 * lr2);
	159	Double_t xD2 = TMath::Power(xD,2);
	160	Double_t yB = TMath::Sqrt(r2 - hr2 + 2 * fHighR * xD - xD2);
	161	Double_t xC = ((xD + TMath::Sqrt(-tanTheta2 * xD2 + r2
	162	+ r2 * tanTheta2))
	163	/ (1 + tanTheta2));
	164	Double_t yC = tanTheta * xC;
	165
	166	fVerticies.Expand(6);
	167	fVerticies.AddAt(new TVector2(fLowR, -yA), 0);
	168	fVerticies.AddAt(new TVector2(xC, -yC), 1);
	169	fVerticies.AddAt(new TVector2(fHighR, -yB), 2);
	170	fVerticies.AddAt(new TVector2(fHighR, yB), 3);
	171	fVerticies.AddAt(new TVector2(xC, yC), 4);
	172	fVerticies.AddAt(new TVector2(fLowR, yA), 5);
	173	#endif
	174
	175	// A's length. Corresponds to distance from nominal beam line to the
	176	// cornor of the active silicon element.
	177	fMinR = GetVertex(1)->Mod(); // GetVertex(5)->Mod();
	178	// A's length. Corresponds to distance from nominal beam line to the
	179	// cornor of the active silicon element.
	180	fMaxR = fHighR;
	181
	182	fRingDepth = (fSiThickness + fPrintboardThickness
	183	+ fCopperThickness + fChipThickness
	184	+ fLegLength + fModuleSpacing + fSpacing);
	185	}
	186
	187	//____________________________________________________________________
	188	TVector2*
	189	AliFMDRing::GetVertex(Int_t i) const
	190	{
	191	// Get the i'th vertex of polygon shape
	192	return static_cast<TVector2*>(fVerticies.At(i));
	193	}
	194
	195	//____________________________________________________________________
	196	TVector2*
	197	AliFMDRing::GetSensorVertex(Int_t i) const
	198	{
	199	// Get the i'th vertex of polygon shape
	200	return static_cast<TVector2*>(fSensorVerticies.At(i));
	201	}
	202
	203	//____________________________________________________________________
	204	TVector2*
	205	AliFMDRing::GetHybridVertex(Int_t i) const
	206	{
	207	// Get the i'th vertex of polygon shape
	208	return static_cast<TVector2*>(fHybridVerticies.At(i));
	209	}
	210
	211	//____________________________________________________________________
	212	TVector2*
	213	AliFMDRing::GetFootPosition(Int_t i) const
	214	{
	215	// Get the i'th vertex of polygon shape
	216	return static_cast<TVector2*>(fFeetPositions.At(i));
	217	}
	218
	219	//____________________________________________________________________
	220	Double_t
	221	AliFMDRing::GetStripRadius(UShort_t strip) const
	222	{
	223	// Return the nominal strip radius
	224	Double_t rmax = GetMaxR();
	225	Double_t stripoff = GetMinR();
	226	Double_t dstrip = (rmax - stripoff) / GetNStrips();
	227	return (strip + .5) * dstrip + stripoff; // fLowR
	228	}
	229
	230	//____________________________________________________________________
	231	Double_t
	232	AliFMDRing::GetModuleDepth() const
	233	{
	234	return (GetSiThickness()
	235	+ GetSpacing()
	236	+ GetPrintboardThickness()
	237	+ GetCopperThickness()
	238	+ GetChipThickness()
	239	+ GetLegLength());
	240
	241	}
	242
	243	//____________________________________________________________________
	244	Double_t
	245	AliFMDRing::GetFullDepth() const
	246	{
	247	return (GetModuleDepth()
	248	+ GetModuleSpacing()
	249	+ GetHoneycombThickness()
	250	+ GetFMDDPrintboardThickness()
	251	+ GetFMDDCopperThickness()
	252	+ GetFMDDChipThickness()
	253	+ 0.5);
	254	}
	255
	256	//____________________________________________________________________
	257	void
	258	AliFMDRing::Detector2XYZ(UShort_t sector,
	259	UShort_t strip,
	260	Double_t& x,
	261	Double_t& y,
	262	Double_t& z) const
	263	{
	264	// Translate detector coordinates (this,sector,strip) to global
	265	// coordinates (x,y,z)
	266	if (sector >= GetNSectors()) {
	267	Error("Detector2XYZ", "Invalid sector number %d (>=%d) in ring %c",
	268	sector, GetNSectors(), fId);
	269	return;
	270	}
	271	if (strip >= GetNStrips()) {
	272	Error("Detector2XYZ", "Invalid strip number %d (>=%d)",
	273	strip, GetNStrips(), fId);
	274	return;
	275	}
	276	Double_t phi = Float_t(sector + .5) / GetNSectors() * 2 * TMath::Pi();
	277	Double_t r = Float_t(strip + .5) / GetNStrips() * (fHighR - fLowR) + fLowR;
	278	x = r * TMath::Cos(phi);
	279	y = r * TMath::Sin(phi);
	280	if (((sector / 2) % 2) == 1)
	281	z += TMath::Sign(fModuleSpacing, z);
	282	}
	283
	284	//____________________________________________________________________
	285	Bool_t
	286	AliFMDRing::XYZ2Detector(Double_t x,
	287	Double_t y,
	288	Double_t z,
	289	UShort_t& sector,
	290	UShort_t& strip) const
	291	{
	292	// Translate global coordinates (x,y,z) to detector coordinates
	293	// (this,sector,strip)
	294	sector = strip = 0;
	295	Double_t r = TMath::Sqrt(x * x + y * y);
	296	Int_t str = Int_t((r - fMinR) / GetPitch());
	297	if (str < 0 \|\| str >= GetNStrips()) return kFALSE;
	298
	299	Double_t phi = TMath::ATan2(y, x) * 180. / TMath::Pi();
	300	if (phi < 0) phi = 360. + phi;
	301	Int_t sec = Int_t(phi / fTheta);
	302	if (sec < 0 \|\| sec >= GetNSectors()) return kFALSE;
	303	if ((sec / 2) % 2 == 1) {
	304	if (TMath::Abs(z - TMath::Sign(fModuleSpacing, z)) >= 0.01)
	305	return kFALSE;
	306	}
	307	else if (TMath::Abs(z) >= 0.01) return kFALSE;
	308
	309	strip = str;
	310	sector = sec;
	311	return kTRUE;
	312	}
	313	//____________________________________________________________________
	314	Float_t
	315	AliFMDRing::GetStripLength(UShort_t strip) const
	316	{
	317	if(strip >= GetNStrips())
	318	Error("GetStripLength", "Invalid strip number %d (>=%d)",
	319	strip, GetNStrips(), fId);
	320
	321	Float_t rad = GetMaxR()-GetMinR();
	322
	323	Float_t segment = rad / GetNStrips();
	324
	325	TVector2* corner1 = GetVertex(2);
	326	TVector2* corner2 = GetVertex(3);
	327
	328	Float_t slope = (corner1->Y() - corner2->Y()) / (corner1->X() - corner2->X());
	329	Float_t constant = (corner2->Y()corner1->X()-(corner2->X()corner1->Y())) / (corner1->X() - corner2->X());
	330	Float_t radius = GetMinR() + strip*segment;
	331
	332	Float_t d = TMath::Power(TMath::Abs(radius*slope),2) + TMath::Power(radius,2) - TMath::Power(constant,2);
	333
	334	Float_t arclength = GetBaseStripLength(strip);
	335	if(d>0) {
	336
	337	Float_t x = (-1TMath::Sqrt(d) -slopeconstant) / (1+TMath::Power(slope,2));
	338	Float_t y = slope*x + constant;
	339	Float_t theta = TMath::ATan2(x,y);
	340
	341	if(x < corner1->X() && y > corner1->Y()) {
	342	arclength = radius*theta; //One sector since theta is by definition half-hybrid
	343
	344	}
	345
	346	}
	347
	348	return arclength;
	349
	350
	351	}
	352	//____________________________________________________________________
	353	Float_t
	354	AliFMDRing::GetBaseStripLength(UShort_t strip) const
	355	{
	356	Float_t rad = GetMaxR()-GetMinR();
	357	Float_t segment = rad / GetNStrips();
	358	Float_t basearc = 2TMath::Pi() / (0.5GetNSectors()); // One hybrid: 36 degrees inner, 18 outer
	359	Float_t radius = GetMinR() + strip*segment;
	360	Float_t basearclength = 0.5basearc radius; // One sector
	361
	362	return basearclength;
	363	}
	364	//
	365	// EOF
	366	//