[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)
{
  // 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);
  }
  else if (fId == 'O' || fId == 'o') {
    SetLowR(15.6);
    SetHighR(28.0);
    SetTheta(18/2);
    SetNStrips(256);
  }
}

//____________________________________________________________________
void
AliFMDRing::Init()
{
  // Initialize 
  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);  

  // A's length. Corresponds to distance from nominal beam line to the
  // cornor of the active silicon element. 
  fMinR = 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));
}

//____________________________________________________________________
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::GetFullDepth() const
{
  return (GetSiThickness() + 
	  GetSpacing() + 
	  GetPrintboardThickness() + 
	  GetCopperThickness() + 
	  GetChipThickness() + 
	  GetModuleSpacing() +
	  GetLegLength() + 
	  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;
}


//
// EOF
//
Commit	Line	Data
4347b38f	1	/**************************************************************************
c4bcfd14	2	* Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved. *
4347b38f	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	**************************************************************************/
4347b38f	15	/* $Id$ */
c2fc1258	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	*/
c4bcfd14	21	//__________________________________________________________________
4347b38f	22	//
4347b38f	23	// Utility class to help implement collection of FMD modules into
6169f936	24	// rings. This is used by AliFMDDetector and AliFMDGeometry.
1a1fdef7	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.
4347b38f	28	//
	29	// Latest changes by Christian Holm Christensen
	30	//
5edc364e	31
9edefa04	32	#include <TMath.h> // ROOT_TMath
	33	#include <TVector2.h> // ROOT_TVector2
	34
02a27b50	35	// #include <AliLog.h> // ALILOG_H
e802be3e	36	#include "AliFMDRing.h" // ALIFMDRING_H
4347b38f	37
1a1fdef7	38	//====================================================================
e6a0eb08	39	ClassImp(AliFMDRing)
1a1fdef7	40	#if 0
	41	; // This is here to keep Emacs for indenting the next line
	42	#endif
4347b38f	43
4347b38f	44	//____________________________________________________________________
1a1fdef7	45	AliFMDRing::AliFMDRing(Char_t id)
	46	: TNamed(Form("FMD%c", id), "Forward multiplicity ring"),
	47	fId(id),
b5ee4425	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),
d98fbfa5	66	fHoneycombThickness(0.),
d98fbfa5	67	fAlThickness(0.),
1a1fdef7	68	fVerticies(0)
4347b38f	69	{
088f8e79	70	// CTOR
1a1fdef7	71	SetBondingWidth();
	72	SetWaferRadius();
	73	SetSiThickness();
	74	SetLegRadius();
	75	SetLegLength();
	76	SetLegOffset();
	77	SetModuleSpacing();
	78	SetPrintboardThickness();
4ac75127	79	SetCopperThickness();
4ac75127	80	SetChipThickness();
a1f80595	81	SetSpacing();
d98fbfa5	82	SetHoneycombThickness();
d98fbfa5	83	SetAlThickness();
4347b38f	84
1a1fdef7	85	if (fId == 'I' \|\| fId == 'i') {
	86	SetLowR(4.3);
	87	SetHighR(17.2);
	88	SetTheta(36/2);
	89	SetNStrips(512);
	90	}
	91	else if (fId == 'O' \|\| fId == 'o') {
	92	SetLowR(15.6);
	93	SetHighR(28.0);
	94	SetTheta(18/2);
	95	SetNStrips(256);
4347b38f	96	}
4347b38f	97	}
4347b38f	98
4347b38f	99	//____________________________________________________________________
4347b38f	100	void
1a1fdef7	101	AliFMDRing::Init()
4347b38f	102	{
088f8e79	103	// Initialize
1a1fdef7	104	Double_t tanTheta = TMath::Tan(fTheta * TMath::Pi() / 180.);
	105	Double_t tanTheta2 = TMath::Power(tanTheta,2);
	106	Double_t r2 = TMath::Power(fWaferRadius,2);
	107	Double_t yA = tanTheta * fLowR;
	108	Double_t lr2 = TMath::Power(fLowR, 2);
	109	Double_t hr2 = TMath::Power(fHighR,2);
	110	Double_t xD = fLowR + TMath::Sqrt(r2 - tanTheta2 * lr2);
	111	Double_t xD2 = TMath::Power(xD,2);
	112	Double_t yB = TMath::Sqrt(r2 - hr2 + 2 * fHighR * xD - xD2);
	113	Double_t xC = ((xD + TMath::Sqrt(-tanTheta2 * xD2 + r2
	114	+ r2 * tanTheta2))
	115	/ (1 + tanTheta2));
	116	Double_t yC = tanTheta * xC;
4347b38f	117
1a1fdef7	118	fVerticies.Expand(6);
	119	fVerticies.AddAt(new TVector2(fLowR, -yA), 0);
	120	fVerticies.AddAt(new TVector2(xC, -yC), 1);
	121	fVerticies.AddAt(new TVector2(fHighR, -yB), 2);
	122	fVerticies.AddAt(new TVector2(fHighR, yB), 3);
	123	fVerticies.AddAt(new TVector2(xC, yC), 4);
	124	fVerticies.AddAt(new TVector2(fLowR, yA), 5);
	125
54e415a8	126	// A's length. Corresponds to distance from nominal beam line to the
	127	// cornor of the active silicon element.
	128	fMinR = GetVertex(5)->Mod();
	129	// A's length. Corresponds to distance from nominal beam line to the
	130	// cornor of the active silicon element.
	131	fMaxR = fHighR;
	132
1a1fdef7	133	fRingDepth = (fSiThickness + fPrintboardThickness
4ac75127	134	+ fCopperThickness + fChipThickness
4ac75127	135	+ fLegLength + fModuleSpacing + fSpacing);
4347b38f	136	}
	137
	138	//____________________________________________________________________
