G4MagneticFieldModel Class Reference

#include <G4MagneticFieldModel.hh>

Inheritance diagram for G4MagneticFieldModel:

Public Types
enum	Representation { fullArrow , lightArrow }

Public Member Functions
virtual void	DescribeYourselfTo (G4VGraphicsScene &sceneHandler)
	G4MagneticFieldModel (G4int nDataPointsPerHalfExtent=3, Representation representation=Representation::fullArrow, G4int arrow3DLineSegmentsPerCircle=6, const G4VisExtent &extentForField=G4VisExtent(), const std::vector< G4PhysicalVolumesSearchScene::Findings > &pvFindings=std::vector< G4PhysicalVolumesSearchScene::Findings >())
virtual G4String	GetCurrentDescription () const
virtual G4String	GetCurrentTag () const
const G4VisExtent &	GetExtent () const
const G4String &	GetGlobalDescription () const
const G4String &	GetGlobalTag () const
const G4ModelingParameters *	GetModelingParameters () const
const G4String &	GetType () const
void	SetExtent (const G4VisExtent &)
void	SetGlobalDescription (const G4String &)
void	SetGlobalTag (const G4String &)
void	SetModelingParameters (const G4ModelingParameters *)
void	SetType (const G4String &)
virtual G4bool	Validate (G4bool warn=true)
virtual	~G4MagneticFieldModel ()

Protected Member Functions
virtual void	GetFieldAtLocation (const G4Field *field, const G4Point3D &position, G4double time, G4Point3D &result) const

Protected Attributes
G4VisExtent	fExtent
G4String	fGlobalDescription
G4String	fGlobalTag
const G4ModelingParameters *	fpMP
G4String	fType

Private Member Functions
	G4MagneticFieldModel (const G4MagneticFieldModel &)
G4MagneticFieldModel &	operator= (const G4MagneticFieldModel &)

Private Attributes
G4int	fArrow3DLineSegmentsPerCircle
G4String	fArrowPrefix
G4VisExtent	fExtentForField
G4int	fNDataPointsPerMaxHalfExtent
std::vector< G4PhysicalVolumesSearchScene::Findings >	fPVFindings
Representation	fRepresentation
G4String	fTypeOfField

Detailed Description

Definition at line 42 of file G4MagneticFieldModel.hh.

Member Enumeration Documentation

Representation

enum G4VFieldModel::Representation

inherited

Enumerator
fullArrow
lightArrow

Definition at line 50 of file G4VFieldModel.hh.

{fullArrow, lightArrow};

Constructor & Destructor Documentation

G4MagneticFieldModel() [1/2]

G4MagneticFieldModel::G4MagneticFieldModel ( G4int  nDataPointsPerHalfExtent = 3, Representation  representation = Representation::fullArrow, G4int  arrow3DLineSegmentsPerCircle = 6, const G4VisExtent &  extentForField = G4VisExtent(), const std::vector< G4PhysicalVolumesSearchScene::Findings > &  pvFindings = std::vector<G4PhysicalVolumesSearchScene::Findings>()  )

inline

Definition at line 46 of file G4MagneticFieldModel.hh.

  : G4VFieldModel
  ("Magnetic","B", extentForField, pvFindings,
  nDataPointsPerHalfExtent, representation, arrow3DLineSegmentsPerCircle)
  {}

~G4MagneticFieldModel()

virtual G4MagneticFieldModel::~G4MagneticFieldModel ( )

inlinevirtual

Definition at line 58 of file G4MagneticFieldModel.hh.

{;}

G4MagneticFieldModel() [2/2]

G4MagneticFieldModel::G4MagneticFieldModel ( const G4MagneticFieldModel &  )

private

Member Function Documentation

DescribeYourselfTo()

void G4VFieldModel::DescribeYourselfTo ( G4VGraphicsScene &  sceneHandler )

virtualinherited

Implements G4VModel.

