| 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 // 27 //
28 // Satoshi TANAKA 28 // Satoshi TANAKA
29 // DAWNFILE view - opens window, hard copy, et 29 // DAWNFILE view - opens window, hard copy, etc.
30 30
>> 31
31 #define __G_ANSI_C__ 32 #define __G_ANSI_C__
32 #define G4DAWNFILE_STRUCTURE_PRIORITY 1. << 33 #define G4DAWNFILE_STRUCTURE_PRIORITY 1.
33 34
34 // #define DEBUG_FR_VIEW 35 // #define DEBUG_FR_VIEW
35 36
36 #include "G4ios.hh" 37 #include "G4ios.hh"
37 #include <stdio.h> 38 #include <stdio.h>
38 #include <string.h> 39 #include <string.h>
39 #include <assert.h> 40 #include <assert.h>
40 41
41 #include "G4VisManager.hh" 42 #include "G4VisManager.hh"
42 #include "G4Scene.hh" 43 #include "G4Scene.hh"
43 #include "G4Vector3D.hh" 44 #include "G4Vector3D.hh"
44 #include "G4VisExtent.hh" 45 #include "G4VisExtent.hh"
45 #include "G4LogicalVolume.hh" 46 #include "G4LogicalVolume.hh"
46 #include "G4VSolid.hh" 47 #include "G4VSolid.hh"
47 #include "G4PhysicalConstants.hh" 48 #include "G4PhysicalConstants.hh"
48 49
49 #include "G4FRConst.hh" 50 #include "G4FRConst.hh"
50 #include "G4DAWNFILE.hh" 51 #include "G4DAWNFILE.hh"
51 #include "G4DAWNFILESceneHandler.hh" 52 #include "G4DAWNFILESceneHandler.hh"
52 #include "G4DAWNFILEViewer.hh" 53 #include "G4DAWNFILEViewer.hh"
53 54
54 //----- constants <<
55 const char FR_ENV_MULTI_WINDOW[] = "G4DAWN_MU <<
56 const char FR_ENV_MULTI_WINDOW2[] = "G4DAWNFIL <<
57 <<
58 //----- G4DAWNFILEViewer, constructor <<
59 G4DAWNFILEViewer::G4DAWNFILEViewer(G4DAWNFILES <<
60 const G4Str <<
61 : G4VViewer(sceneHandler, sceneHandler.Incre <<
62 , fSceneHandler(sceneHandler) <<
63 { <<
64 // Set a g4.prim-file viewer <<
65 strcpy(fG4PrimViewer, "dawn"); <<
66 if(std::getenv("G4DAWNFILE_VIEWER") != NULL) <<
67 { <<
68 strcpy(fG4PrimViewer, std::getenv("G4DAWNF <<
69 } <<
70 55
71 // string for viewer invocation <<
72 if(!strcmp(fG4PrimViewer, "NONE")) <<
73 { <<
74 strcpy(fG4PrimViewerInvocation, ""); <<
75 } <<
76 else <<
77 { <<
78 strcpy(fG4PrimViewerInvocation, fG4PrimVie <<
79 strcat(fG4PrimViewerInvocation, " "); <<
80 strcat(fG4PrimViewerInvocation, fSceneHand <<
81 } <<
82 56
83 // Set a PostScript Viewer << 57 //----- constants
84 // strcpy( fPSViewer, "ghostview" ); << 58 const char FR_ENV_MULTI_WINDOW [] = "G4DAWN_MULTI_WINDOW" ;
85 strcpy(fPSViewer, "gv"); << 59 const char FR_ENV_MULTI_WINDOW2[] = "G4DAWNFILE_MULTI_WINDOW" ;
86 if(std::getenv("G4DAWNFILE_PS_VIEWER") != NU << 60
87 { << 61 //----- G4DAWNFILEViewer, constructor
88 strcpy(fPSViewer, std::getenv("G4DAWNFILE_ << 62 G4DAWNFILEViewer::G4DAWNFILEViewer (G4DAWNFILESceneHandler& sceneHandler,
89 } << 63 const G4String& name):
>> 64 G4VViewer (sceneHandler,
>> 65 sceneHandler.IncrementViewCount (),
>> 66 name),
>> 67 fSceneHandler (sceneHandler)
>> 68 {
>> 69 // Set a g4.prim-file viewer
>> 70 strcpy( fG4PrimViewer, "dawn" );
>> 71 if( std::getenv( "G4DAWNFILE_VIEWER" ) != NULL ) {
>> 72 strcpy( fG4PrimViewer, std::getenv( "G4DAWNFILE_VIEWER" ) ) ;
>> 73 }
>> 74
>> 75 // string for viewer invocation
>> 76 if ( !strcmp( fG4PrimViewer, "NONE" ) ) {
>> 77
>> 78 strcpy( fG4PrimViewerInvocation, "" );
>> 79 } else {
>> 80
>> 81 strcpy( fG4PrimViewerInvocation, fG4PrimViewer );
>> 82 strcat( fG4PrimViewerInvocation, " ");
>> 83 strcat( fG4PrimViewerInvocation, fSceneHandler.GetG4PrimFileName() );
>> 84 }
>> 85
>> 86 // Set a PostScript Viewer
>> 87 // strcpy( fPSViewer, "ghostview" );
>> 88 strcpy( fPSViewer, "gv" );
>> 89 if( std::getenv( "G4DAWNFILE_PS_VIEWER" ) != NULL ) {
>> 90 strcpy( fPSViewer, std::getenv( "G4DAWNFILE_PS_VIEWER" ) ) ;
>> 91 }
>> 92
90 } 93 }
91 94
92 //----- G4DAWNFILEViewer, destructor << 95 //----- G4DAWNFILEViewer, destructor
93 G4DAWNFILEViewer::~G4DAWNFILEViewer() {} << 96 G4DAWNFILEViewer::~G4DAWNFILEViewer ()
>> 97 {}
94 98
95 //----- G4DAWNFILEViewer::SetView () << 99 //----- G4DAWNFILEViewer::SetView ()
96 void G4DAWNFILEViewer::SetView() << 100 void G4DAWNFILEViewer::SetView ()
97 { 101 {
98 #if defined DEBUG_FR_VIEW 102 #if defined DEBUG_FR_VIEW
99 if(G4VisManager::GetVerbosity() >= G4VisMana << 103 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
100 G4cout << "***** G4DAWNFILEViewer::SetView 104 G4cout << "***** G4DAWNFILEViewer::SetView(): No effects" << G4endl;
101 #endif << 105 #endif
102 // Do nothing, since DAWN is running as a di << 106 // Do nothing, since DAWN is running as a different process.
103 // SendViewParameters () will do this job in << 107 // SendViewParameters () will do this job instead.
104 } 108 }
105 109
106 //----- G4DAWNFILEViewer::ClearView() << 110
107 void G4DAWNFILEViewer::ClearView(void) << 111 //----- G4DAWNFILEViewer::ClearView()
>> 112 void
>> 113 G4DAWNFILEViewer::ClearView( void )
108 { 114 {
109 #if defined DEBUG_FR_VIEW 115 #if defined DEBUG_FR_VIEW
110 if(G4VisManager::GetVerbosity() >= G4VisMana << 116 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
111 G4cout << "***** G4DAWNFILEViewer::ClearVi << 117 G4cout << "***** G4DAWNFILEViewer::ClearView (): No effects " << G4endl;
112 #endif 118 #endif
113 if(fSceneHandler.fPrimDest.IsOpen()) << 119 if (fSceneHandler.fPrimDest.IsOpen()) {
114 { << 120 fSceneHandler.fPrimDest.Close();
115 fSceneHandler.fPrimDest.Close(); << 121 // Re-open with same filename...
116 // Re-open with same filename... << 122 fSceneHandler.fPrimDest.Open(fSceneHandler.fG4PrimFileName);
117 fSceneHandler.fPrimDest.Open(fSceneHandler << 123 fSceneHandler.SendStr( FR_G4_PRIM_HEADER );
118 fSceneHandler.SendStr(FR_G4_PRIM_HEADER); << 124 fSceneHandler.FRflag_in_modeling = false;
119 fSceneHandler.FRflag_in_modeling = false; << 125 fSceneHandler.FRBeginModeling();
120 fSceneHandler.FRBeginModeling(); << 126 }
121 } <<
122 } 127 }
123 128
124 //----- G4DAWNFILEViewer::DrawView () << 129
125 void G4DAWNFILEViewer::DrawView() << 130 //----- G4DAWNFILEViewer::DrawView ()
>> 131 void G4DAWNFILEViewer::DrawView ()
126 { 132 {
127 #if defined DEBUG_FR_VIEW 133 #if defined DEBUG_FR_VIEW
128 if(G4VisManager::GetVerbosity() >= G4VisMana << 134 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
129 G4cout << "***** G4DAWNFILEViewer::DrawVie << 135 G4cout << "***** G4DAWNFILEViewer::DrawView () " << G4endl;
130 #endif 136 #endif
131 //----- << 137 //-----
132 fSceneHandler.FRBeginModeling(); << 138 fSceneHandler.FRBeginModeling() ;
>> 139
>> 140 //----- Always visit G4 kernel
>> 141 NeedKernelVisit ();
>> 142
>> 143 //----- Draw
>> 144 ProcessView () ;
133 145
134 //----- Always visit G4 kernel << 146 } // G4DAWNFILEViewer::DrawView ()
135 NeedKernelVisit(); <<
136 147
137 //----- Draw <<
138 ProcessView(); <<
139 148
140 } // G4DAWNFILEViewer::DrawView () <<
141 149
142 //----- G4DAWNFILEViewer::ShowView() << 150 //----- G4DAWNFILEViewer::ShowView()
143 void G4DAWNFILEViewer::ShowView(void) << 151 void G4DAWNFILEViewer::ShowView( void )
144 { 152 {
145 #if defined DEBUG_FR_VIEW 153 #if defined DEBUG_FR_VIEW
146 if(G4VisManager::GetVerbosity() >= G4VisMana << 154 if (G4VisManager::GetVerbosity() >= G4VisManager::errors)
147 G4cout << "***** G4DAWNFILEViewer::ShowVie << 155 G4cout << "***** G4DAWNFILEViewer::ShowView () " << G4endl;
148 #endif 156 #endif
149 157
150 if(fSceneHandler.FRIsInModeling()) << 158 if( fSceneHandler.FRIsInModeling() )
151 { << 159 {
152 //----- End of modeling << 160 //----- End of modeling
153 // !EndModeling, !DrawAll, !CloseDevice, << 161 // !EndModeling, !DrawAll, !CloseDevice,
154 // close g4.prim << 162 // close g4.prim
155 fSceneHandler.FREndModeling(); << 163 fSceneHandler.FREndModeling();
156 << 164
157 //----- Output DAWN GUI file << 165 //----- Output DAWN GUI file
158 SendViewParameters(); << 166 SendViewParameters();
159 << 167
160 //----- string for viewer invocation << 168 //----- string for viewer invocation
161 if(!strcmp(fG4PrimViewer, "NONE")) << 169 if ( !strcmp( fG4PrimViewer, "NONE" ) ) {
162 { << 170
163 strcpy(fG4PrimViewerInvocation, ""); << 171 strcpy( fG4PrimViewerInvocation, "" );
164 } << 172 } else {
165 else << 173
166 { << 174 strcpy( fG4PrimViewerInvocation, fG4PrimViewer );
167 strcpy(fG4PrimViewerInvocation, fG4PrimV << 175 strcat( fG4PrimViewerInvocation, " ");
168 strcat(fG4PrimViewerInvocation, " "); << 176 strcat( fG4PrimViewerInvocation, fSceneHandler.GetG4PrimFileName() );
169 strcat(fG4PrimViewerInvocation, fSceneHa << 177 }
170 } << 178
171 << 179
172 //----- Invoke DAWN << 180 //----- Invoke DAWN
173 G4cout << G4endl; << 181 G4cout << G4endl ;
174 if(false == G4FRofstream::DoesFileExist(fS << 182 if( false == G4FRofstream::DoesFileExist( fSceneHandler.GetG4PrimFileName() ) )
175 { << 183 {
176 G4cout << "ERROR: Failed to generate fil << 184 G4cout << "ERROR: Failed to generate file ";
177 G4cout << fSceneHandler.GetG4PrimFileNam << 185 G4cout << fSceneHandler.GetG4PrimFileName() << G4endl;
178 } << 186
179 else if(strcmp(GetG4PrimViewerInvocation() << 187 } else if( strcmp( GetG4PrimViewerInvocation(), "" ) )
180 { << 188 {
181 G4cout << "File " << fSceneHandler.GetG << 189 G4cout << "File " << fSceneHandler.GetG4PrimFileName() ;
182 G4cout << " is generated." << G4endl; << 190 G4cout << " is generated." << G4endl;
183 G4cout << GetG4PrimViewerInvocation() << << 191 G4cout << GetG4PrimViewerInvocation() << G4endl;
184 int iErr = system(GetG4PrimViewerInvocat << 192 (void) system( GetG4PrimViewerInvocation() );
185 if(iErr != 0) << 193
186 { << 194 } else { // no view, i.e., only file generation
187 G4ExceptionDescription ed; << 195 G4cout << "File " << fSceneHandler.GetG4PrimFileName() ;
188 ed << "Error " << iErr << " when calli << 196 G4cout << " is generated." << G4endl;
189 << GetG4PrimViewerInvocation() << " << 197 G4cout << "No viewer is invoked." << G4endl;
190 G4Exception("G4DAWNFILEViewer::ShowVie << 198 }
191 ed); << 199
192 } << 200 }
193 } <<
194 else <<
195 { // no view, i.e., only file generation <<
196 G4cout << "File " << fSceneHandler.GetG <<
197 G4cout << " is generated." << G4endl; <<
198 G4cout << "No viewer is invoked." << G4e <<
199 } <<
200 } <<
201 201
202 } // G4DAWNFILEViewer::ShowView() << 202 } // G4DAWNFILEViewer::ShowView()
203 203
204 //----- G4DAWNFILEViewer::SendDrawingStyleToDA << 204
205 void G4DAWNFILEViewer::SendDrawingStyleToDAWNG << 205 //----- G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI( std::ostream& out )
>> 206 void G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI( std::ostream& out )
206 { 207 {
207 /////////////////////// << 208 ///////////////////////
208 //#if defined DEBUG_FR_VIEW << 209 //#if defined DEBUG_FR_VIEW
209 // G4cout << "***** G4DAWNFILEViewer::SendD << 210 // G4cout << "***** G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI()" << G4endl;
210 //#endif << 211 //#endif
211 ////////////////////// << 212 //////////////////////
212 << 213
213 G4int style = fVP.GetDrawingStyle(); << 214 G4int style = fVP.GetDrawingStyle();
214 << 215
215 enum << 216 enum { FR_WIREFRAME_STYLE = 1, FR_WF_STORED_STYLE = 2,
216 { << 217 FR_HID_STYLE = 3, FR_HID2_STYLE = 4,
217 FR_WIREFRAME_STYLE = 1, << 218 FR_HID3_STYLE = 5, FR_DRAWING_MODE_END_STYLE = 6 };
218 FR_WF_STORED_STYLE = 2, << 219
219 FR_HID_STYLE = 3, << 220 switch( style )
220 FR_HID2_STYLE = 4, << 221 {
221 FR_HID3_STYLE = 5, << 222 case G4ViewParameters::wireframe:
222 FR_DRAWING_MODE_END_STYLE = 6 << 223 out << FR_WIREFRAME_STYLE << G4endl;
223 }; << 224 break;
224 << 225 case G4ViewParameters::hlr:
225 switch(style) << 226 out << FR_HID2_STYLE << G4endl; // LINE
226 { << 227 break;
227 case G4ViewParameters::wireframe: << 228 case G4ViewParameters::hsr:
228 out << FR_WIREFRAME_STYLE << G4endl; << 229 case G4ViewParameters::hlhsr:
229 break; << 230 out << FR_HID_STYLE << G4endl; // SURFACE
230 case G4ViewParameters::hlr: << 231 break;
231 out << FR_HID2_STYLE << G4endl; // LINE << 232 default:
232 break; << 233 out << FR_WIREFRAME_STYLE << G4endl;
233 case G4ViewParameters::hsr: << 234 break;
234 case G4ViewParameters::hlhsr: << 235 }
235 out << FR_HID_STYLE << G4endl; // SURFA <<
236 break; <<
237 default: <<
238 out << FR_WIREFRAME_STYLE << G4endl; <<
239 break; <<
240 } <<
241 236
242 } // G4DAWNFILEViewer::SendDrawingStyle() << 237 } // G4DAWNFILEViewer::SendDrawingStyle()
243 238
244 //----- << 239
245 void G4DAWNFILEViewer::SendViewParameters() << 240
>> 241 //-----
>> 242 void G4DAWNFILEViewer::SendViewParameters ()
246 { 243 {
247 // Calculates view representation based on e 244 // Calculates view representation based on extent of object being
248 // viewed and (initial) direction of camera. 245 // viewed and (initial) direction of camera. (Note: it can change
249 // later due to user interaction via visuali 246 // later due to user interaction via visualization system's GUI.)
250 247
251 #if defined DEBUG_FR_VIEW 248 #if defined DEBUG_FR_VIEW
252 if(G4VisManager::GetVerbosity() >= G4VisMana << 249 if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
253 { << 250 G4cout << "***** G4DAWNFILEViewer::SendViewParameters() ";
254 G4cout << "***** G4DAWNFILEViewer::SendVie <<
255 G4cout << "(GUI parameters)" << G4endl; 251 G4cout << "(GUI parameters)" << G4endl;
256 } 252 }
257 #endif << 253 #endif
258 <<
259 //----- Magic number to decide camera distan <<
260 const G4double HOW_FAR = 1000.0; // <<
261 const G4double MIN_HALF_ANGLE = 0.01; <<
262 const G4double MAX_HALF_ANGLE = 0.499 * pi; <<
263 <<
264 //----- CALC camera distance <<
265 //..... Note: Camera cannot enter inside obj <<
266 G4double camera_distance; <<
267 G4double radius = fSceneHandler.GetScene()-> <<
268 <<
269 G4double half_view_angle = std::fabs(fVP.Get <<
270 if(half_view_angle > MAX_HALF_ANGLE) <<
271 { <<
272 half_view_angle = MAX_HALF_ANGLE; <<
273 } <<
274 254
275 if(half_view_angle < MIN_HALF_ANGLE) << 255 //----- Magic number to decide camera distance automatically
276 { << 256 const G4double HOW_FAR = 1000.0 ; // to define "infinity"
277 //----- infinity (or ortho projection) << 257 const G4double MIN_HALF_ANGLE = 0.01 ;
278 camera_distance = radius * HOW_FAR; << 258 const G4double MAX_HALF_ANGLE = 0.499 * pi ;
279 } << 259
280 else << 260 //----- CALC camera distance
281 { << 261 //..... Note: Camera cannot enter inside object
282 //----- Calc camera distance from half vie << 262 G4double camera_distance ;
283 camera_distance = radius / std::sin(half_v << 263 G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
284 camera_distance -= fVP.GetDolly(); << 264
285 } << 265 G4double half_view_angle = std::fabs ( fVP.GetFieldHalfAngle () ) ;
286 << 266 if( half_view_angle > MAX_HALF_ANGLE ) {
287 if(camera_distance < radius) << 267 half_view_angle = MAX_HALF_ANGLE ;
288 { << 268 }
289 if(G4VisManager::GetVerbosity() >= G4VisMa << 269
290 { << 270 if( half_view_angle < MIN_HALF_ANGLE ) {
291 G4cout << "WARNING from DAWNFILE driver: << 271 //----- infinity (or ortho projection)
292 G4cout << " Camera cannot enter inside << 272 camera_distance = radius * HOW_FAR ;
293 } << 273 } else {
294 camera_distance = radius; << 274 //----- Calc camera distance from half view angle
295 } << 275 camera_distance = radius / std::sin ( half_view_angle );
>> 276 camera_distance -= fVP.GetDolly();
>> 277 }
>> 278
>> 279 if ( camera_distance < radius ) {
>> 280 if (G4VisManager::GetVerbosity() >= G4VisManager::errors) {
>> 281 G4cout << "WARNING from DAWNFILE driver:" << G4endl;
>> 282 G4cout << " Camera cannot enter inside objects" << G4endl;
>> 283 }
>> 284 camera_distance = radius ;
>> 285 }
>> 286
>> 287 //----- CALC camera direction
>> 288 const G4Vector3D& camera_direction \
>> 289 = fVP.GetViewpointDirection().unit();
>> 290 const G4double v_angle = (180.0 / pi) * camera_direction.theta() ;
>> 291 const G4double h_angle = (180.0 / pi) * camera_direction.phi () ;
>> 292
>> 293
>> 294 //########### Generation of the file .DAWN.history for DAWN GUI
>> 295 //-----
>> 296 std::ofstream gui_out (".DAWN_1.history") ;
>> 297
>> 298 // ######### P1
>> 299
>> 300 //----- camera position
>> 301 gui_out << camera_distance << G4endl;
>> 302 gui_out << v_angle << G4endl ;
>> 303 gui_out << h_angle << G4endl ;
>> 304 gui_out << "0" << G4endl ; // auto target
>> 305
>> 306 //----- target point
>> 307 const G4Point3D& target_point
>> 308 = fSceneHandler.GetScene()->GetStandardTargetPoint()
>> 309 + fVP.GetCurrentTargetPoint();
>> 310 gui_out << target_point.x() << G4endl ;
>> 311 gui_out << target_point.y() << G4endl ;
>> 312 gui_out << target_point.z() << G4endl ;
>> 313
>> 314 //----- Magnification
>> 315 const G4double zoom_factor = fVP.GetZoomFactor();
>> 316 if( half_view_angle < MIN_HALF_ANGLE ) {
>> 317
>> 318 gui_out << zoom_factor << G4endl;
>> 319
>> 320 } else {
>> 321 const G4double FR_HALF_SCREEN_SIZE = 0.5 ;
>> 322 G4double focal_distance \
>> 323 = FR_HALF_SCREEN_SIZE / std::tan( half_view_angle );
>> 324 focal_distance *= zoom_factor ;
>> 325
>> 326 gui_out << "fd" << focal_distance << G4endl;
>> 327
>> 328 }
>> 329 SendDrawingStyleToDAWNGUI( gui_out ) ; // gui_out, viewing mode
>> 330 gui_out << "0.001" << G4endl ; // 3D Tolerance
>> 331 gui_out << "0" << G4endl ; // not display parameters
>> 332
>> 333
>> 334 // ######### P2
>> 335 gui_out << 1 << G4endl; // Source light
>> 336 gui_out << 1 << G4endl;
>> 337 gui_out << 1 << G4endl;
>> 338 gui_out << 0.5 << G4endl; // Ambient light
>> 339 gui_out << 0.5 << G4endl;
>> 340 gui_out << 0.5 << G4endl;
>> 341 gui_out << 19.0 << G4endl; // Light direction (Polar)
>> 342 gui_out << 71.0 << G4endl; // Light direction (Azimuthal)
>> 343
>> 344 // ######### P3
>> 345 gui_out << 0.1 << G4endl; // Real edge width
>> 346 gui_out << 0.1 << G4endl; // outline width
>> 347 gui_out << 0.1 << G4endl; // aux edge width
>> 348 gui_out << 3 << G4endl; // aux edge style
>> 349 gui_out << 70.0<< G4endl; // aux-edge threshold angle
>> 350 gui_out << 0.1 << G4endl; // line width
>> 351 gui_out << 0 << G4endl; // haloing
>> 352 gui_out << 1 << G4endl; // Dashed edged for back faces
296 353
297 //----- CALC camera direction << 354 //######### P4
298 const G4Vector3D& camera_direction = fVP.Get << 355 //----- drawing device
299 const G4double v_angle = (180.0 <<
300 const G4double h_angle = (180.0 <<
301 <<
302 //########### Generation of the file .DAWN.h <<
303 //----- <<
304 std::ofstream gui_out(".DAWN_1.history"); <<
305 <<
306 // ######### P1 <<
307 <<
308 //----- camera position <<
309 gui_out << camera_distance << G4endl; <<
310 gui_out << v_angle << G4endl; <<
311 gui_out << h_angle << G4endl; <<
312 gui_out << "0" << G4endl; // auto target <<
313 <<
314 //----- target point <<
315 const G4Point3D& target_point = <<
316 fSceneHandler.GetScene()->GetStandardTarge <<
317 fVP.GetCurrentTargetPoint(); <<
318 gui_out << target_point.x() << G4endl; <<
319 gui_out << target_point.y() << G4endl; <<
320 gui_out << target_point.z() << G4endl; <<
321 <<
322 //----- Magnification <<
323 const G4double zoom_factor = fVP.GetZoomFact <<
324 if(half_view_angle < MIN_HALF_ANGLE) <<
325 { <<
326 gui_out << zoom_factor << G4endl; <<
327 } <<
328 else <<
329 { <<
330 const G4double FR_HALF_SCREEN_SIZE = 0.5; <<
331 G4double focal_distance = FR_HALF_SCREEN_S <<
332 focal_distance *= zoom_factor; <<
333 <<
334 gui_out << "fd" << focal_distance << G4end <<
335 } <<
336 SendDrawingStyleToDAWNGUI(gui_out); // gui_ <<
337 gui_out << "0.001" << G4endl; // 3D T <<
338 gui_out << "0" << G4endl; // not <<
339 <<
340 // ######### P2 <<
341 gui_out << 1 << G4endl; // Source light <<
342 gui_out << 1 << G4endl; <<
343 gui_out << 1 << G4endl; <<
344 gui_out << 0.5 << G4endl; // Ambient light <<
345 gui_out << 0.5 << G4endl; <<
346 gui_out << 0.5 << G4endl; <<
347 gui_out << 19.0 << G4endl; // Light directi <<
348 gui_out << 71.0 << G4endl; // Light directi <<
349 <<
350 // ######### P3 <<
351 gui_out << 0.1 << G4endl; // Real edge wid <<
352 gui_out << 0.1 << G4endl; // outline wid <<
353 gui_out << 0.1 << G4endl; // aux edge wid <<
354 gui_out << 3 << G4endl; // aux edge sty <<
355 gui_out << 70.0 << G4endl; // aux-edge thre <<
356 gui_out << 0.1 << G4endl; // line width <<
357 gui_out << 0 << G4endl; // haloing <<
358 gui_out << 1 << G4endl; // Dashed edged <<
359 <<
360 //######### P4 <<
361 //----- drawing device <<
362 // enum {PS=1, XWIN=2, PS2=3, XWIN2=4, OPEN 356 // enum {PS=1, XWIN=2, PS2=3, XWIN2=4, OPEN_GL=5, DEVICE_END=6};
363 if(((std::getenv(FR_ENV_MULTI_WINDOW) != NUL << 357 if( ( ( std::getenv( FR_ENV_MULTI_WINDOW ) != NULL ) && \
364 (strcmp(std::getenv(FR_ENV_MULTI_WINDOW) << 358 ( strcmp( std::getenv( FR_ENV_MULTI_WINDOW ),"0" ) ) ) || \
365 ((std::getenv(FR_ENV_MULTI_WINDOW2) != NU << 359 ( ( std::getenv( FR_ENV_MULTI_WINDOW2 ) != NULL ) && \
366 (strcmp(std::getenv(FR_ENV_MULTI_WINDOW2 << 360 ( strcmp( std::getenv( FR_ENV_MULTI_WINDOW2 ),"0" ) ) ) )
367 { << 361 {
368 gui_out << 2 << G4endl; // OpenWindow << 362 gui_out << 2 << G4endl; // OpenWindow
369 } << 363 } else {
370 else << 364 gui_out << 1 << G4endl; // Invoke PS viewer
371 { << 365 }
372 gui_out << 1 << G4endl; // Invoke PS view << 366
373 } << 367 gui_out << GetPSViewer() << G4endl; // PS viewer
>> 368 gui_out << 1 << G4endl ; // Do not add showpage
>> 369 gui_out << 0 << G4endl ; // Non-append mode
374 370
375 gui_out << GetPSViewer() << G4endl; // PS v << 371 gui_out.close();
376 gui_out << 1 << G4endl; // Do n << 372 //########### end of generating file .DAWN.history
377 gui_out << 0 << G4endl; // Non- <<
378 373
379 gui_out.close(); << 374
380 //########### end of generating file .DAWN.h << 375 }
381 } <<
382 376