1a1fdef7	139	TVector2*
1a1fdef7	140	AliFMDRing::GetVertex(Int_t i) const
4347b38f	141	{
088f8e79	142	// Get the i'th vertex of polygon shape
1a1fdef7	143	return static_cast<TVector2*>(fVerticies.At(i));
4347b38f	144	}
4347b38f	145
bf000c32	146	//____________________________________________________________________
	147	Double_t
	148	AliFMDRing::GetStripRadius(UShort_t strip) const
	149	{
	150	// Return the nominal strip radius
	151	Double_t rmax = GetMaxR();
	152	Double_t stripoff = GetMinR();
	153	Double_t dstrip = (rmax - stripoff) / GetNStrips();
	154	return (strip + .5) * dstrip + stripoff; // fLowR
	155	}
	156
d98fbfa5	157	//____________________________________________________________________
	158	Double_t
	159	AliFMDRing::GetFullDepth() const
	160	{
	161	return (GetSiThickness() +
	162	GetSpacing() +
	163	GetPrintboardThickness() +
	164	GetCopperThickness() +
	165	GetChipThickness() +
	166	GetModuleSpacing() +
	167	GetLegLength() +
	168	GetHoneycombThickness() +
	169	GetFMDDPrintboardThickness() +
	170	GetFMDDCopperThickness() +
	171	GetFMDDChipThickness()
	172	+ 0.5);
	173	}
	174
4347b38f	175	//____________________________________________________________________
1a1fdef7	176	void
	177	AliFMDRing::Detector2XYZ(UShort_t sector,
	178	UShort_t strip,
	179	Double_t& x,
	180	Double_t& y,
	181	Double_t& z) const
4347b38f	182	{
088f8e79	183	// Translate detector coordinates (this,sector,strip) to global
088f8e79	184	// coordinates (x,y,z)
1a1fdef7	185	if (sector >= GetNSectors()) {
	186	Error("Detector2XYZ", "Invalid sector number %d (>=%d) in ring %c",
	187	sector, GetNSectors(), fId);
	188	return;
4347b38f	189	}
1a1fdef7	190	if (strip >= GetNStrips()) {
	191	Error("Detector2XYZ", "Invalid strip number %d (>=%d)",
	192	strip, GetNStrips(), fId);
	193	return;
4347b38f	194	}
1a1fdef7	195	Double_t phi = Float_t(sector + .5) / GetNSectors() * 2 * TMath::Pi();
	196	Double_t r = Float_t(strip + .5) / GetNStrips() * (fHighR - fLowR) + fLowR;
	197	x = r * TMath::Cos(phi);
	198	y = r * TMath::Sin(phi);
	199	if (((sector / 2) % 2) == 1)
	200	z += TMath::Sign(fModuleSpacing, z);
4347b38f	201	}
4347b38f	202
54e415a8	203	//____________________________________________________________________
	204	Bool_t
	205	AliFMDRing::XYZ2Detector(Double_t x,
	206	Double_t y,
	207	Double_t z,
	208	UShort_t& sector,
	209	UShort_t& strip) const
	210	{
088f8e79	211	// Translate global coordinates (x,y,z) to detector coordinates
088f8e79	212	// (this,sector,strip)
54e415a8	213	sector = strip = 0;
	214	Double_t r = TMath::Sqrt(x * x + y * y);
	215	Int_t str = Int_t((r - fMinR) / GetPitch());
	216	if (str < 0 \|\| str >= GetNStrips()) return kFALSE;
	217
	218	Double_t phi = TMath::ATan2(y, x) * 180. / TMath::Pi();
	219	if (phi < 0) phi = 360. + phi;
	220	Int_t sec = Int_t(phi / fTheta);
	221	if (sec < 0 \|\| sec >= GetNSectors()) return kFALSE;
	222	if ((sec / 2) % 2 == 1) {
	223	if (TMath::Abs(z - TMath::Sign(fModuleSpacing, z)) >= 0.01)
	224	return kFALSE;
	225	}
	226	else if (TMath::Abs(z) >= 0.01) return kFALSE;
	227
	228	strip = str;
	229	sector = sec;
	230	return kTRUE;
	231	}
	232
	233
4347b38f	234	//
	235	// EOF
	236	//