Definition at line 109 of file G4VFieldModel.cc.

                                                                     {
//  G4cout << "G4VFieldModel::DescribeYourselfTo" << G4endl;
 
  G4TransportationManager* tMgr =
  G4TransportationManager::GetTransportationManager();
  assert(tMgr);
  G4Navigator* navigator = tMgr->GetNavigatorForTracking();
  assert(navigator);
 
  G4FieldManager* globalFieldMgr = tMgr->GetFieldManager();
  const G4Field* globalField = 0;
  const G4String intro = "G4VFieldModel::DescribeYourselfTo: ";
  if (globalFieldMgr) {
    if (globalFieldMgr->DoesFieldExist()) {
      globalField = globalFieldMgr->GetDetectorField();
      if (!globalField) {
        static G4bool warned = false;
        if (!warned) {
          G4cout << intro << "Null global field pointer." << G4endl;
          warned = true;
        }
      }
    }
  } else {
    static G4bool warned = false;
    if (!warned) {
      G4cout << intro << "No global field manager." << G4endl;
      warned = true;
    }
  }
 
  G4VisExtent extent = sceneHandler.GetExtent();
  if (fExtentForField == G4VisExtent::GetNullExtent()) {
    extent = sceneHandler.GetExtent();
  } else {
    extent = fExtentForField;
  }
  const G4double& xMin = extent.GetXmin();
  const G4double& yMin = extent.GetYmin();
  const G4double& zMin = extent.GetZmin();
  const G4double& xMax = extent.GetXmax();
  const G4double& yMax = extent.GetYmax();
  const G4double& zMax = extent.GetZmax();
  const G4double xHalfScene = 0.5 * (xMax - xMin);
  const G4double yHalfScene = 0.5 * (yMax - yMin);
  const G4double zHalfScene = 0.5 * (zMax - zMin);
  const G4double xSceneCentre = 0.5 * (xMax + xMin);
  const G4double ySceneCentre = 0.5 * (yMax + yMin);
  const G4double zSceneCentre = 0.5 * (zMax + zMin);
  const G4double maxHalfScene =
  std::max(xHalfScene,std::max(yHalfScene,zHalfScene));
  if (maxHalfScene <= 0.) {
    G4cout << "Scene extent non-positive." << G4endl;
    return;
  }
 
  // Constants
  const G4double interval = maxHalfScene / fNDataPointsPerMaxHalfExtent;
  const G4int nDataPointsPerXHalfScene = G4int(xHalfScene / interval);
  const G4int nDataPointsPerYHalfScene = G4int(yHalfScene / interval);
  const G4int nDataPointsPerZHalfScene = G4int(zHalfScene / interval);
  const G4int nXSamples = 2 * nDataPointsPerXHalfScene + 1;
  const G4int nYSamples = 2 * nDataPointsPerYHalfScene + 1;
  const G4int nZSamples = 2 * nDataPointsPerZHalfScene + 1;
  const G4int nSamples = nXSamples * nYSamples * nZSamples;
  const G4double arrowLengthMax = 0.8 * interval;
 
  // Working vectors for field values, etc.
  std::vector<G4Point3D> Field(nSamples);          // Initialises to (0,0,0)
  std::vector<G4Point3D> xyz(nSamples);            // Initialises to (0,0,0)
  G4double FieldMagnitudeMax = -std::numeric_limits<G4double>::max();
 
  // Get field values and ascertain maximum field.
  for (G4int i = 0; i < nXSamples; i++) {
    G4double x = xSceneCentre + (i - nDataPointsPerXHalfScene) * interval;
 
    for (G4int j = 0; j < nYSamples; j++) {
      G4double y = ySceneCentre + (j - nDataPointsPerYHalfScene) * interval;
 
      for (G4int k = 0; k < nZSamples; k++) {
        G4double z = zSceneCentre + (k - nDataPointsPerZHalfScene) * interval;
 
        // Calculate indices into working vectors
        const G4int ijk = i * nYSamples * nZSamples + j * nZSamples + k;
    xyz[ijk].set(x,y,z);
 
        G4ThreeVector pos(x,y,z);
 
        // Check if point is in findings
        if (!fPVFindings.empty()) {
          G4bool isInPV = false;
          for (const auto& findings: fPVFindings) {
            G4VPhysicalVolume* pv = findings.fpFoundPV;
            G4int copyNo = findings.fFoundPVCopyNo;
            G4VSolid* solid = pv->GetLogicalVolume()->GetSolid();
            G4PVParameterised* pvParam = dynamic_cast<G4PVParameterised*>(pv);
            if (pvParam) {
              auto* param = pvParam->GetParameterisation();
              solid = param->ComputeSolid(copyNo,pvParam);
              solid->ComputeDimensions(param,copyNo,pvParam);
            }
            // Transform point to local coordinate system
            const auto& transform = findings.fFoundObjectTransformation;
            auto rotation = transform.getRotation();
            auto translation = transform.getTranslation();
            G4ThreeVector lPos = pos; lPos -= translation; lPos.transform(rotation.invert());
            if (solid->Inside(lPos)==kInside) {
              isInPV = true;
              break;
            }
          }
          if (!isInPV) continue;
        }
        // Point is in findings - or there were no findings
 
        // Find volume and field at this location.
        const G4VPhysicalVolume* pPV =
        navigator->LocateGlobalPointAndSetup(pos,0,false,true);
        const G4Field* field = globalField;
        if (pPV) {
          // Get logical volume.
          const G4LogicalVolume* pLV = pPV->GetLogicalVolume();
          if (pLV) {
            // Value for Region, if any, overrides
            G4Region* pRegion = pLV->GetRegion();
            if (pRegion) {
              G4FieldManager* pRegionFieldMgr = pRegion->GetFieldManager();
              if (pRegionFieldMgr) {
                field = pRegionFieldMgr->GetDetectorField();
                // G4cout << "Region with field" << G4endl;
              }
            }
            // 'Local' value from logical volume, if any, overrides
            G4FieldManager* pLVFieldMgr = pLV->GetFieldManager();
            if (pLVFieldMgr) {
              field = pLVFieldMgr->GetDetectorField();
              // G4cout << "Logical volume with field" << G4endl;
            }
          }
        }
 
    G4double time = 0.; // FIXME:  Can we get event time in some way?
 
    // Subclasses will have implemented this for their own field
    GetFieldAtLocation(field, xyz[ijk], time, Field[ijk]);
 
    G4double mag = Field[ijk].mag();
    if (mag > FieldMagnitudeMax) FieldMagnitudeMax = mag;
      } // for (k, z
    }   // for (j, y
  } // for (i, x
 
  if (FieldMagnitudeMax <= 0.) {
    G4cout << "No " << fTypeOfField << " field in this extent." << G4endl;
    return;
  }
 
  for (G4int i = 0; i < nSamples; i++) {
    const G4double Fmag = Field[i].mag();
    const G4double f = Fmag / FieldMagnitudeMax;
    if (f <= 0.) continue;  // Skip zero field locations
 
    G4double red = 0., green = 0., blue = 0., alpha = 1.;
    if (f < 0.5) {  // Linear colour scale: 0->0.5->1 is red->green->blue.
      green = 2. * f;
      red = 2. * (0.5 - f);
    } else {
      blue = 2. * (f - 0.5);
      green = 2. * (1.0 - f);
    }
    const G4Colour arrowColour(red,green,blue,alpha);
 
    // Very small arrows are difficult to see. Better to draw a line.
    G4bool drawAsLine = false;
    switch (fRepresentation) {
      case Representation::fullArrow:
        if (f < 0.1) {
          drawAsLine = true;
        }
        break;
      case Representation::lightArrow:
        drawAsLine = true;
        break;
      default:
        break;
    }
 
    // Head of arrow depends on field direction and strength...
    G4double arrowLength = arrowLengthMax * f;
    // ...but limit the length so it's visible.
    if (f < 0.01) arrowLength = arrowLengthMax * 0.01;
    const G4Point3D head = xyz[i] + arrowLength*Field[i]/Fmag;
 
    if (drawAsLine) {
      G4Polyline FArrowLite;
      G4VisAttributes va(arrowColour);
      va.SetLineWidth(2.);
      FArrowLite.SetVisAttributes(va);
      FArrowLite.push_back(xyz[i]);
      FArrowLite.push_back(head);
      sceneHandler.BeginPrimitives();
      sceneHandler.AddPrimitive(FArrowLite);
      sceneHandler.EndPrimitives();
    } else {
      G4ArrowModel FArrow(xyz[i].x(), xyz[i].y(), xyz[i].z(),
                          head.x(), head.y(), head.z(),
                          arrowLength/5, arrowColour,
                          fArrowPrefix+"Field",
                          fArrow3DLineSegmentsPerCircle);
      FArrow.DescribeYourselfTo(sceneHandler);
    }
  } // for (i, nSamples
}

