| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 ////////////////////////////////////////////// 23 ///////////////////////////////////////////////////////////////////////////////
27 // File: CCalG4Able.cc 24 // File: CCalG4Able.cc
28 // Description: CCalG4Able is the base class o 25 // Description: CCalG4Able is the base class of a Geant4 geometry factory
29 ////////////////////////////////////////////// 26 ///////////////////////////////////////////////////////////////////////////////
30 //Comment/Uncomment next line to unset/set deb 27 //Comment/Uncomment next line to unset/set debug information printing
31 //#define debug 28 //#define debug
32 //#define ddebug 29 //#define ddebug
33 30
34 #ifdef ddebug 31 #ifdef ddebug
35 #include "G4Timer.hh" 32 #include "G4Timer.hh"
36 #endif 33 #endif
37 #ifdef debug 34 #ifdef debug
38 #include "CCalutils.hh" 35 #include "CCalutils.hh"
39 #endif 36 #endif
40 37
41 #include "CCalGeometryConfiguration.hh" 38 #include "CCalGeometryConfiguration.hh"
42 #include "CCalG4Able.hh" 39 #include "CCalG4Able.hh"
43 #include "CCalSensitiveConfiguration.hh" 40 #include "CCalSensitiveConfiguration.hh"
44 41
45 #include "G4Color.hh" 42 #include "G4Color.hh"
46 #include "G4VisAttributes.hh" 43 #include "G4VisAttributes.hh"
47 44
48 45
49 CCalG4Able::CCalG4Able( G4String name ) : << 46 CCalG4Able::CCalG4Able(G4String name):
50 detPhysicalVolume(0), g4ableName(name), sens 47 detPhysicalVolume(0), g4ableName(name), sensitivity(false),
51 visProperties(CCalSensitiveConfiguration::ge 48 visProperties(CCalSensitiveConfiguration::getInstance()->getFileName(name)+".vis") {
52 //Initialize g4VisAtt pointers 49 //Initialize g4VisAtt pointers
53 for (G4int i=0; i<CCalVisualisable::TotalVis << 50 for (int i=0; i<CCalVisualisable::TotalVisTypes; i++) {
54 sensitivity = CCalSensitiveConfiguration::ge << 51 g4VisAtt[i]=0;
>> 52 }
>> 53 sensitivity =
>> 54 CCalSensitiveConfiguration::getInstance()->getSensitiveFlag(name);
55 } 55 }
56 56
57 <<
58 CCalG4Able::~CCalG4Able() { 57 CCalG4Able::~CCalG4Able() {
59 if (detPhysicalVolume) delete[] detPhysicalV << 58 if (detPhysicalVolume)
>> 59 delete[] detPhysicalVolume;
60 } 60 }
61 61
62 << 62 G4VPhysicalVolume* CCalG4Able::PhysicalVolume(G4VPhysicalVolume* pv) {
63 G4VPhysicalVolume* CCalG4Able::PhysicalVolume( << 63 //If detPhysicalVolume is not (nil) the volume has already been built
64 //If detPhysicalVolume is not null the volum << 64 //so return it. In other case, construct it and its daughters, then
65 //so return it. In other case, construct it << 65 //check for sensitivity and build it if set.
66 #ifdef ddebug 66 #ifdef ddebug
67 G4Timer timer; 67 G4Timer timer;
68 timer.Start(); 68 timer.Start();
69 #endif 69 #endif
70 if (CCalGeometryConfiguration::getInstance() 70 if (CCalGeometryConfiguration::getInstance()->getConstructFlag(G4Name())!=0){
71 if (!detPhysicalVolume) { 71 if (!detPhysicalVolume) {
72 detPhysicalVolume = constructIn(pv); 72 detPhysicalVolume = constructIn(pv);
73 for (unsigned int i = 0; i < theG4Detect 73 for (unsigned int i = 0; i < theG4DetectorsInside.size(); i++) {
74 theG4DetectorsInside[i]->PhysicalVolum << 74 theG4DetectorsInside[i]->PhysicalVolume(detPhysicalVolume);
75 } 75 }
76 } << 76 if (sensitivity) {
77 } << 77 #ifdef debug
>> 78 G4cout << "==> Making " << detPhysicalVolume->GetName() << " sensitive..."
>> 79 << G4endl;
>> 80 #endif
>> 81 constructSensitive();
>> 82 } //if sensitivity
>> 83 } //if sensitive
>> 84 } //if construct
78 else { 85 else {
79 G4cout << "NOTE: You decided to skip the c << 86 G4cout << "NOTE: You decided to skip the construction of "
>> 87 << G4Name() << G4endl;
80 } 88 }
81 #ifdef ddebug 89 #ifdef ddebug
82 timer.Stop(); 90 timer.Stop();
83 G4cout << tab << "CCalG4Able::PhysicalVolume << 91 G4cout << tab << "CCalG4Able::PhysicalVolume(...) --> time spent: "
>> 92 << timer << G4endl;
84 #endif 93 #endif
85 return detPhysicalVolume; 94 return detPhysicalVolume;
86 } 95 }
87 96
88 << 97 void CCalG4Able::AddCCalG4Able(CCalG4Able* det) {
89 void CCalG4Able::sensitiveHandling() { <<
90 if ( CCalGeometryConfiguration::getInstance( <<
91 sensitivity ) { <<
92 for (unsigned int i = 0; i < theG4Detector <<
93 #ifdef debug <<
94 G4cout << "==> Making " << detPhysicalVo <<
95 #endif <<
96 theG4DetectorsInside[i]->constructSensit <<
97 } <<
98 } <<
99 } <<
100 <<
101 <<
102 void CCalG4Able::AddCCalG4Able( CCalG4Able* de <<
103 theG4DetectorsInside.push_back(det); 98 theG4DetectorsInside.push_back(det);
104 } 99 }
105 100
106 << 101 void CCalG4Able::setVisType(CCalVisualisable::visType vt, G4LogicalVolume* log) {
107 void CCalG4Able::setVisType( CCalVisualisable: <<
108 if (!g4VisAtt[vt]) { 102 if (!g4VisAtt[vt]) {
109 #ifdef debug 103 #ifdef debug
110 G4cout << "CCalG4Able::setVisType: Constru 104 G4cout << "CCalG4Able::setVisType: Constructing G4VisAttributes for "
111 << log->GetName() << " as " << vt < << 105 << log->GetName() << " as " << vt << G4endl;
112 #endif 106 #endif
113 G4Color col( visProperties.colorRed(vt), v << 107 G4Color col(visProperties.colorRed(vt),
114 visProperties.colorBlue(vt) ); << 108 visProperties.colorGreen(vt),
>> 109 visProperties.colorBlue(vt));
115 G4bool wf = visProperties.isWireFrame 110 G4bool wf = visProperties.isWireFrame(vt);
116 G4bool visible = visProperties.isVisible(v 111 G4bool visible = visProperties.isVisible(vt);
>> 112
117 #ifdef debug 113 #ifdef debug
118 G4cout << "Color: " << visProperties.color << 114 G4cout << "Color: "
119 << ", " << visProperties.colorBlue(vt) < << 115 << visProperties.colorRed(vt) << ", "
120 << "Visible: " << visible << G4endl << 116 << visProperties.colorGreen(vt) << ", "
>> 117 << visProperties.colorBlue(vt) << tab
>> 118 << "Wireframe: " << wf << tab
>> 119 << "Visible: " << visible << G4endl;
121 #endif 120 #endif
122 g4VisAtt[vt] = new G4VisAttributes(col); 121 g4VisAtt[vt] = new G4VisAttributes(col);
123 g4VisAtt[vt]->SetForceWireframe(wf); 122 g4VisAtt[vt]->SetForceWireframe(wf);
124 g4VisAtt[vt]->SetVisibility(visible); 123 g4VisAtt[vt]->SetVisibility(visible);
125 } 124 }
126 log->SetVisAttributes(g4VisAtt[vt]); 125 log->SetVisAttributes(g4VisAtt[vt]);
127 } 126 }
128 127
129 128
130 G4bool CCalG4Able::operator==( const CCalG4Abl << 129
>> 130 G4bool CCalG4Able::operator==(const CCalG4Able& right) const {
131 return detPhysicalVolume==right.detPhysicalV 131 return detPhysicalVolume==right.detPhysicalVolume;
132 } 132 }
133 133
134 134
135 std::ostream& operator<<( std::ostream& os, co << 135
136 if (det.detPhysicalVolume) os << "Physical v << 136 //========================================================================
137 else os << "Physical v << 137 //Protected and private methods.
138 if (det.isSensitive()) os << "and it is Sens << 138
139 else os << "and it is not << 139 //========================================================================
>> 140 //Global operators
>> 141 std::ostream& operator<<(std::ostream& os, const CCalG4Able& det) {
>> 142 if (det.detPhysicalVolume)
>> 143 os << "Physical volume already constructed." << G4endl;
>> 144 else
>> 145 os << "Physical volume still not constructed." << G4endl;
>> 146
>> 147 if (det.isSensitive())
>> 148 os << "and it is Sensitive" << G4endl;
>> 149 else
>> 150 os << "and it is not Sensitive" << G4endl;
>> 151
140 return os; 152 return os;
141 } 153 }
142 154