AliGeant3/AliG3Volume.cxx

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