References G4VGraphicsScene::AddPrimitive(), alpha, G4VGraphicsScene::BeginPrimitives(), G4VSolid::ComputeDimensions(), G4ArrowModel::DescribeYourselfTo(), G4FieldManager::DoesFieldExist(), G4VGraphicsScene::EndPrimitives(), G4VFieldModel::fArrow3DLineSegmentsPerCircle, G4VFieldModel::fArrowPrefix, G4VFieldModel::fExtentForField, G4VFieldModel::fNDataPointsPerMaxHalfExtent, G4VFieldModel::fPVFindings, G4VFieldModel::fRepresentation, G4VFieldModel::fTypeOfField, G4cout, G4endl, G4FieldManager::GetDetectorField(), G4VGraphicsScene::GetExtent(), G4VFieldModel::GetFieldAtLocation(), G4LogicalVolume::GetFieldManager(), G4Region::GetFieldManager(), G4TransportationManager::GetFieldManager(), G4VPhysicalVolume::GetLogicalVolume(), G4TransportationManager::GetNavigatorForTracking(), G4VisExtent::GetNullExtent(), G4PVParameterised::GetParameterisation(), G4LogicalVolume::GetRegion(), G4LogicalVolume::GetSolid(), G4TransportationManager::GetTransportationManager(), G4VisExtent::GetXmax(), G4VisExtent::GetXmin(), G4VisExtent::GetYmax(), G4VisExtent::GetYmin(), G4VisExtent::GetZmax(), G4VisExtent::GetZmin(), G4VSolid::Inside(), kInside, G4INCL::Math::max(), write_gdml::navigator, pos, G4VisAttributes::SetLineWidth(), G4Visible::SetVisAttributes(), CLHEP::Hep3Vector::transform(), G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

