simcore::geo::AuxInfoReader Class Reference

Reads auxiliary information from GDML userinfo block. More...

#include <AuxInfoReader.h>

Public Member Functions
	AuxInfoReader (G4GDMLParser *parser, const framework::config::Parameters &ps)
	Class constructor.
virtual	~AuxInfoReader ()
	Class destructor.
void	readGlobalAuxInfo ()
	Read the global auxiliary information from the auxinfo block.
void	assignAuxInfoToVolumes ()
	Assign auxiliary info to volumes such as sensitive detectors.
ldmx::DetectorHeader *	getDetectorHeader ()
	Get the detector header that was created from the userinfo block.

Private Member Functions
void	createMagneticField (const G4String &name, const G4GDMLAuxListType *auxInfoList)
	Create a magnetic field from GDML data.
void	createRegion (const G4String &name, const G4GDMLAuxListType *auxInfoList)
	Create a detector region from GDML data.
void	selectColorMode (const G4String &mode)
	Select the 'mode' for coloring in the visualization.
void	createVisAttributes (const G4String &name, const G4GDMLAuxListType *auxInfoList)
	Create visualization attributes from GDML data.
void	createDetectorHeader (const G4String &detectorVersion, const G4GDMLAuxListType *auxInfoList)
	Create the detector header from the global auxinfo.

Private Attributes
G4GDMLParser *	parser_
	The GDML parser.
G4GDMLEvaluator *	eval_
	The GDML expression evaluator.
ldmx::DetectorHeader *	detector_header_ {nullptr}
	Detector header with name and version.
std::string	color_mode_
	Color mode for visattributes.
std::vector< std::string >	universal_visattributes_

Detailed Description

Reads auxiliary information from GDML userinfo block.

Note

This class reads information to define a detector header block, sensitive detectors, visualization attributes, magnetic fields, detector IDs, and detector regions from the userinfo block of a GDML file. These objects are then assigned to the appropriate logical volumes which have auxiliary tags that reference these objects by name.

Definition at line 28 of file AuxInfoReader.h.

Constructor & Destructor Documentation

AuxInfoReader()

simcore::geo::AuxInfoReader::AuxInfoReader	(	G4GDMLParser *	parser,
		const framework::config::Parameters &	ps )

Class constructor.

Parameters

parser	The GDML parser.
ps	configuration parameters

Definition at line 30 of file AuxInfoReader.cxx.

    : parser_(theParser), eval_(new G4GDMLEvaluator) {}

~AuxInfoReader()

simcore::geo::AuxInfoReader::~AuxInfoReader ( )

virtual

Class destructor.

Definition at line 34 of file AuxInfoReader.cxx.

                              {
  delete eval_;
  delete detector_header_;
}

References detector_header_, and eval_.

Member Function Documentation

assignAuxInfoToVolumes()

void simcore::geo::AuxInfoReader::assignAuxInfoToVolumes

(

)

Assign auxiliary info to volumes such as sensitive detectors.

