32.5. Importing CAD Geometry

Table of Contents

GDML

Geant4 can import complex geometries that were originally created in CAD or other external tools by using GDML. GDML, the Geometry Description Markup Language, is an XML format that describes volumes, materials, placements, and other geometry features in a way that Geant4 and other tools can understand.

At a high level, you normally follow this chain: create or export a model from a CAD or geometry tool, convert that model to a GDML file, then load the GDML file into your Geant4 application where it becomes part of the detector geometry.

In a typical Geant4 application, the GDML file does not replace your C++ DetectorConstruction class. Instead, your DetectorConstruction class becomes responsible for loading and inserting the GDML geometry into the world volume or another logical volume.

What GDML describes

A GDML file can contain several sections that map to Geant4 concepts:

GDML concept	Geant4 concept	Comment
`<define>`	Constants and expressions	Distances, angles, and other re-used values
`<materials>`	`G4Material` and `G4Element`	Names, densities, compositions
`<solids>`	`G4VSolid` subclasses	Boxes, tubes, boolean solids, etc.
`<structure>`	`G4LogicalVolume` and placements	Logical volumes and their hierarchy
`<setup>`	World definition	Top-level volume used as the world

Inside <structure> the GDML file typically defines volumes by referring to a solid and a material, then specifies how each volume is placed inside its mother volume. This mirrors the Geant4 pattern of solid, logical volume, and physical placement.

Many CAD-derived GDML files only describe geometry. They often come with very generic or automatically generated material names and properties. For detector simulations you frequently replace or refine the materials defined in the original file so that they match realistic densities and compositions.

Loading a GDML file in DetectorConstruction

To load a GDML file, Geant4 provides helper classes in the g4gdml module. In your DetectorConstruction class, you usually use a parser object to read the GDML and then obtain the top volume.

A common pattern is:

Create a G4GDMLParser instance.
Call its Read() method with the path to the GDML file.
Get the top-level logical volume or physical volume from the parser.
Use it as the world volume, or place it inside an existing world.

From Geant4’s point of view, the world volume must be a G4VPhysicalVolume. When you load a GDML file that already defines a world, you typically let the parser build that world and simply return it from Construct().

A minimal style of DetectorConstruction implementation for a fully external world could be:

cpp

#include "G4VUserDetectorConstruction.hh"
#include "G4GDMLParser.hh"
#include "G4PVPlacement.hh"
class DetectorConstruction : public G4VUserDetectorConstruction {
public:
  DetectorConstruction(const G4String& gdmlFile)
  : G4VUserDetectorConstruction(),
    fGdmlFile(gdmlFile) {}
  virtual G4VPhysicalVolume* Construct() {
    G4GDMLParser parser;
    parser.Read(fGdmlFile, false); // validate = false for speed, true for extra checks
    G4VPhysicalVolume* worldPhys = parser.GetWorldVolume();
    return worldPhys;
  }
private:
  G4String fGdmlFile;
};

In this approach, the GDML file must contain a <setup> section that defines which volume is the world. The parser then builds that hierarchy and gives you the ready-to-use physical world.

If you prefer to construct your own world volume in C++ and only place the imported CAD geometry as a sub-detector inside it, you can:

Build the Geant4 world in C++.
Parse the GDML into a separate volume hierarchy.
Place the GDML top volume inside the world.

To do this, you typically access the top logical volume from the parser and then use G4PVPlacement to place it into the world logical volume.

Materials in GDML

When importing CAD geometry through GDML, the material definitions are a critical point. CAD models do not generally know about physical properties such as density or elemental composition. During conversion to GDML, often generic materials are assigned, for example, "Steel" or "Aluminum," with simple or approximate properties.

For realistic simulations, you often want to re-map or override these materials:

Use G4NistManager to create reliable materials by name, such as G4_Al, G4_Pb, or custom tissue-like materials.
After parsing the GDML, traverse the logical volumes and replace the materials that have placeholder names.
Alternatively, write or edit the GDML file to refer directly to Geant4 NIST material names and properties that match your needs.

A geometry imported from CAD should never be used for physics studies without checking and correcting its materials. Geometrically correct but physically wrong materials can lead to completely misleading simulation results.

Coordinate systems and units in GDML

GDML supports units in its attributes. For example, a length might be written as value="10" unit="mm". When Geant4 reads the GDML, it converts these to internal units (which follow the Geant4 unit system). It is important that the units specified in the GDML match what the parser expects. If the original CAD export tool ignores units or uses a different default, the imported geometry could be scaled incorrectly.

