[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUv11Layer.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//*************************************************************************
// This class Defines the Geometry for the ITS Upgrade using TGeo
// This is a work class used to study different configurations
// during the development of the new ITS structure.
//
//  Mario Sitta <sitta@to.infn.it>
//*************************************************************************


/* $Id: AliITSUv11Layer.cxx  */
// General Root includes
#include <TMath.h>
// Root Geometry includes
//#include <AliLog.h>
#include <TGeoManager.h>
#include <TGeoVolume.h>
#include <TGeoPcon.h>
#include <TGeoCone.h>
#include <TGeoTube.h> // contaings TGeoTubeSeg
#include <TGeoArb8.h>
#include <TGeoXtru.h>
#include <TGeoCompositeShape.h>
#include <TGeoMatrix.h>
#include "AliITSUv11Layer.h"
#include "AliITSUGeomTGeo.h"

const Double_t AliITSUv11Layer::fgkDefaultSensorThick = 300*fgkmicron;
const Double_t AliITSUv11Layer::fgkDefaultLadderThick =   1*fgkcm;

ClassImp(AliITSUv11Layer)

#define SQ(A) (A)*(A)

//________________________________________________________________________
AliITSUv11Layer::AliITSUv11Layer(): 
  AliITSv11Geometry(),
  fLayerNumber(0),
  fLayRadius(0),
  fZLength(0),
  fSensorThick(0),
  fLadderThick(0),
  fLadderWidth(0),
  fLadderTilt(0),
  fNLadders(0),
  fNModules(0),
  fDetTypeID(0),
  fIsTurbo(0)
{
  //
  // Standard constructor
  //
}

//________________________________________________________________________
AliITSUv11Layer::AliITSUv11Layer(Int_t debug): 
  AliITSv11Geometry(debug),
  fLayerNumber(0),
  fLayRadius(0),
  fZLength(0),
  fSensorThick(0),
  fLadderThick(0),
  fLadderWidth(0),
  fLadderTilt(0),
  fNLadders(0),
  fNModules(0),
  fDetTypeID(0),
  fIsTurbo(0)
{
  //
  // Constructor setting debugging level
  //
}

//________________________________________________________________________
AliITSUv11Layer::AliITSUv11Layer(Int_t lay, Int_t debug): 
  AliITSv11Geometry(debug),
  fLayerNumber(lay),
  fLayRadius(0),
  fZLength(0),
  fSensorThick(0),
  fLadderThick(0),
  fLadderWidth(0),
  fLadderTilt(0),
  fNLadders(0),
  fNModules(0),
  fDetTypeID(0),
  fIsTurbo(0)
{
  //
  // Constructor setting layer number and debugging level
  //
}

//________________________________________________________________________
AliITSUv11Layer::AliITSUv11Layer(Int_t lay, Bool_t turbo, Int_t debug): 
  AliITSv11Geometry(debug),
  fLayerNumber(lay),
  fLayRadius(0),
  fZLength(0),
  fSensorThick(0),
  fLadderThick(0),
  fLadderWidth(0),
  fLadderTilt(0),
  fNLadders(0),
  fNModules(0),
  fDetTypeID(0),
  fIsTurbo(turbo)
{
  //
  // Constructor setting layer number and debugging level
  // for a "turbo" layer (i.e. where ladders overlap in phi)
  //
}

//________________________________________________________________________
AliITSUv11Layer::AliITSUv11Layer(const AliITSUv11Layer &s):
  AliITSv11Geometry(s.GetDebug()),
  fLayerNumber(s.fLayerNumber),
  fLayRadius(s.fLayRadius),
  fZLength(s.fZLength),
  fSensorThick(s.fSensorThick),
  fLadderThick(s.fLadderThick),
  fLadderWidth(s.fLadderWidth),
  fLadderTilt(s.fLadderTilt),
  fNLadders(s.fNLadders),
  fNModules(s.fNModules),
  fDetTypeID(0),
  fIsTurbo(s.fIsTurbo)
{
  //
  // Copy constructor
  //
}

//________________________________________________________________________
AliITSUv11Layer& AliITSUv11Layer::operator=(const AliITSUv11Layer &s)
{
  //
  // Assignment operator 
  //
  if(&s == this) return *this;

  fLayerNumber = s.fLayerNumber;
  fLayRadius   = s.fLayRadius;
  fZLength     = s.fZLength;
  fSensorThick = s.fSensorThick;
  fLadderThick = s.fLadderThick;
  fLadderWidth = s.fLadderWidth;
  fLadderTilt  = s.fLadderTilt;
  fNLadders    = s.fNLadders;
  fNModules    = s.fNModules;
  fIsTurbo     = s.fIsTurbo;
  fDetTypeID   = s.fDetTypeID;
  return *this;
}

//________________________________________________________________________
AliITSUv11Layer::~AliITSUv11Layer() {
  //
  // Destructor
  //
}

//________________________________________________________________________
void AliITSUv11Layer::CreateLayer(TGeoVolume *moth,
				     const TGeoManager *mgr){
//
// Creates the actual Layer and places inside its mother volume
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (used only to get the proper material)
//
// Output:
//
// Return:
//
// Created:      17 Jun 2011  Mario Sitta
// Updated:      08 Jul 2011  Mario Sitta
//


  // Local variables
  char volname[30];
  Double_t rmin, rmax;
  Double_t xpos, ypos, zpos;
  Double_t alpha;


  // Check if the user set the proper parameters
  if (fLayRadius <= 0) AliFatal(Form("Wrong layer radius (%f)",fLayRadius));
  if (fZLength   <= 0) AliFatal(Form("Wrong layer length (%f)",fZLength));
  if (fNLadders  <= 0) AliFatal(Form("Wrong number of ladders (%d)",fNLadders));
  if (fNModules  <= 0) AliFatal(Form("Wrong number of modules (%d)",fNModules));

  if (fLadderThick <= 0) {
    AliInfo(Form("Ladder thickness wrong or not set (%f), using default (%f)",
		 fLadderThick,fgkDefaultLadderThick));
    fLadderThick = fgkDefaultLadderThick;
  }

  if (fSensorThick <= 0) {
    AliInfo(Form("Sensor thickness wrong or not set (%f), using default (%f)",
		 fSensorThick,fgkDefaultSensorThick));
    fSensorThick = fgkDefaultSensorThick;
  }

  if (fSensorThick > fLadderThick) {
    AliWarning(Form("Sensor thickness (%f) is greater than ladder thickness (%f), fixing",
		 fSensorThick,fLadderThick));
    fSensorThick = fLadderThick;
  }


  // If a Turbo layer is requested, do it and exit
  if (fIsTurbo) {
    CreateLayerTurbo(moth, mgr);
    return;
  }


  // First create the ladder container
  alpha = (360./(2*fNLadders))*TMath::DegToRad();

  //  fLadderWidth = fLayRadius*TMath::Tan(alpha);

  rmin = 0.98*fLayRadius;
  rmax = 1.02*TMath::Sqrt( fLadderWidth*fLadderWidth +
			  (rmin+fLadderThick)*(rmin+fLadderThick) );

  TGeoTube *layer = new TGeoTube(rmin, rmax, 0.5*fZLength);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");

  snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(),fLayerNumber);
  TGeoVolume *layVol = new TGeoVolume(volname, layer, medAir);
  layVol->SetUniqueID(fDetTypeID);

//  layVol->SetVisibility(kFALSE);
  layVol->SetVisibility(kTRUE);
  layVol->SetLineColor(1);

  TGeoVolume *laddVol = CreateLadder();


  // Now build up the layer
  alpha = 360./fNLadders;
  Double_t r = fLayRadius + ((TGeoBBox*)laddVol->GetShape())->GetDY();
  for (Int_t j=0; j<fNLadders; j++) {
    Double_t theta = j*alpha;
    xpos = r*SinD(theta);
    ypos = r*CosD(theta);
    zpos = 0.;
    layVol->AddNode(laddVol, j, new TGeoCombiTrans( xpos, ypos, zpos,
				  new TGeoRotation("",-theta,0,0)));
  }


  // Finally put everything in the mother volume
  moth->AddNode(layVol, 1, 0);


  // Upgrade geometry is served
  return;
}