Definition at line 65 of file AuxInfoReader.cxx.

                                           {
  const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
  std::vector<G4LogicalVolume*>::const_iterator lvciter;
  for (lvciter = lvs->begin(); lvciter != lvs->end(); lvciter++) {
    G4GDMLAuxListType aux_info_list =
        parser_->GetVolumeAuxiliaryInformation(*lvciter);
 
    for (const auto& aux_info : aux_info_list) {
      G4String aux_type = aux_info.type;
      G4String aux_val = aux_info.value;
 
      G4LogicalVolume* lv = (*lvciter);
 
      if (aux_type == "MagneticField") {
        const G4String& mag_field_name = aux_val;
        G4MagneticField* mag_field =
            MagneticFieldStore::getInstance()->getMagneticField(mag_field_name);
        if (mag_field != nullptr) {
          auto mgr = new G4FieldManager(mag_field);
          lv->SetFieldManager(
              mgr,
              true /* FIXME: hard-coded to force field manager to daughters */);
          // G4cout << "Assigned magnetic field " << magFieldName << " to
          // volume " << lv->GetName() << G4endl;
        } else {
          EXCEPTION_RAISE(
              "MissingInfo",
              "Unknown MagneticField ref in volume's auxiliary info: " +
                  std::string(mag_field_name.data()));
        }
      } else if (aux_type == "Region") {
        const G4String& region_name = aux_val;
        G4Region* region = G4RegionStore::GetInstance()->GetRegion(region_name);
        if (region != nullptr) {
          region->AddRootLogicalVolume(lv);
          // G4cout << "Added volume " << lv->GetName() << " to region " <<
          // regionName << G4endl;
        } else {
          EXCEPTION_RAISE("MissingInfo", "Reference region '" +
                                             std::string(region_name.data()) +
                                             "' was not found!");
        }
      } else if (aux_type == "VisAttributes") {
        // Same as when registering visattributes, must match mode (if in use)
        auto match = std::find(universal_visattributes_.begin(),
                               universal_visattributes_.end(), aux_val);
        if (match == universal_visattributes_.end() && color_mode_ != "" &&
            aux_val.find(color_mode_) == std::string::npos) {
          continue;
        }
        const G4String& vis_name = aux_val;
        G4VisAttributes* vis_attributes =
            VisAttributesStore::getInstance()->getVisAttributes(vis_name);
        if (vis_attributes != nullptr) {
          lv->SetVisAttributes(vis_attributes);
          // G4cout << "Assigned VisAttributes " << visName << " to volume "
          // << lv->GetName() << G4endl;
        } else {
          EXCEPTION_RAISE("MissingInfo", "Referenced VisAttributes '" +
                                             std::string(vis_name.data()) +
                                             "' was not found!");
        }
      }
    }
  }
}

References color_mode_, simcore::MagneticFieldStore::getInstance(), simcore::VisAttributesStore::getInstance(), simcore::MagneticFieldStore::getMagneticField(), simcore::VisAttributesStore::getVisAttributes(), and parser_.

createDetectorHeader()

void simcore::geo::AuxInfoReader::createDetectorHeader ( const G4String & detectorVersion, const G4GDMLAuxListType * auxInfoList )

private

Create the detector header from the global auxinfo.

Parameters

detectorVersion	The aux value with the detector version.
auxInfoList	The aux info with the detector header information.

Definition at line 374 of file AuxInfoReader.cxx.

                                                                               {
  int detector_version = atoi(auxValue.c_str());
 
  std::string detector_name("");
  std::string author("");
  std::string description("");
 
  for (const auto& aux_info : *auxInfoList) {
    G4String aux_type = aux_info.type;
    G4String aux_val = aux_info.value;
 
    if (aux_type == "DetectorName") {
      detector_name = aux_val;
    } else if (aux_type == "Author") {
      author = aux_val;
    } else if (aux_type == "Description") {
      description = aux_val;
    }
  }
 
  detector_header_ = new ldmx::DetectorHeader(detector_name, detector_version,
                                              description, author);
 
  /*G4cout << G4endl;
  G4cout << "Read detector header from userinfo: " << G4endl;
  G4cout << "  DetectorName: " << detector_header_->getName() << G4endl;
  G4cout << "  DetectorVersion: " << detector_header_->getVersion() << G4endl;
  G4cout << "  Author: " << detector_header_->getAuthor() << G4endl;
  G4cout << "  Description: " << detector_header_->getDescription() << G4endl;
  G4cout << G4endl;*/
}

References detector_header_.

Referenced by readGlobalAuxInfo().

createMagneticField()

void simcore::geo::AuxInfoReader::createMagneticField ( const G4String & name, const G4GDMLAuxListType * auxInfoList )

private

Create a magnetic field from GDML data.

Parameters

name	The name of the magnetic field.
auxInfoList	The aux info defining the magnetic field.

