Acts::ObjSurfaceWriter Class Reference

#include <ObjSurfaceWriter.h>

Collaboration diagram for Acts::ObjSurfaceWriter:

Classes
class	Config

Public Member Functions
	ObjSurfaceWriter (const Config &cfg)
	Constructor. More...
const std::string &	name () const
	Framework name() method. More...
void	write (const Acts::GeometryContext &gctx, const Acts::Surface &surface)
	The write interface. More...
void	write (const std::string &sinfo)
	write a bit of string More...

Private Member Functions
const Acts::Logger &	logger () const
	Private access to the logging instance. More...

Private Attributes
Config	m_cfg
	the config class More...
ObjHelper::VtnCounter	m_vtnCounter
	vertex, texture, normal More...
std::mutex	m_write_mutex
	mutex to protect multi-threaded writes More...

Detailed Description

An Obj writer for the geometry

Definition at line 23 of file ObjSurfaceWriter.h.

Constructor & Destructor Documentation

ObjSurfaceWriter()

Acts::ObjSurfaceWriter::ObjSurfaceWriter

(

const Config &

cfg

)

Constructor.

Parameters

cfg	is the configuration class

Definition at line 51 of file ObjSurfaceWriter.cxx.

  : m_cfg(cfg)
{
  // Validate the configuration
  if (!m_cfg.logger) {
    throw std::invalid_argument("Missing logger");
  } else if (m_cfg.name.empty()) {
    throw std::invalid_argument("Missing algorithm name");
  } else if (!m_cfg.outputStream) {
    throw std::invalid_argument("Missing output stream");
  }
 
  // Write down the file prefix
  (*(m_cfg.outputStream)) << m_cfg.filePrefix << '\n';
}

Member Function Documentation

logger()

const Acts::Logger& Acts::ObjSurfaceWriter::logger ( ) const

inlineprivate

Private access to the logging instance.

Definition at line 91 of file ObjSurfaceWriter.h.

  {
    return *m_cfg.logger;
  }

name()

const std::string & Acts::ObjSurfaceWriter::name

(

)

const

Framework name() method.

Definition at line 69 of file ObjSurfaceWriter.cxx.

{
  return m_cfg.name;
}

write() [1/2]

void Acts::ObjSurfaceWriter::write	(	const Acts::GeometryContext &	gctx,
		const Acts::Surface &	surface
	)

The write interface.

Parameters

surface

to be written out

Definition at line 83 of file ObjSurfaceWriter.cxx.