//________________________________________________________________________
void AliITSUv11Layer::CreateLayerTurbo(TGeoVolume *moth,
					  const TGeoManager *mgr){
//
// Creates the actual Layer and places inside its mother volume
// A so-called "turbo" layer is a layer where ladders overlap in phi
// User can set width and tilt angle, no check is performed here
// to avoid volume overlaps
//
// Input:
//         moth : the TGeoVolume owing the volume structure
//         mgr  : the GeoManager (used only to get the proper material)
//
// Output:
//
// Return:
//
// Created:      08 Jul 2011  Mario Sitta
// Updated:      08 Mar 2012  Mario Sitta  Correct way to compute container R
//


  // Local variables
  char volname[30];
  Double_t rmin, rmax, rladd, rcont, d;
  Double_t xpos, ypos, zpos;
  Double_t alpha, gamma;


  // Check if the user set the proper (remaining) parameters
  if (fLadderWidth <= 0)
    AliFatal(Form("Wrong ladder width (%f)",fLadderWidth));
  if (TMath::Abs(fLadderTilt) > 45)
    AliWarning(Form("Ladder tilt angle (%f) greater than 45deg",fLadderTilt));


  // First create the ladder container
  // d is half the diagonal of the ladder section
  // rladd is the radius at the ladder's center-of-gravity
  // alpha here is the angle between the diagonal and rladd
  d = 0.5*TMath::Sqrt(fLadderThick*fLadderThick + fLadderWidth*fLadderWidth);
  alpha = TMath::ACos(0.5*fLadderThick/d)*TMath::RadToDeg();
  gamma = alpha - fLadderTilt;
  rladd = fLayRadius + 0.5*fLadderThick;

  // rcont is the radius of the air container
  rcont = RadiusOfTurboContainer();
  
  if (rcont > 0)
    rmin = 0.98*rcont;
  else
    rmin = 0.98*TMath::Sqrt( rladd*rladd + d*d - 2*rladd*d*CosD(gamma) );
  
  rmax = 1.02*TMath::Sqrt( rladd*rladd + d*d + 2*rladd*d*CosD(gamma) );
  
  TGeoTube *layer = new TGeoTube(rmin, rmax, 0.5*fZLength);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");

  snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(), fLayerNumber);
  TGeoVolume *layVol = new TGeoVolume(volname, layer, medAir);
  layVol->SetUniqueID(fDetTypeID);
  layVol->SetVisibility(kTRUE);
  layVol->SetLineColor(1);
  TGeoVolume *laddVol = CreateLadder();


  // Now build up the layer


  // Now build up the layer
  alpha = 360./fNLadders;
  Double_t r = fLayRadius + ((TGeoBBox*)laddVol->GetShape())->GetDY();
  for (Int_t j=0; j<fNLadders; j++) {
    Double_t theta = j*alpha;
    xpos = r*SinD(theta);
    ypos = r*CosD(theta);
    zpos = 0.;
    layVol->AddNode(laddVol, j, new TGeoCombiTrans( xpos, ypos, zpos,
				 new TGeoRotation("",-theta+fLadderTilt,0,0)));
  }


  // Finally put everything in the mother volume
  moth->AddNode(layVol, 1, 0);

  return;
}