Definition at line 132 of file AuxInfoReader.cxx.

                                                                              {
  // Find type of the mag field.
  G4String mag_field_type("");
  for (const auto& aux_info : *auxInfoList) {
    G4String aux_type = aux_info.type;
    G4String aux_val = aux_info.value;
 
    if (aux_type == "MagneticFieldType") {
      mag_field_type = aux_val;
      break;
    }
  }
 
  if (mag_field_type == "") {
    EXCEPTION_RAISE("MissingInfo",
                    "Missing MagFieldType for magnetic field definition.");
  }
 
  G4MagneticField* mag_field = nullptr;
 
  // Create a uniform mag field using the built-in Geant4 type.
  if (mag_field_type == "G4UniformMagField") {
    double bx, by, bz;
    bx = by = bz = 0.;
    for (const auto& aux_info : *auxInfoList) {
      G4String aux_type = aux_info.type;
      G4String aux_val = aux_info.value;
      G4String aux_unit = aux_info.unit;
 
      G4String expr = aux_val + "*" + aux_unit;
      if (aux_type == "bx") {
        bx = eval_->Evaluate(expr);
      } else if (aux_type == "by") {
        by = eval_->Evaluate(expr);
      } else if (aux_type == "bz") {
        bz = eval_->Evaluate(expr);
      }
    }
    G4ThreeVector field_components(bx, by, bz);
    mag_field = new G4UniformMagField(field_components);
 
    // G4cout << "Created G4UniformMagField " << magFieldName << " with field
    // components " << fieldComponents << G4endl << G4endl;
 
    // Create a global 3D field map by reading from a data file.
  } else if (mag_field_type == "MagneticFieldMap3D") {
    string file_name;
    double offset_x{};
    double offset_y{};
    double offset_z{};
 
    for (const auto& aux_info : *auxInfoList) {
      G4String aux_type = aux_info.type;
      G4String aux_val = aux_info.value;
      G4String aux_unit = aux_info.unit;
 
      G4String expr = aux_val + "*" + aux_unit;
 
      if (aux_type == "File") {
        file_name = aux_val;
      } else if (aux_type == "OffsetX") {
        offset_x = eval_->Evaluate(expr);
      } else if (aux_type == "OffsetY") {
        offset_y = eval_->Evaluate(expr);
      } else if (aux_type == "OffsetZ") {
        offset_z = eval_->Evaluate(expr);
      }
    }
 
    if (file_name.size() == 0) {
      EXCEPTION_RAISE("MissingInfo",
                      "File info with field data was not provided.");
    }
 
    // Create new 3D field map.
    mag_field =
        new MagneticFieldMap3D(file_name.c_str(), offset_x, offset_y, offset_z);
 
    // Assign field map as global field.
    G4FieldManager* field_mgr =
        G4TransportationManager::GetTransportationManager()->GetFieldManager();
    if (field_mgr->GetDetectorField() != nullptr) {
      EXCEPTION_RAISE("MisAssign", "Global mag field was already assigned.");
    }
    field_mgr->SetDetectorField(mag_field);
    field_mgr->CreateChordFinder(mag_field);
 
  } else {
    EXCEPTION_RAISE("UnknownType", "Unknown MagFieldType '" +
                                       std::string(mag_field_type.data()) +
                                       "' in auxiliary info.");
  }
 
  MagneticFieldStore::getInstance()->addMagneticField(magFieldName, mag_field);
}

References simcore::MagneticFieldStore::addMagneticField(), eval_, and simcore::MagneticFieldStore::getInstance().

Referenced by readGlobalAuxInfo().

createRegion()

void simcore::geo::AuxInfoReader::createRegion ( const G4String & name, const G4GDMLAuxListType * auxInfoList )

private

Create a detector region from GDML data.

Parameters

name	The name of the detector region.
auxInfoList	The aux info defining the detector region.

Definition at line 229 of file AuxInfoReader.cxx.

                                                                       {
  bool store_trajectories = true;
  for (const auto& aux_info : *auxInfoList) {
    G4String aux_type = aux_info.type;
    G4String aux_val = aux_info.value;
 
    if (aux_type == "StoreTrajectories") {
      if (aux_val == "false") {
        store_trajectories = false;
      } else if (aux_val == "true") {
        store_trajectories = true;
      }
    }
  }
  G4VUserRegionInformation* region_info =
      new UserRegionInformation(store_trajectories);
  // This looks like a memory leak, but isn't. I (Einar) have checked. Geant4
  // registers the region in the constructor and deletes it at the end.
  //
  // Some static analysis tools may struggle with identifying that this one
  // happens to be fine. The NOLINT comment tells clang-tidy to not bother
  // within the region
  //
  // NOLINTBEGIN
  auto region = new G4Region(name);
  region->SetUserInformation(region_info);
  // To get rid of those pesky G4 warnings
  region->SetProductionCuts(G4ProductionCutsTable::GetProductionCutsTable()
                                ->GetDefaultProductionCuts());
}