{
  std::lock_guard<std::mutex> lock(m_write_mutex);
 
  // check
  ACTS_DEBUG(">>Obj: Writer for Surface object called.");
 
  auto scalor = m_cfg.outputScalor;
  // let's get the bounds & the transform
  const Acts::SurfaceBounds& surfaceBounds = surface.bounds();
  auto sTransform = surface.transform(gctx);
 
  // dynamic_cast to PlanarBounds
  const Acts::PlanarBounds* planarBounds
      = dynamic_cast<const Acts::PlanarBounds*>(&surfaceBounds);
  
  const Acts::CylinderBounds* cylinderBounds
      = dynamic_cast<const Acts::CylinderBounds*>(&surfaceBounds);
  
  const Acts::StrawSurface* strawSurface
      = dynamic_cast<const Acts::StrawSurface*>(&surface);
 
  // only continue if the cast worked
  if (m_cfg.outputSensitive) {
    if (planarBounds) {
      ACTS_VERBOSE(">>Obj: Writing out a PlaneSurface");
      // set the precision - just to be sure
      (*(m_cfg.outputStream)) << '\n';
      (*(m_cfg.outputStream)) << std::setprecision(m_cfg.outputPrecision);
      // get the vertices
      auto planarVertices = planarBounds->vertices();
      // loop over the vertices
      std::vector<Acts::Vector3> vertices;
      vertices.reserve(planarVertices.size());
      for (auto pv : planarVertices) {
        // get the point in 3D
        Acts::Vector3 v3D(sTransform * Acts::Vector3(pv.x(), pv.y(), 0.));
        vertices.push_back(v3D);
      }
      // get the thickness and vertical faces
      double                    thickness = 0.;
      std::vector<unsigned int> vfaces;
      if (surface.associatedDetectorElement()) {
        // get the thickness form the detector element
        thickness = surface.associatedDetectorElement()->thickness();
        vfaces    = {1, 1, 1, 1};
      }
      // output to file
      ObjHelper::writePlanarFace(*(m_cfg.outputStream),
                                   m_vtnCounter,
                                   scalor,
                                   vertices,
                                   thickness,
                                   vfaces);
      (*(m_cfg.outputStream)) << '\n';
    }
    else if(cylinderBounds) {
      
      auto cylinderSurface = dynamic_cast<const Acts::CylinderSurface*>(&surface);
      if (cylinderSurface == nullptr) { // protection against nullptr
    ACTS_ERROR("Unable to dynamic cast surface to Acts::CylinderSurface");
    return;
      }
 
      Acts::Polyhedron ph =
          cylinderSurface->polyhedronRepresentation(gctx, 10);
      (*(m_cfg.outputStream)) << objString(ph, m_vtnCounter.vcounter);
      m_vtnCounter.vcounter += ph.vertices.size();
 
    }
    else if(strawSurface) {
 
      Acts::Polyhedron ph =
          strawSurface->polyhedronRepresentation(gctx, 10);
      (*(m_cfg.outputStream)) << objString(ph, m_vtnCounter.vcounter);
      m_vtnCounter.vcounter += ph.vertices.size();
 
    }
    else {
      ACTS_ERROR("Unable to print this bounds type: " << surfaceBounds.type());
    }
  }
 
  // check if you have layer and check what your have
  // dynamic cast to CylinderBounds work the same
  if (cylinderBounds && m_cfg.outputLayerSurface) {
    ACTS_VERBOSE(">>Obj: Writing out a CylinderSurface with r = "
                 << cylinderBounds->get(Acts::CylinderBounds::eR));
    // name the object
    auto layerID = surface.geometryId().layer();
    (*(m_cfg.outputStream))
        << " o Cylinder_" << std::to_string(layerID) << '\n';
    // output to the file
    ObjHelper::writeTube(*(m_cfg.outputStream),
                           m_vtnCounter,
                           scalor,
                           m_cfg.outputPhiSegments,
                           sTransform,
                           cylinderBounds->get(Acts::CylinderBounds::eR),
                           cylinderBounds->get(Acts::CylinderBounds::eHalfLengthZ),
                           m_cfg.outputThickness);
    (*(m_cfg.outputStream)) << '\n';
  }
 
  const Acts::RadialBounds* radialBounds
      = dynamic_cast<const Acts::RadialBounds*>(&surfaceBounds);
  if (radialBounds && m_cfg.outputLayerSurface) {
    ACTS_VERBOSE(">>Obj: Writing out a DiskSurface at z = "
                 << sTransform.translation().z());
    // name the object
    auto layerID = surface.geometryId().layer();
    (*(m_cfg.outputStream)) << "o Disk_" << std::to_string(layerID) << '\n';
    // we use the tube writer in the other direction
    double rMin      = radialBounds->rMin();
    double rMax      = radialBounds->rMax();
    double thickness = rMax - rMin;
    // output to the file
    ObjHelper::writeTube(*(m_cfg.outputStream),
                           m_vtnCounter,
                           scalor,
                           m_cfg.outputPhiSegments,
                           sTransform,
                           0.5 * (rMin + rMax),
                           m_cfg.outputThickness,
                           thickness);
    (*(m_cfg.outputStream)) << '\n';
  }
 
}

write() [2/2]

void Acts::ObjSurfaceWriter::write

(

const std::string &

sinfo

)

write a bit of string

Parameters

is	the string to be written

Definition at line 74 of file ObjSurfaceWriter.cxx.

{
  // lock the mutex for writing
  std::lock_guard<std::mutex> lock(m_write_mutex);
  // and write
  (*m_cfg.outputStream) << sinfo;
}

Member Data Documentation

m_cfg

Config Acts::ObjSurfaceWriter::m_cfg

private

the config class

Definition at line 85 of file ObjSurfaceWriter.h.

m_vtnCounter

ObjHelper::VtnCounter Acts::ObjSurfaceWriter::m_vtnCounter

private

vertex, texture, normal

Definition at line 86 of file ObjSurfaceWriter.h.

m_write_mutex

std::mutex Acts::ObjSurfaceWriter::m_write_mutex

private

mutex to protect multi-threaded writes

Definition at line 87 of file ObjSurfaceWriter.h.

---

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

• ObjSurfaceWriter.h
• ObjSurfaceWriter.cxx