//________________________________________________________________________
TGeoVolume* AliITSUv11Layer::CreateLadder(const TGeoManager *mgr){
//
// Creates the actual Ladder
//
// Input:
//         mgr  : the GeoManager (used only to get the proper material)
//
// Output:
//
// Return:
//
// Created:      22 Jun 2011  Mario Sitta
//

  char volname[30];
  Double_t xlen, ylen, zlen;
  Double_t xpos, ypos, zpos, zmod;
  Double_t alpha;


  // First create all needed shapes
  alpha = (360./(2*fNLadders))*TMath::DegToRad();

  // The ladder
  xlen = fLayRadius*TMath::Tan(alpha);
  if (fIsTurbo) xlen = 0.5*fLadderWidth;
  ylen = 0.5*fLadderThick;
  zlen = 0.5*fZLength;

  TGeoBBox *ladder = new TGeoBBox(xlen, ylen, zlen);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");

  snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLadderPattern(), fLayerNumber);
  TGeoVolume *laddVol = new TGeoVolume(volname, ladder, medAir);

//  laddVol->SetVisibility(kFALSE);
  laddVol->SetVisibility(kTRUE);
  laddVol->SetLineColor(2);
  TGeoVolume *modVol = CreateModule(ladder->GetDX(), ladder->GetDY(),
				    ladder->GetDZ());


  // Now build up the ladder
  zmod = ((TGeoBBox*)modVol->GetShape())->GetDZ();
  for (Int_t j=0; j<fNModules; j++) {
    xpos = 0.;
    ypos = 0.;
    zpos = -ladder->GetDZ() + j*2*zmod + zmod;
    laddVol->AddNode(modVol, j, new TGeoTranslation(xpos, ypos, zpos));
  }


  // Done, return the ladder
  return laddVol;
}

//________________________________________________________________________
TGeoVolume* AliITSUv11Layer::CreateModule(const Double_t xlad,
						   const Double_t ylad,
						   const Double_t zlad,
						   const TGeoManager *mgr){
//
// Creates the actual Module
//
// Input:
//         xlad,ylad,zlad : the ladder dimensions
//         mgr  : the GeoManager (used only to get the proper material)
//
// Output:
//
// Return:
//
// Created:      22 Jun 2011  Mario Sitta
//

  char volname[30];
  Double_t xlen, ylen, zlen;
  Double_t xpos, ypos, zpos;


  // First create all needed shapes

  // The module
  TGeoBBox *module = new TGeoBBox(xlad, ylad, zlad/fNModules);

  // The sensor
  xlen = module->GetDX();
  ylen = 0.5*fSensorThick;
  zlen = module->GetDZ();
  TGeoBBox *sensor = new TGeoBBox(xlen, ylen, zlen);


  // We have all shapes: now create the real volumes
  TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
  TGeoMedium *medSi  = mgr->GetMedium("ITS_SI$");

  snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSModulePattern() ,fLayerNumber);
  TGeoVolume *modVol = new TGeoVolume(volname, module, medAir);
  modVol->SetVisibility(kFALSE);
  modVol->SetLineColor(1);

  snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSSensorPattern(), fLayerNumber);
  TGeoVolume *sensVol = new TGeoVolume(volname, sensor, medSi);
  sensVol->SetVisibility(kTRUE);
  sensVol->SetLineColor(8);
  sensVol->SetLineWidth(1);
  sensVol->SetFillColor(sensVol->GetLineColor());
  sensVol->SetFillStyle(4000); // 0% transparent


  // Now build up the module
  xpos = 0.;
  ypos = -module->GetDY() + sensor->GetDY();
  zpos = 0.;

  modVol->AddNode(sensVol, 1, new TGeoTranslation(xpos, ypos, zpos));


  // Done, return the module
  return modVol;
}