GetCurrentDescription()

G4String G4VModel::GetCurrentDescription ( ) const

virtualinherited

Reimplemented in G4GPSModel, and G4PhysicalVolumeModel.

Definition at line 51 of file G4VModel.cc.

                                                {
  // Override in concrete class if concept of "current" is meaningful.
  return fGlobalDescription;
}

References G4VModel::fGlobalDescription.

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

GetCurrentTag()

G4String G4VModel::GetCurrentTag ( ) const

virtualinherited

Reimplemented in G4GPSModel, and G4PhysicalVolumeModel.

Definition at line 46 of file G4VModel.cc.

                                        {
  // Override in concrete class if concept of "current" is meaningful.
  return fGlobalTag;
}

References G4VModel::fGlobalTag.

Referenced by G4Qt3DSceneHandler::AddPrimitive(), and G4ToolsSGSceneHandler::AddPrimitive().

GetExtent()

const G4VisExtent & G4VModel::GetExtent ( ) const

inherited

Referenced by G4PhysicalVolumeModel::CalculateExtent(), and G4VisCommandSceneAddLogicalVolume::SetNewValue().

GetFieldAtLocation()

void G4MagneticFieldModel::GetFieldAtLocation ( const G4Field *  field, const G4Point3D &  position, G4double  time, G4Point3D &  result  ) const

protectedvirtual

