[u/mrichter/AliRoot.git] / GEODB / AliGTube.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$
*/

// -*- C++ -*-
// 
// 1998/10/19
// ---------------------------------------------------------------------------
//
// AliTube Class
//
// This file is part of the ALICE Geometry Database .
//
// By:  Joana E. Santo & David Collados
//
// ---------------------------------------------------------------------------

#include <TVirtualPad.h>
#include <TView.h>
#include <TCanvas.h>
#include <iostream.h>
#include <TGLKernelABC.h>
#include "TROOT.h"
#include "AliGTube.h"
#include "AliGShape.h"

ClassImp(AliGTube)

AliGTube::AliGTube()
{
    /* Default Constructor */
    fCoTab = NULL;    // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
    fAspectRatio = 1; // defines  (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
    fDz    = 0.;      // half length in z
    fName  = "";
    fNdiv  = 0;       // number of segments (precision)
    fRmax  = 0.;      // ellipse  semi-axis   in  X outside
    fRmin  = 0.;      // ellipse  semi-axis   in  X inside
    fSiTab = NULL;    // Table of sin(fPhi1) .... sin(fPhil+fDphi1)
    fTitle = "";
}

//-------------------------------------------------------------------------

AliGTube::AliGTube( Text_t *name, Text_t *title, Float_t rmin, Float_t rmax, Float_t dz, Float_t aspect ) : AliGShape(name, title)
{
    /* Constructor */
    fCoTab       = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
    fAspectRatio = aspect; // defines  (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
    fDz          = dz;   // half length in z
    fNdiv        = 0;    // number of segments (precision)
    fRmax        = rmax; // ellipse  semi-axis   in  X outside
    fRmin        = rmin; // ellipse  semi-axis   in  X inside
    fSiTab       = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)

    MakeTableOfCoSin();
}


//-------------------------------------------------------------------------

AliGTube::AliGTube( AliGTube *tube ) 
{
    /* Copy Constructor */
    fCoTab       = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
    fAspectRatio = tube->fAspectRatio; // defines  (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
    fDz          = tube->fDz;   // half length in z
    fColor       = tube->fColor;
    fName        = tube->fName;
    fNdiv        = 0;    // number of segments (precision)
    fRmax        = tube->fRmax; // ellipse  semi-axis   in  X outside
    fRmin        = tube->fRmin; // ellipse  semi-axis   in  X inside
    fSiTab       = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)
    fTitle       = tube->fTitle;

    MakeTableOfCoSin();
}

//-------------------------------------------------------------------------

AliGTube::AliGTube(Text_t *name, Text_t *title, Float_t rmax, Float_t dz) : AliGShape(name, title)
{
    /* Tube simplified constructor */
    fCoTab       = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
    fAspectRatio = 1;    // defines  (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
    fDz          = dz;   // half length in z
    fNdiv        = 0;    // number of segments (precision)
    fRmax        = rmax; // ellipse  semi-axis   in  X outside
    fRmin        = 0.;   // ellipse  semi-axis   in  X inside
    fSiTab       = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)

    MakeTableOfCoSin();
}

//-------------------------------------------------------------------------

AliGTube::~AliGTube()
{
    /* Destructor */
    delete [] fCoTab;
    delete [] fSiTab;
}

//-------------------------------------------------------------------------

void AliGTube::MakeTableOfCoSin()
{
    const Double_t PI    = TMath::ATan(1) * 4.0;
    const Double_t TWOPI = 2*PI;

    Int_t j;
    Int_t n = GetNumberOfDivisions ();

    if (fCoTab)
        delete [] fCoTab; // Delete the old tab if any
    fCoTab = new Double_t [n];

    if (!fCoTab ) {
        Error("MakeTableOfCoSin()","No cos table done");
        return;
    }

    if (fSiTab)
        delete [] fSiTab; // Delete the old tab if any
    fSiTab = new Double_t [n];

    if (!fSiTab )
    {
        Error("MakeTableOfCoSin()","No sin table done");
        return;
    }

    Double_t range   = TWOPI;
    Double_t angstep = range/n;

    Double_t ph = 0;
    for (j = 0; j < n; j++)
    {
        ph = j*angstep;
        fCoTab[j] = TMath::Cos(ph);
        fSiTab[j] = TMath::Sin(ph);
    }

}

//-------------------------------------------------------------------------

void AliGTube::DrawShape(Option_t *option)
{
    Draw(option);
    gPad->Update();
}

//-------------------------------------------------------------------------