//________________________________________________________________________
Double_t AliITSUv11Layer::RadiusOfTurboContainer(){
//
// Computes the inner radius of the air container for the Turbo configuration
// as the radius of either the circle tangent to the ladder or the circle
// passing for the ladder's lower vertex
//
// Input:
//         none (all needed parameters are class members)
//
// Output:
//
// Return:
//        the radius of the container if >0, else flag to use the lower vertex
//
// Created:      08 Mar 2012  Mario Sitta
//

  Double_t rr, delta, z, lladd, rladd;

  if (fLadderThick > 89.) // Very big angle: avoid overflows since surely
    return -1;            // the radius from lower vertex is the right value

  rladd = fLayRadius + 0.5*fLadderThick;
  delta = (0.5*fLadderThick)/CosD(fLadderTilt);
  z     = (0.5*fLadderThick)*TanD(fLadderTilt);

  rr = rladd - delta;
  lladd = (0.5*fLadderWidth) - z;

  if ( (rr*SinD(fLadderTilt) < lladd) )
    return (rr*CosD(fLadderTilt));
  else
    return -1;
}

//________________________________________________________________________
void AliITSUv11Layer::SetLadderTilt(const Double_t t){
//
// Sets the Ladder tilt angle (for turbo layers only)
//
// Input:
//         t :  the ladder tilt angle
//
// Output:
//
// Return:
//
// Created:      08 Jul 2011  Mario Sitta
//

  if (fIsTurbo)
    fLadderTilt = t;
  else
    AliError("Not a Turbo layer");

}

//________________________________________________________________________
void AliITSUv11Layer::SetLadderWidth(const Double_t w){
//
// Sets the Ladder width (for turbo layers only)
//
// Input:
//         w :  the ladder width
//
// Output:
//
// Return:
//
// Created:      08 Jul 2011  Mario Sitta
//

  if (fIsTurbo)
    fLadderWidth = w;
  else
    AliError("Not a Turbo layer");

}
Commit	Line	Data
29998a6e	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	//*************************************************************************
	17	// This class Defines the Geometry for the ITS Upgrade using TGeo
	18	// This is a work class used to study different configurations
	19	// during the development of the new ITS structure.
	20	//
	21	// Mario Sitta <sitta@to.infn.it>
	22	//*************************************************************************
	23
	24
451f5018	25	/* $Id: AliITSUv11Layer.cxx */
29998a6e	26	// General Root includes
	27	#include <TMath.h>
	28	// Root Geometry includes
	29	//#include <AliLog.h>
	30	#include <TGeoManager.h>
	31	#include <TGeoVolume.h>
	32	#include <TGeoPcon.h>
	33	#include <TGeoCone.h>
	34	#include <TGeoTube.h> // contaings TGeoTubeSeg
	35	#include <TGeoArb8.h>
	36	#include <TGeoXtru.h>
	37	#include <TGeoCompositeShape.h>
	38	#include <TGeoMatrix.h>
451f5018	39	#include "AliITSUv11Layer.h"
451f5018	40	#include "AliITSUGeomTGeo.h"
29998a6e	41
451f5018	42	const Double_t AliITSUv11Layer::fgkDefaultSensorThick = 300*fgkmicron;
451f5018	43	const Double_t AliITSUv11Layer::fgkDefaultLadderThick = 1*fgkcm;
29998a6e	44
451f5018	45	ClassImp(AliITSUv11Layer)
29998a6e	46
	47	#define SQ(A) (A)*(A)
	48
	49	//________________________________________________________________________
451f5018	50	AliITSUv11Layer::AliITSUv11Layer():
29998a6e	51	AliITSv11Geometry(),
	52	fLayerNumber(0),
	53	fLayRadius(0),
	54	fZLength(0),
	55	fSensorThick(0),
	56	fLadderThick(0),
	57	fLadderWidth(0),
	58	fLadderTilt(0),
	59	fNLadders(0),
	60	fNModules(0),
535d15f5	61	fDetTypeID(0),
29998a6e	62	fIsTurbo(0)
	63	{
	64	//
	65	// Standard constructor
	66	//
	67	}
	68
	69	//________________________________________________________________________
451f5018	70	AliITSUv11Layer::AliITSUv11Layer(Int_t debug):
29998a6e	71	AliITSv11Geometry(debug),
	72	fLayerNumber(0),
	73	fLayRadius(0),
	74	fZLength(0),
	75	fSensorThick(0),
	76	fLadderThick(0),
	77	fLadderWidth(0),
	78	fLadderTilt(0),
	79	fNLadders(0),
	80	fNModules(0),
