GEODB/AliGEODB.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.2  1999/09/29 09:24:19  fca
  19 Introduction of the Copyright and cvs Log
  20
  21 */
  22
  23 //////////////////////////////////////////////////////
  24 //  C++ dummy interface to Geant3 basic routines    //
  25 //////////////////////////////////////////////////////
  26
  27 #include <iostream.h>
  28 #include <TBrowser.h>
  29 #include <TCanvas.h>
  30 #include "AliGEODB.h"
  31 #include "AliGNode.h"
  32 #include "AliGShape.h"
  33 #include "AliGMaterial.h"
  34 #include "AliGTransform.h"
  35 #include "AliGTube.h"
  36 #include "AliGBox.h"
  37 #include "AliGTRD1.h"
  38 #include "AliGPCone.h"
  39 #include "AliGeometry.h"
  40
  41 //---------------------------------------------------------
  42
  43 #define MAXMAT 1000
  44
  45 struct Mater{
  46     char*    fName;
  47     Float_t  fA;
  48     Float_t  fZ;
  49     Float_t  fDens;
  50     Float_t  fRadl;
  51     Float_t  fAbsl;
  52     Float_t* fBuf;
  53     Int_t    fNwbuf;
  54 };
  55
  56 Mater* AliMaterials[MAXMAT]; // Array of Mater structs containing the AliMaterial parameters.
  57
  58 struct Med{
  59     char*    fName;
  60     Int_t    fNmat;
  61     Int_t    fIsvol;
  62     Int_t    fIfield;
  63     Float_t  fFieldm;
  64     Float_t  fTmaxfd;
  65     Float_t  fStemax;
  66     Float_t  fDeemax;
  67     Float_t  fEpsil;
  68     Float_t  fStmin;
  69     Float_t* fUbuf;
  70     Int_t    fNbuf;
  71 };
  72
  73 Med* AliMediums[MAXMAT]; // Array of Med structs containing the AliMedium parameters.
  74
  75 struct NodePosp{
  76     char* name;
  77     char* shape;
  78     Int_t nmed;
  79 };
  80
  81 NodePosp* Posp[MAXMAT];
  82
  83 AliGMaterial* Mat[MAXMAT]; // List of Pointers to my AliGMaterials created
  84
  85 Int_t  MateCount   = 0;
  86 Int_t  MedCount    = 0;
  87 Int_t  MatrCount   = 0;
  88 Int_t  PospCount   = 0;
  89 Int_t  Color       = 2;
  90
  91 TList* listNodes     = new TList(); // List of Nodes
  92 TList* listTransf    = new TList();
  93 TList* listShapes    = new TList();
  94 TList* listMaterials = new TList();
  95
  96 AliGNode* TopNode    = NULL;
  97
  98 /***********************************************************************/
  99
 100 ClassImp(AliGEODB)
 101
 102 /***********************************************************************/
 103
 104 AliGEODB::AliGEODB(const char *title, Int_t) : AliMC("AliGEODB",title)
 105 {
 106     //cout << " AliGEODB" << endl;
 107 }
 108
 109 /***********************************************************************/
 110
 111 void AliGEODB::DefaultRange()
 112 {
 113     cout << " DefaultRange" << endl;
 114 }
 115
 116 //=======================functions from GBASE
 117
 118 /***********************************************************************/
 119
 120 void    AliGEODB::Gfile(const char*, const char*)
 121 {
 122     cout << " Gfile" << endl;
 123 }
 124
 125 /***********************************************************************/
 126
 127 void    AliGEODB::GeomIter()
 128 {
 129     cout << " GeomIter" << endl;
 130 }
 131
 132 /***********************************************************************/
 133
 134 Int_t   AliGEODB::CurrentMaterial(Float_t &, Float_t &, Float_t &, Float_t &, Float_t &) const
 135 {
 136     cout << " CurrentMaterial" << endl;
 137     return 0;
 138 }
 139
 140 /***********************************************************************/
 141
 142 Int_t   AliGEODB::NextVolUp(Text_t*, Int_t&)
 143 {
 144     cout << " NextVolUp" << endl;
 145     return 0;
 146 }
 147
 148 /***********************************************************************/
 149
 150 Int_t   AliGEODB::CurrentVol(Text_t*, Int_t&) const
 151 {
 152     cout << " CurrentVol" << endl;
 153     return 0;
 154 }
 155
 156 /***********************************************************************/
 157
 158 Int_t   AliGEODB::NofVolumes() const
 159 {
 160     cout << " NofVolumes" << endl;
 161     return 0;
 162 }
 163
 164 /***********************************************************************/
 165
 166 Int_t   AliGEODB::CurrentVolOff(Int_t, Text_t*, Int_t&) const
 167 {
 168     cout << " CurrentVolOff" << endl;
 169     return 0;
 170 }
 171
 172 /***********************************************************************/
 173
 174 void    AliGEODB::TrackPosition(Float_t*) const
 175 {
 176     cout << " TrackPosition" << endl;
 177 }
 178
 179 /***********************************************************************/
 180
 181 void    AliGEODB::TrackMomentum(Float_t*) const
 182 {
 183     cout << " TrackMomentum" << endl;
 184 }
 185
 186 /***********************************************************************/
 187
 188 Int_t   AliGEODB::VolId( Text_t* name ) const
 189 {
 190     cout << " VolId" << endl;
 191     return 0;
 192 }
 193
 194 /***********************************************************************/
 195
 196 const char* AliGEODB::VolName(Int_t ) const
 197 {
 198     cout << " VolName" << endl;
 199     return 0;
 200 }
 201
 202 /***********************************************************************/
 203
 204 Float_t AliGEODB::TrackCharge() const
 205 {
 206     cout << " TrackCharge" << endl;
 207     return 0;
 208 }
 209
 210 /***********************************************************************/
 211
 212 Float_t AliGEODB::TrackMass() const
 213 {
 214     cout << " TrackMass" << endl;
 215     return 0;
 216 }
 217
 218 /***********************************************************************/
 219
 220 Bool_t  AliGEODB::TrackInside() const
 221 {
 222     cout << " TrackInside" << endl;
 223     return 0;
 224 }
 225
 226 /***********************************************************************/
 227
 228 Bool_t  AliGEODB::TrackEntering() const
 229 {
 230     cout << " TrackEntering" << endl;
 231     return 0;
 232 }
 233
 234 /***********************************************************************/
 235
 236 Bool_t  AliGEODB::TrackExiting() const
 237 {
 238     cout << " TrackExiting" << endl;
 239     return 0;
 240 }
 241
 242 /***********************************************************************/
 243
 244 Bool_t  AliGEODB::TrackOut() const
 245 {
 246     cout << " TrackOut" << endl;
 247     return 0;
 248 }
 249
 250 /***********************************************************************/
 251
 252 Bool_t  AliGEODB::TrackDisappear() const
 253 {
 254     cout << " TrackDisappear" << endl;
 255     return 0;
 256 }
 257
 258 /***********************************************************************/
 259
 260 Bool_t  AliGEODB::TrackStop() const
 261 {
 262     cout << " TrackStop" << endl;
 263     return 0;
 264 }
 265
 266 /***********************************************************************/
 267
 268 Int_t   AliGEODB::NSecondaries() const
 269 {
 270     cout << " NSecondaries" << endl;
 271     return 0;
 272 }
 273
 274 /***********************************************************************/
 275
 276 const char* AliGEODB::ProdProcess() const
 277 {
 278     cout << " ProdProcess" << endl;
 279     return 0;
 280 }
 281
 282 /***********************************************************************/
 283
 284 void    AliGEODB::GetSecondary(Int_t, Int_t&, Float_t*, Float_t*)
 285 {
 286     cout << " GetSecondary" << endl;
 287 }
 288
 289 /***********************************************************************/
 290
 291 Float_t AliGEODB::MaxStep() const
 292 {
 293     cout << " MaxStep" << endl;
 294     return 0;
 295 }
 296
 297 /***********************************************************************/
 298
 299 void    AliGEODB::SetMaxStep(Float_t )
 300 {
 301     cout << " SetMaxStep" << endl;
 302 }
 303
 304 /***********************************************************************/
 305
 306 void    AliGEODB::GetParticle(const Int_t, char*, Float_t&) const
 307 {
 308     cout << " GetParticle" << endl;
 309 }
 310
 311 /***********************************************************************/
 312
 313 Int_t   AliGEODB::CurrentEvent() const
 314 {
 315     cout << " CurrentEvent" << endl;
 316     return 0;
 317 }
 318
 319 /***********************************************************************/
 320
 321 Int_t   AliGEODB::GetMedium() const
 322 {
 323     cout << " GetMedium" << endl;
 324     return 0;
 325 }
 326
 327 /***********************************************************************/
 328
 329 Float_t AliGEODB::Edep() const
 330 {
 331     cout << " Edep" << endl;
 332     return 0;
 333 }
 334
 335 /***********************************************************************/
 336
 337 Float_t AliGEODB::Etot() const
 338 {
 339     cout << " Etot" << endl;
 340     return 0;
 341 }
 342
 343 /***********************************************************************/
 344
 345 void    AliGEODB::Rndm(Float_t*, const Int_t) const
 346 {
 347     cout << " Rndm" << endl;
 348 }
 349
 350 /***********************************************************************/
 351
 352 Float_t AliGEODB::TrackStep() const
 353 {
 354     cout << " TrackStep" << endl;
 355     return 0;
 356 }
 357
 358 /***********************************************************************/
 359
 360 Float_t AliGEODB::TrackLength() const
 361 {
 362     cout << " TrackLength" << endl;
 363     return 0;
 364 }
 365
 366 /***********************************************************************/
 367
 368 Float_t AliGEODB::TrackTime() const
 369 {
 370     cout << " TrackTime" << endl;
 371     return 0;
 372 }
 373
 374 /***********************************************************************/
 375
 376 Int_t   AliGEODB::TrackPid() const
 377 {
 378     cout << " TrackPid" << endl;
 379     return 0;
 380 }
 381
 382 /***********************************************************************/
 383
 384 Bool_t  AliGEODB::TrackAlive() const
 385 {
 386     cout << " TrackAlive" << endl;
 387     return 0;
 388 }
 389
 390 /***********************************************************************/
 391
 392 void    AliGEODB::StopTrack()
 393 {
 394     cout << " StopTrack" << endl;
 395 }
 396
 397 /***********************************************************************/
 398
 399 void    AliGEODB::StopEvent()
 400 {
 401     cout << " StopEvent" << endl;
 402 }
 403
 404 /***********************************************************************/
 405
 406 void    AliGEODB::SetMaxNStep(Int_t)
 407 {
 408     cout << " SetMaxNStep" << endl;
 409 }
 410
 411 /***********************************************************************/
 412
 413 void    AliGEODB::SetColors()
 414 {
 415     cout << " SetColors" << endl;
 416 }
 417
 418 /***********************************************************************/
 419
 420 Int_t   AliGEODB::GetMaxNStep() const
 421 {
 422     cout << " GetMaxNStep" << endl;
 423     return 0;
 424 }
 425
 426 /***********************************************************************/
 427
 428 void AliGEODB::Material( Int_t& kmat, const char* name, Float_t a, Float_t z, Float_t dens, Float_t radl, Float_t absl,Float_t* buf, Int_t nwbuf )
 429 {
 430     if( MateCount >= MAXMAT ) {
 431         printf( " ERROR: Material number: %d bigger that MAXMAT: %d => Out of array\n", MateCount, MAXMAT );
 432         exit(0);
 433     }
 434
 435     Mater*   AliMat = new Mater;
 436     char*    fname  = new char[strlen(name)+1];
 437     Float_t* fbuf   = new Float_t[nwbuf];
 438
 439     strcpy( fname, name );
 440     fname[strlen(name)] = '\x0';
 441
 442     AliMat->fName  = fname;
 443     AliMat->fA     = a;
 444     AliMat->fZ     = z;
 445     AliMat->fDens  = dens;
 446     AliMat->fRadl  = radl;
 447     AliMat->fAbsl  = absl;
 448     AliMat->fNwbuf = nwbuf;
 449
 450     for( int i=0; i<nwbuf; i++ )
 451         fbuf[i] = buf[i];
 452
 453     AliMat->fBuf = fbuf;
 454
 455     AliMaterials[MateCount] = AliMat;
 456
 457     kmat = MateCount++;
 458 }
 459
 460 /***********************************************************************/
 461
 462 void  AliGEODB::Mixture( Int_t& imat, const char* name, Float_t* a, Float_t* z, Float_t dens, Int_t nlmat, Float_t* wmat )
 463 {
 464     if( MateCount >= MAXMAT ) {
 465         printf( " ERROR: Mixture number: %d bigger that MAXMAT: %d => Out of array\n", MateCount, MAXMAT );
 466         exit(0);
 467     }
 468
 469     Mater* AliMat   = new Mater;
 470     char*    fname  = new char[strlen(name)+1];
 471
 472     strcpy( fname, name );
 473     fname[strlen(name)] = '\x0';
 474
 475     AliMat->fName   = fname;
 476     Float_t MidA    = 0.;
 477     Float_t MidZ    = 0.;
 478     Float_t SUMwmat = 0.;
 479
 480     for( int i=0; i<nlmat; i++ ) {
 481         MidA    += wmat[i]*a[i];
 482         MidZ    += wmat[i]*z[i];
 483         SUMwmat += wmat[i];
 484     }
 485
 486     MidA            = MidA/SUMwmat;
 487     MidZ            = MidZ/SUMwmat;
 488
 489     AliMat->fA      = MidA;
 490     AliMat->fZ      = MidZ;
 491     AliMat->fDens   = dens;
 492     AliMat->fRadl   = 0.;
 493     AliMat->fAbsl   = 0.;
 494     AliMat->fNwbuf  = 0;
 495
 496     AliMat->fBuf    = NULL;
 497
 498     AliMaterials[MateCount] = AliMat;
 499
 500     imat = MateCount++;
 501 }
 502
 503 /***********************************************************************/
 504
 505 void  AliGEODB::Medium( Int_t& numed, const char* name, Int_t nmat, Int_t isvol, Int_t ifield, Float_t fieldm, Float_t tmaxfd, Float_t stemax, Float_t deemax, Float_t epsil, Float_t stmin, Float_t* ubuf, Int_t nbuf )
 506 {
 507     if( MedCount >= MAXMAT ) {
 508         printf( " ERROR: Medium number: %d bigger that MAXMAT: %d => Out of array\n", MedCount, MAXMAT );
 509         exit(0);
 510     }
 511
 512     Med*     AliMed = new Med;
 513     char*    fname  = new char[strlen(name)+1];
 514     Float_t* fUbuf  = new Float_t[nbuf];
 515
 516     strcpy( fname, name );
 517     fname[strlen(name)] = '\x0';
 518
 519     AliMed->fName   = fname;
 520     AliMed->fNmat   = nmat;
 521     AliMed->fIsvol  = isvol;
 522     AliMed->fIfield = ifield;
 523     AliMed->fFieldm = fieldm;
 524     AliMed->fTmaxfd = tmaxfd;
 525     AliMed->fStemax = stemax;
 526     AliMed->fDeemax = deemax;
 527     AliMed->fEpsil  = epsil;
 528     AliMed->fStmin  = stmin;
 529     AliMed->fNbuf   = nbuf;
 530
 531     for( int i=0; i<nbuf; i++ )
 532         fUbuf[i] = ubuf[i];
 533
 534     AliMed->fUbuf = fUbuf;
 535
 536     AliMediums[MedCount] = AliMed;
 537
 538     numed = MedCount++;
 539 }
 540
 541 /***********************************************************************/
 542
 543 void  AliGEODB::Matrix( Int_t &nmate , Float_t theta1, Float_t phi1, Float_t theta2, Float_t phi2, Float_t theta3, Float_t phi3 )
 544 {
 545     char* transname = new char[10];
 546     sprintf(transname, "%s%d", "tra", MatrCount);
 547
 548     AliGTransform* tra = new AliGTransform( transname, transname, theta1, phi1, theta2, phi2, theta3, phi3 );
 549
 550     //printf( " Created new AliGTransform( %s, %s, %f, %f, %f, %f, %f, %f );\n", transname, transname, theta1, phi1, theta2, phi2, theta3, phi3 );
 551
 552     listTransf->AddAt( tra, MatrCount );
 553
 554     nmate = ++MatrCount;
 555
 556 }
 557
 558 /***********************************************************************/
 559
 560 void  AliGEODB::WriteEuclid(const char*, const char*, Int_t, Int_t)
 561 {
 562     cout << " WriteEuclid" << endl;
 563 }
 564
 565 /***********************************************************************/
 566
 567 void  AliGEODB::Gpcxyz()
 568 {
 569     cout << " Gpcxyz " << endl;
 570 }
 571
 572 /***********************************************************************/
 573
 574 void  AliGEODB::Ggclos()
 575 {
 576
 577     for( int i=0; i<listNodes->GetSize(); i++ ) {
 578         AliGNode* node = (AliGNode*) listNodes->At(i);
 579         char* name = new char[strlen(node->GetName())+1];
 580         strcpy(name, node->GetName());
 581         name[strlen(node->GetName())] = '\x0';
 582         node->AddConfig(name, name,"detail",981201,991201);
 583     }
 584
 585     printf( " Total number of nodes = %d\n", listNodes->GetSize() );
 586
 587     SetVisibility( "TPC_1",   1 );
 588     SetVisibility( "TGAS_1",  1 );
 589     SetVisibility( "TPSG_1",  1 );
 590     SetVisibility( "TPHV_1",  1 );
 591     SetVisibility( "TRCS_1",  1 );
 592     SetVisibility( "TSGA_1",  1 );
 593     SetVisibility( "TRCL_1",  1 );
 594     SetVisibility( "TLGA_1",  1 );
 595     SetVisibility( "TSST_1",  1 );
 596     SetVisibility( "TSST_2",  1 );
 597     SetVisibility( "TSST_3",  1 );
 598     SetVisibility( "TSST_4",  1 );
 599     SetVisibility( "TSST_5",  1 );
 600     SetVisibility( "TSST_6",  1 );
 601     SetVisibility( "TSST_7",  1 );
 602     SetVisibility( "TSST_8",  1 );
 603     SetVisibility( "TSST_9",  1 );
 604     SetVisibility( "TSST_10", 1 );
 605     SetVisibility( "TSST_11", 1 );
 606     SetVisibility( "TSST_12", 1 );
 607     SetVisibility( "TSST_13", 1 );
 608     SetVisibility( "TSST_14", 1 );
 609     SetVisibility( "TSST_15", 1 );
 610     SetVisibility( "TSST_16", 1 );
 611     SetVisibility( "TSST_17", 1 );
 612     SetVisibility( "TSST_18", 1 );
 613     SetVisibility( "TSST_19", 1 );
 614     SetVisibility( "TSST_20", 1 );
 615     SetVisibility( "TSST_21", 1 );
 616     SetVisibility( "TSST_22", 1 );
 617     SetVisibility( "TSST_23", 1 );
 618     SetVisibility( "TLST_1",  1 );
 619     SetVisibility( "TLST_2",  1 );
 620     SetVisibility( "TLST_3",  1 );
 621     SetVisibility( "TLST_4",  1 );
 622     SetVisibility( "TLST_5",  1 );
 623     SetVisibility( "TLST_6",  1 );
 624     SetVisibility( "TLST_7",  1 );
 625     SetVisibility( "TLST_8",  1 );
 626     SetVisibility( "TLST_9",  1 );
 627     SetVisibility( "TLST_10", 1 );
 628     SetVisibility( "TLST_11", 1 );
 629     SetVisibility( "TLST_12", 1 );
 630     SetVisibility( "TLST_13", 1 );
 631     SetVisibility( "TLST_14", 1 );
 632     SetVisibility( "TLST_15", 1 );
 633     SetVisibility( "TLST_16", 1 );
 634     SetVisibility( "TLST_17", 1 );
 635     SetVisibility( "TLST_18", 1 );
 636     SetVisibility( "TLST_19", 1 );
 637     SetVisibility( "TLST_20", 1 );
 638     SetVisibility( "TLST_21", 1 );
 639     SetVisibility( "TLST_22", 1 );
 640     SetVisibility( "TLST_23", 1 );
 641     SetVisibility( "TLST_24", 1 );
 642     SetVisibility( "TLST_25", 1 );
 643     SetVisibility( "TLST_26", 1 );
 644     SetVisibility( "TLST_27", 1 );
 645     SetVisibility( "TLST_28", 1 );
 646     SetVisibility( "TLST_29", 1 );
 647     SetVisibility( "TLST_30", 1 );
 648     SetVisibility( "TLST_31", 1 );
 649     SetVisibility( "TLST_32", 1 );
 650     SetVisibility( "TLST_33", 1 );
 651     SetVisibility( "TLST_34", 1 );
 652     SetVisibility( "TLST_35", 1 );
 653     SetVisibility( "TLST_36", 1 );
 654     SetVisibility( "TLST_37", 1 );
 655     SetVisibility( "TLST_38", 1 );
 656     SetVisibility( "TLST_39", 1 );
 657     SetVisibility( "TLST_40", 1 );
 658     SetVisibility( "TLST_41", 1 );
 659     SetVisibility( "TLST_42", 1 );
 660     SetVisibility( "TLST_43", 1 );
 661     SetVisibility( "TLST_44", 1 );
 662     SetVisibility( "TLST_45", 1 );
 663     SetVisibility( "TLST_46", 1 );
 664     SetVisibility( "TLST_47", 1 );
 665     SetVisibility( "TLST_48", 1 );
 666     SetVisibility( "TLST_49", 1 );
 667     SetVisibility( "TLST_50", 1 );
 668     SetVisibility( "TLST_51", 1 );
 669     SetVisibility( "TLST_52", 1 );
 670     SetVisibility( "TSWS_1",  1 );
 671     SetVisibility( "TSWS_2",  1 );
 672     SetVisibility( "TSWS_3",  1 );
 673     SetVisibility( "TPW1_1",  1 );
 674     SetVisibility( "TPW2_1",  1 );
 675     SetVisibility( "TPW3_1",  1 );
 676     SetVisibility( "TPW4_1",  1 );
 677     SetVisibility( "TSPI_1",  1 );
 678     SetVisibility( "TSP1_1",  1 );
 679     SetVisibility( "TSPO_1",  1 );
 680     SetVisibility( "TSP2_1",  1 );
 681     SetVisibility( "TSWH_1",  1 );
 682     SetVisibility( "TSW1_1",  1 );
 683     SetVisibility( "TCOV_1",  1 );
 684     SetVisibility( "TPOI_1",  1 );
 685     SetVisibility( "TSWS_4",  1 );
 686     SetVisibility( "TSWS_5",  1 );
 687     SetVisibility( "TSWS_6",  1 );
 688     SetVisibility( "TSWS_7",  1 );
 689     SetVisibility( "TSWS_8",  1 );
 690     SetVisibility( "TSWS_9",  1 );
 691     SetVisibility( "TSWS_10", 1 );
 692     SetVisibility( "TSWS_11", 1 );
 693     SetVisibility( "TSWS_12", 1 );
 694     SetVisibility( "TSWS_13", 1 );
 695     SetVisibility( "TPIV_1",  1 );
 696     SetVisibility( "TPVD_1",  1 );
 697
 698     printf( " Visibilities activated \n" );
 699
 700     AliGeometry* Geom1 = new AliGeometry( "Geom1", "Geom1", TopNode, 0 );
 701
 702     TCanvas* c1 = new TCanvas( "TPC", "Geometry Shapes", 100, 100, 750, 750 );
 703     c1->Range(0,0,1,1);
 704     c1->SetFillColor(32); // Light Green
 705     c1->SetBorderSize(3);
 706     c1->SetBorderMode(0); // -1 (down) 0 (no) 1 (up)
 707
 708     TopNode->Draw("same");
 709
 710     TFile* file1 = new TFile( "GeoDB.root", "RECREATE" );
 711     cout << endl << " Storing GeoDB.root file.  Please, be patient...    :-)" << endl;
 712     TopNode->SaveAll(file1);
 713
 714     file1->cd();
 715
 716     if( Geom1 ) {
 717         Geom1->Write();
 718         cout << " Geometry saved in disk " << endl;
 719     }
 720
 721     file1->Write();
 722     file1->Close();
 723
 724     TFile* file2 = new TFile( "GeoDB.root", "READ" );
 725     file2->cd();
 726     AliGeometry* Geom2  = new AliGeometry( (AliGeometry*) file2->Get("Geom1") );
 727
 728     // Retrieve the memory tree structure from AliGeoDB.root and stores it in memory, being tree_root the top node
 729     AliGNode* tree_root = new AliGNode( Geom2->FileToMemTree( file2 ) );
 730     //AliGNode* tree_root = new AliGNode( Geom2->FileToMemTree( "GeoDB.root", "Geom1" ) );
 731
 732     TFile* file3 = new TFile( "GeoDB2.root", "RECREATE" );
 733     cout << " Storing GeoDB2.root file. Please, be patient again...   :-)" << endl;
 734     tree_root->SaveAll( file3 ); // Memory tree structure saved in disk (second time)
 735
 736     file3->cd();
 737
 738     if( Geom2 ) {
 739         Geom2->Write();
 740         cout << " Geometry saved in disk " << endl;
 741     }
 742
 743     file3->Write();
 744     file3->Close();
 745
 746     file2->Close();
 747
 748     cout << " The two databases are stored in disk." << endl;
 749
 750     TFile* file4 = new TFile( "GeoDB.root" , "READ" );
 751     TFile* file5 = new TFile( "GeoDB2.root", "READ" );
 752
 753     TBrowser* a = new TBrowser();
 754
 755     //DrawTree( TopNode, 0 );
 756 }
 757
 758 /***********************************************************************/
 759
 760 void AliGEODB::SetVisibility(Text_t* name, Int_t val)
 761 {
 762    AliGNode* node = (AliGNode*) listNodes->FindObject( name );
 763
 764    if( node )
 765        node->SetVis(val);
 766    else
 767        printf( " ERROR!!! I couldn't find the node %s in the listNodes.\n", name );
 768 }
 769
 770 /***********************************************************************/
 771
 772 void AliGEODB::DrawTree( AliGNode* topnode, Int_t tabs )
 773 {
 774
 775     for( int i=0; topnode->GetNodeFromfNode(i); i++ ) {
 776         for( int j=0; j<tabs; j++ )
 777             cout << " ";
 778         cout << topnode->GetNodeFromfNode(i)->GetName() << endl;
 779         tabs+=5;
 780         DrawTree( topnode->GetNodeFromfNode(i), tabs );
 781         tabs-=5;
 782     }
 783
 784 }
 785
 786 /***********************************************************************/
 787
 788 void  AliGEODB::Glast()
 789 {
 790     cout << " Glast " << endl;
 791 }
 792
 793 /***********************************************************************/
 794
 795 void  AliGEODB::Gprint(const char*)
 796 {
 797     cout << " Gprint " << endl;
 798 }
 799
 800 /***********************************************************************/
 801
 802 void  AliGEODB::Grun()
 803 {
 804     cout << " Grun " << endl;
 805 }
 806
 807 /***********************************************************************/
 808
 809 void  AliGEODB::Gtrig()
 810 {
 811     cout << " Gtrig " << endl;
 812 }
 813
 814 /***********************************************************************/
 815
 816 void  AliGEODB::Gtrigc()
 817 {
 818     cout << " Gtrigc " << endl;
 819 }
 820
 821 /***********************************************************************/
 822
 823 void  AliGEODB::Gtrigi()
 824 {
 825     cout << " Gtrigi " << endl;
 826 }
 827
 828 /***********************************************************************/
 829
 830 void  AliGEODB::Gwork(Int_t)
 831 {
 832     cout << " Gwork " << endl;
 833 }
 834
 835 /***********************************************************************/
 836
 837 void  AliGEODB::Gzinit()
 838 {
 839     cout << " Gzinit " << endl;
 840 }
 841
 842 //=======================functions from GCONS
 843
 844 /***********************************************************************/
 845
 846 void  AliGEODB::Gfmate(Int_t, char*, Float_t&, Float_t&, Float_t&, Float_t&, Float_t&, Float_t*, Int_t&)
 847 {
 848     cout << " Gfmate " << endl;
 849 }
 850
 851 /***********************************************************************/
 852
 853 void  AliGEODB::Gfpart(Int_t, char*, Int_t&, Float_t&, Float_t&, Float_t&)
 854 {
 855     cout << " Gfpart " << endl;
 856 }
 857
 858 /***********************************************************************/
 859
 860 void  AliGEODB::Gftmed(Int_t, char*, Int_t&, Int_t&, Int_t&, Float_t&, Float_t&,Float_t&, Float_t&, Float_t&, Float_t&, Float_t*, Int_t*)
 861 {
 862     cout << " Gftmed " << endl;
 863 }
 864
 865 /***********************************************************************/
 866
 867 void  AliGEODB::Gmate() {
 868     cout << " Gmate " << endl;
 869 }
 870
 871 /***********************************************************************/
 872
 873 void  AliGEODB::Gpart()
 874 {
 875     AliGTransform* Identity = new AliGTransform("Identity","Identity","rot 0. 0. 0.");
 876     //printf( " Created new AliGTransform( Identity, Identity, rot 0. 0. 0. );\n" );
 877
 878     listTransf->AddAt( Identity, MatrCount );
 879     MatrCount++;
 880
 881     AliGBox*  box  = new AliGBox("box","box", 400,400,400);
 882     AliGNode* ALIC = new AliGNode( "ALIC", 1,"ALIC", box);
 883     TopNode = ALIC;
 884
 885     listNodes->Add(ALIC);
 886 }
 887
 888 /***********************************************************************/
 889
 890 void  AliGEODB::Gsdk(Int_t, Float_t*, Int_t*) {
 891     cout << " Gsdk " << endl;
 892 }
 893
 894 /***********************************************************************/
 895
 896 void  AliGEODB::Gsmate(Int_t, const char*, Float_t, Float_t, Float_t, Float_t, Float_t) {
 897     cout << " Gsmate " << endl;
 898 }
 899
 900 /***********************************************************************/
 901
 902 void  AliGEODB::Gsmixt(Int_t, const char*, Float_t*, Float_t*, Float_t, Int_t, Float_t*) {
 903     cout << " Gsmixt " << endl;
 904 }
 905
 906 /***********************************************************************/
 907
 908 void  AliGEODB::Gspart(Int_t, const char*, Int_t,   Float_t, Float_t, Float_t) {
 909     cout << " Gspart " << endl;
 910 }
 911
 912 /***********************************************************************/
 913
 914 void  AliGEODB::Gstmed(Int_t, const char*, Int_t, Int_t, Int_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t) {
 915     cout << " Gstmed " << endl;
 916 }
 917
 918 /***********************************************************************/
 919
 920 void  AliGEODB::Gstpar(Int_t, const char*, Float_t)
 921 {
 922     //cout << " Gstpar " << endl;
 923 }
 924
 925 /***********************************************************************/
 926
 927 void  AliGEODB::Gsckov(Int_t, Int_t, Float_t *, Float_t *, Float_t *, Float_t *)
 928 {
 929     cout << " Gsclov " << endl;
 930 }
 931
 932 /***********************************************************************/
 933
 934 //=======================functions from GKINE
 935
 936 void  AliGEODB::Gfkine(Int_t, Float_t*, Float_t*, Int_t&, Int_t&)
 937 {
 938     cout << " Gfkine" << endl;
 939 }
 940
 941 /***********************************************************************/
 942
 943 void  AliGEODB::Gfvert(Int_t, Float_t*, Int_t&, Int_t&, Float_t&)
 944 {
 945     cout << " Gfvert" << endl;
 946 }
 947
 948 /***********************************************************************/
 949
 950 Int_t AliGEODB::Gskine(Float_t*, Int_t, Int_t, Float_t*, Int_t)
 951 {
 952     cout << " Gskine" << endl;
 953     return 0;
 954 }
 955
 956 /***********************************************************************/
 957
 958 Int_t AliGEODB::Gsvert(Float_t*, Int_t, Int_t, Float_t*, Int_t)
 959 {
 960     cout << " Gsvert" << endl;
 961     return 0;
 962 }
 963
 964 /***********************************************************************/
 965
 966 //=======================functions from GPHYS
 967
 968 void  AliGEODB::Gphysi()
 969 {
 970     cout << " Gphysi" << endl;
 971 }
 972
 973 /***********************************************************************/
 974
 975 //=======================functions from GTRAK
 976
 977 void  AliGEODB::Gdebug()
 978 {
 979     cout << " Gdebug" << endl;
 980 }
 981
 982 /***********************************************************************/
 983
 984 void  AliGEODB::Gekbin()
 985 {
 986     cout << " Gekbin" << endl;
 987 }
 988
 989 /***********************************************************************/
 990
 991 void  AliGEODB::Gfinds()
 992 {
 993     cout << " Gfinds" << endl;
 994 }
 995
 996 /***********************************************************************/
 997
 998 void  AliGEODB::Gsking(Int_t)
 999 {
1000     cout << " Gsking" << endl;
1001 }
1002
1003 /***********************************************************************/
1004
1005 void  AliGEODB::Gskpho(Int_t)
1006 {
1007     cout << " Gskpho" << endl;
1008 }
1009
1010 /***********************************************************************/
1011
1012 void  AliGEODB::Gsstak(Int_t)
1013 {
1014     cout << " Gsstak" << endl;
1015 }
1016
1017 /***********************************************************************/
1018
1019 void  AliGEODB::Gsxyz()
1020 {
1021     cout << " Gsxyz" << endl;
1022 }
1023
1024 /***********************************************************************/
1025
1026 void  AliGEODB::Gtrack()
1027 {
1028     cout << " Gtrack" << endl;
1029 }
1030
1031 /***********************************************************************/
1032
1033 void  AliGEODB::Gtreve()
1034 {
1035     cout << " Gtreve" << endl;
1036 }
1037
1038 /***********************************************************************/
1039
1040 void  AliGEODB::Grndm(Float_t*, const Int_t) const
1041 {
1042     cout << " Grndm" << endl;
1043 }
1044
1045 /***********************************************************************/
1046
1047 void  AliGEODB::Grndmq(Int_t&, Int_t&, const Int_t, const Text_t*)
1048 {
1049     cout << " Grndmq" << endl;
1050 }
1051
1052 /***********************************************************************/
1053
1054 //=======================functions from GDRAW
1055
1056 void  AliGEODB::Gdxyz(Int_t )
1057 {
1058     cout << " Gdxyz" << endl;
1059 }
1060
1061 /***********************************************************************/
1062
1063 void  AliGEODB::Gdcxyz()
1064 {
1065     cout << " Gdcxyz" << endl;
1066 }
1067
1068 /***********************************************************************/
1069
1070 //=======================functions from GGEOM
1071
1072 void  AliGEODB::Gdtom(Float_t*, Float_t*, Int_t)
1073 {
1074   printf( " Gdtom.\n" );
1075 }
1076
1077 /***********************************************************************/
1078
1079 void  AliGEODB::Glmoth(const char*, Int_t, Int_t&, Int_t*, Int_t*)
1080 {
1081   printf( " Glmoth.\n" );
1082
1083 }
1084
1085 /***********************************************************************/
1086
1087 void  AliGEODB::Gmedia(Float_t*, Int_t&)
1088 {
1089   printf( " Gmedia.\n" );
1090 }
1091
1092 /***********************************************************************/
1093
1094 void  AliGEODB::Gmtod(Float_t*, Float_t*, Int_t)
1095 {
1096   printf( " Gmtod.\n" );
1097 }
1098
1099 /***********************************************************************/
1100
1101 void  AliGEODB::Gsdvn(const char* name, const char* parentname, Int_t ndiv, Int_t iaxis)
1102 {
1103     cout << " Inside Gsdvn " << endl;
1104     /* Divides one node in Ndiv nodes in the iaxis direction*/
1105
1106     char* transfname = new char[10];
1107     char* nodename   = new char[10];
1108
1109     AliGNode* parent = (AliGNode*) listNodes->FindObject(parentname);
1110
1111     /* Find the shape that will result from the division*/
1112
1113     /* BOX */
1114     if( parent->GetShape()->ClassName() == "AliGBox" ) {
1115         AliGMaterial* material = new AliGMaterial(parent->GetMaterial());
1116
1117         Float_t Dx, Dy, Dz;
1118
1119         switch (iaxis) {
1120             case 1 : Dx = ((AliGBox*)(parent->GetShape()))->GetX() / ndiv;
1121                      Dy = ((AliGBox*)(parent->GetShape()))->GetY();
1122                      Dz = ((AliGBox*)(parent->GetShape()))->GetZ();
1123                      break;
1124
1125             case 2 : Dx = ((AliGBox*)(parent->GetShape()))->GetX() ;
1126                      Dy = ((AliGBox*)(parent->GetShape()))->GetY()/ ndiv;
1127                      Dz = ((AliGBox*)(parent->GetShape()))->GetZ();
1128                      break;
1129
1130             case 3 : Dx = ((AliGBox*)(parent->GetShape()))->GetX() ;
1131                      Dy = ((AliGBox*)(parent->GetShape()))->GetY();
1132                      Dz = ((AliGBox*)(parent->GetShape()))->GetZ()/ ndiv;
1133                      break;
1134
1135             default: Dx = Dy = Dz = 0.;
1136         };
1137
1138         AliGBox* box = new AliGBox("box","box", Dx, Dy, Dz);
1139
1140         /* Create the nodes son*/
1141
1142         Float_t x, y, z;
1143         Text_t* expression;
1144
1145         for( int i=0; i<ndiv; i++ ) {
1146             //nodename = "Node";
1147             nodename[4] = '\x0';
1148             sprintf( nodename, "%s%d", nodename, i );
1149             transfname = "trans";
1150             transfname[5] = '\x0';
1151             sprintf( transfname, "%s%d", transfname, i );
1152
1153             switch (iaxis) {
1154                 case 'X' :
1155                 case 'x' : x = ndiv *i;
1156                            y = 0;
1157                            z = 0;
1158                            break;
1159                 case 'Y' :
1160                 case 'y' : x = 0;
1161                            y = ndiv *i;
1162                            z = 0;
1163                            break;
1164
1165                 case 'Z' :
1166                 case 'z' : x = 0;
1167                            y = 0;
1168                            z = ndiv *i;
1169                            break;
1170             };
1171
1172             /* Positioning the sons (only translations) and adding them to the parent*/
1173
1174             sprintf( expression, "%s %f %f %f", "tra", x, y, z );
1175             AliGTransform* tran = new AliGTransform( transfname, transfname, expression );
1176
1177             char* nodname = new char[strlen(name)];
1178             strcpy( nodname, name );
1179             AliGNode* son = new AliGNode( nodname, i, nodname, box, material );
1180             if( nodname ) delete [] nodname;
1181
1182             parent->Add( son, tran );
1183             parent->AddConfig("","");
1184             listNodes->AddLast(son);
1185         }
1186     }
1187 }
1188
1189 /***********************************************************************/
1190
1191 void  AliGEODB::Gsdvn2(const char*, const char*, Int_t, Int_t, Float_t, Int_t)
1192 {
1193   printf( " Gsdvn2.\n" );
1194 }
1195
1196 /***********************************************************************/
1197
1198 void  AliGEODB::Gsdvs(const char*, const char*, Float_t, Int_t, Int_t)
1199 {
1200   printf( " Gsdvs.\n" );
1201 }
1202
1203 /***********************************************************************/
1204
1205 void  AliGEODB::Gsdvs2(const char*, const char*, Float_t, Int_t, Float_t, Int_t)
1206 {
1207   printf( " Gsdvs2.\n" );
1208 }
1209
1210 /***********************************************************************/
1211
1212 void  AliGEODB::Gsdvt(const char*, const char*, Float_t, Int_t, Int_t, Int_t)
1213 {
1214   printf( " Gsdvt.\n" );
1215 }
1216
1217 /***********************************************************************/
1218
1219 void  AliGEODB::Gsdvt2(const char *, const char *, Float_t, Int_t, Float_t, Int_t, Int_t)
1220 {
1221   printf( " Gsdvt2.\n" );
1222 }
1223
1224 /***********************************************************************/
1225
1226 void  AliGEODB::Gsord(const char*, Int_t)
1227 {
1228   // Aqui entra pero dice Federico que Dummy.
1229 }
1230
1231 /***********************************************************************/
1232
1233 void  AliGEODB::Gspos( const char *name, Int_t nr, const char *mother, Float_t x, Float_t y, Float_t z, Int_t irot, const char* konly )
1234 {
1235
1236     if( !strcmp(mother, "ALIC") )
1237         mother = "ALIC_1";
1238
1239     AliGNode* son    = NULL;
1240     AliGNode* parent = NULL;
1241
1242     char* nodename   = new char[strlen(name)+1];
1243     strcpy( nodename, name );
1244     nodename[strlen(name)] = '\x0';
1245
1246     TObjLink *lnk = listNodes->FirstLink();
1247     int quit=0;
1248
1249     while( (lnk) && (!quit) ) {
1250         TObject *obj = lnk->GetObject();
1251
1252         if( obj->GetName() ) {
1253             char* NodeName = new char[strlen(obj->GetName())+1];
1254             strcpy( NodeName, obj->GetName() );
1255             NodeName[strlen(obj->GetName())] = '\x0';
1256
1257             int i;
1258             for( i=0; NodeName[i]!='_'; i++ );
1259
1260             if( !strncmp(nodename, NodeName, i) )
1261                 son = (AliGNode*) obj;
1262             else
1263                 if( !strncmp(mother, NodeName, i) )
1264                     parent = (AliGNode*) obj;
1265
1266             if( NodeName ) delete [] NodeName;
1267
1268             if( (son != NULL) && (parent != NULL) )
1269                 quit = 1;
1270         }
1271
1272         lnk = lnk->Next();
1273     }
1274
1275     if( son == NULL ) {
1276         cout << " ERROR in Gspos. Couldn't find node " << nodename << " inside listNodes." << endl;
1277         exit(1);
1278     }
1279     else
1280         if( parent == NULL) {
1281             cout << " ERROR in Gspos. Couldn't find node " << mother << " inside listNodes." << endl;
1282             exit(1);
1283         }
1284
1285     AliGTransform* tra = (AliGTransform*)listTransf->At(MatrCount - 1);
1286
1287     TVector* matrix = tra->GetMatrix();
1288     char* transname = new char[10];
1289     sprintf(transname, "%s%d", "tra", MatrCount );
1290
1291     TVector &mat = *matrix;
1292     AliGTransform* newtra = new AliGTransform(transname, transname, mat(0), mat(1),  mat(2), mat(4), mat(5), mat(6),mat(8), mat(9), mat(10), x, y, z);
1293
1294     //printf( "\n Created new AliGTransform( %s, %s, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f );\n", transname, transname, mat(0), mat(1), mat(2), mat(4), mat(5), mat(6), mat(8), mat(9), mat(10), x, y, z );
1295
1296     listTransf->AddAt(newtra, MatrCount);
1297     MatrCount++;
1298
1299     parent->Add(son, newtra);
1300     //printf( " %s->Add( %s, %s );\n", parent->GetName(), son->GetName(), newtra->GetName() );
1301 }
1302
1303 /***********************************************************************/
1304
1305 void  AliGEODB::Gsposp( const char* nodename, Int_t nr, const char* mother, Float_t x, Float_t y, Float_t z, Int_t irot, const char* konly, Float_t* upar, Int_t np )
1306 {
1307     //printf( "\n" );
1308
1309     Int_t i;
1310
1311     for( i=0; i<PospCount; i++ )
1312         if( !strcmp(Posp[i]->name, nodename) )
1313             break;
1314
1315     char* shapename  = Posp[i]->shape;
1316     Int_t nmed       = Posp[i]->nmed;
1317
1318     char* fnodename  = new char[strlen(nodename)+1];
1319     strcpy(fnodename, nodename);
1320     fnodename[strlen(nodename)] = '\x0';
1321
1322     char* fmother    = new char[strlen(mother)+1];
1323     strcpy(fmother, mother);
1324     fmother[strlen(mother)] = '\x0';
1325
1326     AliGNode* parent = NULL;
1327
1328     TObjLink *lnk = listNodes->FirstLink();
1329     int quit=0;
1330
1331     while( (lnk) && (!quit) ) {
1332         TObject *obj = lnk->GetObject();
1333
1334         if( obj->GetName() ) {
1335             char* NodeName = new char[strlen(obj->GetName())];
1336             strcpy( NodeName, obj->GetName() );
1337
1338             int i;
1339             for( i=0; NodeName[i]!='_'; i++ );
1340
1341             if( !strncmp(fmother, NodeName, i) )
1342                     parent = (AliGNode*) obj ;
1343
1344             if( NodeName ) delete [] NodeName;
1345
1346             if( parent != NULL )
1347                 quit = 1;
1348         }
1349
1350         lnk = lnk->Next();
1351     }
1352
1353     if( parent == NULL) {
1354         cout << " ERROR in Gsposp. Couldn't find node " << mother << " inside listNodes." << endl;
1355         exit(1);
1356     }
1357
1358     Int_t nmat = AliMediums[nmed]->fNmat;
1359
1360     AliGMaterial* MyMaterial = NULL;
1361
1362     for( int j=0; j<listMaterials->GetSize(); j++ )
1363         if( ((AliGMaterial*) listMaterials->At(j))->GetfImat() == nmat ) {
1364             MyMaterial = (AliGMaterial*) listMaterials->At(j);
1365             /*printf( " AliGMaterial( %d, %s, %s, %d, %d, %f, %f, %f, %f, %f, %f, *fUbuf, %d, %f, %f, %f, %f, %f, *fBuf, %d ); already existed.\n", nmat,AliMaterials[nmat]->fName, AliMaterials[nmat]->fName, AliMediums[nmed]->fIsvol, AliMediums[nmed]->fIfield, AliMediums[nmed]->fFieldm, AliMediums[nmed]->fTmaxfd, AliMediums[nmed]->fStemax, AliMediums[nmed]->fDeemax, AliMediums[nmed]->fEpsil, AliMediums[nmed]->fStmin, AliMediums[nmed]->fNbuf, AliMaterials[nmat]->fA, AliMaterials[nmat]->fZ, AliMaterials[nmat]->fDens, AliMaterials[nmat]->fRadl, AliMaterials[nmat]->fAbsl, AliMaterials[nmat]->fNwbuf );*/
1366             break;
1367         }
1368
1369     if( MyMaterial == NULL ) {
1370         MyMaterial = new AliGMaterial( nmat, AliMaterials[nmat]->fName, AliMaterials[nmat]->fName, AliMediums[nmed]->fIsvol, AliMediums[nmed]->fIfield, AliMediums[nmed]->fFieldm, AliMediums[nmed]->fTmaxfd, AliMediums[nmed]->fStemax, AliMediums[nmed]->fDeemax, AliMediums[nmed]->fEpsil, AliMediums[nmed]->fStmin, AliMediums[nmed]->fUbuf, AliMediums[nmed]->fNbuf,  AliMaterials[nmat]->fA, AliMaterials[nmat]->fZ, AliMaterials[nmat]->fDens, AliMaterials[nmat]->fRadl, AliMaterials[nmat]->fAbsl, AliMaterials[nmat]
1371 ->fBuf, AliMaterials[nmat]->fNwbuf );
1372
1373         /*printf( " Created new AliGMaterial( %d, %s, %s, %d, %d, %f, %f, %f, %f, %f, %f, *fUbuf, %d, %f, %f, %f, %f, %f, *fBuf, %d );\n", nmat,AliMaterials[nmat]->fName, AliMaterials[nmat]->fName, AliMediums[nmed]->fIsvol, AliMediums[nmed]->fIfield, AliMediums[nmed]->fFieldm, AliMediums[nmed]->fTmaxfd, AliMediums[nmed]->fStemax, AliMediums[nmed]->fDeemax, AliMediums[nmed]->fEpsil, AliMediums[nmed]->fStmin, AliMediums[nmed]->fNbuf, AliMaterials[nmat]->fA, AliMaterials[nmat]->fZ, AliMaterials[nmat]->fDens, AliMaterials[nmat]->fRadl, AliMaterials[nmat]->fAbsl, AliMaterials[nmat]->fNwbuf );*/
1374
1375         listMaterials->Add( MyMaterial );
1376     }
1377
1378     AliGNode* son = NULL;
1379
1380     // Different constructor depending on the shape
1381     if( !strncmp(shapename, "TUBE", 4) ) {
1382
1383         AliGTube* Shape = NULL;
1384
1385         for( int j=0; j<listShapes->GetSize(); j++ )
1386             if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1387                 Shape = (AliGTube*) listShapes->At(j);
1388                 //printf( " AliGTube( %s, %s, %f, %f, %f ); already existed.\n", shapename, shapename, upar[0], upar[1], upar[2] );
1389                 break;
1390             }
1391
1392         if( Shape == NULL ) {
1393             Shape = new AliGTube( shapename, shapename, upar[0], upar[1], upar[2] );
1394             //printf( " Created new AliGTube( %s, %s, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2] );
1395             listShapes->Add(Shape);
1396         }
1397
1398         Shape->SetCol(Color);
1399         son = new AliGNode( fnodename, nr, fnodename, Shape, MyMaterial );
1400     }
1401     else
1402         if( !strncmp(shapename, "BOX", 3) ) {
1403
1404             AliGBox* Shape = NULL;
1405
1406             for( int j=0; j<listShapes->GetSize(); j++ )
1407                 if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1408                     Shape = (AliGBox*) listShapes->At(j);
1409                     //printf( " AliGBox( %s, %s, %f, %f, %f ); already existed.\n", shapename, shapename, upar[0], upar[1], upar[2] );
1410                     break;
1411                 }
1412
1413             if( Shape == NULL ) {
1414                 Shape = new AliGBox( shapename, shapename, upar[0], upar[1], upar[2] );
1415                 //printf( " Created new AliGBox( %s, %s, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2] );
1416                 listShapes->Add(Shape);
1417             }
1418
1419             Shape->SetCol(Color);
1420             son = new AliGNode( fnodename, nr, fnodename, Shape, MyMaterial );
1421         }
1422         else
1423             if( !strncmp(shapename, "TRD1", 4) ) {
1424
1425                 AliGTRD1* Shape = NULL;
1426
1427                 for( int j=0; j<listShapes->GetSize(); j++ )
1428                     if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1429                         Shape = (AliGTRD1*) listShapes->At(j);
1430                         //printf( " AliGTRD1( %s, %s, %f, %f, %f, %f ); already existed.\n", shapename, shapename, upar[0], upar[1], upar[2], upar[3] );
1431                         break;
1432                     }
1433
1434                 if( Shape == NULL ) {
1435                     Shape = new AliGTRD1( shapename, shapename, upar[0], upar[1], upar[2], upar[3] );
1436                     //printf( " Created new AliGTRD1( %s, %s, %f, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2], upar[3] );
1437                     listShapes->Add(Shape);
1438                 }
1439
1440                 Shape->SetCol(Color);
1441                 son = new AliGNode( fnodename, nr, fnodename, Shape, MyMaterial );
1442             }
1443             else
1444                 if( !strncmp(shapename, "PCON", 4) ) {
1445
1446                     AliGPCone* Shape = NULL;
1447
1448                     for( int j=0; j<listShapes->GetSize(); j++ )
1449                         if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1450                             Shape = (AliGPCone*) listShapes->At(j);
1451                             //printf( " AliGPCone( %s, %s, %f, %f, %f ); already existed.\n", shapename, shapename, upar[0], upar[1], upar[2] );
1452                             break;
1453                         }
1454
1455                     if( Shape == NULL ) {
1456                         Shape = new AliGPCone( shapename, shapename, upar, np );
1457                         //printf( " Created new AliGPCone( %s, %s, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2] );
1458                         listShapes->Add(Shape);
1459                     }
1460
1461                     Shape->SetCol(Color);
1462                     son = new AliGNode( fnodename, nr, fnodename, Shape, MyMaterial );
1463                 }
1464
1465     Color++;
1466     if( Color == 50 )
1467         Color = 0;
1468
1469     AliGTransform* tra = (AliGTransform*) listTransf->At(0);
1470
1471     TVector* matrix = tra->GetMatrix();
1472
1473     char* transname = new char[10];
1474     sprintf( transname, "%s%d", "tra", MatrCount );
1475
1476     TVector &mat = *matrix;
1477     AliGTransform* newtra = new AliGTransform(transname, transname, mat(0), mat(1),  mat(2), mat(4), mat(5), mat(6), mat(8), mat(9), mat(10), x, y, z);
1478
1479     //printf( " Created new AliGTransform( %s, %s, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f );\n", transname, transname, mat(0), mat(1), mat(2), mat(4), mat(5), mat(6), mat(8), mat(9), mat(10), x, y, z );
1480
1481     listTransf->AddAt(newtra, MatrCount);
1482     MatrCount++;
1483
1484     parent->Add(son, newtra);
1485
1486     //printf( " %s->Add( %s, %s );\n", parent->GetName(), son->GetName(), newtra->GetName() );
1487
1488     listNodes->Add(son);
1489 }
1490
1491 /***********************************************************************/
1492
1493 void  AliGEODB::Gsrotm(Int_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t)
1494 {
1495   printf( " Gsrotm.\n" );
1496 }
1497
1498 /***********************************************************************/
1499
1500 void  AliGEODB::Gprotm(Int_t)
1501 {
1502   printf( " Gprotm.\n" );
1503 }
1504
1505 /***********************************************************************/
1506
1507 Int_t AliGEODB::Gsvolu(const char* vname, const char* shape, Int_t nmed, Float_t* upar, Int_t np)
1508 {
1509     Int_t lenvname = strlen(vname);
1510
1511     char* nodename = new char[lenvname+1];
1512     strcpy( nodename, vname );
1513     nodename[lenvname] = '\x0';
1514
1515     int pos;
1516     for( pos=0; pos<lenvname; pos++ )
1517         if( (nodename[pos] == '\x0') || (nodename[pos] == ' ') )
1518             break;
1519
1520     if( pos < lenvname ) {
1521         if( nodename ) delete [] nodename;
1522         nodename = new char[pos+1];
1523         strncpy( nodename, vname, pos );
1524         nodename[pos] = '\x0';
1525     }
1526
1527     char* shapename = new char[strlen(shape)+1];
1528     strcpy( shapename, shape );
1529     shapename[strlen(shape)] = '\x0';
1530
1531     //printf( "\n Trying to build node: %s with shape: %s, nmed: %d, upar[0]: %f and np: %d\n", nodename, shapename, nmed, upar[0], np );
1532
1533     if( !np ) {
1534         /* if number of parameters is 0, stores the nodename, shapename and nmed to be used in GSPOSP */
1535         NodePosp* AliPosp = new NodePosp;
1536         AliPosp->name     = nodename;
1537         AliPosp->shape    = shapename;
1538         AliPosp->nmed     = nmed;
1539         Posp[PospCount]   = AliPosp;
1540         PospCount++;
1541         return 0;
1542     }
1543
1544     if( (listNodes) && (listNodes->FindObject(nodename)) ) { // Trying to find the node inside listNodes
1545         // The node existed in listNodes.
1546         printf( "\n ERROR!!! Node %s already existed in listNodes\n", nodename );
1547         exit(1);
1548     }
1549     else {
1550         // It's a new node.
1551         Int_t nmat = AliMediums[nmed]->fNmat;
1552
1553         AliGMaterial* MyMaterial = NULL;
1554
1555         for( int j=0; j<listMaterials->GetSize(); j++ )
1556             if( ((AliGMaterial*) listMaterials->At(j))->GetfImat() == nmat ) {
1557                 MyMaterial = (AliGMaterial*) listMaterials->At(j);
1558                 /*printf( " AliGMaterial( %d, %s, %s, %d, %d, %f, %f, %f, %f, %f, %f, *fUbuf, %d, %f, %f, %f, %f, %f, *fBuf, %d ); already existed.\n", nmat,AliMaterials[nmat]->fName, AliMaterials[nmat]->fName, AliMediums[nmed]->fIsvol, AliMediums[nmed]->fIfield, AliMediums[nmed]->fFieldm, AliMediums[nmed]->fTmaxfd, AliMediums[nmed]->fStemax, AliMediums[nmed]->fDeemax, AliMediums[nmed]->fEpsil, AliMediums[nmed]->fStmin, AliMediums[nmed]->fNbuf, AliMaterials[nmat]->fA, AliMaterials[nmat]->fZ, AliMaterials[nmat]->fDens, AliMaterials[nmat]->fRadl, AliMaterials[nmat]->fAbsl, AliMaterials[nmat]->fNwbuf );*/
1559                 break;
1560             }
1561
1562         if( MyMaterial == NULL ) {
1563             MyMaterial = new AliGMaterial( nmat, AliMaterials[nmat]->fName, AliMaterials[nmat]->fName, AliMediums[nmed]->fIsvol, AliMediums[nmed]->fIfield, AliMediums[nmed]->fFieldm, AliMediums[nmed]->fTmaxfd, AliMediums[nmed]->fStemax, AliMediums[nmed]->fDeemax, AliMediums[nmed]->fEpsil, AliMediums[nmed]->fStmin, AliMediums[nmed]->fUbuf, AliMediums[nmed]->fNbuf,  AliMaterials[nmat]->fA, AliMaterials[nmat]->fZ, AliMaterials[nmat]->fDens, AliMaterials[nmat]->fRadl, AliMaterials[nmat]->fAbsl, AliMaterials[nmat]->fBuf, AliMaterials[nmat]->fNwbuf );
1564
1565             listMaterials->Add( MyMaterial );
1566
1567             /*printf( " Created new AliGMaterial( %d, %s, %s, %d, %d, %f, %f, %f, %f, %f, %f, *fUbuf, %d, %f, %f, %f, %f, %f, *fBuf, %d );\n", nmat,AliMaterials[nmat]->fName, AliMaterials[nmat]->fName, AliMediums[nmed]->fIsvol, AliMediums[nmed]->fIfield, AliMediums[nmed]->fFieldm, AliMediums[nmed]->fTmaxfd, AliMediums[nmed]->fStemax, AliMediums[nmed]->fDeemax, AliMediums[nmed]->fEpsil, AliMediums[nmed]->fStmin, AliMediums[nmed]->fNbuf, AliMaterials[nmat]->fA, AliMaterials[nmat]->fZ, AliMaterials[nmat]->fDens, AliMaterials[nmat]->fRadl, AliMaterials[nmat]->fAbsl, AliMaterials[nmat]->fNwbuf );*/
1568         }
1569
1570         // Different constructor depending on the shape
1571         AliGNode* node = NULL;
1572
1573         if( !strncmp(shapename, "TUBE", 4) ) {
1574
1575             AliGTube* Shape = NULL;
1576
1577             for( int j=0; j<listShapes->GetSize(); j++ )
1578                 if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1579                     Shape = (AliGTube*) listShapes->At(j);
1580                     printf( " AliGTube( %s, %s, %f, %f, %f ); already existed.\n", shapename, shapename, upar[0], upar[1], upar[2] );
1581                     break;
1582                 }
1583
1584             if( Shape == NULL ) {
1585                 Shape = new AliGTube( shapename, shapename, upar[0], upar[1], upar[2] );
1586                 //printf( " Created new AliGTube( %s, %s, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2] );
1587                 listShapes->Add(Shape);
1588             }
1589
1590             Shape->SetCol(Color);
1591             node = new AliGNode( nodename, 1, nodename, Shape, MyMaterial );
1592         }
1593         else
1594             if( !strncmp(shapename, "BOX", 3) ) {
1595
1596                 AliGBox* Shape = NULL;
1597
1598                 for( int j=0; j<listShapes->GetSize(); j++ )
1599                     if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1600                         Shape = (AliGBox*) listShapes->At(j);
1601                         printf( " AliGBox( %s, %s, %f, %f, %f ); already existed.\n", shapename, shapename, upar[0], upar[1], upar[2] );
1602                         break;
1603                     }
1604
1605                 if( Shape == NULL ) {
1606                     Shape = new AliGBox( shapename, shapename, upar[0], upar[1], upar[2] );
1607                     //printf( " Created new AliGBox( %s, %s, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2] );
1608                     listShapes->Add(Shape);
1609                 }
1610
1611                 Shape->SetCol(Color);
1612                 node = new AliGNode( nodename, 1, nodename, Shape, MyMaterial );
1613             }
1614             else
1615                 if( !strncmp(shapename, "TRD1", 4) ) {
1616
1617                     AliGTRD1* Shape = NULL;
1618
1619                     for( int j=0; j<listShapes->GetSize(); j++ )
1620                         if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1621                             Shape = (AliGTRD1*) listShapes->At(j);
1622
1623                             break;
1624                         }
1625
1626                     if( Shape == NULL ) {
1627                         Shape = new AliGTRD1( shapename, shapename, upar[0], upar[1], upar[2], upar[3] );
1628                         //printf( " Created new AliGTRD1( %s, %s, %f, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2], upar[3] );
1629                         listShapes->Add(Shape);
1630                     }
1631
1632                     Shape->SetCol(Color);
1633                     node = new AliGNode( nodename, 1, nodename, Shape, MyMaterial );
1634                 }
1635                 else
1636                     if( !strncmp(shapename, "PCON", 4) ) {
1637
1638                         AliGPCone* Shape = NULL;
1639
1640                         for( int j=0; j<listShapes->GetSize(); j++ )
1641                             if( ((AliGShape*) listShapes->At(j))->GetName() == shapename ) {
1642                                 Shape = (AliGPCone*) listShapes->At(j);
1643                                 break;
1644                             }
1645
1646                         if( Shape == NULL ) {
1647                             Shape = new AliGPCone( shapename, shapename, upar, np );
1648                             //printf( " Created new AliGPCone( %s, %s, %f, %f, %f );\n", shapename, shapename, upar[0], upar[1], upar[2] );
1649                             listShapes->Add(Shape);
1650                         }
1651
1652                         Shape->SetCol(Color);
1653                         node = new AliGNode( nodename, 1, nodename, Shape, MyMaterial );
1654                     }
1655
1656         //printf( " Created new AliGNode( %s, %d, %s, %s, %s );\n", nodename, 1+listNodes->GetSize(), nodename, shapename, MyMaterial->GetName() );
1657
1658         listNodes->Add(node);
1659
1660         //printf( " node->fShape->Color = %d\n", node->GetShape()->GetCol() );
1661
1662         Color++;
1663         if( Color == 50 )
1664             Color = 1;
1665     }
1666
1667     return 0;
1668 }
1669
1670 /***********************************************************************/
1671
1672 void  AliGEODB::Gsatt(const char*, const char*, Int_t)
1673 {
1674   printf( " Gsatt.\n" );
1675 }
1676
1677 /***********************************************************************/
1678
1679 void  AliGEODB::Gfpara(const char*, Int_t, Int_t, Int_t&, Int_t&, Float_t*, Float_t*)
1680 {
1681   printf( " Gfpara.\n" );
1682 }
1683
1684 /***********************************************************************/
1685
1686 void  AliGEODB::Gckpar(Int_t, Int_t, Float_t*)
1687 {
1688   printf( " Gckpar.\n" );
1689 }
1690
1691 /***********************************************************************/
1692
1693 void  AliGEODB::Gckmat(Int_t, char*)
1694 {
1695   printf( " Gckmat.\n" );
1696 }
1697
1698 /***********************************************************************/
1699
1700 //=======================DRAW functions
1701
1702 void  AliGEODB::InitHIGZ()
1703 {
1704     printf( "InitHIGZ.\n" );
1705 }
1706
1707 /***********************************************************************/
1708
1709 void  AliGEODB::Gdopen(Int_t)
1710 {
1711     printf( "Gdopen.\n" );
1712 }
1713
1714 /***********************************************************************/
1715
1716 void  AliGEODB::Gdclose()
1717 {
1718     printf( "Gdclose.\n" );
1719 }
1720
1721 /***********************************************************************/
1722
1723 void  AliGEODB::Gdelete(Int_t)
1724 {
1725     cout << " Gdelete" << endl;
1726 }
1727
1728 /***********************************************************************/
1729
1730 void  AliGEODB::Gdshow(Int_t)
1731 {
1732     cout << " Gdshow" << endl;
1733 }
1734
1735 /***********************************************************************/
1736
1737 void  AliGEODB::Gdopt(const char *,const char *)
1738 {
1739     cout << " Gdopt" << endl;
1740 }
1741
1742 /***********************************************************************/
1743
1744 void  AliGEODB::Gdraw(const char *,Float_t, Float_t, Float_t,Float_t,Float_t,Float_t,Float_t)
1745 {
1746     cout << " Gdraw" << endl;
1747 }
1748
1749 /***********************************************************************/
1750
1751 void  AliGEODB::Gdrawc(const char *,Int_t, Float_t,Float_t,Float_t,Float_t,Float_t)
1752 {
1753     cout << " Gdrawc" << endl;
1754 }
1755
1756 /***********************************************************************/
1757
1758 void  AliGEODB::Gdrawx(const char *,Float_t, Float_t, Float_t, Float_t, Float_t,Float_t,Float_t,Float_t,Float_t)
1759 {
1760     cout << " Gdrawx" << endl;
1761 }
1762
1763 /***********************************************************************/
1764
1765 void  AliGEODB::Gdhead(Int_t, const char *, Float_t)
1766 {
1767     cout << " Gdhead" << endl;
1768 }
1769
1770 /***********************************************************************/
1771
1772 void  AliGEODB::Gdman(Float_t, Float_t, const char *)
1773 {
1774     cout << " Gdman" << endl;
1775 }
1776
1777 /***********************************************************************/
1778
1779 void  AliGEODB::Gdspec(const char *)
1780 {
1781     cout << " Gdspec" << endl;
1782 }
1783
1784 /***********************************************************************/
1785
1786 void  AliGEODB::DrawOneSpec(const char *)
1787 {
1788     cout << " DrawOneSpec" << endl;
1789 }
1790
1791 /***********************************************************************/
1792
1793 void  AliGEODB::Gdtree(const char *,Int_t,Int_t)
1794 {
1795     cout << " Gdtree" << endl;
1796 }
1797
1798 /***********************************************************************/
1799
1800 void  AliGEODB::GdtreeParent(const char *,Int_t,Int_t)
1801 {
1802     cout << " GdtreeParent" << endl;
1803 }
1804
1805 /***********************************************************************/
1806
1807 //=======================Set functions
1808
1809 void AliGEODB::SetABAN(Int_t)
1810 {
1811     cout << " SetABAN" << endl;
1812 }
1813
1814 /***********************************************************************/
1815
1816 void AliGEODB::SetANNI(Int_t)
1817 {
1818     cout << " SetANNI" << endl;
1819 }
1820
1821 /***********************************************************************/
1822
1823 void AliGEODB::SetAUTO(Int_t)
1824 {
1825     cout << " SetAUTO" << endl;
1826 }
1827
1828 /***********************************************************************/
1829
1830 void AliGEODB::SetBOMB(Float_t)
1831 {
1832     cout << " SetBOMB" << endl;
1833 }
1834
1835 /***********************************************************************/
1836
1837 void AliGEODB::SetBREM(Int_t)
1838 {
1839     cout << " SetBREM" << endl;
1840 }
1841
1842 /***********************************************************************/
1843
1844 void AliGEODB::SetCKOV(Int_t)
1845 {
1846     cout << " SetCKOV" << endl;
1847 }
1848
1849 /***********************************************************************/
1850
1851 void AliGEODB::SetClipBox(const char *,Float_t,Float_t, Float_t,Float_t,Float_t,Float_t)
1852 {
1853     cout << " SetClipBox" << endl;
1854 }
1855
1856 /***********************************************************************/
1857
1858 void AliGEODB::SetCOMP(Int_t)
1859 {
1860     cout << " SetCOMP" << endl;
1861 }
1862
1863 /***********************************************************************/
1864
1865 void AliGEODB::SetCUTS( Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t )
1866 {
1867     cout << " SetCUTS" << endl;
1868 }
1869
1870 /***********************************************************************/
1871
1872 void AliGEODB::SetDCAY(Int_t)
1873 {
1874     cout << " SetDCAY" << endl;
1875 }
1876
1877 /***********************************************************************/
1878
1879 void AliGEODB::SetDEBU(Int_t, Int_t, Int_t)
1880 {
1881     cout << " SetDEBU" << endl;
1882 }
1883
1884 /***********************************************************************/
1885
1886 void AliGEODB::SetDRAY(Int_t)
1887 {
1888     cout << " SetDRAY" << endl;
1889 }
1890
1891 /***********************************************************************/
1892
1893 void AliGEODB::SetHADR(Int_t)
1894 {
1895     cout << " SetHADR" << endl;
1896 }
1897
1898 /***********************************************************************/
1899
1900 void AliGEODB::SetKINE(Int_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t, Float_t,Float_t )
1901 {
1902     cout << " SetKINE" << endl;
1903 }
1904
1905 /***********************************************************************/
1906
1907 void AliGEODB::SetLOSS(Int_t)
1908 {
1909     cout << " SetLOSS" << endl;
1910 }
1911
1912 /***********************************************************************/
1913
1914 void AliGEODB::SetMULS(Int_t)
1915 {
1916     cout << " SetMULS" << endl;
1917 }
1918
1919 /***********************************************************************/
1920
1921 void AliGEODB::SetMUNU(Int_t)
1922 {
1923     cout << " SetMUNU" << endl;
1924 }
1925
1926 /***********************************************************************/
1927
1928 void AliGEODB::SetOPTI(Int_t)
1929 {
1930     cout << " SetOPTI" << endl;
1931 }
1932
1933 /***********************************************************************/
1934
1935 void AliGEODB::SetPAIR(Int_t)
1936 {
1937     cout << " SetPAIR" << endl;
1938 }
1939
1940 /***********************************************************************/
1941
1942 void AliGEODB::SetPFIS(Int_t)
1943 {
1944     cout << " SetPFIS" << endl;
1945 }
1946
1947 /***********************************************************************/
1948
1949 void AliGEODB::SetPHOT(Int_t)
1950 {
1951     cout << " SetPHOT" << endl;
1952 }
1953
1954 /***********************************************************************/
1955
1956 void AliGEODB::SetRAYL(Int_t)
1957 {
1958     cout << " SetRAYL" << endl;
1959 }
1960
1961 /***********************************************************************/
1962
1963 void AliGEODB::SetSWIT(Int_t , Int_t)
1964 {
1965     cout << " SetSWIT" << endl;
1966 }
1967
1968 /***********************************************************************/
1969
1970 void AliGEODB::SetTRIG(Int_t)
1971 {
1972     cout << " SetTRIG" << endl;
1973 }
1974
1975 /***********************************************************************/
1976
1977 void AliGEODB::Vname(const char *, char *)
1978 {
1979     cout << " Vname" << endl;
1980 }
1981
1982 /***********************************************************************/
1983
1984 void AliGEODB::InitLego()
1985 {
1986     cout << " InitLego" << endl;
1987 }
1988
1989 /***********************************************************************/
1990
1991 extern "C" void sxpart_(){}