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 *	detectorHeader_ {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 30 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 28 of file AuxInfoReader.cxx.

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

simcore::geo::AuxInfoReader::eval_

G4GDMLEvaluator * eval_

The GDML expression evaluator.

Definition AuxInfoReader.h:101

simcore::geo::AuxInfoReader::parser_

G4GDMLParser * parser_

The GDML parser.

Definition AuxInfoReader.h:96

◆ ~AuxInfoReader()

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

virtual

Class destructor.

Definition at line 32 of file AuxInfoReader.cxx.

                              {
  delete eval_;
  delete detectorHeader_;
}

References detectorHeader_, and eval_.

Member Function Documentation

◆ assignAuxInfoToVolumes()

void simcore::geo::AuxInfoReader::assignAuxInfoToVolumes ( )

Assign auxiliary info to volumes such as sensitive detectors.

Definition at line 61 of file AuxInfoReader.cxx.

                                           {
  const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
  std::vector<G4LogicalVolume*>::const_iterator lvciter;
  for (lvciter = lvs->begin(); lvciter != lvs->end(); lvciter++) {
    G4GDMLAuxListType auxInfoList =
        parser_->GetVolumeAuxiliaryInformation(*lvciter);
 
    for (const auto& auxInfo : auxInfoList) {
      G4String auxType = auxInfo.type;
      G4String auxVal = auxInfo.value;
 
      G4LogicalVolume* lv = (*lvciter);
 
      if (auxType == "MagneticField") {
        const G4String& magFieldName = auxVal;
        G4MagneticField* magField =
            MagneticFieldStore::getInstance()->getMagneticField(magFieldName);
        if (magField != nullptr) {
          auto mgr = new G4FieldManager(magField);
          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(magFieldName.data()));
        }
      } else if (auxType == "Region") {
        const G4String& regionName = auxVal;
        G4Region* region = G4RegionStore::GetInstance()->GetRegion(regionName);
        if (region != nullptr) {
          region->AddRootLogicalVolume(lv);
          // G4cout << "Added volume " << lv->GetName() << " to region " <<
          // regionName << G4endl;
        } else {
          EXCEPTION_RAISE("MissingInfo", "Reference region '" +
                                             std::string(regionName.data()) +
                                             "' was not found!");
        }
      } else if (auxType == "VisAttributes") {
        const G4String& visName = auxVal;
        G4VisAttributes* visAttributes =
            VisAttributesStore::getInstance()->getVisAttributes(visName);
        if (visAttributes != nullptr) {
          lv->SetVisAttributes(visAttributes);
          // G4cout << "Assigned VisAttributes " << visName << " to volume "
          // << lv->GetName() << G4endl;
        } else {
          EXCEPTION_RAISE("MissingInfo", "Referenced VisAttributes '" +
                                             std::string(visName.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 315 of file AuxInfoReader.cxx.

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

References detectorHeader_.

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

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

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

                                                                       {
  bool storeTrajectories = true;
  for (const auto& auxInfo : *auxInfoList) {
    G4String auxType = auxInfo.type;
    G4String auxVal = auxInfo.value;
 
    if (auxType == "StoreTrajectories") {
      if (auxVal == "false") {
        storeTrajectories = false;
      } else if (auxVal == "true") {
        storeTrajectories = true;
      }
    }
  }
  G4VUserRegionInformation* regionInfo =
      new UserRegionInformation(storeTrajectories);
  // 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(regionInfo);
}

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

                                                                              {
  std::array<G4double, 4> rgba = {1., 1., 1., 1.};
  G4bool visible = true;
  G4bool dauInvisible = false;
  G4bool forceWireframe = false;
  G4bool forceSolid = false;
  G4double lineWidth = 1.0;
  G4VisAttributes::LineStyle lineStyle = G4VisAttributes::unbroken;
 
  for (const auto& auxInfo : *auxInfoList) {
    G4String auxType = auxInfo.type;
    G4String auxVal = auxInfo.value;
 
    if (auxType == "R") {
      rgba[0] = atof(auxVal.c_str());
    } else if (auxType == "G") {
      rgba[1] = atof(auxVal.c_str());
    } else if (auxType == "B") {
      rgba[2] = atof(auxVal.c_str());
    } else if (auxType == "A") {
      rgba[3] = atof(auxVal.c_str());
    } else if (auxType == "Style") {
      if (auxVal == "wireframe") {
        forceWireframe = true;
      } else if (auxVal == "solid") {
        forceSolid = true;
      }
    } else if (auxType == "DaughtersInvisible") {
      if (auxVal == "true") {
        dauInvisible = true;
      } else if (auxVal == "false") {
        dauInvisible = false;
      }
    } else if (auxType == "Visible") {
      if (auxVal == "true") {
        visible = true;
      } else if (auxVal == "false") {
        visible = false;
      }
    } else if (auxType == "LineStyle") {
      if (auxVal == "unbroken") {
        lineStyle = G4VisAttributes::unbroken;
      } else if (auxVal == "dashed") {
        lineStyle = G4VisAttributes::dashed;
      } else if (auxVal == "dotted") {
        lineStyle = G4VisAttributes::dotted;
      }
    } else if (auxType == "LineWidth") {
      lineWidth = atof(auxVal.c_str());
    }
  }
 
  auto visAttributes = new G4VisAttributes();
  visAttributes->SetColor(rgba[0], rgba[1], rgba[2], rgba[3]);
  visAttributes->SetVisibility(visible);
  visAttributes->SetDaughtersInvisible(dauInvisible);
  visAttributes->SetForceWireframe(forceWireframe);
  visAttributes->SetForceSolid(forceSolid);
  visAttributes->SetLineWidth(lineWidth);
  visAttributes->SetLineStyle(lineStyle);
  VisAttributesStore::getInstance()->addVisAttributes(name, visAttributes);
 
  // 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 58 of file AuxInfoReader.h.

58{ return detectorHeader_; }

References detectorHeader_.

◆ readGlobalAuxInfo()

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

Read the global auxiliary information from the auxinfo block.

Definition at line 37 of file AuxInfoReader.cxx.

                                      {
  const G4GDMLAuxListType* auxInfoList = parser_->GetAuxList();
  for (const auto& auxInfo : *auxInfoList) {
    G4String auxType = auxInfo.type;
    G4String auxVal = auxInfo.value;
 
    if (auxType == "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 (auxType == "MagneticField") {
      createMagneticField(auxVal, auxInfo.auxList);
    } else if (auxType == "Region") {
      createRegion(auxVal, auxInfo.auxList);
    } else if (auxType == "VisAttributes") {
      createVisAttributes(auxVal, auxInfo.auxList);
    } else if (auxType == "DetectorVersion") {
      createDetectorHeader(auxVal, auxInfo.auxList);
    }
  }
  return;
}

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

Member Data Documentation

◆ detectorHeader_

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

private

Detector header with name and version.

Definition at line 106 of file AuxInfoReader.h.

106{nullptr};

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

◆ eval_

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

private

The GDML expression evaluator.

Definition at line 101 of file AuxInfoReader.h.

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

◆ parser_

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

private

The GDML parser.

Definition at line 96 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

◆ detectorHeader_

◆ eval_

◆ parser_