535d15f5	81	fDetTypeID(0),
29998a6e	82	fIsTurbo(0)
	83	{
	84	//
	85	// Constructor setting debugging level
	86	//
	87	}
	88
	89	//________________________________________________________________________
451f5018	90	AliITSUv11Layer::AliITSUv11Layer(Int_t lay, Int_t debug):
29998a6e	91	AliITSv11Geometry(debug),
	92	fLayerNumber(lay),
	93	fLayRadius(0),
	94	fZLength(0),
	95	fSensorThick(0),
	96	fLadderThick(0),
	97	fLadderWidth(0),
	98	fLadderTilt(0),
	99	fNLadders(0),
	100	fNModules(0),
535d15f5	101	fDetTypeID(0),
29998a6e	102	fIsTurbo(0)
	103	{
	104	//
	105	// Constructor setting layer number and debugging level
	106	//
	107	}
	108
	109	//________________________________________________________________________
451f5018	110	AliITSUv11Layer::AliITSUv11Layer(Int_t lay, Bool_t turbo, Int_t debug):
29998a6e	111	AliITSv11Geometry(debug),
	112	fLayerNumber(lay),
	113	fLayRadius(0),
	114	fZLength(0),
	115	fSensorThick(0),
	116	fLadderThick(0),
	117	fLadderWidth(0),
	118	fLadderTilt(0),
	119	fNLadders(0),
	120	fNModules(0),
535d15f5	121	fDetTypeID(0),
29998a6e	122	fIsTurbo(turbo)
	123	{
	124	//
	125	// Constructor setting layer number and debugging level
	126	// for a "turbo" layer (i.e. where ladders overlap in phi)
	127	//
	128	}
	129
	130	//________________________________________________________________________
451f5018	131	AliITSUv11Layer::AliITSUv11Layer(const AliITSUv11Layer &s):
29998a6e	132	AliITSv11Geometry(s.GetDebug()),
	133	fLayerNumber(s.fLayerNumber),
	134	fLayRadius(s.fLayRadius),
	135	fZLength(s.fZLength),
	136	fSensorThick(s.fSensorThick),
	137	fLadderThick(s.fLadderThick),
	138	fLadderWidth(s.fLadderWidth),
	139	fLadderTilt(s.fLadderTilt),
	140	fNLadders(s.fNLadders),
	141	fNModules(s.fNModules),
535d15f5	142	fDetTypeID(0),
29998a6e	143	fIsTurbo(s.fIsTurbo)
	144	{
	145	//
	146	// Copy constructor
	147	//
	148	}
	149
	150	//________________________________________________________________________
451f5018	151	AliITSUv11Layer& AliITSUv11Layer::operator=(const AliITSUv11Layer &s)
29998a6e	152	{
	153	//
	154	// Assignment operator
	155	//
	156	if(&s == this) return *this;
	157
	158	fLayerNumber = s.fLayerNumber;
	159	fLayRadius = s.fLayRadius;
	160	fZLength = s.fZLength;
	161	fSensorThick = s.fSensorThick;
	162	fLadderThick = s.fLadderThick;
	163	fLadderWidth = s.fLadderWidth;
	164	fLadderTilt = s.fLadderTilt;
	165	fNLadders = s.fNLadders;
	166	fNModules = s.fNModules;
	167	fIsTurbo = s.fIsTurbo;
535d15f5	168	fDetTypeID = s.fDetTypeID;
29998a6e	169	return *this;
	170	}
	171
	172	//________________________________________________________________________
451f5018	173	AliITSUv11Layer::~AliITSUv11Layer() {
29998a6e	174	//
	175	// Destructor
	176	//
	177	}
	178
	179	//________________________________________________________________________
