G4ModelingParameters.hh File Reference

#include "globals.hh"
#include "G4VisExtent.hh"
#include "G4VisAttributes.hh"
#include "G4VPhysicalVolume.hh"
#include <vector>
#include <utility>
#include "G4ModelingParameters.icc"

Go to the source code of this file.

Classes
class	G4ModelingParameters
class	G4ModelingParameters::PVNameCopyNo
class	G4ModelingParameters::PVPointerCopyNo
class	G4ModelingParameters::VisAttributesModifier
struct	G4ModelingParameters::TimeParameters

Functions
std::ostream &	operator<< (std::ostream &os, const G4ModelingParameters &)
std::ostream &	operator<< (std::ostream &os, const G4ModelingParameters::PVNameCopyNoPath &)
std::ostream &	operator<< (std::ostream &os, const G4ModelingParameters::PVPointerCopyNoPath &)
std::ostream &	operator<< (std::ostream &os, const std::vector< G4ModelingParameters::VisAttributesModifier > &)

Function Documentation

operator<<() [1/4]

std::ostream & operator<<	(	std::ostream &	os,
		const G4ModelingParameters &	mp )

Definition at line 167 of file G4ModelingParameters.cc.

{
  os << "Modeling parameters (warning ";
  if (mp.fWarning) os << "true";
  else os << "false";
  os << "):";
 
  const G4VisAttributes* va = mp.fpDefaultVisAttributes;
  os << "\n  Default vis. attributes: ";
  if (va) os << *va;
  else os << "none";
 
  os << "\n  Current requested drawing style: ";
  switch (mp.fDrawingStyle) {
    case G4ModelingParameters::wf:
      os << "wireframe"; break;
    case G4ModelingParameters::hlr:
      os << "hidden line removal (hlr)"; break;
    case G4ModelingParameters::hsr:
      os << "surface (hsr)"; break;
    case G4ModelingParameters::hlhsr:
      os << "surface and edges (hlhsr)"; break;
    case G4ModelingParameters::cloud:
      os << "cloud"; break;
    default: os << "unrecognised"; break;
  }
 
  os << "\n  Number of cloud points: " << mp.fNumberOfCloudPoints;
 
  os << "\n  Culling: ";
  if (mp.fCulling) os << "on";
  else            os << "off";
 
  os << "\n  Culling invisible objects: ";
  if (mp.fCullInvisible) os << "on";
  else                  os << "off";
 
  os << "\n  Density culling: ";
  if (mp.fDensityCulling) {
    os << "on - invisible if density less than "
       << mp.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
  }
  else os << "off";
 
  os << "\n  Culling daughters covered by opaque mothers: ";
  if (mp.fCullCovered) os << "on";
  else                os << "off";
 
  os << "\n  Colour by density: ";
  if (mp.fCBDAlgorithmNumber <= 0) {
    os << "inactive";
  } else {
    os << "Algorithm " << mp.fCBDAlgorithmNumber << ", Parameters:";
    for (auto p: mp.fCBDParameters) {
      os << ' ' << G4BestUnit(p,"Volumic Mass");
    }
  }
 
  os << "\n  Explode factor: " << mp.fExplodeFactor
     << " about centre: " << mp.fExplodeCentre;
 
  os << "\n  No. of sides used in circle polygon approximation: "
     << mp.fNoOfSides;
 
  os << "\n  Section (DCUT) shape (G4DisplacedSolid) pointer: ";
  if (!mp.fpSectionSolid) os << "non-";
  os << "null";
 
  os << "\n  Cutaway mode: ";
  if (mp.GetCutawayMode() == G4ModelingParameters::cutawayUnion) os << "union";
  else if (mp.GetCutawayMode() == G4ModelingParameters::cutawayIntersection) os << "intersection";
 
  os << "\n  Cutaway (DCUT) shape (G4DisplacedSolid) pointer: ";
  if (!mp.fpCutawaySolid) os << "non-";
  os << "null";
 
  os << "\n  Event pointer: " << mp.fpEvent;
 
  os << "\n  Vis attributes modifiers: ";
  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
  mp.fVisAttributesModifiers;
  if (vams.empty()) {
    os << "None";
  } else {
    os << vams;
  }
 
  os << "\n  Special Mesh Rendering: ";
  if (mp.fSpecialMeshRendering) {
    os << "on: ";
    if (mp.fSpecialMeshVolumes.empty()) {
      os << "all meshes";
    } else {
      os << "selected meshes";
      for (const auto& vol: mp.fSpecialMeshVolumes) {
        os << "\n    " << vol.GetName() << ':' << vol.GetCopyNo();
      }
    }
  } else os << "off";
 
  os << "\nTransparency by depth: " << mp.fTransparencyByDepth
  << ", option: " << mp.fTransparencyByDepthOption;
 
  return os;
}