Referenced by readGlobalAuxInfo().

createVisAttributes()

void simcore::geo::AuxInfoReader::createVisAttributes ( const G4String & name, const G4GDMLAuxListType * auxInfoList )

private

Create visualization attributes from GDML data.

Parameters

name	The name of the visualization attributes.
auxInfoList	The aux info defining the visualization attributes.

Definition at line 289 of file AuxInfoReader.cxx.

                                                                              {
  std::array<G4double, 4> rgba = {1., 1., 1., 1.};
  G4bool visible = true;
  G4bool dau_invisible = false;
  G4bool force_wireframe = false;
  G4bool force_solid = false;
  G4double line_width = 1.0;
  G4VisAttributes::LineStyle line_style = G4VisAttributes::unbroken;
 
  // There are some visattributes which should be accepted regardless of mode
  universal_visattributes_ = {
      "InvisibleNoDau", "InvisibleShowDau", "NoDau",     "GrayWireFrame",
      "BlueWireFrame",  "BlueSolid",        "Invisible", "SpVis"};
  auto match = std::find(universal_visattributes_.begin(),
                         universal_visattributes_.end(), name);
 
  // If a visattribute is not universal, a color mode is set, and the
  // visattribute doesn't match the current mode, don't register it
  if (match == universal_visattributes_.end() && color_mode_ != "" &&
      name.find(color_mode_) == std::string::npos) {
    ldmx_log(debug) << "VisAttribute " << name
                    << " doesn't match current mode. Skipping...";
    return;
    // Note that if color mode is not set, the last visattributes
    // defined for each volume will be the active ones
  }
 
  for (const auto& aux_info : *auxInfoList) {
    G4String aux_type = aux_info.type;
    G4String aux_val = aux_info.value;
 
    if (aux_type == "R") {
      rgba[0] = atof(aux_val.c_str());
    } else if (aux_type == "G") {
      rgba[1] = atof(aux_val.c_str());
    } else if (aux_type == "B") {
      rgba[2] = atof(aux_val.c_str());
    } else if (aux_type == "A") {
      rgba[3] = atof(aux_val.c_str());
    } else if (aux_type == "Style") {
      if (aux_val == "wireframe") {
        force_wireframe = true;
      } else if (aux_val == "solid") {
        force_solid = true;
      }
    } else if (aux_type == "DaughtersInvisible") {
      if (aux_val == "true") {
        dau_invisible = true;
      } else if (aux_val == "false") {
        dau_invisible = false;
      }
    } else if (aux_type == "Visible") {
      if (aux_val == "true") {
        visible = true;
      } else if (aux_val == "false") {
        visible = false;
      }
    } else if (aux_type == "LineStyle") {
      if (aux_val == "unbroken") {
        line_style = G4VisAttributes::unbroken;
      } else if (aux_val == "dashed") {
        line_style = G4VisAttributes::dashed;
      } else if (aux_val == "dotted") {
        line_style = G4VisAttributes::dotted;
      }
    } else if (aux_type == "LineWidth") {
      line_width = atof(aux_val.c_str());
    }
  }
 
  auto vis_attributes = new G4VisAttributes();
  vis_attributes->SetColor(rgba[0], rgba[1], rgba[2], rgba[3]);
  vis_attributes->SetVisibility(visible);
  vis_attributes->SetDaughtersInvisible(dau_invisible);
  vis_attributes->SetForceWireframe(force_wireframe);
  vis_attributes->SetForceSolid(force_solid);
  vis_attributes->SetLineWidth(line_width);
  vis_attributes->SetLineStyle(line_style);
  VisAttributesStore::getInstance()->addVisAttributes(name, vis_attributes);
 
  // G4cout << "Created VisAttributes " << name << G4endl << (*visAttributes) <<
  // G4endl << G4endl;
}

References simcore::VisAttributesStore::addVisAttributes(), color_mode_, and simcore::VisAttributesStore::getInstance().

Referenced by readGlobalAuxInfo().

getDetectorHeader()

ldmx::DetectorHeader * simcore::geo::AuxInfoReader::getDetectorHeader ( )

inline

Get the detector header that was created from the userinfo block.

Returns

The detector header.

Definition at line 56 of file AuxInfoReader.h.

{ return detector_header_; }