451f5018	180	void AliITSUv11Layer::CreateLayer(TGeoVolume *moth,
29998a6e	181	const TGeoManager *mgr){
	182	//
	183	// Creates the actual Layer and places inside its mother volume
	184	//
	185	// Input:
	186	// moth : the TGeoVolume owing the volume structure
	187	// mgr : the GeoManager (used only to get the proper material)
	188	//
	189	// Output:
	190	//
	191	// Return:
	192	//
	193	// Created: 17 Jun 2011 Mario Sitta
	194	// Updated: 08 Jul 2011 Mario Sitta
	195	//
	196
	197
	198	// Local variables
	199	char volname[30];
	200	Double_t rmin, rmax;
	201	Double_t xpos, ypos, zpos;
	202	Double_t alpha;
	203
	204
	205	// Check if the user set the proper parameters
	206	if (fLayRadius <= 0) AliFatal(Form("Wrong layer radius (%f)",fLayRadius));
	207	if (fZLength <= 0) AliFatal(Form("Wrong layer length (%f)",fZLength));
	208	if (fNLadders <= 0) AliFatal(Form("Wrong number of ladders (%d)",fNLadders));
	209	if (fNModules <= 0) AliFatal(Form("Wrong number of modules (%d)",fNModules));
	210
	211	if (fLadderThick <= 0) {
	212	AliInfo(Form("Ladder thickness wrong or not set (%f), using default (%f)",
	213	fLadderThick,fgkDefaultLadderThick));
	214	fLadderThick = fgkDefaultLadderThick;
	215	}
	216
	217	if (fSensorThick <= 0) {
	218	AliInfo(Form("Sensor thickness wrong or not set (%f), using default (%f)",
	219	fSensorThick,fgkDefaultSensorThick));
	220	fSensorThick = fgkDefaultSensorThick;
	221	}
	222
	223	if (fSensorThick > fLadderThick) {
	224	AliWarning(Form("Sensor thickness (%f) is greater than ladder thickness (%f), fixing",
	225	fSensorThick,fLadderThick));
	226	fSensorThick = fLadderThick;
	227	}
	228
	229
	230	// If a Turbo layer is requested, do it and exit
	231	if (fIsTurbo) {
	232	CreateLayerTurbo(moth, mgr);
	233	return;
	234	}
	235
	236
	237	// First create the ladder container
	238	alpha = (360./(2fNLadders))TMath::DegToRad();
d0674db6	239
d0674db6	240	// fLadderWidth = fLayRadius*TMath::Tan(alpha);
29998a6e	241
	242	rmin = 0.98*fLayRadius;
	243	rmax = 1.02TMath::Sqrt( fLadderWidthfLadderWidth +
	244	(rmin+fLadderThick)*(rmin+fLadderThick) );
	245
	246	TGeoTube layer = new TGeoTube(rmin, rmax, 0.5fZLength);
	247
	248
	249	// We have all shapes: now create the real volumes
	250	TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
	251
451f5018	252	snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(),fLayerNumber);
29998a6e	253	TGeoVolume *layVol = new TGeoVolume(volname, layer, medAir);
535d15f5	254	layVol->SetUniqueID(fDetTypeID);
29998a6e	255
	256	// layVol->SetVisibility(kFALSE);
	257	layVol->SetVisibility(kTRUE);
	258	layVol->SetLineColor(1);
	259
	260	TGeoVolume *laddVol = CreateLadder();
	261
	262
	263	// Now build up the layer
	264	alpha = 360./fNLadders;
	265	Double_t r = fLayRadius + ((TGeoBBox*)laddVol->GetShape())->GetDY();
	266	for (Int_t j=0; j<fNLadders; j++) {
	267	Double_t theta = j*alpha;
	268	xpos = r*SinD(theta);
	269	ypos = r*CosD(theta);
	270	zpos = 0.;
451f5018	271	layVol->AddNode(laddVol, j, new TGeoCombiTrans( xpos, ypos, zpos,
29998a6e	272	new TGeoRotation("",-theta,0,0)));
	273	}
	274
	275
	276	// Finally put everything in the mother volume
	277	moth->AddNode(layVol, 1, 0);
	278
	279
	280	// Upgrade geometry is served
	281	return;
	282	}
	283
	284	//________________________________________________________________________
