[u/mrichter/AliRoot.git] / TGeant3 / AliG3Volume.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.                  *
 **************************************************************************/

/*
$Log$
*/

/*
Old Logs: AliDrawVolume.cxx,v $
Revision 1.1  2000/07/13 16:19:10  fca
Mainly coding conventions + some small bug fixes

Revision 1.8  2000/07/12 08:56:32  fca
Coding convention correction and warning removal

Revision 1.7  2000/06/28 21:27:45  morsch
Most coding rule violations corrected.
Still to do: Split the file (on file per class) ? Avoid the global variables.
Copy constructors and assignment operators (dummy ?)

Revision 1.6  2000/04/14 11:07:46  morsch
Correct volume to medium assignment in case several media are asigned to the
same material.

Revision 1.5  2000/03/20 15:11:03  fca
Mods to make the code compile on HP

Revision 1.4  2000/01/18 16:12:08  morsch
Bug in calculation of number of volume divisions and number of positionings corrected
Browser for Material and Media properties added

Revision 1.3  1999/11/14 14:31:14  fca
Correct small error and remove compilation warnings on HP

Revision 1.2  1999/11/10 16:53:35  fca
The new geometry viewer from A.Morsch

*/

/* 
 *  Version: 0
 *  Written by Andreas Morsch
 *  
 * 
 *
 * For questions critics and suggestions to this part of the code
 * contact andreas.morsch@cern.ch
 * 
 **************************************************************************/

#include "AliG3Volume.h"
#include <TArrayF.h>
#include "TMaterial.h"
#include "TShape.h"
#include "TTUBE.h"
#include "TBRIK.h"
#include "TTRD1.h"
#include "TTRD2.h"
#include "TTRAP.h"
#include "TTUBS.h"
#include "TCONE.h"
#include "TCONS.h"
#include "TSPHE.h"
#include "TPARA.h"
#include "TPGON.h"
#include "TPCON.h"
#include "TTUBS.h"
#include "TELTU.h"
#include "THYPE.h"
#include "TGTRA.h"
#include "TCTUB.h"

ClassImp(AliG3Volume)

    AliG3Volume::AliG3Volume(const char* name) 
	: TNamed(name, " ")
{
// Constructor

    fTheta  = 30;
    fPhi    = 30;
    fPsi    = 0;
    fU      = 10;
    fV      = 10;
    fUscale = 0.01;
    fVscale = 0.01;
    fHide=0;
    fShadow=0;
    fFill=1;
    fSeen=1;
    fClip=0;
    fClipXmin=0.;
    fClipXmax=2000.;
    fClipYmin=0.;
    fClipYmax=2000.;
    fClipZmin=0.;
    fClipZmax=2000.;
    fNParam = 0;
    fPosition.Set(3);
    fCopies = new TList;
    fNCopies = 0;
    fPosp = kFALSE;
    fAxis = -1;
}

AliG3Volume::AliG3Volume(const AliG3Volume& volume)
    : TNamed(volume)
{
// Constructor

    fTheta  = 30;
    fPhi    = 30;
    fPsi    = 0;
    fU      = 10;
    fV      = 10;
    fUscale = 0.01;
    fVscale = 0.01;
    fHide=0;
    fShadow=0;
    fFill=1;
    fSeen=1;
    fClip=0;
    fClipXmin=0.;
    fClipXmax=2000.;
    fClipYmin=0.;
    fClipYmax=2000.;
    fClipZmin=0.;
    fClipZmax=2000.;
    fAxis = -1;
//
    fIdVolume   = volume.GetIdVolume();
    fIdCopy     = volume.GetIdCopy();
    fIdMedium   = volume.Medium();
    fIdMaterial = volume.Material();
    fPosition   = volume.Position(0);
    fShape      = volume.Shape();
    fRotMatrix  = volume.RotMatrix();
    TArrayF par;
    volume.Parameters(0, fParameters);
    fNCopies    = volume.NCopies();
    fPosp       = volume.Posp();
    
    fNParam     = volume.NParam();
    fCopies     = volume.Copies();
    fRotMatrix  = volume.RotMatrix();
    volume.Division(fNdiv, fAxis, fStartC, fStep);
    
}


