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	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.

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 27 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 32 of file AuxInfoReader.cxx.

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

simcore::geo::AuxInfoReader::eval_

G4GDMLEvaluator * eval_

The GDML expression evaluator.

Definition AuxInfoReader.h:98

simcore::geo::AuxInfoReader::parser_

G4GDMLParser * parser_

The GDML parser.

Definition AuxInfoReader.h:93

◆ ~AuxInfoReader()

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

virtual

Class destructor.

Definition at line 36 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") {
        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 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 322 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 125 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 222 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 255 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;
 
  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(), 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 55 of file AuxInfoReader.h.

55{ return detector_header_; }

References detector_header_.

◆ readGlobalAuxInfo()

void simcore::geo::AuxInfoReader::readGlobalAuxInfo ( )

Read the global auxiliary information from the auxinfo block.

Definition at line 41 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 == "VisAttributes") {
      createVisAttributes(aux_val, aux_info.auxList);
    } else if (aux_type == "DetectorVersion") {
      createDetectorHeader(aux_val, aux_info.auxList);
    }
  }
  return;
}

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

Member Data Documentation

◆ detector_header_

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

private

Detector header with name and version.

Definition at line 103 of file AuxInfoReader.h.

103{nullptr};

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

◆ eval_

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

private

The GDML expression evaluator.

Definition at line 98 of file AuxInfoReader.h.

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

◆ parser_

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

private

The GDML parser.

Definition at line 93 of file AuxInfoReader.h.

Referenced by assignAuxInfoToVolumes(), and readGlobalAuxInfo().

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

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AuxInfoReader()

◆ ~AuxInfoReader()

Member Function Documentation

◆ assignAuxInfoToVolumes()

◆ createDetectorHeader()

◆ createMagneticField()

◆ createRegion()

◆ createVisAttributes()

◆ getDetectorHeader()

◆ readGlobalAuxInfo()

Member Data Documentation

◆ detector_header_

◆ eval_

◆ parser_