451f5018	285	void AliITSUv11Layer::CreateLayerTurbo(TGeoVolume *moth,
29998a6e	286	const TGeoManager *mgr){
	287	//
	288	// Creates the actual Layer and places inside its mother volume
	289	// A so-called "turbo" layer is a layer where ladders overlap in phi
	290	// User can set width and tilt angle, no check is performed here
	291	// to avoid volume overlaps
	292	//
	293	// Input:
	294	// moth : the TGeoVolume owing the volume structure
	295	// mgr : the GeoManager (used only to get the proper material)
	296	//
	297	// Output:
	298	//
	299	// Return:
	300	//
	301	// Created: 08 Jul 2011 Mario Sitta
362fe8e0	302	// Updated: 08 Mar 2012 Mario Sitta Correct way to compute container R
29998a6e	303	//
	304
	305
	306	// Local variables
	307	char volname[30];
362fe8e0	308	Double_t rmin, rmax, rladd, rcont, d;
29998a6e	309	Double_t xpos, ypos, zpos;
	310	Double_t alpha, gamma;
	311
	312
	313	// Check if the user set the proper (remaining) parameters
	314	if (fLadderWidth <= 0)
	315	AliFatal(Form("Wrong ladder width (%f)",fLadderWidth));
	316	if (TMath::Abs(fLadderTilt) > 45)
	317	AliWarning(Form("Ladder tilt angle (%f) greater than 45deg",fLadderTilt));
	318
	319
	320	// First create the ladder container
	321	// d is half the diagonal of the ladder section
	322	// rladd is the radius at the ladder's center-of-gravity
362fe8e0	323	// alpha here is the angle between the diagonal and rladd
29998a6e	324	d = 0.5TMath::Sqrt(fLadderThickfLadderThick + fLadderWidth*fLadderWidth);
29998a6e	325	alpha = TMath::ACos(0.5fLadderThick/d)TMath::RadToDeg();
362fe8e0	326	gamma = alpha - fLadderTilt;
29998a6e	327	rladd = fLayRadius + 0.5*fLadderThick;
29998a6e	328
362fe8e0	329	// rcont is the radius of the air container
362fe8e0	330	rcont = RadiusOfTurboContainer();
d0674db6	331
362fe8e0	332	if (rcont > 0)
	333	rmin = 0.98*rcont;
	334	else
d0674db6	335	rmin = 0.98TMath::Sqrt( rladdrladd + dd - 2rladddCosD(gamma) );
d0674db6	336
29998a6e	337	rmax = 1.02TMath::Sqrt( rladdrladd + dd + 2rladddCosD(gamma) );
d0674db6	338
29998a6e	339	TGeoTube layer = new TGeoTube(rmin, rmax, 0.5fZLength);
	340
	341
	342	// We have all shapes: now create the real volumes
	343	TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
	344
451f5018	345	snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLayerPattern(), fLayerNumber);
29998a6e	346	TGeoVolume *layVol = new TGeoVolume(volname, layer, medAir);
535d15f5	347	layVol->SetUniqueID(fDetTypeID);
29998a6e	348	layVol->SetVisibility(kTRUE);
29998a6e	349	layVol->SetLineColor(1);
29998a6e	350	TGeoVolume *laddVol = CreateLadder();
	351
	352
	353	// Now build up the layer
	354
	355
	356	// Now build up the layer
	357	alpha = 360./fNLadders;
	358	Double_t r = fLayRadius + ((TGeoBBox*)laddVol->GetShape())->GetDY();
	359	for (Int_t j=0; j<fNLadders; j++) {
	360	Double_t theta = j*alpha;
	361	xpos = r*SinD(theta);
	362	ypos = r*CosD(theta);
	363	zpos = 0.;
451f5018	364	layVol->AddNode(laddVol, j, new TGeoCombiTrans( xpos, ypos, zpos,
29998a6e	365	new TGeoRotation("",-theta+fLadderTilt,0,0)));
	366	}
	367
	368
	369	// Finally put everything in the mother volume
	370	moth->AddNode(layVol, 1, 0);
	371
	372	return;
	373	}
	374
	375	//________________________________________________________________________
451f5018	376	TGeoVolume* AliITSUv11Layer::CreateLadder(const TGeoManager *mgr){
29998a6e	377	//
	378	// Creates the actual Ladder
	379	//
	380	// Input:
	381	// mgr : the GeoManager (used only to get the proper material)
	382	//
	383	// Output:
	384	//
	385	// Return:
	386	//
	387	// Created: 22 Jun 2011 Mario Sitta
	388	//
	389
	390	char volname[30];
	391	Double_t xlen, ylen, zlen;
	392	Double_t xpos, ypos, zpos, zmod;
	393	Double_t alpha;
	394
	395
	396	// First create all needed shapes
	397	alpha = (360./(2fNLadders))TMath::DegToRad();
	398
	399	// The ladder
	400	xlen = fLayRadius*TMath::Tan(alpha);
d0674db6	401	if (fIsTurbo) xlen = 0.5*fLadderWidth;
29998a6e	402	ylen = 0.5*fLadderThick;
	403	zlen = 0.5*fZLength;
	404
	405	TGeoBBox *ladder = new TGeoBBox(xlen, ylen, zlen);
	406
	407
	408	// We have all shapes: now create the real volumes
	409	TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
	410
451f5018	411	snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSLadderPattern(), fLayerNumber);
29998a6e	412	TGeoVolume *laddVol = new TGeoVolume(volname, ladder, medAir);
	413
	414	// laddVol->SetVisibility(kFALSE);
	415	laddVol->SetVisibility(kTRUE);
	416	laddVol->SetLineColor(2);
29998a6e	417	TGeoVolume *modVol = CreateModule(ladder->GetDX(), ladder->GetDY(),
	418	ladder->GetDZ());
	419
	420
	421	// Now build up the ladder
	422	zmod = ((TGeoBBox*)modVol->GetShape())->GetDZ();
	423	for (Int_t j=0; j<fNModules; j++) {
	424	xpos = 0.;
	425	ypos = 0.;
	426	zpos = -ladder->GetDZ() + j2zmod + zmod;
451f5018	427	laddVol->AddNode(modVol, j, new TGeoTranslation(xpos, ypos, zpos));
29998a6e	428	}
	429
	430
	431	// Done, return the ladder
	432	return laddVol;
	433	}
	434
	435	//________________________________________________________________________