void AliG3Volume::Draw(Option_t *)
{
// Wraps the geant Gdraw
    gMC->Gsatt(fName,"seen", fSeen);
    
    if (fHide) {
	gMC->Gdopt("hide", "on");
    } else {
	gMC->Gdopt("hide", "off");
    }

    if (fShadow) {
	gMC->Gdopt("shad", "on");
	gMC->Gsatt("*", "fill", fFill);
    } else {
	gMC->Gdopt("shad", "off");
    }

    	gMC->SetClipBox(".");
    if (fClip) {
	gMC->SetClipBox("*", fClipXmin, fClipXmax, 
			fClipYmin, fClipYmax, fClipZmin, fClipZmax);
    } else {
	gMC->SetClipBox(".");
    }
    

    gMC->Gdraw(fName, fTheta, fPhi, fPsi, fU, fV, fUscale, fVscale);
    THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
    if (higz) higz->Update();
}

void AliG3Volume::DrawSpec()
{
// Wraps the Geant DrawSpec
    gMC->Gsatt(fName,"seen", fSeen);
    
    if (fHide) {
	gMC->Gdopt("hide", "on");
    } else {
	gMC->Gdopt("hide", "off");
    }

    if (fShadow) {
	gMC->Gdopt("shad", "on");
	gMC->Gsatt("*", "fill", fFill);
    } else {
	gMC->Gdopt("shad", "off");
    }

    gMC->SetClipBox(".");
    if (fClip) {
	gMC->SetClipBox("*", fClipXmin, fClipXmax, fClipYmin, fClipYmax, fClipZmin, fClipZmax);
    } else {
	gMC->SetClipBox(".");
    }
    

    ((TGeant3*) gMC)->DrawOneSpec(fName);
    THIGZ *higz = (THIGZ*)gROOT->GetListOfCanvases()->FindObject("higz");
    if (higz) higz->Update();
}

void AliG3Volume::SetParam(Int_t ip, Float_t param)
{
// Set drawing parameters
    switch (ip) {
    case kTheta:
	fTheta=param;
	break;
    case kPhi:
	fPhi=param;
	break;
    case kPsi:
	fPsi=param;
	break;
    case kU:
	fU=param;
	break;
    case kV:
	fV=param;
	break;
    case kUscale:
	fUscale=param;
	break;
    case kVscale:
	fVscale=param;
	break;
    case kHide:
	fHide=Int_t(param);
	break;
    case kShadow:
	fShadow=Int_t(param);
	break;
    case kFill:
	fFill=Int_t(param);
	break;
    case kSeen:
	fSeen=Int_t(param);
	break;
    case kClip:
	fClip=Int_t(param);
	break;
    case kClipXmin:
	fClipXmin=param;
	break;
    case kClipXmax:
	fClipXmax=param;
	break;
    case kClipYmin:
	fClipYmin=param;
	break;
    case kClipYmax:
	fClipYmax=param;
	break;
    case kClipZmin:
	fClipZmin=param;
	break;
    case kClipZmax:
	fClipZmax=param;
	break;
    }
}

Float_t  AliG3Volume::GetParam(Int_t ip)
{
// Get drawing parameters
    switch (ip) {
    case kTheta:
	return fTheta;
    case kPhi:
	return fPhi;
    case kPsi:
	return fPsi;
    case kU:
	return fU;
    case kV:
	return fV;
    case kUscale:
	return fUscale;
    case kVscale:
	return fVscale;
    case kHide:
	return Float_t(fHide);
    case kShadow:
	return Float_t(fShadow);
    case kFill:
	return Float_t(fFill);
    case kSeen:
	return Float_t(fSeen);
    case kClip:
	return Float_t(fClip);
    case kClipXmin:
	return fClipXmin;
    case kClipXmax:
	return fClipXmax;
    case kClipYmin:
	return fClipYmin;
    case kClipYmax:
	return fClipYmax;
    case kClipZmin:
	return fClipZmin;
    case kClipZmax:
	return fClipZmax;
    default:
	return 0.;
    }
    return 0.;
}

