Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/FukuiRenderer/src/G4DAWNFILEViewer.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/FukuiRenderer/src/G4DAWNFILEViewer.cc (Version 11.3.0) and /visualization/FukuiRenderer/src/G4DAWNFILEViewer.cc (Version 9.2.p1)


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