]> git.uio.no Git - u/mrichter/AliRoot.git/blame - GEODB/AliGEODB.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Coding convention rules obeyed
[u/mrichter/AliRoot.git] / GEODB / AliGEODB.cxx
CommitLineData
4c039060 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/*
17$Log$
6a935c13 18Revision 1.2 1999/09/29 09:24:19 fca
19Introduction of the Copyright and cvs Log
20
4c039060 21*/
22
ab2f6604 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
45struct 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
56Mater* AliMaterials[MAXMAT]; // Array of Mater structs containing the AliMaterial parameters.
57
58struct 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
73Med* AliMediums[MAXMAT]; // Array of Med structs containing the AliMedium parameters.
74
75struct NodePosp{
76 char* name;
77 char* shape;
78 Int_t nmed;
79};
80
81NodePosp* Posp[MAXMAT];
82
83AliGMaterial* Mat[MAXMAT]; // List of Pointers to my AliGMaterials created
84
85Int_t MateCount = 0;
86Int_t MedCount = 0;
87Int_t MatrCount = 0;
88Int_t PospCount = 0;
89Int_t Color = 2;
90
91TList* listNodes = new TList(); // List of Nodes
92TList* listTransf = new TList();
93TList* listShapes = new TList();
94TList* listMaterials = new TList();
95
96AliGNode* TopNode = NULL;
97
98/***********************************************************************/
99
100ClassImp(AliGEODB)
101
102/***********************************************************************/
103
104AliGEODB::AliGEODB(const char *title, Int_t) : AliMC("AliGEODB",title)
105{
106 //cout << " AliGEODB" << endl;
107}
108
109/***********************************************************************/
110
111void AliGEODB::DefaultRange()
112{
113 cout << " DefaultRange" << endl;
114}
115
116//=======================functions from GBASE
117
118/***********************************************************************/
119
120void AliGEODB::Gfile(const char*, const char*)
121{
122 cout << " Gfile" << endl;
123}
124
125/***********************************************************************/
126
127void AliGEODB::GeomIter()
128{
129 cout << " GeomIter" << endl;
130}
131
132/***********************************************************************/
133
134Int_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
142Int_t AliGEODB::NextVolUp(Text_t*, Int_t&)
143{
144 cout << " NextVolUp" << endl;
145 return 0;
146}
147
148/***********************************************************************/
149
150Int_t AliGEODB::CurrentVol(Text_t*, Int_t&) const
151{
152 cout << " CurrentVol" << endl;
153 return 0;
154}
155
156/***********************************************************************/
157
158Int_t AliGEODB::NofVolumes() const
159{
160 cout << " NofVolumes" << endl;
161 return 0;
162}
163
164/***********************************************************************/
165
166Int_t AliGEODB::CurrentVolOff(Int_t, Text_t*, Int_t&) const
167{
168 cout << " CurrentVolOff" << endl;
169 return 0;
170}
171
172/***********************************************************************/
173
174void AliGEODB::TrackPosition(Float_t*) const
175{
176 cout << " TrackPosition" << endl;
177}
178
179/***********************************************************************/
180
181void AliGEODB::TrackMomentum(Float_t*) const
182{
183 cout << " TrackMomentum" << endl;
184}
185
186/***********************************************************************/
187
188Int_t AliGEODB::VolId( Text_t* name ) const
189{
190 cout << " VolId" << endl;
191 return 0;
192}
193
194/***********************************************************************/
195
196const char* AliGEODB::VolName(Int_t ) const
197{
198 cout << " VolName" << endl;
199 return 0;
200}
201
202/***********************************************************************/
203
204Float_t AliGEODB::TrackCharge() const
205{
206 cout << " TrackCharge" << endl;
207 return 0;
208}
209
210/***********************************************************************/
211
212Float_t AliGEODB::TrackMass() const
213{
214 cout << " TrackMass" << endl;
215 return 0;
216}
217
218/***********************************************************************/
219
220Bool_t AliGEODB::TrackInside() const
221{
222 cout << " TrackInside" << endl;
223 return 0;
224}
225
226/***********************************************************************/
227
228Bool_t AliGEODB::TrackEntering() const
229{
230 cout << " TrackEntering" << endl;
231 return 0;
232}
233
234/***********************************************************************/
235
236Bool_t AliGEODB::TrackExiting() const
237{
238 cout << " TrackExiting" << endl;
239 return 0;
240}
241
242/***********************************************************************/
243
244Bool_t AliGEODB::TrackOut() const
245{
246 cout << " TrackOut" << endl;
247 return 0;
248}
249
250/***********************************************************************/
251
252Bool_t AliGEODB::TrackDisappear() const
253{
254 cout << " TrackDisappear" << endl;
255 return 0;
256}
257
258/***********************************************************************/
259
260Bool_t AliGEODB::TrackStop() const
261{
262 cout << " TrackStop" << endl;
263 return 0;
264}
265
266/***********************************************************************/
267
268Int_t AliGEODB::NSecondaries() const
269{
270 cout << " NSecondaries" << endl;
271 return 0;
272}
273
274/***********************************************************************/
275
6a935c13 276const char* AliGEODB::ProdProcess() const
ab2f6604 277{
278 cout << " ProdProcess" << endl;
6a935c13 279 return 0;
ab2f6604 280}
281
282/***********************************************************************/
283
284void AliGEODB::GetSecondary(Int_t, Int_t&, Float_t*, Float_t*)
285{
286 cout << " GetSecondary" << endl;
287}
288
289/***********************************************************************/
290
291Float_t AliGEODB::MaxStep() const
292{
293 cout << " MaxStep" << endl;
294 return 0;
295}
296
297/***********************************************************************/
298
299void AliGEODB::SetMaxStep(Float_t )
300{
301 cout << " SetMaxStep" << endl;
302}
303
304/***********************************************************************/
305
306void AliGEODB::GetParticle(const Int_t, char*, Float_t&) const
307{
308 cout << " GetParticle" << endl;
309}
310
311/***********************************************************************/
312
313Int_t AliGEODB::CurrentEvent() const
314{
315 cout << " CurrentEvent" << endl;
316 return 0;
317}
318
319/***********************************************************************/
320
321Int_t AliGEODB::GetMedium() const
322{
323 cout << " GetMedium" << endl;
324 return 0;
325}
326
327/***********************************************************************/
328
329Float_t AliGEODB::Edep() const
330{
331 cout << " Edep" << endl;
332 return 0;
333}
334
335/***********************************************************************/
336
337Float_t AliGEODB::Etot() const
338{
339 cout << " Etot" << endl;
340 return 0;
341}
342
343/***********************************************************************/
344
345void AliGEODB::Rndm(Float_t*, const Int_t) const
346{
347 cout << " Rndm" << endl;
348}
349
350/***********************************************************************/
351
352Float_t AliGEODB::TrackStep() const
353{
354 cout << " TrackStep" << endl;
355 return 0;
356}
357
358/***********************************************************************/
359
360Float_t AliGEODB::TrackLength() const
361{
362 cout << " TrackLength" << endl;
363 return 0;
364}
365
366/***********************************************************************/
367
368Float_t AliGEODB::TrackTime() const
369{
370 cout << " TrackTime" << endl;
371 return 0;
372}
373
374/***********************************************************************/
375
376Int_t AliGEODB::TrackPid() const
377{
378 cout << " TrackPid" << endl;
379 return 0;
380}
381
382/***********************************************************************/
383
384Bool_t AliGEODB::TrackAlive() const
385{
386 cout << " TrackAlive" << endl;
387 return 0;
388}
389
390/***********************************************************************/
391
392void AliGEODB::StopTrack()
393{
394 cout << " StopTrack" << endl;
395}
396
397/***********************************************************************/
398
399void AliGEODB::StopEvent()
400{
401 cout << " StopEvent" << endl;
402}
403
404/***********************************************************************/
405
406void AliGEODB::SetMaxNStep(Int_t)
407{
408 cout << " SetMaxNStep" << endl;
409}
410
411/***********************************************************************/
412
413void AliGEODB::SetColors()
414{
415 cout << " SetColors" << endl;
416}
417
418/***********************************************************************/
419
420Int_t AliGEODB::GetMaxNStep() const
421{
422 cout << " GetMaxNStep" << endl;
423 return 0;
424}
425
426/***********************************************************************/
427
428void 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
462void 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
505void 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
543void 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
560void AliGEODB::WriteEuclid(const char*, const char*, Int_t, Int_t)
561{
562 cout << " WriteEuclid" << endl;
563}
564
565/***********************************************************************/
566
567void AliGEODB::Gpcxyz()
568{
569 cout << " Gpcxyz " << endl;
570}
571
572/***********************************************************************/
573
574void 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
760void 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
772void 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
788void AliGEODB::Glast()
789{
790 cout << " Glast " << endl;
791}
792
793/***********************************************************************/
794
795void AliGEODB::Gprint(const char*)
796{
797 cout << " Gprint " << endl;
798}
799
800/***********************************************************************/
801
802void AliGEODB::Grun()
803{
804 cout << " Grun " << endl;
805}
806
807/***********************************************************************/
808
809void AliGEODB::Gtrig()
810{
811 cout << " Gtrig " << endl;
812}
813
814/***********************************************************************/
815
816void AliGEODB::Gtrigc()
817{
818 cout << " Gtrigc " << endl;
819}
820
821/***********************************************************************/
822
823void AliGEODB::Gtrigi()
824{
825 cout << " Gtrigi " << endl;
826}
827
828/***********************************************************************/
829
830void AliGEODB::Gwork(Int_t)
831{
832 cout << " Gwork " << endl;
833}
834
835/***********************************************************************/
836
837void AliGEODB::Gzinit()
838{
839 cout << " Gzinit " << endl;
840}
841
842//=======================functions from GCONS
843
844/***********************************************************************/
845
846void 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
853void AliGEODB::Gfpart(Int_t, char*, Int_t&, Float_t&, Float_t&, Float_t&)
854{
855 cout << " Gfpart " << endl;
856}
857
858/***********************************************************************/
859
860void 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
867void AliGEODB::Gmate() {
868 cout << " Gmate " << endl;
869}
870
871/***********************************************************************/
872
873void 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
890void AliGEODB::Gsdk(Int_t, Float_t*, Int_t*) {
891 cout << " Gsdk " << endl;
892}
893
894/***********************************************************************/
895
896void AliGEODB::Gsmate(Int_t, const char*, Float_t, Float_t, Float_t, Float_t, Float_t) {
897 cout << " Gsmate " << endl;
898}
899
900/***********************************************************************/
901
902void AliGEODB::Gsmixt(Int_t, const char*, Float_t*, Float_t*, Float_t, Int_t, Float_t*) {
903 cout << " Gsmixt " << endl;
904}
905
906/***********************************************************************/
907
908void AliGEODB::Gspart(Int_t, const char*, Int_t, Float_t, Float_t, Float_t) {
909 cout << " Gspart " << endl;
910}
911
912/***********************************************************************/
913
914void 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
920void AliGEODB::Gstpar(Int_t, const char*, Float_t)
921{
922 //cout << " Gstpar " << endl;
923}
924
925/***********************************************************************/
926
927void 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
936void AliGEODB::Gfkine(Int_t, Float_t*, Float_t*, Int_t&, Int_t&)
937{
938 cout << " Gfkine" << endl;
939}
940
941/***********************************************************************/
942
943void AliGEODB::Gfvert(Int_t, Float_t*, Int_t&, Int_t&, Float_t&)
944{
945 cout << " Gfvert" << endl;
946}
947
948/***********************************************************************/
949
950Int_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
958Int_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
968void AliGEODB::Gphysi()
969{
970 cout << " Gphysi" << endl;
971}
972
973/***********************************************************************/
974
975//=======================functions from GTRAK
976
977void AliGEODB::Gdebug()
978{
979 cout << " Gdebug" << endl;
980}
981
982/***********************************************************************/
983
984void AliGEODB::Gekbin()
985{
986 cout << " Gekbin" << endl;
987}
988
989/***********************************************************************/
990
991void AliGEODB::Gfinds()
992{
993 cout << " Gfinds" << endl;
994}
995
996/***********************************************************************/
997
998void AliGEODB::Gsking(Int_t)
999{
1000 cout << " Gsking" << endl;
1001}
1002
1003/***********************************************************************/
1004
1005void AliGEODB::Gskpho(Int_t)
1006{
1007 cout << " Gskpho" << endl;
1008}
1009
1010/***********************************************************************/
1011
1012void AliGEODB::Gsstak(Int_t)
1013{
1014 cout << " Gsstak" << endl;
1015}
1016
1017/***********************************************************************/
1018
1019void AliGEODB::Gsxyz()
1020{
1021 cout << " Gsxyz" << endl;
1022}
1023
1024/***********************************************************************/
1025
1026void AliGEODB::Gtrack()
1027{
1028 cout << " Gtrack" << endl;
1029}
1030
1031/***********************************************************************/
1032
1033void AliGEODB::Gtreve()
1034{
1035 cout << " Gtreve" << endl;
1036}
1037
1038/***********************************************************************/
1039
1040void AliGEODB::Grndm(Float_t*, const Int_t) const
1041{
1042 cout << " Grndm" << endl;
1043}
1044
1045/***********************************************************************/
1046
1047void 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
1056void AliGEODB::Gdxyz(Int_t )
1057{
1058 cout << " Gdxyz" << endl;
1059}
1060
1061/***********************************************************************/
1062
1063void AliGEODB::Gdcxyz()
1064{
1065 cout << " Gdcxyz" << endl;
1066}
1067
1068/***********************************************************************/
1069
1070//=======================functions from GGEOM
1071
1072void AliGEODB::Gdtom(Float_t*, Float_t*, Int_t)
1073{
1074 printf( " Gdtom.\n" );
1075}
1076
1077/***********************************************************************/
1078
1079void AliGEODB::Glmoth(const char*, Int_t, Int_t&, Int_t*, Int_t*)
1080{
1081 printf( " Glmoth.\n" );
1082
1083}
1084
1085/***********************************************************************/
1086
1087void AliGEODB::Gmedia(Float_t*, Int_t&)
1088{
1089 printf( " Gmedia.\n" );
1090}
1091
1092/***********************************************************************/
1093
1094void AliGEODB::Gmtod(Float_t*, Float_t*, Int_t)
1095{
1096 printf( " Gmtod.\n" );
1097}
1098
1099/***********************************************************************/
1100
1101void 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
1191void AliGEODB::Gsdvn2(const char*, const char*, Int_t, Int_t, Float_t, Int_t)
1192{
1193 printf( " Gsdvn2.\n" );
1194}
1195
1196/***********************************************************************/
1197
1198void AliGEODB::Gsdvs(const char*, const char*, Float_t, Int_t, Int_t)
1199{
1200 printf( " Gsdvs.\n" );
1201}
1202
1203/***********************************************************************/
1204
1205void AliGEODB::Gsdvs2(const char*, const char*, Float_t, Int_t, Float_t, Int_t)
1206{
1207 printf( " Gsdvs2.\n" );
1208}
1209
1210/***********************************************************************/
1211
1212void AliGEODB::Gsdvt(const char*, const char*, Float_t, Int_t, Int_t, Int_t)
1213{
1214 printf( " Gsdvt.\n" );
1215}
1216
1217/***********************************************************************/
1218
1219void 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
1226void AliGEODB::Gsord(const char*, Int_t)
1227{
1228 // Aqui entra pero dice Federico que Dummy.
1229}
1230
1231/***********************************************************************/
1232
1233void 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
1305void 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
1493void 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
1500void AliGEODB::Gprotm(Int_t)
1501{
1502 printf( " Gprotm.\n" );
1503}
1504
1505/***********************************************************************/
1506
1507Int_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
1672void AliGEODB::Gsatt(const char*, const char*, Int_t)
1673{
1674 printf( " Gsatt.\n" );
1675}
1676
1677/***********************************************************************/
1678
1679void 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
1686void AliGEODB::Gckpar(Int_t, Int_t, Float_t*)
1687{
1688 printf( " Gckpar.\n" );
1689}
1690
1691/***********************************************************************/
1692
1693void AliGEODB::Gckmat(Int_t, char*)
1694{
1695 printf( " Gckmat.\n" );
1696}
1697
1698/***********************************************************************/
1699
1700//=======================DRAW functions
1701
1702void AliGEODB::InitHIGZ()
1703{
1704 printf( "InitHIGZ.\n" );
1705}
1706
1707/***********************************************************************/
1708
1709void AliGEODB::Gdopen(Int_t)
1710{
1711 printf( "Gdopen.\n" );
1712}
1713
1714/***********************************************************************/
1715
1716void AliGEODB::Gdclose()
1717{
1718 printf( "Gdclose.\n" );
1719}
1720
1721/***********************************************************************/
1722
1723void AliGEODB::Gdelete(Int_t)
1724{
1725 cout << " Gdelete" << endl;
1726}
1727
1728/***********************************************************************/
1729
1730void AliGEODB::Gdshow(Int_t)
1731{
1732 cout << " Gdshow" << endl;
1733}
1734
1735/***********************************************************************/
1736
1737void AliGEODB::Gdopt(const char *,const char *)
1738{
1739 cout << " Gdopt" << endl;
1740}
1741
1742/***********************************************************************/
1743
1744void 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
1751void 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
1758void 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
1765void AliGEODB::Gdhead(Int_t, const char *, Float_t)
1766{
1767 cout << " Gdhead" << endl;
1768}
1769
1770/***********************************************************************/
1771
1772void AliGEODB::Gdman(Float_t, Float_t, const char *)
1773{
1774 cout << " Gdman" << endl;
1775}
1776
1777/***********************************************************************/
1778
1779void AliGEODB::Gdspec(const char *)
1780{
1781 cout << " Gdspec" << endl;
1782}
1783
1784/***********************************************************************/
1785
1786void AliGEODB::DrawOneSpec(const char *)
1787{
1788 cout << " DrawOneSpec" << endl;
1789}
1790
1791/***********************************************************************/
1792
1793void AliGEODB::Gdtree(const char *,Int_t,Int_t)
1794{
1795 cout << " Gdtree" << endl;
1796}
1797
1798/***********************************************************************/
1799
1800void AliGEODB::GdtreeParent(const char *,Int_t,Int_t)
1801{
1802 cout << " GdtreeParent" << endl;
1803}
1804
1805/***********************************************************************/
1806
1807//=======================Set functions
1808
1809void AliGEODB::SetABAN(Int_t)
1810{
1811 cout << " SetABAN" << endl;
1812}
1813
1814/***********************************************************************/
1815
1816void AliGEODB::SetANNI(Int_t)
1817{
1818 cout << " SetANNI" << endl;
1819}
1820
1821/***********************************************************************/
1822
1823void AliGEODB::SetAUTO(Int_t)
1824{
1825 cout << " SetAUTO" << endl;
1826}
1827
1828/***********************************************************************/
1829
1830void AliGEODB::SetBOMB(Float_t)
1831{
1832 cout << " SetBOMB" << endl;
1833}
1834
1835/***********************************************************************/
1836
1837void AliGEODB::SetBREM(Int_t)
1838{
1839 cout << " SetBREM" << endl;
1840}
1841
1842/***********************************************************************/
1843
1844void AliGEODB::SetCKOV(Int_t)
1845{
1846 cout << " SetCKOV" << endl;
1847}
1848
1849/***********************************************************************/
1850
1851void 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
1858void AliGEODB::SetCOMP(Int_t)
1859{
1860 cout << " SetCOMP" << endl;
1861}
1862
1863/***********************************************************************/
1864
1865void 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
1872void AliGEODB::SetDCAY(Int_t)
1873{
1874 cout << " SetDCAY" << endl;
1875}
1876
1877/***********************************************************************/
1878
1879void AliGEODB::SetDEBU(Int_t, Int_t, Int_t)
1880{
1881 cout << " SetDEBU" << endl;
1882}
1883
1884/***********************************************************************/
1885
1886void AliGEODB::SetDRAY(Int_t)
1887{
1888 cout << " SetDRAY" << endl;
1889}
1890
1891/***********************************************************************/
1892
1893void AliGEODB::SetHADR(Int_t)
1894{
1895 cout << " SetHADR" << endl;
1896}
1897
1898/***********************************************************************/
1899
1900void 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
1907void AliGEODB::SetLOSS(Int_t)
1908{
1909 cout << " SetLOSS" << endl;
1910}
1911
1912/***********************************************************************/
1913
1914void AliGEODB::SetMULS(Int_t)
1915{
1916 cout << " SetMULS" << endl;
1917}
1918
1919/***********************************************************************/
1920
1921void AliGEODB::SetMUNU(Int_t)
1922{
1923 cout << " SetMUNU" << endl;
1924}
1925
1926/***********************************************************************/
1927
1928void AliGEODB::SetOPTI(Int_t)
1929{
1930 cout << " SetOPTI" << endl;
1931}
1932
1933/***********************************************************************/
1934
1935void AliGEODB::SetPAIR(Int_t)
1936{
1937 cout << " SetPAIR" << endl;
1938}
1939
1940/***********************************************************************/
1941
1942void AliGEODB::SetPFIS(Int_t)
1943{
1944 cout << " SetPFIS" << endl;
1945}
1946
1947/***********************************************************************/
1948
1949void AliGEODB::SetPHOT(Int_t)
1950{
1951 cout << " SetPHOT" << endl;
1952}
1953
1954/***********************************************************************/
1955
1956void AliGEODB::SetRAYL(Int_t)
1957{
1958 cout << " SetRAYL" << endl;
1959}
1960
1961/***********************************************************************/
1962
1963void AliGEODB::SetSWIT(Int_t , Int_t)
1964{
1965 cout << " SetSWIT" << endl;
1966}
1967
1968/***********************************************************************/
1969
1970void AliGEODB::SetTRIG(Int_t)
1971{
1972 cout << " SetTRIG" << endl;
1973}
1974
1975/***********************************************************************/
1976
1977void AliGEODB::Vname(const char *, char *)
1978{
1979 cout << " Vname" << endl;
1980}
1981
1982/***********************************************************************/
1983
1984void AliGEODB::InitLego()
1985{
1986 cout << " InitLego" << endl;
1987}
1988
1989/***********************************************************************/
1990
1991extern "C" void sxpart_(){}