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