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