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 | // AliGPCone 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 <TView.h> |
34 | #include <TVirtualPad.h> |
35 | #include <iostream.h> |
36 | #include <TGLKernelABC.h> |
37 | #include <TCanvas.h> |
38 | #include "AliGPCone.h" |
39 | #include "TROOT.h" |
40 | |
41 | ClassImp(AliGPCone) |
42 | |
43 | AliGPCone::AliGPCone() : AliGShape() |
44 | { |
45 | /* Default Constructor */ |
46 | |
47 | fPhi1 = 0.; |
48 | fDphi1 = 0.; |
49 | fNz = 0; |
50 | fNdiv = 0; |
51 | fRmin = NULL; |
52 | fRmax = NULL; |
53 | fDz = NULL; |
54 | fCoTab = NULL; |
55 | fSiTab = NULL; |
56 | } |
57 | |
58 | //------------------------------------------------------------------------- |
59 | |
60 | AliGPCone::AliGPCone( AliGPCone* pcone ) |
61 | { |
62 | /* Copy Constructor */ |
63 | if( pcone->fNz < 2 ) { |
64 | Error( pcone->GetName(), "number of z planes for %s must be at least two !", pcone->GetName() ); |
65 | return; |
66 | } |
67 | |
68 | fName = pcone->fName; |
69 | fTitle = pcone->fTitle; |
70 | |
71 | fColor = pcone->fColor; |
72 | fPhi1 = pcone->fPhi1; |
73 | fDphi1 = pcone->fDphi1; |
74 | fNz = pcone->fNz; |
75 | fNdiv = pcone->fNdiv; |
76 | |
77 | fRmin = new Float_t [fNz+1]; |
78 | fRmax = new Float_t [fNz+1]; |
79 | fDz = new Float_t [fNz+1]; |
80 | |
81 | fCoTab = NULL; |
82 | fSiTab = NULL; |
83 | |
84 | while (fDphi1 > 360) fDphi1 -= 360; |
85 | |
86 | MakeTableOfCoSin(); |
87 | |
88 | for( int k=0; k<fNz; k++ ) { |
89 | fDz[k] = pcone->fDz[k]; |
90 | fRmin[k] = pcone->fRmin[k]; |
91 | fRmax[k] = pcone->fRmax[k]; |
92 | } |
93 | |
94 | } |
95 | |
96 | //------------------------------------------------------------------------- |
97 | |
98 | AliGPCone::AliGPCone( Text_t *name, Text_t *title, Float_t phi1, Float_t dphi1, Int_t nz ) : AliGShape(name, title) |
99 | { |
100 | /* Constructor */ |
101 | |
102 | if (nz < 2 ) { |
103 | Error(name, "number of z planes for %s must be at least two !", name); |
104 | return; |
105 | } |
106 | |
107 | fPhi1 = phi1; |
108 | fDphi1 = dphi1; |
109 | fNz = nz; |
110 | fNdiv = 0; |
111 | fRmin = new Float_t [fNz+1]; |
112 | fRmax = new Float_t [fNz+1]; |
113 | fDz = new Float_t [fNz+1]; |
114 | |
115 | fCoTab = NULL; |
116 | fSiTab = NULL; |
117 | |
118 | while (fDphi1 > 360) fDphi1 -= 360; |
119 | |
120 | MakeTableOfCoSin(); |
121 | } |
122 | |
123 | //--------------------------------------------------------------------------- |
124 | |
125 | AliGPCone::AliGPCone( Text_t *name, Text_t* title, Float_t *upar, Int_t np) : AliGShape(name, title) |
126 | { |
127 | if (upar[2] < 2 ) { |
128 | Error(name, "number of z planes for %s must be at least two !", name); |
129 | return; |
130 | } |
131 | |
132 | fPhi1 = upar[0]; |
133 | fDphi1 = upar[1]; |
134 | fNz = (Int_t) upar[2]; |
135 | fNdiv = 0; |
136 | fRmin = new Float_t [fNz+1]; |
137 | fRmax = new Float_t [fNz+1]; |
138 | fDz = new Float_t [fNz+1]; |
139 | fCoTab = NULL; |
140 | fSiTab = NULL; |
141 | |
142 | while (fDphi1 > 360) fDphi1 -= 360; |
143 | |
144 | MakeTableOfCoSin(); |
145 | |
146 | for( int j=3, k=0; k<fNz; k++ ) { |
147 | fDz[k] = upar[j]; |
148 | fRmin[k] = upar[j+1]; |
149 | fRmax[k] = upar[j+2]; |
150 | j+=3; |
151 | } |
152 | } |
153 | |
154 | //------------------------------------------------------------------------- |
155 | |
156 | AliGPCone::AliGPCone( Text_t *name, Text_t* title, Float_t phi1, Float_t dphi1, Int_t nz, Float_t Z[10], Float_t RMIN[10], Float_t RMAX[10] ) : AliGShape(name, title) |
157 | { |
158 | cout << " ENTRA EN EL CONSTRUCTOR CHUNGO !!!!!! " << endl; |
159 | |
160 | //AliGPCone(name, title, phi1, dphi1, nz); |
161 | |
162 | //for (int i= 0; i<nz; i++) |
163 | //DefineSection(i, Z[i], RMIN[i], RMAX[i]); |
164 | } |
165 | |
166 | //--------------------------------------------------------------------------- |
167 | |
168 | AliGPCone::~AliGPCone() |
169 | { |
170 | /* Destructor */ |
171 | |
172 | if( fRmin ) delete [] fRmin; |
173 | if( fRmax ) delete [] fRmax; |
174 | if( fDz ) delete [] fDz; |
175 | //if( fSiTab ) delete fSiTab; |
176 | //if( fCoTab ) delete fCoTab; |
177 | |
178 | fRmin = NULL; |
179 | fRmax = NULL; |
180 | fDz = NULL; |
181 | //fCoTab = NULL; |
182 | //fSiTab = NULL; |
183 | } |
184 | |
185 | //------------------------------------------------------------------------- |
186 | |
187 | void AliGPCone::DrawShape(Option_t *option) |
188 | { |
189 | Draw(option); |
190 | gPad->Update(); |
191 | } |
192 | |
193 | //------------------------------------------------------------------------- |
194 | |
195 | void AliGPCone::Draw(Option_t *option) |
196 | { |
197 | //cout << " Entra en " << this->GetName() << "::Draw " << endl; |
198 | |
199 | TString opt = option; |
200 | opt.ToLower(); |
201 | |
202 | if( !gPad ) { |
203 | //TCanvas* Cone = new TCanvas("AliGPCone","AliGPCone",0,0,400,300); |
204 | gPad = new TCanvas("AliGPCone","AliGPCone",0,0,400,300); |
205 | gPad->Range(0,0,1,1); |
206 | gPad->SetFillColor(32); // Light Green |
207 | gPad->SetBorderSize(3); |
208 | gPad->SetBorderMode(0); // -1 (down) 0 (no) 1 (up) |
209 | } |
210 | else { |
211 | if( !opt.Contains("same") ) { |
212 | gPad->Clear(); |
213 | gPad->SetName("AliGPCone"); |
214 | gPad->SetTitle("AliGPCone"); |
215 | } |
216 | else { |
217 | gPad->SetName("AliShapes"); |
218 | gPad->SetTitle("AliShapes"); |
219 | } |
220 | } |
221 | |
222 | AppendPad(option); |
223 | TView *view = gPad->GetView(); |
224 | |
225 | if (!view) |
226 | view = new TView(1); |
227 | |
228 | view->SetAutoRange(kTRUE); |
229 | Paint(option); |
230 | view->SetAutoRange(kFALSE); |
231 | //cout << " Sale de " << this->GetName() << "::Draw " << endl; |
232 | } |
233 | |
234 | //------------------------------------------------------------------------- |
235 | |
236 | void AliGPCone::SetPoints(Float_t *buff) |
237 | { |
238 | //*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*Create PCON points*-*-*-*-*-*-*-*-*-*-*-*-*-*-* |
239 | //*-* ================== |
240 | |
241 | Int_t i, j; |
242 | Int_t indx = 0; |
243 | |
244 | if (buff) { |
245 | |
246 | Int_t n = GetNumberOfDivisions()+1; |
247 | |
248 | //*-* We've to check whether the table does exist and create it |
249 | //*-* since fCoTab/fSiTab are not saved with any TShape::Streamer function |
250 | if (!fCoTab) MakeTableOfCoSin(); |
251 | |
252 | for (i = 0; i < fNz; i++) |
253 | { |
254 | for (j = 0; j < n; j++) |
255 | { |
256 | buff[indx++] = fRmin[i] * fCoTab[j]; |
257 | buff[indx++] = fRmin[i] * fSiTab[j]; |
258 | buff[indx++] = fDz[i]; |
259 | } |
260 | for (j = 0; j < n; j++) |
261 | { |
262 | buff[indx++] = fRmax[i] * fCoTab[j]; |
263 | buff[indx++] = fRmax[i] * fSiTab[j]; |
264 | buff[indx++] = fDz[i]; |
265 | } |
266 | } |
267 | } |
268 | } |
269 | |
270 | //------------------------------------------------------------------------- |
271 | |
272 | void AliGPCone::Paint(Option_t *option) |
273 | { |
274 | |
275 | //*-*-*-*-*-*-*-*Paint this 3-D shape with its current attributes*-*-*-*-*-*-*-* |
276 | //*-* ================================================ |
277 | |
278 | Int_t i, j; |
279 | if (fNz < 2) return; |
280 | const Int_t n = GetNumberOfDivisions()+1; |
281 | |
282 | SetLineColor( GetCol() ); |
283 | |
284 | Int_t numpoints = fNz*2*n; |
285 | if (numpoints <= 0) return; |
286 | //*-* Allocate memory for points *-* |
287 | |
288 | Float_t *points = new Float_t[3*numpoints]; |
289 | if (!points) return; |
290 | SetPoints(points); |
291 | |
292 | Bool_t rangeView = strcmp(option,"range")==0 ? kTRUE : kFALSE; |
293 | if (!rangeView && gPad->GetView3D()) PaintGLPoints(points); |
294 | |
295 | //== for (i = 0; i < numpoints; i++) |
296 | //== gNode->Local2Master(&points[3*i],&points[3*i]); |
297 | |
298 | Bool_t specialCase = kFALSE; |
299 | |
300 | if (fDphi1 == 360) //mark this as a very special case, when |
301 | specialCase = kTRUE; //we have to draw this PCON like a TUBE |
302 | |
303 | X3DBuffer *buff = new X3DBuffer; |
304 | |
305 | if (buff) { |
306 | buff->numPoints = numpoints; |
307 | buff->numSegs = 4*(fNz*n-1+(specialCase == kTRUE)); |
308 | buff->numPolys = 2*(fNz*n-1+(specialCase == kTRUE)); |
309 | } |
310 | |
311 | //*-* Allocate memory for points *-* |
312 | |
313 | buff->points = points; |
314 | |
315 | Int_t c = ((GetLineColor() % 8) - 1) * 4; // Basic colors: 0, 1, ... 7 |
316 | if (c < 0) c = 0; |
317 | |
318 | //*-* Allocate memory for segments *-* |
319 | |
320 | Int_t indx, indx2, k; |
321 | indx = indx2 = 0; |
322 | |
323 | buff->segs = new Int_t[buff->numSegs*3]; |
324 | if (buff->segs) { |
325 | |
326 | //inside & outside circles, number of segments: 2*fNz*(n-1) |
327 | // special case number of segments: 2*fNz*n |
328 | for (i = 0; i < fNz*2; i++) { |
329 | indx2 = i*n; |
330 | for (j = 1; j < n; j++) { |
331 | buff->segs[indx++] = c; |
332 | buff->segs[indx++] = indx2+j-1; |
333 | buff->segs[indx++] = indx2+j; |
334 | } |
335 | if (specialCase) { |
336 | buff->segs[indx++] = c; |
337 | buff->segs[indx++] = indx2+j-1; |
338 | buff->segs[indx++] = indx2; |
339 | } |
340 | } |
341 | |
342 | //bottom & top lines, number of segments: 2*n |
343 | for (i = 0; i < 2; i++) { |
344 | indx2 = i*(fNz-1)*2*n; |
345 | for (j = 0; j < n; j++) { |
346 | buff->segs[indx++] = c; |
347 | buff->segs[indx++] = indx2+j; |
348 | buff->segs[indx++] = indx2+n+j; |
349 | } |
350 | } |
351 | |
352 | //inside & outside cilindres, number of segments: 2*(fNz-1)*n |
353 | for (i = 0; i < (fNz-1); i++) { |
354 | |
355 | //inside cilinder |
356 | indx2 = i*n*2; |
357 | for (j = 0; j < n; j++) { |
358 | buff->segs[indx++] = c+2; |
359 | buff->segs[indx++] = indx2+j; |
360 | buff->segs[indx++] = indx2+n*2+j; |
361 | } |
362 | //outside cilinder |
363 | indx2 = i*n*2+n; |
364 | for (j = 0; j < n; j++) { |
365 | buff->segs[indx++] = c+3; |
366 | buff->segs[indx++] = indx2+j; |
367 | buff->segs[indx++] = indx2+n*2+j; |
368 | } |
369 | } |
370 | |
371 | //left & right sections, number of segments: 2*(fNz-2) |
372 | // special case number of segments: 0 |
373 | if (!specialCase) { |
374 | for (i = 1; i < (fNz-1); i++) { |
375 | for (j = 0; j < 2; j++) { |
376 | buff->segs[indx++] = c; |
377 | buff->segs[indx++] = 2*i * n + j*(n-1); |
378 | buff->segs[indx++] = (2*i+1) * n + j*(n-1); |
379 | } |
380 | } |
381 | } |
382 | } |
383 | |
384 | |
385 | Int_t m = n - 1 + (specialCase == kTRUE); |
386 | |
387 | //*-* Allocate memory for polygons *-* |
388 | |
389 | indx = 0; |
390 | |
391 | buff->polys = new Int_t[buff->numPolys*6]; |
392 | |
393 | if (buff->polys) { |
394 | |
395 | //bottom & top, number of polygons: 2*(n-1) |
396 | // special case number of polygons: 2*n |
397 | for (i = 0; i < 2; i++) { |
398 | for (j = 0; j < n-1; j++) { |
399 | buff->polys[indx++] = c+3; |
400 | buff->polys[indx++] = 4; |
401 | buff->polys[indx++] = 2*fNz*m+i*n+j; |
402 | buff->polys[indx++] = i*(fNz*2-2)*m+m+j; |
403 | buff->polys[indx++] = 2*fNz*m+i*n+j+1; |
404 | buff->polys[indx++] = i*(fNz*2-2)*m+j; |
405 | } |
406 | if (specialCase) { |
407 | buff->polys[indx++] = c+3; |
408 | buff->polys[indx++] = 4; |
409 | buff->polys[indx++] = 2*fNz*m+i*n+j; |
410 | buff->polys[indx++] = i*(fNz*2-2)*m+m+j; |
411 | buff->polys[indx++] = 2*fNz*m+i*n; |
412 | buff->polys[indx++] = i*(fNz*2-2)*m+j; |
413 | } |
414 | } |
415 | |
416 | |
417 | //inside & outside, number of polygons: (fNz-1)*2*(n-1) |
418 | for (k = 0; k < (fNz-1); k++) { |
419 | for (i = 0; i < 2; i++) { |
420 | for (j = 0; j < n-1; j++) { |
421 | buff->polys[indx++] = c+i; |
422 | buff->polys[indx++] = 4; |
423 | buff->polys[indx++] = (2*k+i*1)*m+j; |
424 | buff->polys[indx++] = fNz*2*m+(2*k+i*1+2)*n+j; |
425 | buff->polys[indx++] = (2*k+i*1+2)*m+j; |
426 | buff->polys[indx++] = fNz*2*m+(2*k+i*1+2)*n+j+1; |
427 | } |
428 | if (specialCase) { |
429 | buff->polys[indx++] = c+i; |
430 | buff->polys[indx++] = 4; |
431 | buff->polys[indx++] = (2*k+i*1)*m+j; |
432 | buff->polys[indx++] = fNz*2*m+(2*k+i*1+2)*n+j; |
433 | buff->polys[indx++] = (2*k+i*1+2)*m+j; |
434 | buff->polys[indx++] = fNz*2*m+(2*k+i*1+2)*n; |
435 | } |
436 | } |
437 | } |
438 | |
439 | |
440 | //left & right sections, number of polygons: 2*(fNz-1) |
441 | // special case number of polygons: 0 |
442 | if (!specialCase) { |
443 | indx2 = fNz*2*(n-1); |
444 | for (k = 0; k < (fNz-1); k++) { |
445 | for (i = 0; i < 2; i++) { |
446 | buff->polys[indx++] = c+2; |
447 | buff->polys[indx++] = 4; |
448 | buff->polys[indx++] = k==0 ? indx2+i*(n-1) : indx2+2*fNz*n+2*(k-1)+i; |
449 | buff->polys[indx++] = indx2+2*(k+1)*n+i*(n-1); |
450 | buff->polys[indx++] = indx2+2*fNz*n+2*k+i; |
451 | buff->polys[indx++] = indx2+(2*k+3)*n+i*(n-1); |
452 | } |
453 | } |
454 | buff->polys[indx-8] = indx2+n; |
455 | buff->polys[indx-2] = indx2+2*n-1; |
456 | } |
457 | } |
458 | |
459 | //*-* Paint in the pad |
460 | |
461 | PaintShape(buff,rangeView); |
462 | |
463 | if (strstr(option, "x3d")) { |
464 | if(buff && buff->points && buff->segs) |
465 | FillX3DBuffer(buff); |
466 | else { |
467 | gSize3D.numPoints -= buff->numPoints; |
468 | gSize3D.numSegs -= buff->numSegs; |
469 | gSize3D.numPolys -= buff->numPolys; |
470 | } |
471 | } |
472 | |
473 | delete [] points; |
474 | if (buff->segs) delete [] buff->segs; |
475 | if (buff->polys) delete [] buff->polys; |
476 | if (buff) delete buff; |
477 | |
478 | } |
479 | |
480 | //------------------------------------------------------------------------- |
481 | |
482 | void AliGPCone::MakeTableOfCoSin() |
483 | { |
484 | const Double_t PI = TMath::ATan(1) * 4.0; |
485 | const Double_t ragrad = PI/180.0; |
486 | |
487 | Int_t j; |
488 | Int_t n = GetNumberOfDivisions () + 1; |
489 | if (fCoTab) |
490 | delete [] fCoTab; // Delete the old tab if any |
491 | fCoTab = new Double_t [n]; |
492 | if (!fCoTab ) return; |
493 | |
494 | if (fSiTab) |
495 | delete [] fSiTab; // Delete the old tab if any |
496 | fSiTab = new Double_t [n]; |
497 | if (!fSiTab ) return; |
498 | |
499 | Double_t range = Double_t(fDphi1 * ragrad); |
500 | Double_t phi1 = Double_t(fPhi1 * ragrad); |
501 | Double_t angstep = range/(n-1); |
502 | |
503 | Double_t ph = phi1; |
504 | for (j = 0; j < n; j++) |
505 | { |
506 | ph = phi1 + j*angstep; |
507 | fCoTab[j] = TMath::Cos(ph); |
508 | fSiTab[j] = TMath::Sin(ph); |
509 | } |
510 | |
511 | } |
512 | |
513 | //---------------------------------------------------- |
514 | |
515 | void AliGPCone::SetNumberOfDivisions (Int_t p) |
516 | { |
517 | if (GetNumberOfDivisions () == p) return; |
518 | fNdiv=p; |
519 | MakeTableOfCoSin(); |
520 | } |
521 | |
522 | //------------------------------------------------------- |
523 | |
524 | void AliGPCone::DefineSection(Int_t secNum, Float_t z, Float_t rmin, Float_t rmax ) |
525 | { |
526 | |
527 | //*-*-*-*-*-*-*-*-*-*Defines section secNum of the polycone*-*-*-*-*-*-*-*-*-*-* |
528 | //*-* ====================================== |
529 | // |
530 | // - rmin radius of the inner circle in the cross-section |
531 | // |
532 | // - rmax radius of the outer circle in the cross-section |
533 | // |
534 | // - z z coordinate of the section |
535 | |
536 | if ((secNum < 0) || (secNum >= fNz)) return; |
537 | |
538 | fRmin[secNum] = rmin; |
539 | fRmax[secNum] = rmax; |
540 | fDz[secNum] = z; |
541 | } |
542 | |
543 | //------------------------------------------------------- |
544 | |
545 | void AliGPCone::Streamer(TBuffer &R__b) |
546 | { |
547 | // Stream an object of class AliGPCone. |
548 | |
549 | if (R__b.IsReading()) { |
550 | Version_t R__v = R__b.ReadVersion(); if (R__v) { } |
551 | AliGShape::Streamer(R__b); |
552 | R__b.ReadArray(fSiTab); // |
553 | R__b.ReadArray(fCoTab); // |
554 | R__b >> fPhi1; |
555 | R__b >> fDphi1; |
556 | R__b >> fNz; |
557 | R__b.ReadArray(fRmin); // |
558 | R__b.ReadArray(fRmax); // |
559 | R__b.ReadArray(fDz); // |
560 | R__b >> fNdiv; |
561 | } else { |
562 | R__b.WriteVersion(AliGPCone::IsA()); |
563 | AliGShape::Streamer(R__b); |
564 | R__b.WriteArray(fSiTab, GetNumberOfDivisions()+1); // |
565 | R__b.WriteArray(fCoTab, GetNumberOfDivisions()+1); // |
566 | R__b << fPhi1; |
567 | R__b << fDphi1; |
568 | R__b << fNz; |
569 | R__b.WriteArray(fRmin, fNz+1); // |
570 | R__b.WriteArray(fRmax, fNz+1); // |
571 | R__b.WriteArray(fDz, fNz+1); // |
572 | R__b << fNdiv; |
573 | } |
574 | } |
575 | |
576 | //------------------------------------------------------- |
577 | |
578 | |