Implements G4VFieldModel.

Definition at line 43 of file G4MagneticFieldModel.cc.

                                                   {
  if (!field) return;           // No action if no field
 
  G4double xyzt[4] = { position.x(), position.y(), position.z(), time };
  G4double BEvals[6] = {0.};        // Field returns {Bx,By,Bz,Ex,Ey,Ez}
  field->GetFieldValue(xyzt, BEvals);
 
  result.set(BEvals[0], BEvals[1], BEvals[2]);
  return;
}

References G4Field::GetFieldValue(), and HepGeom::BasicVector3D< T >::set().

GetGlobalDescription()

const G4String & G4VModel::GetGlobalDescription ( ) const

inherited

Referenced by G4Scene::AddRunDurationModel(), and anonymous_namespace{G4Scene.cc}::PrintInvalidModel().

GetGlobalTag()

const G4String & G4VModel::GetGlobalTag ( ) const

inherited

Referenced by G4Qt3DSceneHandler::CreateNewNode().

GetModelingParameters()

const G4ModelingParameters * G4VModel::GetModelingParameters ( ) const

inherited

Referenced by G4ASCIITreeSceneHandler::EndModeling(), and G4OpenGLSceneHandler::ScaledFlush().

GetType()

const G4String & G4VModel::GetType ( ) const

inherited

Referenced by G4OpenGLStoredQtSceneHandler::ExtraPOProcessing().

operator=()

G4MagneticFieldModel & G4MagneticFieldModel::operator= ( const G4MagneticFieldModel &  )

private

SetExtent()

void G4VModel::SetExtent ( const G4VisExtent &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), and G4VisCommandSceneAddScale::SetNewValue().

SetGlobalDescription()

void G4VModel::SetGlobalDescription ( const G4String &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4VisCommandSceneAddText2D::SetNewValue().

SetGlobalTag()

void G4VModel::SetGlobalTag ( const G4String &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), G4VisCommandSceneAddText2D::SetNewValue(), and G4VisCommandsTouchable::SetNewValue().

SetModelingParameters()

void G4VModel::SetModelingParameters ( const G4ModelingParameters *  )

inherited

Referenced by G4LogicalVolumeModel::DescribeYourselfTo(), G4ASCIITreeSceneHandler::EndModeling(), G4TouchableUtils::FindTouchableProperties(), G4VSceneHandler::ProcessScene(), G4VisCommandSetTouchable::SetNewValue(), G4VisCommandSetVolumeForField::SetNewValue(), G4VisCommandsTouchable::SetNewValue(), and G4VisCommandViewerCentreOn::SetNewValue().

SetType()

void G4VModel::SetType ( const G4String &  )

inherited

Referenced by G4VisCommandSceneAddUserAction::AddVisAction(), G4VisCommandSceneAddArrow2D::SetNewValue(), G4VisCommandSceneAddDate::SetNewValue(), G4VisCommandSceneAddEventID::SetNewValue(), G4VisCommandSceneAddExtent::SetNewValue(), G4VisCommandSceneAddFrame::SetNewValue(), G4VisCommandSceneAddLine::SetNewValue(), G4VisCommandSceneAddLine2D::SetNewValue(), G4VisCommandSceneAddLogo::SetNewValue(), G4VisCommandSceneAddLogo2D::SetNewValue(), G4VisCommandSceneAddScale::SetNewValue(), and G4VisCommandSceneAddText2D::SetNewValue().

Validate()

G4bool G4VModel::Validate ( G4bool  warn = true )

virtualinherited

Reimplemented in G4PhysicalVolumeModel, and G4LogicalVolumeModel.

Definition at line 56 of file G4VModel.cc.

                                 {
  return true;
}

Field Documentation

fArrow3DLineSegmentsPerCircle

G4int G4VFieldModel::fArrow3DLineSegmentsPerCircle

privateinherited

Definition at line 102 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo(), and G4VFieldModel::G4VFieldModel().

fArrowPrefix

G4String G4VFieldModel::fArrowPrefix

privateinherited

Definition at line 104 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo().

fExtent

G4VisExtent G4VModel::fExtent

protectedinherited

Definition at line 101 of file G4VModel.hh.

Referenced by G4PhysicalVolumeModel::CalculateExtent(), G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), and G4PlotterModel::G4PlotterModel().

