00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #include "G4ModelingParameters.hh"
00034
00035 #include "G4ios.hh"
00036 #include "G4VisAttributes.hh"
00037 #include "G4ExceptionSeverity.hh"
00038 #include "G4SystemOfUnits.hh"
00039 #include "G4VSolid.hh"
00040 #include "G4VPhysicalVolume.hh"
00041 #include "G4PhysicalVolumeModel.hh"
00042
00043 G4ModelingParameters::G4ModelingParameters ():
00044 fWarning (true),
00045 fpDefaultVisAttributes (0),
00046 fDrawingStyle (wf),
00047 fCulling (false),
00048 fCullInvisible (false),
00049 fDensityCulling (false),
00050 fVisibleDensity (0.01 * g / cm3),
00051 fCullCovered (false),
00052 fExplodeFactor (1.),
00053 fNoOfSides (24),
00054 fpSectionSolid (0),
00055 fpCutawaySolid (0),
00056 fpEvent (0)
00057 {}
00058
00059 G4ModelingParameters::G4ModelingParameters
00060 (const G4VisAttributes* pDefaultVisAttributes,
00061 G4ModelingParameters::DrawingStyle drawingStyle,
00062 G4bool isCulling,
00063 G4bool isCullingInvisible,
00064 G4bool isDensityCulling,
00065 G4double visibleDensity,
00066 G4bool isCullingCovered,
00067 G4int noOfSides
00068 ):
00069 fWarning (true),
00070 fpDefaultVisAttributes (pDefaultVisAttributes),
00071 fDrawingStyle (drawingStyle),
00072 fCulling (isCulling),
00073 fCullInvisible (isCullingInvisible),
00074 fDensityCulling (isDensityCulling),
00075 fVisibleDensity (visibleDensity),
00076 fCullCovered (isCullingCovered),
00077 fExplodeFactor (1.),
00078 fNoOfSides (noOfSides),
00079 fpSectionSolid (0),
00080 fpCutawaySolid (0),
00081 fpEvent (0)
00082 {}
00083
00084 G4ModelingParameters::~G4ModelingParameters ()
00085 {
00086 delete fpSectionSolid;
00087 delete fpCutawaySolid;
00088 }
00089
00090 G4ModelingParameters::VisAttributesModifier::VisAttributesModifier
00091 (const G4VisAttributes& visAtts,
00092 G4ModelingParameters::VisAttributesSignifier signifier,
00093 const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& path):
00094 fVisAtts(visAtts), fSignifier(signifier)
00095 {
00096 typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
00097 typedef std::vector<PVNodeID> PVPath;
00098 typedef PVPath::const_iterator PVPathConstIterator;
00099 PVPathConstIterator i;
00100 for (i = path.begin();
00101 i != path.end();
00102 ++i) {
00103 fPVNameCopyNoPath.push_back
00104 (PVNameCopyNo
00105 (i->GetPhysicalVolume()->GetName(),
00106 i->GetCopyNo()));
00107 }
00108 }
00109
00110 void G4ModelingParameters::SetVisibleDensity (G4double visibleDensity) {
00111 const G4double reasonableMaximum = 10.0 * g / cm3;
00112 if (visibleDensity < 0 && fWarning) {
00113 G4cout << "G4ModelingParameters::SetVisibleDensity: attempt to set negative "
00114 "density - ignored." << G4endl;
00115 }
00116 else {
00117 if (fVisibleDensity > reasonableMaximum && fWarning) {
00118 G4cout << "G4ModelingParameters::SetVisibleDensity: density > "
00119 << reasonableMaximum
00120 << " g / cm3 - did you mean this?"
00121 << G4endl;
00122 }
00123 fVisibleDensity = visibleDensity;
00124 }
00125 }
00126
00127 G4int G4ModelingParameters::SetNoOfSides (G4int nSides) {
00128 const G4int nSidesMin = 12;
00129 if (nSides < nSidesMin) {
00130 nSides = nSidesMin;
00131 if (fWarning)
00132 G4cout << "G4ModelingParameters::SetNoOfSides: attempt to set the"
00133 "\nnumber of sides per circle < " << nSidesMin
00134 << "; forced to" << nSides << G4endl;
00135 }
00136 fNoOfSides = nSides;
00137 return fNoOfSides;
00138 }
00139
00140 void G4ModelingParameters::SetSectionSolid
00141 (G4VSolid* pSectionSolid) {
00142 delete fpSectionSolid;
00143 fpSectionSolid = pSectionSolid;
00144 }
00145
00146 void G4ModelingParameters::SetCutawaySolid
00147 (G4VSolid* pCutawaySolid) {
00148 delete fpCutawaySolid;
00149 fpCutawaySolid = pCutawaySolid;
00150 }
00151
00152 std::ostream& operator << (std::ostream& os, const G4ModelingParameters& mp)
00153 {
00154 os << "Modeling parameters (warning ";
00155 if (mp.fWarning) os << "true";
00156 else os << "false";
00157 os << "):";
00158
00159 const G4VisAttributes* va = mp.fpDefaultVisAttributes;
00160 os << "\n Default vis. attributes: ";
00161 if (va) os << *va;
00162 else os << "none";
00163
00164 os << "\n Current requested drawing style: ";
00165 switch (mp.fDrawingStyle) {
00166 case G4ModelingParameters::wf:
00167 os << "wireframe"; break;
00168 case G4ModelingParameters::hlr:
00169 os << "hidden line removal (hlr)"; break;
00170 case G4ModelingParameters::hsr:
00171 os << "surface (hsr)"; break;
00172 case G4ModelingParameters::hlhsr:
00173 os << "surface and edges (hlhsr)"; break;
00174 default: os << "unrecognised"; break;
00175 }
00176
00177 os << "\n Culling: ";
00178 if (mp.fCulling) os << "on";
00179 else os << "off";
00180
00181 os << "\n Culling invisible objects: ";
00182 if (mp.fCullInvisible) os << "on";
00183 else os << "off";
00184
00185 os << "\n Density culling: ";
00186 if (mp.fDensityCulling) {
00187 os << "on - invisible if density less than "
00188 << mp.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
00189 }
00190 else os << "off";
00191
00192 os << "\n Culling daughters covered by opaque mothers: ";
00193 if (mp.fCullCovered) os << "on";
00194 else os << "off";
00195
00196 os << "\n Explode factor: " << mp.fExplodeFactor
00197 << " about centre: " << mp.fExplodeCentre;
00198
00199 os << "\n No. of sides used in circle polygon approximation: "
00200 << mp.fNoOfSides;
00201
00202 os << "\n Section (DCUT) shape (G4VSolid) pointer: ";
00203 if (!mp.fpSectionSolid) os << "non-";
00204 os << "null";
00205
00206 os << "\n Cutaway (DCUT) shape (G4VSolid) pointer: ";
00207 if (!mp.fpCutawaySolid) os << "non-";
00208 os << "null";
00209
00210 os << "\n Event pointer: " << mp.fpEvent;
00211
00212 os << "\n Vis attributes modifiers: ";
00213 const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
00214 mp.fVisAttributesModifiers;
00215 if (vams.empty()) {
00216 os << "None";
00217 } else {
00218 os << vams;
00219 }
00220
00221 return os;
00222 }
00223
00224 G4bool G4ModelingParameters::operator !=
00225 (const G4ModelingParameters& mp) const {
00226
00227 if (
00228 (fWarning != mp.fWarning) ||
00229 (*fpDefaultVisAttributes != *mp.fpDefaultVisAttributes) ||
00230 (fCulling != mp.fCulling) ||
00231 (fCullInvisible != mp.fCullInvisible) ||
00232 (fDensityCulling != mp.fDensityCulling) ||
00233 (fCullCovered != mp.fCullCovered) ||
00234 (fExplodeFactor != mp.fExplodeFactor) ||
00235 (fExplodeCentre != mp.fExplodeCentre) ||
00236 (fNoOfSides != mp.fNoOfSides) ||
00237 (fpSectionSolid != mp.fpSectionSolid) ||
00238 (fpCutawaySolid != mp.fpCutawaySolid) ||
00239 (fpEvent != mp.fpEvent)
00240 )
00241 return true;
00242
00243 if (fDensityCulling &&
00244 (fVisibleDensity != mp.fVisibleDensity)) return true;
00245
00246 if (VAMSNotEqual(fVisAttributesModifiers, mp.fVisAttributesModifiers))
00247 return true;
00248
00249 return false;
00250 }
00251
00252 G4bool G4ModelingParameters::PVNameCopyNoPathNotEqual
00253 (const G4ModelingParameters::PVNameCopyNoPath& path1,
00254 const G4ModelingParameters::PVNameCopyNoPath& path2)
00255 {
00256 if (path1.size() != path2.size()) return true;
00257 if (path1.empty()) return false;
00258 PVNameCopyNoPathConstIterator i1, i2;
00259 for (i1 = path1.begin(), i2 = path2.begin();
00260 i1 != path1.end();
00261 ++i1, ++i2) {
00262 if (i1->GetName() != i2->GetName()) return true;
00263 if (i1->GetCopyNo() != i2->GetCopyNo()) return true;
00264 }
00265 return false;
00266 }
00267
00268 G4bool G4ModelingParameters::VAMSNotEqual
00269 (const std::vector<G4ModelingParameters::VisAttributesModifier>& vams1,
00270 const std::vector<G4ModelingParameters::VisAttributesModifier>& vams2)
00271 {
00272 if (vams1.size() != vams2.size()) return true;
00273 if (vams1.empty()) return false;
00274 std::vector<VisAttributesModifier>::const_iterator i1, i2;
00275 for (i1 = vams1.begin(), i2 = vams2.begin();
00276 i1 != vams1.end();
00277 ++i1, ++i2) {
00278 const PVNameCopyNoPath& vam1Path = i1->GetPVNameCopyNoPath();
00279 const PVNameCopyNoPath& vam2Path = i2->GetPVNameCopyNoPath();
00280 if (PVNameCopyNoPathNotEqual(vam1Path,vam2Path)) return true;
00281 if (i1->GetVisAttributesSignifier() != i2->GetVisAttributesSignifier())
00282 return true;
00283 const G4VisAttributes& vam1VisAtts = i1->GetVisAttributes();
00284 const G4VisAttributes& vam2VisAtts = i2->GetVisAttributes();
00285 const G4Colour& c1 = vam1VisAtts.GetColour();
00286 const G4Colour& c2 = vam2VisAtts.GetColour();
00287 switch (i1->GetVisAttributesSignifier()) {
00288 case G4ModelingParameters::VASVisibility:
00289 if (vam1VisAtts.IsVisible() != vam2VisAtts.IsVisible())
00290 return true;
00291 break;
00292 case G4ModelingParameters::VASDaughtersInvisible:
00293 if (vam1VisAtts.IsDaughtersInvisible() !=
00294 vam2VisAtts.IsDaughtersInvisible())
00295 return true;
00296 break;
00297 case G4ModelingParameters::VASColour:
00298 if (c1 != c2)
00299 return true;
00300 break;
00301 case G4ModelingParameters::VASLineStyle:
00302 if (vam1VisAtts.GetLineStyle() != vam2VisAtts.GetLineStyle())
00303 return true;
00304 break;
00305 case G4ModelingParameters::VASLineWidth:
00306 if (vam1VisAtts.GetLineWidth() != vam2VisAtts.GetLineWidth())
00307 return true;
00308 break;
00309 case G4ModelingParameters::VASForceWireframe:
00310 if (vam1VisAtts.GetForcedDrawingStyle() !=
00311 vam2VisAtts.GetForcedDrawingStyle())
00312 return true;
00313 break;
00314 case G4ModelingParameters::VASForceSolid:
00315 if (vam1VisAtts.GetForcedDrawingStyle() !=
00316 vam2VisAtts.GetForcedDrawingStyle())
00317 return true;
00318 break;
00319 case G4ModelingParameters::VASForceAuxEdgeVisible:
00320 if (vam1VisAtts.IsForceAuxEdgeVisible() !=
00321 vam2VisAtts.IsForceAuxEdgeVisible())
00322 return true;
00323 break;
00324 case G4ModelingParameters::VASForceLineSegmentsPerCircle:
00325 if (vam1VisAtts.GetForcedLineSegmentsPerCircle() !=
00326 vam2VisAtts.GetForcedLineSegmentsPerCircle())
00327 return true;
00328 break;
00329 }
00330 }
00331 return false;
00332 }
00333
00334 std::ostream& operator <<
00335 (std::ostream& os, const G4ModelingParameters::PVNameCopyNoPath& path)
00336 {
00337
00338 G4ModelingParameters::PVNameCopyNoPathConstIterator i;
00339 for (i = path.begin(); i != path.end(); ++i) {
00340 if (i != path.begin()) {
00341 os << ", ";
00342 }
00343 os << i->GetName() << ':' << i->GetCopyNo();
00344 }
00345 return os;
00346 }
00347
00348 std::ostream& operator <<
00349 (std::ostream& os,
00350 const std::vector<G4ModelingParameters::VisAttributesModifier>& vams)
00351 {
00352 std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
00353 iModifier;
00354 for (iModifier = vams.begin();
00355 iModifier != vams.end();
00356 ++iModifier) {
00357 const G4ModelingParameters::PVNameCopyNoPath& vamPath =
00358 iModifier->GetPVNameCopyNoPath();
00359 os << '\n' << vamPath;
00360 const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
00361 const G4Colour& c = vamVisAtts.GetColour();
00362 switch (iModifier->GetVisAttributesSignifier()) {
00363 case G4ModelingParameters::VASVisibility:
00364 os << " visibility ";
00365 if (vamVisAtts.IsVisible()) {
00366 os << "true";
00367 } else {
00368 os << "false";
00369 }
00370 break;
00371 case G4ModelingParameters::VASDaughtersInvisible:
00372 os << " daughtersInvisible ";
00373 if (vamVisAtts.IsDaughtersInvisible()) {
00374 os << "true";
00375 } else {
00376 os << "false";
00377 }
00378 break;
00379 case G4ModelingParameters::VASColour:
00380 os << " colour " << c;
00381 break;
00382 case G4ModelingParameters::VASLineStyle:
00383 os << " lineStyle ";
00384 switch (vamVisAtts.GetLineStyle()) {
00385 case G4VisAttributes::unbroken:
00386 os << "unbroken";
00387 break;
00388 case G4VisAttributes::dashed:
00389 os << "dashed";
00390 break;
00391 case G4VisAttributes::dotted:
00392 os << "dotted";
00393 }
00394 break;
00395 case G4ModelingParameters::VASLineWidth:
00396 os << " lineWidth "
00397 << vamVisAtts.GetLineWidth();
00398 break;
00399 case G4ModelingParameters::VASForceWireframe:
00400 if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
00401 os << " forceWireframe ";
00402 if (vamVisAtts.IsForceDrawingStyle()) {
00403 os << "true";
00404 } else {
00405 os << "false";
00406 }
00407 }
00408 break;
00409 case G4ModelingParameters::VASForceSolid:
00410 if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
00411 os << " forceSolid ";
00412 if (vamVisAtts.IsForceDrawingStyle()) {
00413 os << "true";
00414 } else {
00415 os << "false";
00416 }
00417 }
00418 break;
00419 case G4ModelingParameters::VASForceAuxEdgeVisible:
00420 os << " forceAuxEdgeVisible ";
00421 if (vamVisAtts.IsForceAuxEdgeVisible()) {
00422 os << "true";
00423 } else {
00424 os << "false";
00425 }
00426 break;
00427 case G4ModelingParameters::VASForceLineSegmentsPerCircle:
00428 os << " lineSegmentsPerCircle "
00429 << vamVisAtts.GetForcedLineSegmentsPerCircle();
00430 break;
00431 }
00432 }
00433
00434 return os;
00435 }
00436