Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4Scene.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/management/src/G4Scene.cc (Version 11.3.0) and /visualization/management/src/G4Scene.cc (Version 9.1)


  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: G4Scene.cc,v 1.23 2006/11/26 15:51:12 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-01 $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // Scene data  John Allison  19th July 1996.       31 // Scene data  John Allison  19th July 1996.
 30                                                    32 
 31 #include "G4Scene.hh"                              33 #include "G4Scene.hh"
 32                                                    34 
 33 #include "G4Vector3D.hh"                           35 #include "G4Vector3D.hh"
 34 #include "G4BoundingExtentScene.hh"            <<  36 #include "G4BoundingSphereScene.hh"
 35 #include "G4VisAttributes.hh"                      37 #include "G4VisAttributes.hh"
 36 #include "G4PhysicalVolumeModel.hh"                38 #include "G4PhysicalVolumeModel.hh"
 37 #include "G4TransportationManager.hh"              39 #include "G4TransportationManager.hh"
 38                                                    40 
 39 #include <set>                                 << 
 40                                                << 
 41 #define G4warn G4cout                          << 
 42                                                << 
 43 G4Scene::G4Scene (const G4String& name):           41 G4Scene::G4Scene (const G4String& name):
 44   fName (name),                                    42   fName (name),
 45   fRefreshAtEndOfEvent(true),                      43   fRefreshAtEndOfEvent(true),
 46   fRefreshAtEndOfRun(true),                        44   fRefreshAtEndOfRun(true),
 47   fMaxNumberOfKeptEvents(100)                  <<  45   fMaxNumberOfKeptEvents(0)
 48 {} // Note all other data members have default     46 {} // Note all other data members have default initial values.
 49                                                    47 
 50 G4Scene::~G4Scene () {}                            48 G4Scene::~G4Scene () {}
 51                                                    49 
 52 namespace {                                    <<  50 G4bool G4Scene::AddRunDurationModel (G4VModel* pModel, G4bool warn) {
 53   void PrintInvalidModel(const G4VModel* model <<  51   std::vector<G4VModel*>::const_iterator i;
 54   {                                            <<  52   for (i = fRunDurationModelList.begin ();
 55     G4ExceptionDescription ed;                 <<  53        i != fRunDurationModelList.end (); ++i) {
 56     ed << "Invalid model \"" << model->GetGlob <<  54     if (pModel -> GetGlobalDescription () ==
 57     << "\".\n  Not included in extent calculat <<  55   (*i) -> GetGlobalDescription ()) break;
 58     G4Exception                                << 
 59     ("G4Scene::CalculateExtent",               << 
 60      "visman0201", JustWarning, ed);           << 
 61   }                                            << 
 62 }                                              << 
 63                                                << 
 64 void G4Scene::CalculateExtent ()               << 
 65 {                                              << 
 66   G4BoundingExtentScene boundingExtentScene;   << 
 67                                                << 
 68   for (size_t i = 0; i < fRunDurationModelList << 
 69     if (fRunDurationModelList[i].fActive) {    << 
 70       G4VModel* model = fRunDurationModelList[ << 
 71       if (model -> Validate()) {               << 
 72         const G4VisExtent& thisExtent = model  << 
 73         if (thisExtent != G4VisExtent::GetNull << 
 74           boundingExtentScene.AccrueBoundingEx << 
 75         }                                      << 
 76       } else {                                 << 
 77         PrintInvalidModel(model);              << 
 78       }                                        << 
 79     }                                          << 
 80   }                                                56   }
 81                                                <<  57   if (i != fRunDurationModelList.end ()) {
 82   for (size_t i = 0; i < fEndOfEventModelList. <<  58     if (warn) {
 83     if (fEndOfEventModelList[i].fActive) {     <<  59       G4cout << "G4Scene::AddRunDurationModel: model \""
 84       G4VModel* model = fEndOfEventModelList[i <<  60        << pModel -> GetGlobalDescription ()
 85       if (model -> Validate()) {               <<  61        << "\"\n  is already in the run-duration list of scene \""
 86         const G4VisExtent& thisExtent = model  <<  62        << fName
 87         if (thisExtent != G4VisExtent::GetNull <<  63        << "\"."
 88           boundingExtentScene.AccrueBoundingEx <<  64        << G4endl;
 89         }                                      << 
 90       } else {                                 << 
 91         PrintInvalidModel(model);              << 
 92       }                                        << 
 93     }                                              65     }
                                                   >>  66     return false;
 94   }                                                67   }
                                                   >>  68   fRunDurationModelList.push_back (pModel);
                                                   >>  69   CalculateExtent ();
                                                   >>  70   return true;
                                                   >>  71 }
 95                                                    72 
 96   for (size_t i = 0; i < fEndOfRunModelList.si <<  73 void G4Scene::CalculateExtent () {
 97     if (fEndOfRunModelList[i].fActive) {       <<  74   G4int nModels = fRunDurationModelList.size ();
 98       G4VModel* model = fEndOfRunModelList[i]. <<  75   G4BoundingSphereScene boundingSphereScene;
 99       if (model -> Validate()) {               <<  76   for (G4int i = 0; i < nModels; i++) {
100         const G4VisExtent& thisExtent = model  <<  77     const G4VisExtent& thisExtent =
101         if (thisExtent != G4VisExtent::GetNull <<  78       fRunDurationModelList[i] -> GetExtent ();
102           boundingExtentScene.AccrueBoundingEx <<  79     G4Point3D thisCentre = thisExtent.GetExtentCentre ();
103         }                                      <<  80     G4double thisRadius = thisExtent.GetExtentRadius ();
104       } else {                                 <<  81     thisCentre.transform (fRunDurationModelList[i] -> GetTransformation ());
105         PrintInvalidModel(model);              <<  82     boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
106       }                                        << 
107     }                                          << 
108   }                                                83   }
109                                                <<  84   fExtent = boundingSphereScene.GetBoundingSphereExtent ();
110   fExtent = boundingExtentScene.GetBoundingExt << 
111   fStandardTargetPoint = fExtent.GetExtentCent     85   fStandardTargetPoint = fExtent.GetExtentCentre ();
112   if (fExtent.GetExtentRadius() <= 0.) {       << 
113   G4Exception                                  << 
114     ("G4Scene::CalculateExtent",               << 
115      "visman0202", JustWarning,                << 
116      "Scene has no extent.  Please activate or << 
117      "\nThe camera needs to have something to  << 
118            "\nAdd a volume. (You may need \"/r << 
119            "\nOr use \"/vis/scene/add/extent\" << 
120      "\n\"/vis/scene/list\" to see list of mod << 
121   }                                            << 
122 }                                                  86 }
123                                                    87 
124 G4bool G4Scene::AddWorldIfEmpty (G4bool warn)      88 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) {
125   G4bool successful = true;                        89   G4bool successful = true;
126   if (IsEmpty ()) {                                90   if (IsEmpty ()) {
127     successful = false;                            91     successful = false;
128     G4VPhysicalVolume* pWorld =                    92     G4VPhysicalVolume* pWorld =
129       G4TransportationManager::GetTransportati     93       G4TransportationManager::GetTransportationManager ()
130       -> GetNavigatorForTracking () -> GetWorl     94       -> GetNavigatorForTracking () -> GetWorldVolume ();
131     if (pWorld) {                                  95     if (pWorld) {
132       const G4VisAttributes* pVisAttribs =         96       const G4VisAttributes* pVisAttribs =
133   pWorld -> GetLogicalVolume () -> GetVisAttri     97   pWorld -> GetLogicalVolume () -> GetVisAttributes ();
134       if (!pVisAttribs || pVisAttribs -> IsVis     98       if (!pVisAttribs || pVisAttribs -> IsVisible ()) {
135   if (warn) {                                      99   if (warn) {
136     G4warn <<                                  << 100     G4cout << 
137       "Your \"world\" has no vis attributes or    101       "Your \"world\" has no vis attributes or is marked as visible."
138       "\n  For a better view of the contents,     102       "\n  For a better view of the contents, mark the world as"
139       " invisible, e.g.,"                         103       " invisible, e.g.,"
140       "\n  myWorldLogicalVol ->"                  104       "\n  myWorldLogicalVol ->"
141     " SetVisAttributes (G4VisAttributes::GetIn << 105       " SetVisAttributes (G4VisAttributes::Invisible);"
142      << G4endl;                                   106      << G4endl;
143   }                                               107   }
144       }                                           108       }
145       successful = AddRunDurationModel (new G4    109       successful = AddRunDurationModel (new G4PhysicalVolumeModel (pWorld));
146       // Note: default depth and no modeling p    110       // Note: default depth and no modeling parameters.
147       if (successful) {                           111       if (successful) {
148   if (warn) {                                     112   if (warn) {
149     G4warn <<                                  << 113     G4cout <<
150     "G4Scene::AddWorldIfEmpty: The scene had n << 114     "G4Scene::AddWorldIfEmpty: The scene was empty of run-duration models."
151     "\n  \"world\" has been added.";              115     "\n  \"world\" has been added.";
152     G4warn << G4endl;                          << 116     G4cout << G4endl;
153   }                                               117   }
154       }                                           118       }
155     }                                             119     }
156   }                                               120   }
157   return successful;                              121   return successful;
158 }                                                 122 }
159                                                   123 
160 G4bool G4Scene::AddRunDurationModel (G4VModel* << 
161 {                                              << 
162   std::vector<Model>::const_iterator i;        << 
163   for (i = fRunDurationModelList.begin ();     << 
164        i != fRunDurationModelList.end (); ++i) << 
165     if (pModel -> GetGlobalDescription () ==   << 
166   i->fpModel->GetGlobalDescription ()) break;  << 
167   }                                            << 
168   if (i != fRunDurationModelList.end ()) {     << 
169     if (warn) {                                << 
170       G4warn << "G4Scene::AddRunDurationModel: << 
171       << pModel -> GetGlobalDescription ()     << 
172       << "\"\n  is already in the run-duration << 
173       << fName                                 << 
174       << "\"."                                 << 
175       << G4endl;                               << 
176     }                                          << 
177     return false;                              << 
178   }                                            << 
179   fRunDurationModelList.push_back (Model(pMode << 
180   CalculateExtent ();                          << 
181   return true;                                 << 
182 }                                              << 
183                                                << 
184 G4bool G4Scene::AddEndOfEventModel (G4VModel*     124 G4bool G4Scene::AddEndOfEventModel (G4VModel* pModel, G4bool warn) {
185   std::size_t i, nModels = fEndOfEventModelLis << 125   G4int i, nModels = fEndOfEventModelList.size ();
186   for (i = 0; i < nModels; ++i) {              << 126   for (i = 0; i < nModels; i++) {
187     if (pModel -> GetGlobalDescription () ==      127     if (pModel -> GetGlobalDescription () ==
188   fEndOfEventModelList[i].fpModel -> GetGlobal << 128   fEndOfEventModelList [i] -> GetGlobalDescription ()) break;
189   }                                               129   }
190   if (i < nModels) {                              130   if (i < nModels) {
                                                   >> 131     delete fEndOfEventModelList[i];
                                                   >> 132     fEndOfEventModelList[i] = pModel;
191     if (warn) {                                   133     if (warn) {
192       G4warn << "G4Scene::AddEndOfEventModel:  << 134       G4cout << "G4Scene::AddEndOfEventModel: a model \""
193        << pModel -> GetGlobalDescription ()       135        << pModel -> GetGlobalDescription ()
194        << "\"\n  is already in the end-of-even    136        << "\"\n  is already in the end-of-event list of scene \""
195        << fName << "\"."                       << 137        << fName <<
196        << G4endl;                              << 138   "\".\n  The old model has been deleted; this new model replaces it."
197     }                                          << 
198     return false;                              << 
199   }                                            << 
200   fEndOfEventModelList.push_back (Model(pModel << 
201   CalculateExtent ();                          << 
202   return true;                                 << 
203 }                                              << 
204                                                << 
205 G4bool G4Scene::AddEndOfRunModel (G4VModel* pM << 
206   std::size_t i, nModels = fEndOfRunModelList. << 
207   for (i = 0; i < nModels; ++i) {              << 
208     if (pModel -> GetGlobalDescription () ==   << 
209   fEndOfRunModelList[i].fpModel -> GetGlobalDe << 
210   }                                            << 
211   if (i < nModels) {                           << 
212     if (warn) {                                << 
213       G4warn << "G4Scene::AddEndOfRunModel: a  << 
214        << pModel -> GetGlobalDescription ()    << 
215        << "\"\n  is already in the end-of-run  << 
216        << fName << "\"."                       << 
217        << G4endl;                                 139        << G4endl;
218     }                                             140     }
219     return false;                              << 141     return true;  // Model replaced sucessfully.
220   }                                               142   }
221   fEndOfRunModelList.push_back (pModel);       << 143   fEndOfEventModelList.push_back (pModel);
222   CalculateExtent ();                          << 
223   return true;                                    144   return true;
224 }                                                 145 }
225                                                   146 
226 std::ostream& operator << (std::ostream& os, c << 147 std::ostream& operator << (std::ostream& os, const G4Scene& s) {
227                                                   148 
228   size_t i;                                       149   size_t i;
229                                                   150 
230   os << "Scene data:";                            151   os << "Scene data:";
231                                                   152 
232   os << "\n  Run-duration model list:";           153   os << "\n  Run-duration model list:";
233   if (scene.fRunDurationModelList.size () == 0 << 154   for (i = 0; i < s.fRunDurationModelList.size (); i++) {
234     os << " none";                             << 155     os << "\n  " << *(s.fRunDurationModelList[i]);
235   }                                            << 
236   for (i = 0; i < scene.fRunDurationModelList. << 
237     if (scene.fRunDurationModelList[i].fActive << 
238     else os << "\n  Inactive: ";               << 
239     os << *(scene.fRunDurationModelList[i].fpM << 
240   }                                               156   }
241                                                   157 
242   os << "\n  End-of-event model list:";           158   os << "\n  End-of-event model list:";
243   if (scene.fEndOfEventModelList.size () == 0) << 159   for (i = 0; i < s.fEndOfEventModelList.size (); i++) {
244     os << " none";                             << 160     os << "\n  " << *(s.fEndOfEventModelList[i]);
245   }                                            << 
246   for (i = 0; i < scene.fEndOfEventModelList.s << 
247     if (scene.fEndOfEventModelList[i].fActive) << 
248     else os << "\n  Inactive: ";               << 
249     os << *(scene.fEndOfEventModelList[i].fpMo << 
250   }                                            << 
251                                                << 
252   os << "\n  End-of-run model list:";          << 
253   if (scene.fEndOfRunModelList.size () == 0) { << 
254     os << " none";                             << 
255   }                                            << 
256   for (i = 0; i < scene.fEndOfRunModelList.siz << 
257     if (scene.fEndOfRunModelList[i].fActive) o << 
258     else os << "\n  Inactive: ";               << 
259     os << *(scene.fEndOfRunModelList[i].fpMode << 
260   }                                               161   }
261                                                   162 
262   os << "\n  Overall extent or bounding box: " << 163   os << "\n  Extent or bounding box: " << s.fExtent;
263                                                   164 
264   os << "\n  Standard target point:  " << scen << 165   os << "\n  Standard target point:  " << s.fStandardTargetPoint;
265                                                   166 
266   os << "\n  End of event action set to \"";      167   os << "\n  End of event action set to \"";
267   if (scene.fRefreshAtEndOfEvent) os << "refre << 168   if (s.fRefreshAtEndOfEvent) os << "refresh\"";
268   else {                                          169   else {
269     os << "accumulate (maximum number of kept     170     os << "accumulate (maximum number of kept events: ";
270     if (scene.fMaxNumberOfKeptEvents >= 0) os  << 171     if (s.fMaxNumberOfKeptEvents >= 0) os << s.fMaxNumberOfKeptEvents;
271     else os << "unlimited";                       172     else os << "unlimited";
272     os << ")";                                    173     os << ")";
273   }                                               174   }
274                                                   175 
275   os << "\n  End of run action set to \"";        176   os << "\n  End of run action set to \"";
276   if (scene.fRefreshAtEndOfRun) os << "refresh << 177   if (s.fRefreshAtEndOfRun) os << "refresh";
277   else os << "accumulate";                        178   else os << "accumulate";
278   os << "\"";                                     179   os << "\"";
279                                                   180 
280   return os;                                      181   return os;
281 }                                                 182 }
282                                                   183 
283 G4bool G4Scene::operator != (const G4Scene& sc << 184 G4bool G4Scene::operator != (const G4Scene& s) const {
284   if (                                            185   if (
285       (fRunDurationModelList.size () !=           186       (fRunDurationModelList.size () !=
286        scene.fRunDurationModelList.size ())    << 187        s.fRunDurationModelList.size ())                 ||
287       (fEndOfEventModelList.size () !=         << 188       (fExtent               != s.fExtent)              ||
288        scene.fEndOfEventModelList.size ())     << 189       !(fStandardTargetPoint == s.fStandardTargetPoint) ||
289       (fEndOfRunModelList.size () !=           << 190       fRefreshAtEndOfEvent   != s.fRefreshAtEndOfEvent  ||
290        scene.fEndOfRunModelList.size ())       << 191       fRefreshAtEndOfRun     != s.fRefreshAtEndOfRun    ||
291       (fExtent               != scene.fExtent) << 192       fMaxNumberOfKeptEvents != s.fMaxNumberOfKeptEvents
292       !(fStandardTargetPoint == scene.fStandar << 
293       fRefreshAtEndOfEvent   != scene.fRefresh << 
294       fRefreshAtEndOfRun     != scene.fRefresh << 
295       fMaxNumberOfKeptEvents != scene.fMaxNumb << 
296       ) return true;                              193       ) return true;
297                                                   194 
298   /* A complete comparison should, perhaps, in << 
299      individual models, but it is not easy to  << 
300      all models.  Also, it would be unfeasible << 
301      implement opeerator!= if we ever get roun << 
302      user-defined models.  Moreover, there is  << 
303      objects, apart from changing fRefreshAtEn << 
304      models are concerned, all you can ever do << 
305      on size (above) is enough.                << 
306                                                << 
307   for (size_t i = 0; i < fRunDurationModelList    195   for (size_t i = 0; i < fRunDurationModelList.size (); i++) {
308     if (fRunDurationModelList[i] != scene.fRun << 196     if (fRunDurationModelList[i] != s.fRunDurationModelList[i])
309       return true;                             << 
310   }                                            << 
311                                                << 
312   for (size_t i = 0; i < fEndOfEventModelList. << 
313     if (fEndOfEventModelList[i] != scene.fEndO << 
314       return true;                             << 
315   }                                            << 
316                                                << 
317   for (size_t i = 0; i < fEndOfRunModelList.si << 
318     if (fEndOfRunModelList[i] != scene.fEndOfR << 
319       return true;                                197       return true;
320   }                                               198   }
321   */                                           << 
322                                                   199 
323   return false;                                   200   return false;
324 }                                                 201 }
325                                                   202