void  AliG3Volume::AddCopy(AliG3Volume* volume)
{
    volume->SetIdMaterial(Material());
    fCopies->Add(volume);
    fNCopies++;
}

AliG3Volume* AliG3Volume::Copy(Int_t i)
{
    return (AliG3Volume*) fCopies->At(i);
}


TArrayF AliG3Volume::Position(Int_t i) const
{
//
// Get position for volume copy i 
//
    if (i==0) {
	return fPosition;
    } else {
	return ((AliG3Volume*) fCopies->At(i-1))->Position(0);
    }
}

void AliG3Volume::SetPosition(Float_t x, Float_t y, Float_t z)
{
//
// Set position
//
  fPosition[0] = x;
  fPosition[1] = y;
  fPosition[2] = z;
}


void  AliG3Volume::SetParameters(Int_t np, Float_t* param) 
{
//
// Set parameters 
//
    fParameters.Set(np);
    for (Int_t j=0; j<np; j++) fParameters[j]=param[j];
    fNParam = np;
}
    

void  AliG3Volume::Parameters(Int_t i, TArrayF& param) const
{
//
// Get parameters for volume copy i 
//
    TArrayF p;
    if (i==0) {
	p = fParameters;
    } else {
	((AliG3Volume*) (fCopies->At(i-1)))->Parameters(0, p);
    }
    Int_t np = fNParam;
    param.Set(np);
    for (Int_t j=0; j<np; j++) {
	param[j] = p.At(j);
    }
}
    