operator<<() [2/4]

std::ostream & operator<<	(	std::ostream &	os,
		const G4ModelingParameters::PVNameCopyNoPath &	path )

Definition at line 381 of file G4ModelingParameters.cc.

{
  os << "Touchable path: ";
  if (path.empty()) {
    os << "empty";
  } else {
    os << "physical-volume-name:copy-number pairs:\n  ";
    G4ModelingParameters::PVNameCopyNoPathConstIterator i;
    for (i = path.begin(); i != path.end(); ++i) {
      if (i != path.begin()) {
        os << ',';
      }
      os << i->GetName() << ':' << i->GetCopyNo();
    }
  }
  return os;
}

operator<<() [3/4]

std::ostream & operator<<	(	std::ostream &	os,
		const G4ModelingParameters::PVPointerCopyNoPath &	path )

Definition at line 413 of file G4ModelingParameters.cc.

{
  os << "Touchable path: physical-volume-pointer:copy-number pairs:\n  ";
  G4ModelingParameters::PVPointerCopyNoPathConstIterator i;
  for (i = path.begin(); i != path.end(); ++i) {
    if (i != path.begin()) {
      os << ',';
    }
    os << '(' << (void*)(i->GetPVPointer()) << ')' << i->GetName() << ':' << i->GetCopyNo();
  }
  return os;
}

operator<<() [4/4]

std::ostream & operator<<	(	std::ostream &	os,
		const std::vector< G4ModelingParameters::VisAttributesModifier > &	vams )

Definition at line 427 of file G4ModelingParameters.cc.

{
  std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
  iModifier;
  for (iModifier = vams.begin();
       iModifier != vams.end();
       ++iModifier) {
    const G4ModelingParameters::PVNameCopyNoPath& vamPath =
    iModifier->GetPVNameCopyNoPath();
    os << '\n' << vamPath;
    const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
    const G4Colour& c = vamVisAtts.GetColour();
    switch (iModifier->GetVisAttributesSignifier()) {
      case G4ModelingParameters::VASVisibility:
        os << " visibility ";
        if (vamVisAtts.IsVisible()) {
          os << "true";
        } else {
          os << "false";
        }
        break;
      case G4ModelingParameters::VASDaughtersInvisible:
        os << " daughtersInvisible ";
        if (vamVisAtts.IsDaughtersInvisible()) {
          os << "true";
        } else {
          os << "false";
        }
        break;
      case G4ModelingParameters::VASColour:
        os << " colour " << c;
        break;
      case G4ModelingParameters::VASLineStyle:
        os << " lineStyle ";
        switch (vamVisAtts.GetLineStyle()) {
          case G4VisAttributes::unbroken:
            os << "unbroken";
            break;
          case G4VisAttributes::dashed:
            os << "dashed";
            break;
          case G4VisAttributes::dotted:
            os << "dotted";
        }
        break;
      case G4ModelingParameters::VASLineWidth:
        os << " lineWidth "
        << vamVisAtts.GetLineWidth();
        break;
      case G4ModelingParameters::VASForceWireframe:
        if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
          os << " forceWireframe ";
          if (vamVisAtts.IsForceDrawingStyle()) {
            os << "true";
          } else {
            os << "false";
          }
        }
        break;
      case G4ModelingParameters::VASForceSolid:
        if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
          os << " forceSolid ";
          if (vamVisAtts.IsForceDrawingStyle()) {
            os << "true";
          } else {
            os << "false";
          }
        }
        break;
      case G4ModelingParameters::VASForceCloud:
        if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::cloud) {
          os << " forceCloud ";
          if (vamVisAtts.IsForceDrawingStyle()) {
            os << "true";
          } else {
            os << "false";
          }
        }
        break;
      case G4ModelingParameters::VASForceNumberOfCloudPoints:
        os << " numberOfCloudPoints "
        << vamVisAtts.GetForcedNumberOfCloudPoints();
        break;
      case G4ModelingParameters::VASForceAuxEdgeVisible:
        os << " forceAuxEdgeVisible: ";
        if (!vamVisAtts.IsForceDrawingStyle()) {
          os << "not ";
        }
        os << " forced";
        if (vamVisAtts.IsForceAuxEdgeVisible()) {
          os << ": ";
          if (vamVisAtts.IsForcedAuxEdgeVisible()) {
            os << "true";
          } else {
            os << "false";
          }
        }
        break;
      case G4ModelingParameters::VASForceLineSegmentsPerCircle:
        os << " lineSegmentsPerCircle "
        << vamVisAtts.GetForcedLineSegmentsPerCircle();
        break;
    }
  }
 
  return os;
}