void AliGTube::Draw(Option_t *option)
{
    //cout << " Entra en " << this->GetName() << "::Draw " << endl;
    TString opt = option;
    opt.ToLower();

    if( !gPad ) {
        gPad = new TCanvas("AliGTube","AliGTube",0,0,400,300);
        gPad->Range(0,0,1,1);
        gPad->SetFillColor(32); // Light Green
        gPad->SetBorderSize(3);
        gPad->SetBorderMode(0); // -1 (down) 0 (no) 1 (up)
    }
    else {
        if( !opt.Contains("same") ) {
            gPad->Clear();
            gPad->SetName("AliGTube");
            gPad->SetTitle("AliGTube");
        }
        else {
            gPad->SetName("AliShapes");
            gPad->SetTitle("AliShapes"); 
        }
    }

    AppendPad(option);
    TView *view = gPad->GetView();

    if (!view)
        view = new TView(1);

    view->SetAutoRange(kTRUE);
    Paint(option);
    view->SetAutoRange(kFALSE);

    cout << " Sale de " << this->GetName() << "::Draw " << endl;
}

//-------------------------------------------------------------------------

void AliGTube::Paint(Option_t *option)
{
//*-*-*-*-*-*-*-*Paint this 3-D shape with its current attributes*-*-*-*-*-*-*-*
//*-*            ================================================

    SetLineColor( GetCol() );
        
    Int_t i, j;
    Int_t n = GetNumberOfDivisions();
    const Int_t numpoints = 4*n;

//*-* Allocate memory for points *-*

    Float_t *points = new Float_t[3*numpoints];
    if (!points) return;
  
    SetPoints(points);

    if (gPad->GetView3D()) PaintGLPoints(points);

//==   for (i = 0; i < numpoints; i++)
//==            gNode->Local2Master(&points[3*i],&points[3*i]);

    X3DBuffer *buff = new X3DBuffer;
    if (buff) {
        buff->numPoints = numpoints;
        buff->numSegs   = n*8;
        buff->numPolys  = n*4;
    }


//*-* Allocate memory for points *-*

    buff->points = points;

    Int_t c = ((GetLineColor() % 8) - 1) * 4;     // Basic colors: 0, 1, ... 7
    if (c < 0) c = 0;

//*-* Allocate memory for segments *-*

    buff->segs = new Int_t[buff->numSegs*3];
    if (buff->segs) {
        for (i = 0; i < 4; i++) {
            for (j = 0; j < n; j++) {
                buff->segs[(i*n+j)*3  ] = c;
                buff->segs[(i*n+j)*3+1] = i*n+j;
                buff->segs[(i*n+j)*3+2] = i*n+j+1;
            }
            buff->segs[(i*n+j-1)*3+2] = i*n;
        }
        for (i = 4; i < 6; i++) {
            for (j = 0; j < n; j++) {
                buff->segs[(i*n+j)*3  ] = c+1;
                buff->segs[(i*n+j)*3+1] = (i-4)*n+j;
                buff->segs[(i*n+j)*3+2] = (i-2)*n+j;
            }
        }
        for (i = 6; i < 8; i++) {
            for (j = 0; j < n; j++) {
                buff->segs[(i*n+j)*3  ] = c;
                buff->segs[(i*n+j)*3+1] = 2*(i-6)*n+j;
                buff->segs[(i*n+j)*3+2] = (2*(i-6)+1)*n+j;
            }
        }
    }

//*-* Allocate memory for polygons *-*

    Int_t indx = 0;

    buff->polys = new Int_t[buff->numPolys*6];
    if (buff->polys) {
        for (i = 0; i < 2; i++) {
            for (j = 0; j < n; j++) {
                indx = 6*(i*n+j);
                buff->polys[indx  ] = c;
                buff->polys[indx+1] = 4;
                buff->polys[indx+2] = i*n+j;
                buff->polys[indx+3] = (4+i)*n+j;
                buff->polys[indx+4] = (2+i)*n+j;
                buff->polys[indx+5] = (4+i)*n+j+1;
            }
            buff->polys[indx+5] = (4+i)*n;
        }
        for (i = 2; i < 4; i++) {
            for (j = 0; j < n; j++) {
                indx = 6*(i*n+j);
                buff->polys[indx  ] = c+(i-2)*2+1;
                buff->polys[indx+1] = 4;
                buff->polys[indx+2] = (i-2)*2*n+j;
                buff->polys[indx+3] = (4+i)*n+j;
                buff->polys[indx+4] = ((i-2)*2+1)*n+j;
                buff->polys[indx+5] = (4+i)*n+j+1;
            }
            buff->polys[indx+5] = (4+i)*n;
        }
    }

    //*-* Paint in the pad
    //*-* Paint in the pad
    Bool_t rangeView = strcmp(option,"range")==0 ? kTRUE : kFALSE;
   
    PaintShape(buff,rangeView);
    //PaintShape(buff);

    if (strstr(option, "x3d")) {
        if(buff && buff->points && buff->segs)
            FillX3DBuffer(buff);
        else {
            gSize3D.numPoints -= buff->numPoints;
            gSize3D.numSegs   -= buff->numSegs;
            gSize3D.numPolys  -= buff->numPolys;
        }
    }
    
   if( points ) delete [] points;
  
    //if (buff->points)   delete [] buff->points;
    
    if (buff->segs)     delete [] buff->segs;
    
    if (buff->polys)    delete [] buff->polys;
    
    if (buff)           delete    buff;
      
}