fExtentForField

G4VisExtent G4VFieldModel::fExtentForField

privateinherited

Definition at line 86 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo(), and G4VFieldModel::G4VFieldModel().

fGlobalDescription

G4String G4VModel::fGlobalDescription

protectedinherited

Definition at line 100 of file G4VModel.hh.

Referenced by G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), G4DigiModel::G4DigiModel(), G4GPSModel::G4GPSModel(), G4HitsModel::G4HitsModel(), G4LogicalVolumeModel::G4LogicalVolumeModel(), G4PhysicalVolumeModel::G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), G4VFieldModel::G4VFieldModel(), and G4VModel::GetCurrentDescription().

fGlobalTag

G4String G4VModel::fGlobalTag

protectedinherited

Definition at line 99 of file G4VModel.hh.

Referenced by G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), G4DigiModel::G4DigiModel(), G4GPSModel::G4GPSModel(), G4HitsModel::G4HitsModel(), G4LogicalVolumeModel::G4LogicalVolumeModel(), G4PhysicalVolumeModel::G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), G4VFieldModel::G4VFieldModel(), G4PhysicalVolumeModel::GetCurrentTag(), and G4VModel::GetCurrentTag().

fNDataPointsPerMaxHalfExtent

G4int G4VFieldModel::fNDataPointsPerMaxHalfExtent

privateinherited

Definition at line 94 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo(), and G4VFieldModel::G4VFieldModel().

fpMP

const G4ModelingParameters* G4VModel::fpMP

protectedinherited

Definition at line 102 of file G4VModel.hh.

Referenced by G4PhysicalVolumeModel::CalculateExtent(), G4PhysicalVolumeModel::DescribeAndDescend(), G4PhysicalVolumeModel::DescribeSolid(), G4DigiModel::DescribeYourselfTo(), G4HitsModel::DescribeYourselfTo(), G4LogicalVolumeModel::DescribeYourselfTo(), G4PhysicalVolumeModel::DescribeYourselfTo(), G4TrajectoriesModel::DescribeYourselfTo(), G4CallbackModel< F >::DescribeYourselfTo(), and G4PhysicalVolumeModel::VisitGeometryAndGetVisReps().

fPVFindings

std::vector<G4PhysicalVolumesSearchScene::Findings> G4VFieldModel::fPVFindings

privateinherited

Definition at line 89 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo(), and G4VFieldModel::G4VFieldModel().

fRepresentation

Representation G4VFieldModel::fRepresentation

privateinherited

Definition at line 101 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo(), and G4VFieldModel::G4VFieldModel().

fType

G4String G4VModel::fType

protectedinherited

Definition at line 98 of file G4VModel.hh.

Referenced by G4AxesModel::Construct(), G4ArrowModel::G4ArrowModel(), G4DigiModel::G4DigiModel(), G4GPSModel::G4GPSModel(), G4HitsModel::G4HitsModel(), G4LogicalVolumeModel::G4LogicalVolumeModel(), G4PhysicalVolumeModel::G4PhysicalVolumeModel(), G4PlotterModel::G4PlotterModel(), G4PSHitsModel::G4PSHitsModel(), G4TextModel::G4TextModel(), G4TrajectoriesModel::G4TrajectoriesModel(), and G4VFieldModel::G4VFieldModel().

fTypeOfField

G4String G4VFieldModel::fTypeOfField

privateinherited

Definition at line 103 of file G4VFieldModel.hh.

Referenced by G4VFieldModel::DescribeYourselfTo().

---

The documentation for this class was generated from the following files:

• source/visualization/modeling/include/G4MagneticFieldModel.hh
• source/visualization/modeling/src/G4MagneticFieldModel.cc