References detector_header_.

readGlobalAuxInfo()

void simcore::geo::AuxInfoReader::readGlobalAuxInfo

(

)

Read the global auxiliary information from the auxinfo block.

Definition at line 39 of file AuxInfoReader.cxx.

                                      {
  const G4GDMLAuxListType* aux_info_list = parser_->GetAuxList();
  for (const auto& aux_info : *aux_info_list) {
    G4String aux_type = aux_info.type;
    G4String aux_val = aux_info.value;
 
    if (aux_type == "SensDet") {
      std::cerr
          << "[ WARN ] : Not defining SensDet in GDML since v1.0 of SimCore. "
             "See https://github.com/LDMX-Software/SimCore/issues/39"
          << std::endl;
    } else if (aux_type == "MagneticField") {
      createMagneticField(aux_val, aux_info.auxList);
    } else if (aux_type == "Region") {
      createRegion(aux_val, aux_info.auxList);
    } else if (aux_type == "ColorMode") {
      selectColorMode(aux_val);
    } else if (aux_type == "VisAttributes") {
      createVisAttributes(aux_val, aux_info.auxList);
    } else if (aux_type == "DetectorVersion") {
      createDetectorHeader(aux_val, aux_info.auxList);
    }
  }
  return;
}

References createDetectorHeader(), createMagneticField(), createRegion(), createVisAttributes(), parser_, and selectColorMode().

selectColorMode()

void simcore::geo::AuxInfoReader::selectColorMode ( const G4String & mode )

private

Select the 'mode' for coloring in the visualization.

Parameters

name	The selected mode

Definition at line 262 of file AuxInfoReader.cxx.

                                                        {
  // Chooses which coloring scheme to use for the visattributes
  // Currently (March 2026) there are two modes implemented:
  //    Region: Only visattributes with "Region" in the name will be applied
  //    Material: Only visattributes with "Material" in the name will be applied
  // The Region mode colors all volumes in the same subdetector the same color
  // For example, all volumes in the HCal will be colored orange
  // The Material mode colors each volume based on which material it's made from
  //'Unimportant' materials (like glue) are left uncolored or invisible
  // To add more modes follow these steps:
  // 1) Make more visattributes in 'visattributes.gdml'
  //       Your new attribute names must share a common string, like "Region"
  // 2) Add the shared string as a valid option in this function
 
  std::vector<std::string> valid_modes = {"Region", "Material"};
 
  auto match = std::find(valid_modes.begin(), valid_modes.end(), mode);
 
  if (match == valid_modes.end()) {
    EXCEPTION_RAISE("InvalidMode", "Color mode setting " + mode +
                                       " doesn't match any available modes!");
  }
 
  // If the input matches a valid mode (doesn't matter which one), proceed
  color_mode_ = mode;
}

References color_mode_.

Referenced by readGlobalAuxInfo().

Member Data Documentation

color_mode_

std::string simcore::geo::AuxInfoReader::color_mode_

private

Color mode for visattributes.

Definition at line 115 of file AuxInfoReader.h.

Referenced by assignAuxInfoToVolumes(), createVisAttributes(), and selectColorMode().

detector_header_

ldmx::DetectorHeader* simcore::geo::AuxInfoReader::detector_header_ {nullptr}

private

Detector header with name and version.

Definition at line 110 of file AuxInfoReader.h.

{nullptr};

Referenced by createDetectorHeader(), getDetectorHeader(), and ~AuxInfoReader().

eval_

G4GDMLEvaluator* simcore::geo::AuxInfoReader::eval_

private

The GDML expression evaluator.

Definition at line 105 of file AuxInfoReader.h.

Referenced by createMagneticField(), and ~AuxInfoReader().

parser_

G4GDMLParser* simcore::geo::AuxInfoReader::parser_

private

The GDML parser.

Definition at line 100 of file AuxInfoReader.h.

Referenced by assignAuxInfoToVolumes(), and readGlobalAuxInfo().

universal_visattributes_

std::vector<std::string> simcore::geo::AuxInfoReader::universal_visattributes_

private

Definition at line 116 of file AuxInfoReader.h.

---

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

• SimCore/include/SimCore/Geo/AuxInfoReader.h
• SimCore/src/SimCore/Geo/AuxInfoReader.cxx