//-------------------------------------------------------------------------

void AliGTube::PaintGLPoints(Float_t *vertex)
{
//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*Paint BRIK via OpenGL *-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                            =====================
    gGLKernel->PaintCone(vertex,GetNumberOfDivisions(),2);
}

//-------------------------------------------------------------------------

void AliGTube::SetPoints(Float_t *buff)
{
//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*Create TUBE points*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                          ==================

    Float_t dz;
    Int_t j, n;

    n = GetNumberOfDivisions();

    dz = fDz;

    Int_t indx = 0;

    if (buff) {
//*-* We've to checxk whether the table does exist and create it
//*-* since fCoTab/fSiTab are not saved with any TShape::Streamer function
        if (!fCoTab)   MakeTableOfCoSin();

        for (j = 0; j < n; j++) {
            buff[indx+6*n] = buff[indx] = fRmin * fCoTab[j];
            indx++;
            buff[indx+6*n] = buff[indx] = fAspectRatio*fRmin * fSiTab[j];
            indx++;
            buff[indx+6*n] = dz;
            buff[indx]     =-dz;
            indx++;
        }
        for (j = 0; j < n; j++) {
            buff[indx+6*n] = buff[indx] = fRmax * fCoTab[j];
            indx++;
            buff[indx+6*n] = buff[indx] = fAspectRatio*fRmax * fSiTab[j];
            indx++;
            buff[indx+6*n]= dz;
            buff[indx]    =-dz;
            indx++;
        }
    }
}

//-------------------------------------------------------------------------

void AliGTube::Sizeof3D() const
{
//*-*-*-*-*-*Return total X3D size of this shape with its attributes*-*-*-*-*-*-*
//*-*        =======================================================

  cout << " Entra en AliGTube::Sizeof3D() " << endl;

    Int_t n = GetNumberOfDivisions();

    gSize3D.numPoints += n*4;
    gSize3D.numSegs   += n*8;
    gSize3D.numPolys  += n*4;
}

//-------------------------------------------------------------------------

void AliGTube::Streamer(TBuffer &R__b)
{
   // Stream an object of class AliGTube.

   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(); if (R__v) { }
      AliGShape::Streamer(R__b);
      R__b.ReadArray(fCoTab); //
      R__b >> fAspectRatio;
      R__b >> fDz;
      R__b >> fNdiv;
      R__b >> fRmax;
      R__b >> fRmin;
      R__b.ReadArray(fSiTab); //
   } else {
      R__b.WriteVersion(AliGTube::IsA());
      AliGShape::Streamer(R__b);
      R__b.WriteArray(fCoTab, GetNumberOfDivisions()); //
      R__b << fAspectRatio;
      R__b << fDz;
      R__b << fNdiv;
      R__b << fRmax;
      R__b << fRmin;
      R__b.WriteArray(fSiTab, GetNumberOfDivisions()); //
   }
}

