Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/modeling/src/G4ModelingParameters.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/modeling/src/G4ModelingParameters.cc (Version 11.3.0) and /visualization/modeling/src/G4ModelingParameters.cc (Version 5.0)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 //                                                 23 //
                                                   >>  24 // $Id: G4ModelingParameters.cc,v 1.5 2001/07/11 10:09:23 gunter Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-05-00 $
 27 //                                                 26 //
 28 //                                                 27 // 
 29 // John Allison  31st December 1997.               28 // John Allison  31st December 1997.
 30 // Parameters associated with the modeling of      29 // Parameters associated with the modeling of GEANT4 objects.
 31                                                    30 
 32 #include "G4ModelingParameters.hh"                 31 #include "G4ModelingParameters.hh"
 33                                                    32 
 34 #include "G4ios.hh"                                33 #include "G4ios.hh"
 35 #include "G4VisAttributes.hh"                      34 #include "G4VisAttributes.hh"
 36 #include "G4ExceptionSeverity.hh"              << 
 37 #include "G4SystemOfUnits.hh"                  << 
 38 #include "G4VSolid.hh"                         << 
 39 #include "G4DisplacedSolid.hh"                 << 
 40 #include "G4VPhysicalVolume.hh"                << 
 41 #include "G4PhysicalVolumeModel.hh"            << 
 42 #include "G4UnitsTable.hh"                     << 
 43                                                << 
 44 #define G4warn G4cout                          << 
 45                                                    35 
 46 G4ModelingParameters::G4ModelingParameters ():     36 G4ModelingParameters::G4ModelingParameters ():
 47   fWarning               (true),               << 
 48   fpDefaultVisAttributes (0),                      37   fpDefaultVisAttributes (0),
 49   fDrawingStyle          (wf),                 <<  38   fRepStyle              (polyhedron),
 50   fNumberOfCloudPoints   (10000),              << 
 51   fCulling               (false),                  39   fCulling               (false),
 52   fCullInvisible         (false),                  40   fCullInvisible         (false),
 53   fDensityCulling        (false),                  41   fDensityCulling        (false),
 54   fVisibleDensity        (0.01 * g / cm3),         42   fVisibleDensity        (0.01 * g / cm3),
 55   fCullCovered           (false),                  43   fCullCovered           (false),
 56   fCBDAlgorithmNumber    (0),                  << 
 57   fExplodeFactor         (1.),                 << 
 58   fNoOfSides             (24),                     44   fNoOfSides             (24),
 59   fpSectionSolid         (0),                  <<  45   fViewGeom              (true),
 60   fCutawayMode           (cutawayUnion),       <<  46   fViewHits              (true),
 61   fpCutawaySolid         (0),                  <<  47   fViewDigis             (true)
 62   fpEvent                (0),                  << 
 63   fSpecialMeshRendering  (false)               << 
 64 {}                                                 48 {}
 65                                                    49 
 66 G4ModelingParameters::G4ModelingParameters         50 G4ModelingParameters::G4ModelingParameters
 67 (const G4VisAttributes* pDefaultVisAttributes,     51 (const G4VisAttributes* pDefaultVisAttributes,
 68  G4ModelingParameters::DrawingStyle drawingSty <<  52  G4ModelingParameters::RepStyle repStyle,
 69  G4bool isCulling,                                 53  G4bool isCulling,
 70  G4bool isCullingInvisible,                        54  G4bool isCullingInvisible,
 71  G4bool isDensityCulling,                          55  G4bool isDensityCulling,
 72  G4double visibleDensity,                          56  G4double visibleDensity,
 73  G4bool isCullingCovered,                          57  G4bool isCullingCovered,
 74  G4int noOfSides                                   58  G4int noOfSides
 75  ):                                                59  ):
 76   fWarning        (true),                      << 
 77   fpDefaultVisAttributes (pDefaultVisAttribute     60   fpDefaultVisAttributes (pDefaultVisAttributes),
 78   fDrawingStyle   (drawingStyle),              <<  61   fRepStyle       (repStyle),
 79   fNumberOfCloudPoints (10000),                << 
 80   fCulling        (isCulling),                     62   fCulling        (isCulling),
 81   fCullInvisible  (isCullingInvisible),            63   fCullInvisible  (isCullingInvisible),
 82   fDensityCulling (isDensityCulling),              64   fDensityCulling (isDensityCulling),
 83   fVisibleDensity (visibleDensity),                65   fVisibleDensity (visibleDensity),
 84   fCullCovered    (isCullingCovered),              66   fCullCovered    (isCullingCovered),
 85   fCBDAlgorithmNumber (0),                     << 
 86   fExplodeFactor  (1.),                        << 
 87   fNoOfSides      (noOfSides),                     67   fNoOfSides      (noOfSides),
 88   fpSectionSolid  (0),                         <<  68   fViewGeom       (true),
 89   fCutawayMode    (cutawayUnion),              <<  69   fViewHits       (true),
 90   fpCutawaySolid  (0),                         <<  70   fViewDigis      (true)
 91   fpEvent         (0),                         << 
 92   fSpecialMeshRendering (false)                << 
 93 {}                                                 71 {}
 94                                                    72 
 95 G4ModelingParameters::~G4ModelingParameters () <<  73 G4ModelingParameters::G4ModelingParameters
 96 {                                              <<  74 (const G4VisAttributes* pDefaultVisAttributes,
 97   delete fpSectionSolid;                       <<  75  G4ModelingParameters::RepStyle repStyle,
 98   delete fpCutawaySolid;                       <<  76  G4bool isCulling,
 99 }                                              <<  77  G4bool isCullingInvisible,
                                                   >>  78  G4bool isDensityCulling,
                                                   >>  79  G4double visibleDensity,
                                                   >>  80  G4bool isCullingCovered,
                                                   >>  81  G4int noOfSides,
                                                   >>  82  G4bool isViewGeom,
                                                   >>  83  G4bool isViewHits,
                                                   >>  84  G4bool isViewDigis
                                                   >>  85  ):
                                                   >>  86   fpDefaultVisAttributes (pDefaultVisAttributes),
                                                   >>  87   fRepStyle       (repStyle),
                                                   >>  88   fCulling        (isCulling),
                                                   >>  89   fCullInvisible  (isCullingInvisible),
                                                   >>  90   fDensityCulling (isDensityCulling),
                                                   >>  91   fVisibleDensity (visibleDensity),
                                                   >>  92   fCullCovered    (isCullingCovered),
                                                   >>  93   fNoOfSides      (noOfSides),
                                                   >>  94   fViewGeom       (isViewGeom),
                                                   >>  95   fViewHits       (isViewHits),
                                                   >>  96   fViewDigis      (isViewDigis)
                                                   >>  97 {}
100                                                    98 
101 //G4ModelingParameters::VisAttributesModifier: <<  99 G4ModelingParameters::~G4ModelingParameters () {}
102 //(const G4VisAttributes& visAtts,             << 
103 // G4ModelingParameters::VisAttributesSignifie << 
104 // const std::vector<G4PhysicalVolumeModel::G4 << 
105 //fVisAtts(visAtts), fSignifier(signifier)     << 
106 //{                                            << 
107 //  typedef G4PhysicalVolumeModel::G4PhysicalV << 
108 //  typedef std::vector<PVNodeID> PVPath;      << 
109 //  typedef PVPath::const_iterator PVPathConst << 
110 //  PVPathConstIterator i;                     << 
111 //  for (i = path.begin();                     << 
112 //       i != path.end();                      << 
113 //       ++i) {                                << 
114 //    fPVNameCopyNoPath.push_back              << 
115 //    (PVNameCopyNo                            << 
116 //     (i->GetPhysicalVolume()->GetName(),     << 
117 //      i->GetCopyNo()));                      << 
118 //  }                                          << 
119 //}                                            << 
120                                                   100 
121 void G4ModelingParameters::SetVisibleDensity (    101 void G4ModelingParameters::SetVisibleDensity (G4double visibleDensity) {
122   const G4double reasonableMaximum = 10.0 * g     102   const G4double reasonableMaximum = 10.0 * g / cm3;
123   if (visibleDensity < 0 && fWarning) {        << 103   if (visibleDensity < 0) {
124     G4warn << "G4ModelingParameters::SetVisibl << 104     G4cout << "G4ModelingParameters::SetVisibleDensity: attempt to set negative "
125       "density - ignored." << G4endl;             105       "density - ignored." << G4endl;
126   }                                               106   }
127   else {                                          107   else {
128     if (fVisibleDensity > reasonableMaximum && << 108     if (fVisibleDensity > reasonableMaximum) {
129       G4warn << "G4ModelingParameters::SetVisi << 109       G4cout << "G4ModelingParameters::SetVisibleDensity: density > "
130      << reasonableMaximum                         110      << reasonableMaximum
131      << " g / cm3 - did you mean this?"           111      << " g / cm3 - did you mean this?"
132      << G4endl;                                   112      << G4endl;
133     }                                             113     }
134     fVisibleDensity = visibleDensity;             114     fVisibleDensity = visibleDensity;
135   }                                               115   }
136 }                                                 116 }
137                                                   117 
138 G4int G4ModelingParameters::SetNoOfSides (G4in << 118 void G4ModelingParameters::SetNoOfSides (G4int nSides) {
139   const G4int  nSidesMin = fpDefaultVisAttribu << 119   const G4int  nSidesMin = 3;
140   if (nSides < nSidesMin) {                       120   if (nSides < nSidesMin) {
141     nSides = nSidesMin;                           121     nSides = nSidesMin;
142     if (fWarning)                              << 122     G4cout << "G4ModelingParameters::SetNoOfSides: attempt to set the"
143       G4warn << "G4ModelingParameters::SetNoOf << 123       "\nnumber of sides per circle < " << nSidesMin
144   "\nnumber of sides per circle < " << nSidesM << 124    << "; forced to" << nSides << G4endl;
145        << "; forced to" << nSides << G4endl;   << 
146   }                                               125   }
147   fNoOfSides = nSides;                            126   fNoOfSides = nSides;
148   return fNoOfSides;                           << 
149 }                                                 127 }
150                                                   128 
151 void G4ModelingParameters::SetSectionSolid     << 129 void G4ModelingParameters::PrintDifferences
152 (G4DisplacedSolid* pSectionSolid) {            << 130 (const G4ModelingParameters& that) const {
153   delete fpSectionSolid;                       << 
154   fpSectionSolid = pSectionSolid;              << 
155 }                                              << 
156                                                << 
157 void G4ModelingParameters::SetCutawaySolid     << 
158 (G4DisplacedSolid* pCutawaySolid) {            << 
159   delete fpCutawaySolid;                       << 
160   fpCutawaySolid = pCutawaySolid;              << 
161 }                                              << 
162                                                << 
163 std::ostream& operator << (std::ostream& os, c << 
164 {                                              << 
165   os << "Modeling parameters (warning ";       << 
166   if (mp.fWarning) os << "true";               << 
167   else os << "false";                          << 
168   os << "):";                                  << 
169                                                   131 
170   const G4VisAttributes* va = mp.fpDefaultVisA << 132   if (
171   os << "\n  Default vis. attributes: ";       << 133       (fpDefaultVisAttributes != that.fpDefaultVisAttributes) ||
172   if (va) os << *va;                           << 134       (fRepStyle              != that.fRepStyle)              ||
173   else os << "none";                           << 135       (fCulling               != that.fCulling)               ||
174                                                << 136       (fCullInvisible         != that.fCullInvisible)         ||
175   os << "\n  Current requested drawing style:  << 137       (fDensityCulling        != that.fDensityCulling)        ||
176   switch (mp.fDrawingStyle) {                  << 138       (fVisibleDensity        != that.fVisibleDensity)        ||
177     case G4ModelingParameters::wf:             << 139       (fCullCovered           != that.fCullCovered)           ||
178       os << "wireframe"; break;                << 140       (fNoOfSides             != that.fNoOfSides)             ||
179     case G4ModelingParameters::hlr:            << 141       (fViewGeom              != that.fViewGeom)              ||
180       os << "hidden line removal (hlr)"; break << 142       (fViewHits              != that.fViewHits)              ||
181     case G4ModelingParameters::hsr:            << 143       (fViewDigis             != that.fViewDigis))
182       os << "surface (hsr)"; break;            << 144     G4cout << "Difference in 1st batch." << G4endl;
183     case G4ModelingParameters::hlhsr:          << 145 }
184       os << "surface and edges (hlhsr)"; break << 146 
185     case G4ModelingParameters::cloud:          << 147 G4std::ostream& operator << (G4std::ostream& os, const G4ModelingParameters& mp) {
186       os << "cloud"; break;                    << 148   os << "Modeling parameters and options:";
187     default: os << "unrecognised"; break;      << 149 
                                                   >> 150   os << "\n  Default vis. attributes: " << *mp.fpDefaultVisAttributes;
                                                   >> 151 
                                                   >> 152   os << "\n  Representation style for graphics reps, if needed: ";
                                                   >> 153   switch (mp.fRepStyle) {
                                                   >> 154   case G4ModelingParameters::wireframe:
                                                   >> 155     os << "wireframe"; break;
                                                   >> 156   case G4ModelingParameters::polyhedron:
                                                   >> 157     os << "polyhedron"; break;
                                                   >> 158   case G4ModelingParameters::nurbs:
                                                   >> 159     os << "nurbs"; break;
                                                   >> 160   default: os << "unrecognised"; break;
188   }                                               161   }
189                                                   162 
190   os << "\n  Number of cloud points: " << mp.f << 
191                                                << 
192   os << "\n  Culling: ";                          163   os << "\n  Culling: ";
193   if (mp.fCulling) os << "on";                    164   if (mp.fCulling) os << "on";
194   else            os << "off";                    165   else            os << "off";
195                                                   166 
196   os << "\n  Culling invisible objects: ";        167   os << "\n  Culling invisible objects: ";
197   if (mp.fCullInvisible) os << "on";              168   if (mp.fCullInvisible) os << "on";
198   else                  os << "off";              169   else                  os << "off";
199                                                   170 
200   os << "\n  Density culling: ";                  171   os << "\n  Density culling: ";
201   if (mp.fDensityCulling) {                       172   if (mp.fDensityCulling) {
202     os << "on - invisible if density less than    173     os << "on - invisible if density less than "
203        << mp.fVisibleDensity / (1. * g / cm3)     174        << mp.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
204   }                                               175   }
205   else os << "off";                               176   else os << "off";
206                                                   177 
207   os << "\n  Culling daughters covered by opaq    178   os << "\n  Culling daughters covered by opaque mothers: ";
208   if (mp.fCullCovered) os << "on";                179   if (mp.fCullCovered) os << "on";
209   else                os << "off";                180   else                os << "off";
210                                                   181 
211   os << "\n  Colour by density: ";             << 
212   if (mp.fCBDAlgorithmNumber <= 0) {           << 
213     os << "inactive";                          << 
214   } else {                                     << 
215     os << "Algorithm " << mp.fCBDAlgorithmNumb << 
216     for (auto p: mp.fCBDParameters) {          << 
217       os << ' ' << G4BestUnit(p,"Volumic Mass" << 
218     }                                          << 
219   }                                            << 
220                                                << 
221   os << "\n  Explode factor: " << mp.fExplodeF << 
222      << " about centre: " << mp.fExplodeCentre << 
223                                                << 
224   os << "\n  No. of sides used in circle polyg    182   os << "\n  No. of sides used in circle polygon approximation: "
225      << mp.fNoOfSides;                            183      << mp.fNoOfSides;
226                                                   184 
227   os << "\n  Section (DCUT) shape (G4Displaced << 185   os << "\n  View geometry: ";
228   if (!mp.fpSectionSolid) os << "non-";        << 186   if (mp.fViewGeom) os << "true";
229   os << "null";                                << 187   else os << "false";
230                                                << 
231   os << "\n  Cutaway mode: ";                  << 
232   if (mp.GetCutawayMode() == G4ModelingParamet << 
233   else if (mp.GetCutawayMode() == G4ModelingPa << 
234                                                << 
235   os << "\n  Cutaway (DCUT) shape (G4Displaced << 
236   if (!mp.fpCutawaySolid) os << "non-";        << 
237   os << "null";                                << 
238                                                << 
239   os << "\n  Event pointer: " << mp.fpEvent;   << 
240                                                << 
241   os << "\n  Vis attributes modifiers: ";      << 
242   const std::vector<G4ModelingParameters::VisA << 
243   mp.fVisAttributesModifiers;                  << 
244   if (vams.empty()) {                          << 
245     os << "None";                              << 
246   } else {                                     << 
247     os << vams;                                << 
248   }                                            << 
249                                                   188 
250   os << "\n  Special Mesh Rendering: ";        << 189   os << "\n  View hits    : ";
251   if (mp.fSpecialMeshRendering) {              << 190   if (mp.fViewHits) os << "true";
252     os << "on: ";                              << 191   else os << "false";
253     if (mp.fSpecialMeshVolumes.empty()) {      << 192 
254       os << "all meshes";                      << 193   os << "\n  View digits  : ";
255     } else {                                   << 194   if (mp.fViewDigis) os << "true";
256       os << "selected meshes";                 << 195   else os << "false";
257       for (const auto& vol: mp.fSpecialMeshVol << 
258   os << "\n    " << vol.GetName() << ':' << vo << 
259       }                                        << 
260     }                                          << 
261   } else os << "off";                          << 
262                                                   196 
263   return os;                                      197   return os;
264 }                                                 198 }
265                                                   199 
266 G4bool G4ModelingParameters::operator !=          200 G4bool G4ModelingParameters::operator !=
267 (const G4ModelingParameters& mp) const {          201 (const G4ModelingParameters& mp) const {
268                                                   202 
269   if (                                            203   if (
270       (fWarning                != mp.fWarning) << 
271       (*fpDefaultVisAttributes != *mp.fpDefaul    204       (*fpDefaultVisAttributes != *mp.fpDefaultVisAttributes) ||
272       (fDrawingStyle           != mp.fDrawingS << 205       (fRepStyle               != mp.fRepStyle)               ||
273       (fNumberOfCloudPoints    != mp.fNumberOf << 
274       (fCulling                != mp.fCulling)    206       (fCulling                != mp.fCulling)                ||
275       (fCullInvisible          != mp.fCullInvi    207       (fCullInvisible          != mp.fCullInvisible)          ||
276       (fDensityCulling         != mp.fDensityC    208       (fDensityCulling         != mp.fDensityCulling)         ||
277       (fCullCovered            != mp.fCullCove    209       (fCullCovered            != mp.fCullCovered)            ||
278       (fCBDAlgorithmNumber     != mp.fCBDAlgor << 
279       (fExplodeFactor          != mp.fExplodeF << 
280       (fExplodeCentre          != mp.fExplodeC << 
281       (fNoOfSides              != mp.fNoOfSide    210       (fNoOfSides              != mp.fNoOfSides)              ||
282       (fpSectionSolid          != mp.fpSection << 211       (fViewGeom               != mp.fViewGeom)               ||
283       (fCutawayMode            != mp.fCutawayM << 212       (fViewHits               != mp.fViewHits)               ||
284       (fpCutawaySolid          != mp.fpCutaway << 213       (fViewDigis              != mp.fViewDigis))
285       (fpEvent                 != mp.fpEvent)  << 
286       (fSpecialMeshRendering   != mp.fSpecialM << 
287       )                                        << 
288     return true;                                  214     return true;
289                                                   215 
290   if (fDensityCulling &&                          216   if (fDensityCulling &&
291       (fVisibleDensity != mp.fVisibleDensity))    217       (fVisibleDensity != mp.fVisibleDensity)) return true;
292                                                   218 
293   if (fCBDAlgorithmNumber > 0) {               << 
294     if (fCBDParameters.size() != mp.fCBDParame << 
295     else if (fCBDParameters != mp.fCBDParamete << 
296   }                                            << 
297                                                << 
298   if (fVisAttributesModifiers != mp.fVisAttrib << 
299     return true;                               << 
300                                                << 
301   if (fSpecialMeshRendering) {                 << 
302     if (fSpecialMeshVolumes != mp.fSpecialMesh << 
303       return true;;                            << 
304   }                                            << 
305                                                << 
306   return false;                                << 
307 }                                              << 
308                                                << 
309 G4bool G4ModelingParameters::VisAttributesModi << 
310 (const G4ModelingParameters::VisAttributesModi << 
311 {                                              << 
312   if (fSignifier != rhs.fSignifier) return tru << 
313   if (fPVNameCopyNoPath != rhs.fPVNameCopyNoPa << 
314   switch (fSignifier) {                        << 
315     case G4ModelingParameters::VASVisibility:  << 
316       if (fVisAtts.IsVisible() != rhs.fVisAtts << 
317         return true;                           << 
318       break;                                   << 
319     case G4ModelingParameters::VASDaughtersInv << 
320       if (fVisAtts.IsDaughtersInvisible() !=   << 
321           rhs.fVisAtts.IsDaughtersInvisible()) << 
322         return true;                           << 
323       break;                                   << 
324     case G4ModelingParameters::VASColour:      << 
325       if (fVisAtts.GetColour() != rhs.fVisAtts << 
326         return true;                           << 
327       break;                                   << 
328     case G4ModelingParameters::VASLineStyle:   << 
329       if (fVisAtts.GetLineStyle() != rhs.fVisA << 
330         return true;                           << 
331       break;                                   << 
332     case G4ModelingParameters::VASLineWidth:   << 
333       if (fVisAtts.GetLineWidth() != rhs.fVisA << 
334         return true;                           << 
335       break;                                   << 
336     case G4ModelingParameters::VASForceWirefra << 
337     case G4ModelingParameters::VASForceSolid:  << 
338     case G4ModelingParameters::VASForceCloud:  << 
339       if (fVisAtts.GetForcedDrawingStyle() !=  << 
340           rhs.fVisAtts.GetForcedDrawingStyle() << 
341         return true;                           << 
342       break;                                   << 
343     case G4ModelingParameters::VASForceNumberO << 
344       if (fVisAtts.GetForcedNumberOfCloudPoint << 
345           rhs.fVisAtts.GetForcedNumberOfCloudP << 
346         return true;                           << 
347       break;                                   << 
348     case G4ModelingParameters::VASForceAuxEdge << 
349       if (fVisAtts.IsForceAuxEdgeVisible() !=  << 
350           rhs.fVisAtts.IsForceAuxEdgeVisible() << 
351           fVisAtts.IsForcedAuxEdgeVisible() != << 
352           rhs.fVisAtts.IsForcedAuxEdgeVisible( << 
353         return true;                           << 
354       break;                                   << 
355     case G4ModelingParameters::VASForceLineSeg << 
356       if (fVisAtts.GetForcedLineSegmentsPerCir << 
357           rhs.fVisAtts.GetForcedLineSegmentsPe << 
358         return true;                           << 
359       break;                                   << 
360   }                                            << 
361   return false;                                   219   return false;
362 }                                                 220 }
363                                                << 
364 G4bool G4ModelingParameters::PVNameCopyNo::ope << 
365 (const G4ModelingParameters::PVNameCopyNo& rhs << 
366 {                                              << 
367   if (fName != rhs.fName) return true;         << 
368   if (fCopyNo != rhs.fCopyNo) return true;     << 
369   return false;                                << 
370 }                                              << 
371                                                << 
372 std::ostream& operator <<                      << 
373 (std::ostream& os, const G4ModelingParameters: << 
374 {                                              << 
375   os << "Touchable path: ";                    << 
376   if (path.empty()) {                          << 
377     os << "empty";                             << 
378   } else {                                     << 
379     os << "physical-volume-name:copy-number pa << 
380     G4ModelingParameters::PVNameCopyNoPathCons << 
381     for (i = path.begin(); i != path.end(); ++ << 
382       if (i != path.begin()) {                 << 
383         os << ',';                             << 
384       }                                        << 
385       os << i->GetName() << ':' << i->GetCopyN << 
386     }                                          << 
387   }                                            << 
388   return os;                                   << 
389 }                                              << 
390                                                << 
391 const G4String& G4ModelingParameters::PVPointe << 
392 {                                              << 
393   return fpPV->GetName();                      << 
394 }                                              << 
395                                                << 
396 G4bool G4ModelingParameters::PVPointerCopyNo:: << 
397 (const G4ModelingParameters::PVPointerCopyNo&  << 
398 {                                              << 
399   if (fpPV != rhs.fpPV) return true;           << 
400   if (fCopyNo != rhs.fCopyNo) return true;     << 
401   return false;                                << 
402 }                                              << 
403                                                << 
404 std::ostream& operator <<                      << 
405 (std::ostream& os, const G4ModelingParameters: << 
406 {                                              << 
407   os << "Touchable path: physical-volume-point << 
408   G4ModelingParameters::PVPointerCopyNoPathCon << 
409   for (i = path.begin(); i != path.end(); ++i) << 
410     if (i != path.begin()) {                   << 
411       os << ',';                               << 
412     }                                          << 
413     os << '(' << (void*)(i->GetPVPointer()) << << 
414   }                                            << 
415   return os;                                   << 
416 }                                              << 
417                                                << 
418 std::ostream& operator <<                      << 
419 (std::ostream& os,                             << 
420  const std::vector<G4ModelingParameters::VisAt << 
421 {                                              << 
422   std::vector<G4ModelingParameters::VisAttribu << 
423   iModifier;                                   << 
424   for (iModifier = vams.begin();               << 
425        iModifier != vams.end();                << 
426        ++iModifier) {                          << 
427     const G4ModelingParameters::PVNameCopyNoPa << 
428     iModifier->GetPVNameCopyNoPath();          << 
429     os << '\n' << vamPath;                     << 
430     const G4VisAttributes& vamVisAtts = iModif << 
431     const G4Colour& c = vamVisAtts.GetColour() << 
432     switch (iModifier->GetVisAttributesSignifi << 
433       case G4ModelingParameters::VASVisibility << 
434         os << " visibility ";                  << 
435         if (vamVisAtts.IsVisible()) {          << 
436           os << "true";                        << 
437         } else {                               << 
438           os << "false";                       << 
439         }                                      << 
440         break;                                 << 
441       case G4ModelingParameters::VASDaughtersI << 
442         os << " daughtersInvisible ";          << 
443         if (vamVisAtts.IsDaughtersInvisible()) << 
444           os << "true";                        << 
445         } else {                               << 
446           os << "false";                       << 
447         }                                      << 
448         break;                                 << 
449       case G4ModelingParameters::VASColour:    << 
450         os << " colour " << c;                 << 
451         break;                                 << 
452       case G4ModelingParameters::VASLineStyle: << 
453         os << " lineStyle ";                   << 
454         switch (vamVisAtts.GetLineStyle()) {   << 
455           case G4VisAttributes::unbroken:      << 
456             os << "unbroken";                  << 
457             break;                             << 
458           case G4VisAttributes::dashed:        << 
459             os << "dashed";                    << 
460             break;                             << 
461           case G4VisAttributes::dotted:        << 
462             os << "dotted";                    << 
463         }                                      << 
464         break;                                 << 
465       case G4ModelingParameters::VASLineWidth: << 
466         os << " lineWidth "                    << 
467         << vamVisAtts.GetLineWidth();          << 
468         break;                                 << 
469       case G4ModelingParameters::VASForceWiref << 
470         if (vamVisAtts.GetForcedDrawingStyle() << 
471           os << " forceWireframe ";            << 
472           if (vamVisAtts.IsForceDrawingStyle() << 
473             os << "true";                      << 
474           } else {                             << 
475             os << "false";                     << 
476           }                                    << 
477         }                                      << 
478         break;                                 << 
479       case G4ModelingParameters::VASForceSolid << 
480         if (vamVisAtts.GetForcedDrawingStyle() << 
481           os << " forceSolid ";                << 
482           if (vamVisAtts.IsForceDrawingStyle() << 
483             os << "true";                      << 
484           } else {                             << 
485             os << "false";                     << 
486           }                                    << 
487         }                                      << 
488         break;                                 << 
489       case G4ModelingParameters::VASForceCloud << 
490         if (vamVisAtts.GetForcedDrawingStyle() << 
491           os << " forceCloud ";                << 
492           if (vamVisAtts.IsForceDrawingStyle() << 
493             os << "true";                      << 
494           } else {                             << 
495             os << "false";                     << 
496           }                                    << 
497         }                                      << 
498         break;                                 << 
499       case G4ModelingParameters::VASForceNumbe << 
500         os << " numberOfCloudPoints "          << 
501         << vamVisAtts.GetForcedNumberOfCloudPo << 
502         break;                                 << 
503       case G4ModelingParameters::VASForceAuxEd << 
504         os << " forceAuxEdgeVisible: ";        << 
505         if (!vamVisAtts.IsForceDrawingStyle()) << 
506           os << "not ";                        << 
507         }                                      << 
508         os << " forced";                       << 
509         if (vamVisAtts.IsForceAuxEdgeVisible() << 
510           os << ": ";                          << 
511           if (vamVisAtts.IsForcedAuxEdgeVisibl << 
512             os << "true";                      << 
513           } else {                             << 
514             os << "false";                     << 
515           }                                    << 
516         }                                      << 
517         break;                                 << 
518       case G4ModelingParameters::VASForceLineS << 
519         os << " lineSegmentsPerCircle "        << 
520         << vamVisAtts.GetForcedLineSegmentsPer << 
521         break;                                 << 
522     }                                          << 
523   }                                            << 
524                                                << 
525   return os;                                   << 
526 }                                              << 
527                                                << 
528                                                   221