451f5018	436	TGeoVolume* AliITSUv11Layer::CreateModule(const Double_t xlad,
29998a6e	437	const Double_t ylad,
	438	const Double_t zlad,
	439	const TGeoManager *mgr){
	440	//
	441	// Creates the actual Module
	442	//
	443	// Input:
	444	// xlad,ylad,zlad : the ladder dimensions
	445	// mgr : the GeoManager (used only to get the proper material)
	446	//
	447	// Output:
	448	//
	449	// Return:
	450	//
	451	// Created: 22 Jun 2011 Mario Sitta
	452	//
	453
	454	char volname[30];
	455	Double_t xlen, ylen, zlen;
	456	Double_t xpos, ypos, zpos;
	457
	458
	459	// First create all needed shapes
	460
	461	// The module
	462	TGeoBBox *module = new TGeoBBox(xlad, ylad, zlad/fNModules);
	463
	464	// The sensor
	465	xlen = module->GetDX();
	466	ylen = 0.5*fSensorThick;
	467	zlen = module->GetDZ();
	468	TGeoBBox *sensor = new TGeoBBox(xlen, ylen, zlen);
	469
	470
	471	// We have all shapes: now create the real volumes
	472	TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
	473	TGeoMedium *medSi = mgr->GetMedium("ITS_SI$");
	474
451f5018	475	snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSModulePattern() ,fLayerNumber);
29998a6e	476	TGeoVolume *modVol = new TGeoVolume(volname, module, medAir);
29998a6e	477	modVol->SetVisibility(kFALSE);
	478	modVol->SetLineColor(1);
	479
451f5018	480	snprintf(volname, 30, "%s%d", AliITSUGeomTGeo::GetITSSensorPattern(), fLayerNumber);
29998a6e	481	TGeoVolume *sensVol = new TGeoVolume(volname, sensor, medSi);
29998a6e	482	sensVol->SetVisibility(kTRUE);
	483	sensVol->SetLineColor(8);
	484	sensVol->SetLineWidth(1);
	485	sensVol->SetFillColor(sensVol->GetLineColor());
	486	sensVol->SetFillStyle(4000); // 0% transparent
	487
	488
	489	// Now build up the module
	490	xpos = 0.;
	491	ypos = -module->GetDY() + sensor->GetDY();
	492	zpos = 0.;
	493
	494	modVol->AddNode(sensVol, 1, new TGeoTranslation(xpos, ypos, zpos));
	495
	496
	497	// Done, return the module
	498	return modVol;
	499	}
	500
362fe8e0	501	//________________________________________________________________________
451f5018	502	Double_t AliITSUv11Layer::RadiusOfTurboContainer(){
362fe8e0	503	//
	504	// Computes the inner radius of the air container for the Turbo configuration
	505	// as the radius of either the circle tangent to the ladder or the circle
	506	// passing for the ladder's lower vertex
	507	//
	508	// Input:
	509	// none (all needed parameters are class members)
	510	//
	511	// Output:
	512	//
	513	// Return:
	514	// the radius of the container if >0, else flag to use the lower vertex
	515	//
	516	// Created: 08 Mar 2012 Mario Sitta
	517	//
	518
	519	Double_t rr, delta, z, lladd, rladd;
	520
	521	if (fLadderThick > 89.) // Very big angle: avoid overflows since surely
	522	return -1; // the radius from lower vertex is the right value
	523
	524	rladd = fLayRadius + 0.5*fLadderThick;
	525	delta = (0.5*fLadderThick)/CosD(fLadderTilt);
	526	z = (0.5fLadderThick)TanD(fLadderTilt);
	527
	528	rr = rladd - delta;
	529	lladd = (0.5*fLadderWidth) - z;
	530
	531	if ( (rr*SinD(fLadderTilt) < lladd) )
	532	return (rr*CosD(fLadderTilt));
	533	else
	534	return -1;
	535	}
	536
29998a6e	537	//________________________________________________________________________
451f5018	538	void AliITSUv11Layer::SetLadderTilt(const Double_t t){
29998a6e	539	//
	540	// Sets the Ladder tilt angle (for turbo layers only)
	541	//
	542	// Input:
	543	// t : the ladder tilt angle
	544	//
	545	// Output:
	546	//
	547	// Return:
	548	//
	549	// Created: 08 Jul 2011 Mario Sitta
	550	//
	551
	552	if (fIsTurbo)
	553	fLadderTilt = t;
	554	else
	555	AliError("Not a Turbo layer");
	556
	557	}
	558
	559	//________________________________________________________________________
451f5018	560	void AliITSUv11Layer::SetLadderWidth(const Double_t w){
29998a6e	561	//
	562	// Sets the Ladder width (for turbo layers only)
	563	//
	564	// Input:
	565	// w : the ladder width
	566	//
	567	// Output:
	568	//
	569	// Return:
	570	//
	571	// Created: 08 Jul 2011 Mario Sitta
	572	//
	573
	574	if (fIsTurbo)
	575	fLadderWidth = w;
	576	else
	577	AliError("Not a Turbo layer");
	578
	579	}