//-------------------------------------------------------------------------
Commit	Line	Data
4c039060	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
ab2f6604	20	// -- C++ --
	21	//
	22	// 1998/10/19
	23	// ---------------------------------------------------------------------------
	24	//
	25	// AliTube Class
	26	//
	27	// This file is part of the ALICE Geometry Database .
	28	//
	29	// By: Joana E. Santo & David Collados
	30	//
	31	// ---------------------------------------------------------------------------
	32
	33	#include <TVirtualPad.h>
	34	#include <TView.h>
	35	#include <TCanvas.h>
	36	#include <iostream.h>
	37	#include <TGLKernelABC.h>
	38	#include "TROOT.h"
	39	#include "AliGTube.h"
	40	#include "AliGShape.h"
	41
	42	ClassImp(AliGTube)
	43
	44	AliGTube::AliGTube()
	45	{
	46	/* Default Constructor */
	47	fCoTab = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
	48	fAspectRatio = 1; // defines (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
	49	fDz = 0.; // half length in z
	50	fName = "";
	51	fNdiv = 0; // number of segments (precision)
	52	fRmax = 0.; // ellipse semi-axis in X outside
	53	fRmin = 0.; // ellipse semi-axis in X inside
	54	fSiTab = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)
	55	fTitle = "";
	56	}
	57
	58	//-------------------------------------------------------------------------
	59
	60	AliGTube::AliGTube( Text_t name, Text_t title, Float_t rmin, Float_t rmax, Float_t dz, Float_t aspect ) : AliGShape(name, title)
	61	{
	62	/* Constructor */
	63	fCoTab = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
	64	fAspectRatio = aspect; // defines (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
	65	fDz = dz; // half length in z
	66	fNdiv = 0; // number of segments (precision)
	67	fRmax = rmax; // ellipse semi-axis in X outside
	68	fRmin = rmin; // ellipse semi-axis in X inside
	69	fSiTab = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)
	70
	71	MakeTableOfCoSin();
	72	}
	73
	74
	75	//-------------------------------------------------------------------------
	76
	77	AliGTube::AliGTube( AliGTube *tube )
	78	{
	79	/* Copy Constructor */
	80	fCoTab = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
	81	fAspectRatio = tube->fAspectRatio; // defines (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
	82	fDz = tube->fDz; // half length in z
	83	fColor = tube->fColor;
84	fName = tube->fName;
85	fNdiv = 0; // number of segments (precision)
86	fRmax = tube->fRmax; // ellipse semi-axis in X outside
87	fRmin = tube->fRmin; // ellipse semi-axis in X inside
88	fSiTab = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)
89	fTitle = tube->fTitle;
90
91	MakeTableOfCoSin();
92	}
93
94	//-------------------------------------------------------------------------
95
96	AliGTube::AliGTube(Text_t name, Text_t title, Float_t rmax, Float_t dz) : AliGShape(name, title)
97	{
98	/* Tube simplified constructor */
99	fCoTab = NULL; // Table of cos(fPhi1) .... cos(fPhil+fDphi1)
100	fAspectRatio = 1; // defines (the ellipse semi-axis in Y)/(the ellipse semi-axis in X)
101	fDz = dz; // half length in z
102	fNdiv = 0; // number of segments (precision)
103	fRmax = rmax; // ellipse semi-axis in X outside
104	fRmin = 0.; // ellipse semi-axis in X inside
105	fSiTab = NULL; // Table of sin(fPhi1) .... sin(fPhil+fDphi1)
106
107	MakeTableOfCoSin();
108	}
109
110	//-------------------------------------------------------------------------
111
112	AliGTube::~AliGTube()
113	{
114	/* Destructor */
115	delete [] fCoTab;
116	delete [] fSiTab;
117	}
118
119	//-------------------------------------------------------------------------
120
121	void AliGTube::MakeTableOfCoSin()
122	{
123	const Double_t PI = TMath::ATan(1) * 4.0;
124	const Double_t TWOPI = 2*PI;
125
126	Int_t j;
127	Int_t n = GetNumberOfDivisions ();
128
129	if (fCoTab)
130	delete [] fCoTab; // Delete the old tab if any
131	fCoTab = new Double_t [n];
132
133	if (!fCoTab ) {
134	Error("MakeTableOfCoSin()","No cos table done");
135	return;
136	}
137
138	if (fSiTab)
139	delete [] fSiTab; // Delete the old tab if any
140	fSiTab = new Double_t [n];
141
142	if (!fSiTab )
143	{
144	Error("MakeTableOfCoSin()","No sin table done");
145	return;
146	}
147
148	Double_t range = TWOPI;
149	Double_t angstep = range/n;
150
151	Double_t ph = 0;
152	for (j = 0; j < n; j++)
153	{
154	ph = j*angstep;
155	fCoTab[j] = TMath::Cos(ph);
156	fSiTab[j] = TMath::Sin(ph);
157	}
158
159	}
160
161	//-------------------------------------------------------------------------
162
163	void AliGTube::DrawShape(Option_t *option)
164	{
165	Draw(option);
166	gPad->Update();
167	}
168
169	//-------------------------------------------------------------------------
170
171	void AliGTube::Draw(Option_t *option)
172	{
173	//cout << " Entra en " << this->GetName() << "::Draw " << endl;
174	TString opt = option;
175	opt.ToLower();
176
177	if( !gPad ) {
178	gPad = new TCanvas("AliGTube","AliGTube",0,0,400,300);
179	gPad->Range(0,0,1,1);
180	gPad->SetFillColor(32); // Light Green
181	gPad->SetBorderSize(3);
182	gPad->SetBorderMode(0); // -1 (down) 0 (no) 1 (up)
183	}
184	else {
185	if( !opt.Contains("same") ) {
186	gPad->Clear();
187	gPad->SetName("AliGTube");
188	gPad->SetTitle("AliGTube");
189	}
190	else {
191	gPad->SetName("AliShapes");
192	gPad->SetTitle("AliShapes");
193	}
194	}
195
196	AppendPad(option);
197	TView *view = gPad->GetView();
198
199	if (!view)
200	view = new TView(1);
201
202	view->SetAutoRange(kTRUE);
203	Paint(option);
204	view->SetAutoRange(kFALSE);
205
206	cout << " Sale de " << this->GetName() << "::Draw " << endl;
207	}
208
209	//-------------------------------------------------------------------------
210
211	void AliGTube::Paint(Option_t *option)
212	{
213	//-------Paint this 3-D shape with its current attributes-------
214	//- ================================================
215
216	SetLineColor( GetCol() );
217
218	Int_t i, j;
219	Int_t n = GetNumberOfDivisions();
220	const Int_t numpoints = 4*n;
221
222	//- Allocate memory for points -
223
224	Float_t points = new Float_t[3numpoints];
225	if (!points) return;
226
227	SetPoints(points);
228
229	if (gPad->GetView3D()) PaintGLPoints(points);
230
231	//== for (i = 0; i < numpoints; i++)
232	//== gNode->Local2Master(&points[3i],&points[3i]);
233
234	X3DBuffer *buff = new X3DBuffer;
235	if (buff) {
236	buff->numPoints = numpoints;
237	buff->numSegs = n*8;
238	buff->numPolys = n*4;
239	}
240
241
242	//- Allocate memory for points -
243
244	buff->points = points;
245
246	Int_t c = ((GetLineColor() % 8) - 1) * 4; // Basic colors: 0, 1, ... 7
247	if (c < 0) c = 0;
248
249	//- Allocate memory for segments -
250
251	buff->segs = new Int_t[buff->numSegs*3];
252	if (buff->segs) {
253	for (i = 0; i < 4; i++) {
254	for (j = 0; j < n; j++) {
255	buff->segs[(in+j)3 ] = c;
256	buff->segs[(in+j)3+1] = i*n+j;
257	buff->segs[(in+j)3+2] = i*n+j+1;
258	}
259	buff->segs[(in+j-1)3+2] = i*n;
260	}
261	for (i = 4; i < 6; i++) {
262	for (j = 0; j < n; j++) {
263	buff->segs[(in+j)3 ] = c+1;
264	buff->segs[(in+j)3+1] = (i-4)*n+j;
265	buff->segs[(in+j)3+2] = (i-2)*n+j;
266	}
267	}
268	for (i = 6; i < 8; i++) {
269	for (j = 0; j < n; j++) {
270	buff->segs[(in+j)3 ] = c;
271	buff->segs[(in+j)3+1] = 2(i-6)n+j;
272	buff->segs[(in+j)3+2] = (2(i-6)+1)n+j;
273	}
274	}
275	}
276
277	//- Allocate memory for polygons -
278
279	Int_t indx = 0;
280
281	buff->polys = new Int_t[buff->numPolys*6];
282	if (buff->polys) {
283	for (i = 0; i < 2; i++) {
284	for (j = 0; j < n; j++) {
285	indx = 6(in+j);
286	buff->polys[indx ] = c;
287	buff->polys[indx+1] = 4;
288	buff->polys[indx+2] = i*n+j;
289	buff->polys[indx+3] = (4+i)*n+j;
290	buff->polys[indx+4] = (2+i)*n+j;
291	buff->polys[indx+5] = (4+i)*n+j+1;
292	}
293	buff->polys[indx+5] = (4+i)*n;
294	}
295	for (i = 2; i < 4; i++) {
296	for (j = 0; j < n; j++) {
297	indx = 6(in+j);
298	buff->polys[indx ] = c+(i-2)*2+1;
299	buff->polys[indx+1] = 4;
300	buff->polys[indx+2] = (i-2)2n+j;
301	buff->polys[indx+3] = (4+i)*n+j;
302	buff->polys[indx+4] = ((i-2)2+1)n+j;
303	buff->polys[indx+5] = (4+i)*n+j+1;
304	}
305	buff->polys[indx+5] = (4+i)*n;
306	}
307	}
308
309	//- Paint in the pad
310	//- Paint in the pad
311	Bool_t rangeView = strcmp(option,"range")==0 ? kTRUE : kFALSE;
312
313	PaintShape(buff,rangeView);
314	//PaintShape(buff);
315
316	if (strstr(option, "x3d")) {
317	if(buff && buff->points && buff->segs)
318	FillX3DBuffer(buff);
319	else {
320	gSize3D.numPoints -= buff->numPoints;
321	gSize3D.numSegs -= buff->numSegs;
322	gSize3D.numPolys -= buff->numPolys;
323	}
324	}
325
326	if( points ) delete [] points;
327
328	//if (buff->points) delete [] buff->points;
329
330	if (buff->segs) delete [] buff->segs;
331
332	if (buff->polys) delete [] buff->polys;
333
334	if (buff) delete buff;
335
336	}
337
338	//-------------------------------------------------------------------------
339
340	void AliGTube::PaintGLPoints(Float_t *vertex)
341	{
342	//---------------Paint BRIK via OpenGL ------------*
343	//- =====================
344	gGLKernel->PaintCone(vertex,GetNumberOfDivisions(),2);
345	}
346
347	//-------------------------------------------------------------------------
348
349	void AliGTube::SetPoints(Float_t *buff)
350	{
351	//--------------Create TUBE points---------------*
352	//- ==================
353
354	Float_t dz;
355	Int_t j, n;
356
357	n = GetNumberOfDivisions();
358
359	dz = fDz;
360
361	Int_t indx = 0;
362
363	if (buff) {
364	//- We've to checxk whether the table does exist and create it
365	//- since fCoTab/fSiTab are not saved with any TShape::Streamer function
366	if (!fCoTab) MakeTableOfCoSin();
367
368	for (j = 0; j < n; j++) {
369	buff[indx+6n] = buff[indx] = fRmin fCoTab[j];
370	indx++;
371	buff[indx+6n] = buff[indx] = fAspectRatiofRmin * fSiTab[j];
372	indx++;
373	buff[indx+6*n] = dz;
374	buff[indx] =-dz;
375	indx++;
376	}
377	for (j = 0; j < n; j++) {
378	buff[indx+6n] = buff[indx] = fRmax fCoTab[j];
379	indx++;
380	buff[indx+6n] = buff[indx] = fAspectRatiofRmax * fSiTab[j];
381	indx++;
382	buff[indx+6*n]= dz;
383	buff[indx] =-dz;
384	indx++;
385	}
386	}
387	}
388
389	//-------------------------------------------------------------------------
390
391	void AliGTube::Sizeof3D() const
392	{
393	//-----Return total X3D size of this shape with its attributes------*
394	//- =======================================================
395
396	cout << " Entra en AliGTube::Sizeof3D() " << endl;
397
398	Int_t n = GetNumberOfDivisions();
399
400	gSize3D.numPoints += n*4;
401	gSize3D.numSegs += n*8;
402	gSize3D.numPolys += n*4;
403	}
404
405	//-------------------------------------------------------------------------
406
407	void AliGTube::Streamer(TBuffer &R__b)
408	{
409	// Stream an object of class AliGTube.
410
411	if (R__b.IsReading()) {
412	Version_t R__v = R__b.ReadVersion(); if (R__v) { }
413	AliGShape::Streamer(R__b);
414	R__b.ReadArray(fCoTab); //
415	R__b >> fAspectRatio;
416	R__b >> fDz;
417	R__b >> fNdiv;
418	R__b >> fRmax;
419	R__b >> fRmin;
420	R__b.ReadArray(fSiTab); //
421	} else {
422	R__b.WriteVersion(AliGTube::IsA());
423	AliGShape::Streamer(R__b);
424	R__b.WriteArray(fCoTab, GetNumberOfDivisions()); //
425	R__b << fAspectRatio;
426	R__b << fDz;
427	R__b << fNdiv;
428	R__b << fRmax;
429	R__b << fRmin;
430	R__b.WriteArray(fSiTab, GetNumberOfDivisions()); //
431	}
432	}
433
434	//-------------------------------------------------------------------------
435