void AliG3Volume::CreateTShape(char* nameV, TMaterial* mat)
{
//
// Create a root volume from G3 volume
//
    Int_t   ip;
    
    Float_t kRadDeg = 180./TMath::Pi();
    Float_t theta, phi, alpha1, alpha2;
    Float_t p1, p2;
    
    TShape* nShape=0;
    const char* tmp = mat->GetName();
    char nameM[21];
    strncpy(nameM, tmp, 20);
    nameM[20]='\0';
    switch(fShape)
    {
    case 1:
// BOX
	nShape = new TBRIK(nameV,"BRIK",nameM,fParameters[0], fParameters[1], fParameters[2]);
	break;
	
    case 2:
// TRD1	  
	nShape = new TTRD1(nameV, "TRD1", nameM, fParameters[0], fParameters[1], fParameters[2],
			   fParameters[3]);
	break;
	
    case 3:
// TRD2
	nShape = new TTRD2(nameV, "TRD2", nameM, fParameters[0], fParameters[1], fParameters[2], 
			   fParameters[3], fParameters[4]);
	break;
	
    case 4:
// TRAP
	p1     = fParameters[1];
	p2     = fParameters[2];
	
	theta  = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
	phi    = TMath::ATan2(p2,p1)*kRadDeg;
	alpha1 = fParameters[6 ]*kRadDeg;
	alpha2 = fParameters[10]*kRadDeg;

	if (theta < 0.) theta+=180.;
	
	nShape =  new TTRAP(nameV, "TRAP", nameM, fParameters[0], 
			    theta, phi,
			    fParameters[3], fParameters[4], fParameters[5], 
			    alpha1, 
			    fParameters[7], fParameters[8], fParameters[9], 
			    alpha2);
	break;
	
    case 5:
// TUBE
	nShape =  new TTUBE(nameV,"TUBE",nameM,fParameters[0], fParameters[1], fParameters[2]);
	break;
	
    case 6:
// TUBS
	nShape =  new TTUBS(nameV,"TUBS",nameM,fParameters[0], fParameters[1], fParameters[2], 
			    fParameters[3], fParameters[4]);
	break;
	
    case 7:
// CONE
	nShape =  new TCONE(nameV, "CONE", nameM, fParameters[0], fParameters[1], fParameters[2], 
			    fParameters[3], fParameters[4]);
	break;
	
    case 8:
	
// CONS
	nShape =  new TCONS(nameV, "CONS", nameM, fParameters[0], fParameters[1], fParameters[2], 
			    fParameters[3], fParameters[4], fParameters[5], fParameters[6]);
	break;
	
    case 9:
// SPHE
	
	nShape =  new TSPHE(nameV, "SPHE", nameM, fParameters[0], fParameters[1], fParameters[2], 
			    fParameters[3], fParameters[4], fParameters[5]);
	break;
	
    case 10:
// PARA
	alpha1 = fParameters[3]*kRadDeg;
	p1     = fParameters[4];
	p2     = fParameters[5];
	theta  = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
	phi    = TMath::ATan2(p2,p1)*kRadDeg;

	nShape =  new TPARA(nameV, "PARA", nameM, fParameters[0], fParameters[1], fParameters[2], 
				    alpha1, theta, phi);
	break;
	
    case 11:
// PGON
	nShape =  new TPGON(nameV, "PGON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]), 
			    Int_t(fParameters[3]));
	for (ip=0; ip<Int_t(fParameters[3]); ip++) {
	    ((TPGON*) nShape)->DefineSection(ip, fParameters[4+3*ip], fParameters[4+3*ip+1], 
					     fParameters[4+3*ip+2]);
	}
	break;
	
    case 12:
// PCON
	nShape = new TPCON(nameV, "PCON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]));
	for (ip=0; ip<Int_t(fParameters[2]); ip++) {
	    ((TPCON*) nShape)->DefineSection(ip, fParameters[3+3*ip], fParameters[3+3*ip+1], 
					     fParameters[3+3*ip+2]);
	}
	break;
	
    case 13:
// ELTU  
	nShape = new TELTU(nameV,"ELTU",nameM,fParameters[0], fParameters[1], fParameters[2]);
	break;
	
    case 14:
// HYPE
	nShape = new THYPE(nameV,"HYPE",nameM,fParameters[0], fParameters[1], fParameters[2], 
			   fParameters[3]);
	break;
	
    case 15:
// GTRA
	nShape = new TGTRA(nameV, "GTRA", nameM, fParameters[0], fParameters[1], fParameters[2], 
			   fParameters[3], fParameters[4], fParameters[5], fParameters[6], 
			   fParameters[7], fParameters[8], fParameters[9], fParameters[10], 
			   fParameters[11]);
	break;
	
    case 16:
// CTUB
	nShape = new TCTUB(nameV, "CTUB", nameM, fParameters[0], fParameters[1], fParameters[2], 
			   fParameters[3], fParameters[4], fParameters[5], fParameters[6], 
			   fParameters[7], fParameters[8], fParameters[9], fParameters[10]);
	break;
    default:
	break;
    }
    if (nShape) {
	Float_t density = mat->GetDensity();
	if (density < 0.01) {
	    nShape->SetVisibility(0);
	} else {
	    nShape->SetVisibility(1);
	}
	
	Int_t color = Int_t(density/20.*100.);
	nShape->SetLineColor(color);
    }
}

void   AliG3Volume::SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step)
{
    fNdiv   = ndiv;
    fAxis   = axis;
    fStartC = start;
    fStep   = step;
}

void   AliG3Volume::Division(Int_t& ndiv, Int_t& axis, Float_t& start, Float_t& step) const
{
    ndiv  = fNdiv;
    axis  = fAxis;
    start = fStartC;
    step  = fStep;
}
Commit	Line	Data
3b7275e7	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	$Log$
	18	*/
	19
	20	/*
	21	Old Logs: AliDrawVolume.cxx,v $
	22	Revision 1.1 2000/07/13 16:19:10 fca
	23	Mainly coding conventions + some small bug fixes
	24
	25	Revision 1.8 2000/07/12 08:56:32 fca
	26	Coding convention correction and warning removal
	27
	28	Revision 1.7 2000/06/28 21:27:45 morsch
	29	Most coding rule violations corrected.
	30	Still to do: Split the file (on file per class) ? Avoid the global variables.
	31	Copy constructors and assignment operators (dummy ?)
	32
	33	Revision 1.6 2000/04/14 11:07:46 morsch
	34	Correct volume to medium assignment in case several media are asigned to the
	35	same material.
	36
	37	Revision 1.5 2000/03/20 15:11:03 fca
	38	Mods to make the code compile on HP
	39
	40	Revision 1.4 2000/01/18 16:12:08 morsch
	41	Bug in calculation of number of volume divisions and number of positionings corrected
	42	Browser for Material and Media properties added
	43
	44	Revision 1.3 1999/11/14 14:31:14 fca
	45	Correct small error and remove compilation warnings on HP
	46
	47	Revision 1.2 1999/11/10 16:53:35 fca
	48	The new geometry viewer from A.Morsch
	49
	50	*/
	51
	52	/*
	53	* Version: 0
	54	* Written by Andreas Morsch
	55	*
	56	*
	57	*
	58	* For questions critics and suggestions to this part of the code
	59	* contact andreas.morsch@cern.ch
	60	*
	61	**************************************************************************/
	62
	63	#include "AliG3Volume.h"
	64	#include <TArrayF.h>