To avoid surprises:

Confirm the unit settings in the CAD export or intermediate conversion tool.
Inspect a few known dimensions after import, for example by printing the half-lengths of solids or using visualization, to ensure that sizes are correct.
Avoid mixing inconsistent unit tags in a single GDML file.

The coordinate system in GDML is right-handed and directly maps to the Geant4 world coordinate system. Any placements in the file are interpreted as positions and rotations relative to their mother volumes, just like in C++ placements.

Validating an imported GDML geometry

After importing a GDML geometry, you should validate it inside Geant4. The most basic checks are:

Use visualization to draw the world and verify that shapes appear as expected.
Use the built-in geometry overlap checks in Geant4 to look for overlapping volumes.
Check that the world is large enough to contain all imported volumes with some safety margin.

Because CAD-derived geometries are often complex, they can contain tiny overlaps, coincident surfaces, or very thin volumes that cause numerical issues in tracking. The overlap checking tools help you catch these early before you start long simulations.

If you see tracking problems such as particles getting stuck or large step sizes in vacuum gaps that should not exist, it might indicate a problem in how the CAD model was converted or how solids were approximated.

External geometry

While GDML is the most widely supported format for exchanging geometry with Geant4, it is not the only way to bring CAD or external models into a simulation. External geometry in this context means any geometry that was not hand defined with Geant4 C++ classes, but instead comes from external files or external geometry kernels.

There are two main ideas:

Use dedicated converters that take CAD formats and produce GDML or Geant4-compatible classes.
Use interfaces that let Geant4 query another geometry engine at run time.

Both approaches aim to reuse complex models without re-implementing them in C++.

From CAD to Geant4 through converters

Many CAD systems use proprietary or specialized formats such as STEP, IGES, or various mesh formats (STL, OBJ, etc.). Geant4 does not read these directly. Instead, you use separate tools or libraries that convert these files into either GDML or directly into Geant4 solids.

Typical workflows include:

Export the geometry from a CAD program into a neutral format such as STEP or STL.
Run a conversion tool that reads the neutral format and outputs GDML. There are several community tools and scripts for STEP to GDML or STL to GDML conversion.
Import the resulting GDML into Geant4 as described in the previous section.

Another style is to convert CAD meshes into tessellated solids. A tessellated solid in Geant4 is made of triangular facets and can approximate arbitrary shapes. Some tools generate C++ code that creates a G4TessellatedSolid, or they may generate a GDML <tessellated> solid. This approach is useful when you want a single closed shape from a surface mesh, for example for shielding blocks or complex housings.

When relying on converters you should consider:

How they treat geometric tolerances and small gaps.
Whether they preserve or simplify complex features.
How they assign materials to individual parts.

Even a perfect geometric conversion does not automatically provide realistic material properties or physics relevance.

Using external geometry engines

In some advanced applications, Geant4 is used together with an external geometry engine. In this arrangement, another library, often used for CAD or for detector modeling, is responsible for precise geometry representation, while Geant4 performs particle transport by querying that engine.

Examples include:

Interfaces between Geant4 and experiment-specific geometry descriptions, such as those used in large HEP detectors.
Use of geometry kernels that provide constructive solid geometry or mesh-based representations, which Geant4 can intersect for tracking.

From the point of view of a beginner-level application, these are specialized setups that require custom integration and are usually not needed. However, it is useful to know that such interfaces exist, especially if you encounter references to "importing geometry from an experiment framework" or from "a CAD kernel" in advanced documentation.

The key idea is that Geant4 does not always need to own all geometry definitions as G4VSolid and G4LogicalVolume objects. Instead, it can be configured to ask another system questions like "how far until the next boundary" or "what material is at this point" and use the answers for tracking.

Choosing a strategy for CAD-based geometry

When you want to bring a CAD model into a beginner-friendly Geant4 project, the most practical approach is almost always:

Export from CAD to a neutral format such as STEP.
Convert that neutral format to GDML or to a tessellated solid using an available tool.
Load the GDML into your DetectorConstruction class.
Replace or refine material definitions in C++.
Validate the geometry with visualization and overlap checks.

Direct use of external geometry engines or custom CAD interfaces is more complex and typically goes beyond an introductory course. It is usually adopted in large collaborative projects, where the geometry description has to be shared between multiple simulation and reconstruction programs.

No matter which strategy you choose, the goal is the same: to reuse an existing detailed geometry efficiently while maintaining control over the physical properties of the materials and the structure of the detector as it appears to Geant4.