65	#include "TMaterial.h"
66	#include "TShape.h"
67	#include "TTUBE.h"
68	#include "TBRIK.h"
69	#include "TTRD1.h"
70	#include "TTRD2.h"
71	#include "TTRAP.h"
72	#include "TTUBS.h"
73	#include "TCONE.h"
74	#include "TCONS.h"
75	#include "TSPHE.h"
76	#include "TPARA.h"
77	#include "TPGON.h"
78	#include "TPCON.h"
79	#include "TTUBS.h"
80	#include "TELTU.h"
81	#include "THYPE.h"
82	#include "TGTRA.h"
83	#include "TCTUB.h"
84
85	ClassImp(AliG3Volume)
86
87	AliG3Volume::AliG3Volume(const char* name)
88	: TNamed(name, " ")
89	{
90	// Constructor
91
92	fTheta = 30;
93	fPhi = 30;
94	fPsi = 0;
95	fU = 10;
96	fV = 10;
97	fUscale = 0.01;
98	fVscale = 0.01;
99	fHide=0;
100	fShadow=0;
101	fFill=1;
102	fSeen=1;
103	fClip=0;
104	fClipXmin=0.;
105	fClipXmax=2000.;
106	fClipYmin=0.;
107	fClipYmax=2000.;
108	fClipZmin=0.;
109	fClipZmax=2000.;
110	fNParam = 0;
111	fPosition.Set(3);
112	fCopies = new TList;
113	fNCopies = 0;
114	fPosp = kFALSE;
115	fAxis = -1;
116	}
117
118	AliG3Volume::AliG3Volume(const AliG3Volume& volume)
119	: TNamed(volume)
120	{
121	// Constructor
122
123	fTheta = 30;
124	fPhi = 30;
125	fPsi = 0;
126	fU = 10;
127	fV = 10;
128	fUscale = 0.01;
129	fVscale = 0.01;
130	fHide=0;
131	fShadow=0;
132	fFill=1;
133	fSeen=1;
134	fClip=0;
135	fClipXmin=0.;
136	fClipXmax=2000.;
137	fClipYmin=0.;
138	fClipYmax=2000.;
139	fClipZmin=0.;
140	fClipZmax=2000.;
141	fAxis = -1;
142	//
143	fIdVolume = volume.GetIdVolume();
144	fIdCopy = volume.GetIdCopy();
145	fIdMedium = volume.Medium();
146	fIdMaterial = volume.Material();
147	fPosition = volume.Position(0);
148	fShape = volume.Shape();
149	fRotMatrix = volume.RotMatrix();
150	TArrayF par;
151	volume.Parameters(0, fParameters);
152	fNCopies = volume.NCopies();
153	fPosp = volume.Posp();
154
155	fNParam = volume.NParam();
156	fCopies = volume.Copies();
157	fRotMatrix = volume.RotMatrix();
158	volume.Division(fNdiv, fAxis, fStartC, fStep);
159
160	}
161
162
163
164
165	void AliG3Volume::Draw(Option_t *)
166	{
167	// Wraps the geant Gdraw
168	gMC->Gsatt(fName,"seen", fSeen);
169
170	if (fHide) {
171	gMC->Gdopt("hide", "on");
172	} else {
173	gMC->Gdopt("hide", "off");
174	}
175
176	if (fShadow) {
177	gMC->Gdopt("shad", "on");
178	gMC->Gsatt("*", "fill", fFill);
179	} else {
180	gMC->Gdopt("shad", "off");
181	}
182
183	gMC->SetClipBox(".");
184	if (fClip) {
185	gMC->SetClipBox("*", fClipXmin, fClipXmax,
186	fClipYmin, fClipYmax, fClipZmin, fClipZmax);
187	} else {
188	gMC->SetClipBox(".");
189	}
190
191
192	gMC->Gdraw(fName, fTheta, fPhi, fPsi, fU, fV, fUscale, fVscale);
193	THIGZ higz = (THIGZ)gROOT->GetListOfCanvases()->FindObject("higz");
194	if (higz) higz->Update();
195	}
196
197	void AliG3Volume::DrawSpec()
198	{
199	// Wraps the Geant DrawSpec
200	gMC->Gsatt(fName,"seen", fSeen);
201
202	if (fHide) {
203	gMC->Gdopt("hide", "on");
204	} else {
205	gMC->Gdopt("hide", "off");
206	}
207
208	if (fShadow) {
209	gMC->Gdopt("shad", "on");
210	gMC->Gsatt("*", "fill", fFill);
211	} else {
212	gMC->Gdopt("shad", "off");
213	}
214
215	gMC->SetClipBox(".");
216	if (fClip) {
217	gMC->SetClipBox("*", fClipXmin, fClipXmax, fClipYmin, fClipYmax, fClipZmin, fClipZmax);
218	} else {
219	gMC->SetClipBox(".");
220	}
221
222
223	((TGeant3*) gMC)->DrawOneSpec(fName);
224	THIGZ higz = (THIGZ)gROOT->GetListOfCanvases()->FindObject("higz");
225	if (higz) higz->Update();
226	}
227
228	void AliG3Volume::SetParam(Int_t ip, Float_t param)
229	{
230	// Set drawing parameters
231	switch (ip) {
232	case kTheta:
233	fTheta=param;
234	break;
235	case kPhi:
236	fPhi=param;
237	break;
238	case kPsi:
239	fPsi=param;
240	break;
241	case kU:
242	fU=param;
243	break;
244	case kV:
245	fV=param;
246	break;
247	case kUscale:
248	fUscale=param;
249	break;
250	case kVscale:
251	fVscale=param;
252	break;
253	case kHide:
254	fHide=Int_t(param);
255	break;
256	case kShadow:
257	fShadow=Int_t(param);
258	break;
259	case kFill:
260	fFill=Int_t(param);
261	break;
262	case kSeen:
263	fSeen=Int_t(param);
264	break;
265	case kClip:
266	fClip=Int_t(param);
267	break;
268	case kClipXmin:
269	fClipXmin=param;
270	break;
271	case kClipXmax:
272	fClipXmax=param;
273	break;
274	case kClipYmin:
275	fClipYmin=param;
276	break;
277	case kClipYmax:
278	fClipYmax=param;
279	break;
280	case kClipZmin:
281	fClipZmin=param;
282	break;
283	case kClipZmax:
284	fClipZmax=param;
285	break;
286	}
287	}
288
289	Float_t AliG3Volume::GetParam(Int_t ip)
290	{
291	// Get drawing parameters
292	switch (ip) {
293	case kTheta:
294	return fTheta;
295	case kPhi:
296	return fPhi;
297	case kPsi:
298	return fPsi;
299	case kU:
300	return fU;
301	case kV:
302	return fV;
303	case kUscale:
304	return fUscale;
305	case kVscale:
306	return fVscale;
307	case kHide:
308	return Float_t(fHide);
309	case kShadow:
310	return Float_t(fShadow);
311	case kFill:
312	return Float_t(fFill);
313	case kSeen:
314	return Float_t(fSeen);
315	case kClip:
316	return Float_t(fClip);
317	case kClipXmin:
318	return fClipXmin;
319	case kClipXmax:
320	return fClipXmax;
321	case kClipYmin:
322	return fClipYmin;
323	case kClipYmax:
324	return fClipYmax;
325	case kClipZmin:
326	return fClipZmin;
327	case kClipZmax:
328	return fClipZmax;
329	default:
330	return 0.;
331	}
332	return 0.;
333	}
334
335	void AliG3Volume::AddCopy(AliG3Volume* volume)
336	{
337	volume->SetIdMaterial(Material());
338	fCopies->Add(volume);
339	fNCopies++;
340	}
341
342	AliG3Volume* AliG3Volume::Copy(Int_t i)
343	{
344	return (AliG3Volume*) fCopies->At(i);
345	}
346
347
348	TArrayF AliG3Volume::Position(Int_t i) const
349	{
350	//
351	// Get position for volume copy i
352	//
353	if (i==0) {
354	return fPosition;
355	} else {
356	return ((AliG3Volume*) fCopies->At(i-1))->Position(0);
357	}
358	}
359
360	void AliG3Volume::SetPosition(Float_t x, Float_t y, Float_t z)
361	{
362	//
363	// Set position
364	//
365	fPosition[0] = x;
366	fPosition[1] = y;
367	fPosition[2] = z;
368	}
369
370
371	void AliG3Volume::SetParameters(Int_t np, Float_t* param)
372	{
373	//
374	// Set parameters
375	//
376	fParameters.Set(np);
377	for (Int_t j=0; j<np; j++) fParameters[j]=param[j];
378	fNParam = np;
379	}
380
381
382	void AliG3Volume::Parameters(Int_t i, TArrayF& param) const
383	{
384	//
385	// Get parameters for volume copy i
386	//
387	TArrayF p;
388	if (i==0) {
389	p = fParameters;
390	} else {
391	((AliG3Volume*) (fCopies->At(i-1)))->Parameters(0, p);
392	}
393	Int_t np = fNParam;
394	param.Set(np);
395	for (Int_t j=0; j<np; j++) {
396	param[j] = p.At(j);
397	}
398	}
399
400
401	void AliG3Volume::CreateTShape(char* nameV, TMaterial* mat)
402	{
403	//
404	// Create a root volume from G3 volume
405	//
406	Int_t ip;
407
408	Float_t kRadDeg = 180./TMath::Pi();
409	Float_t theta, phi, alpha1, alpha2;
410	Float_t p1, p2;
411
412	TShape* nShape=0;
413	const char* tmp = mat->GetName();
414	char nameM[21];
415	strncpy(nameM, tmp, 20);
416	nameM[20]='\0';
417	switch(fShape)
418	{
419	case 1:
420	// BOX
421	nShape = new TBRIK(nameV,"BRIK",nameM,fParameters[0], fParameters[1], fParameters[2]);
422	break;
423
424	case 2:
425	// TRD1
426	nShape = new TTRD1(nameV, "TRD1", nameM, fParameters[0], fParameters[1], fParameters[2],
427	fParameters[3]);
428	break;
429
430	case 3:
431	// TRD2
432	nShape = new TTRD2(nameV, "TRD2", nameM, fParameters[0], fParameters[1], fParameters[2],
433	fParameters[3], fParameters[4]);
434	break;
435
436	case 4:
437	// TRAP
438	p1 = fParameters[1];
439	p2 = fParameters[2];
440
441	theta = TMath::ATan(TMath::Sqrt(p1p1+p2p2))*kRadDeg;
442	phi = TMath::ATan2(p2,p1)*kRadDeg;
443	alpha1 = fParameters[6 ]*kRadDeg;
444	alpha2 = fParameters[10]*kRadDeg;
445
446	if (theta < 0.) theta+=180.;
447
448	nShape = new TTRAP(nameV, "TRAP", nameM, fParameters[0],
449	theta, phi,
450	fParameters[3], fParameters[4], fParameters[5],
451	alpha1,
452	fParameters[7], fParameters[8], fParameters[9],
453	alpha2);
454	break;
455
456	case 5:
457	// TUBE
458	nShape = new TTUBE(nameV,"TUBE",nameM,fParameters[0], fParameters[1], fParameters[2]);
459	break;
460
461	case 6:
462	// TUBS
463	nShape = new TTUBS(nameV,"TUBS",nameM,fParameters[0], fParameters[1], fParameters[2],
464	fParameters[3], fParameters[4]);
465	break;
466
467	case 7:
468	// CONE
469	nShape = new TCONE(nameV, "CONE", nameM, fParameters[0], fParameters[1], fParameters[2],
470	fParameters[3], fParameters[4]);
471	break;
472
473	case 8:
474
475	// CONS
476	nShape = new TCONS(nameV, "CONS", nameM, fParameters[0], fParameters[1], fParameters[2],
477	fParameters[3], fParameters[4], fParameters[5], fParameters[6]);
478	break;
479
480	case 9:
481	// SPHE
482
483	nShape = new TSPHE(nameV, "SPHE", nameM, fParameters[0], fParameters[1], fParameters[2],
484	fParameters[3], fParameters[4], fParameters[5]);
485	break;
486
487	case 10:
488	// PARA
489	alpha1 = fParameters[3]*kRadDeg;
490	p1 = fParameters[4];
491	p2 = fParameters[5];
492	theta = TMath::ATan(TMath::Sqrt(p1p1+p2p2))*kRadDeg;
493	phi = TMath::ATan2(p2,p1)*kRadDeg;
494
495	nShape = new TPARA(nameV, "PARA", nameM, fParameters[0], fParameters[1], fParameters[2],
496	alpha1, theta, phi);
497	break;
498
499	case 11:
500	// PGON
501	nShape = new TPGON(nameV, "PGON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]),
502	Int_t(fParameters[3]));
503	for (ip=0; ip<Int_t(fParameters[3]); ip++) {
504	((TPGON) nShape)->DefineSection(ip, fParameters[4+3ip], fParameters[4+3*ip+1],
505	fParameters[4+3*ip+2]);
506	}
507	break;
508
509	case 12:
510	// PCON
511	nShape = new TPCON(nameV, "PCON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]));
512	for (ip=0; ip<Int_t(fParameters[2]); ip++) {
513	((TPCON) nShape)->DefineSection(ip, fParameters[3+3ip], fParameters[3+3*ip+1],
514	fParameters[3+3*ip+2]);
515	}
516	break;
517
518	case 13:
519	// ELTU
520	nShape = new TELTU(nameV,"ELTU",nameM,fParameters[0], fParameters[1], fParameters[2]);
521	break;
522
523	case 14:
524	// HYPE
525	nShape = new THYPE(nameV,"HYPE",nameM,fParameters[0], fParameters[1], fParameters[2],
526	fParameters[3]);
527	break;
528
529	case 15:
530	// GTRA
531	nShape = new TGTRA(nameV, "GTRA", nameM, fParameters[0], fParameters[1], fParameters[2],
532	fParameters[3], fParameters[4], fParameters[5], fParameters[6],
533	fParameters[7], fParameters[8], fParameters[9], fParameters[10],
534	fParameters[11]);
535	break;
536
537	case 16:
538	// CTUB
539	nShape = new TCTUB(nameV, "CTUB", nameM, fParameters[0], fParameters[1], fParameters[2],
540	fParameters[3], fParameters[4], fParameters[5], fParameters[6],
541	fParameters[7], fParameters[8], fParameters[9], fParameters[10]);
542	break;
543	default:
544	break;
545	}
546	if (nShape) {
547	Float_t density = mat->GetDensity();
548	if (density < 0.01) {
549	nShape->SetVisibility(0);
550	} else {
551	nShape->SetVisibility(1);
552	}
553
554	Int_t color = Int_t(density/20.*100.);
555	nShape->SetLineColor(color);
556	}
557	}
558
559	void AliG3Volume::SetDivision(Int_t ndiv, Int_t axis, Float_t start, Float_t step)
560	{
561	fNdiv = ndiv;
562	fAxis = axis;
563	fStartC = start;
564	fStep = step;
565	}
566
567	void AliG3Volume::Division(Int_t& ndiv, Int_t& axis, Float_t& start, Float_t& step) const
568	{
569	ndiv = fNdiv;
570	axis = fAxis;
571	start = fStartC;
572	step = fStep;
573	}