diff --git a/DDCore/src/DetElement.cpp b/DDCore/src/DetElement.cpp
index 3310c1896aa2b504290577aa89d4d2cda48844aa..6f0dce1b121e4c7ed971cfa858d5592f323d0d2e 100644
--- a/DDCore/src/DetElement.cpp
+++ b/DDCore/src/DetElement.cpp
@@ -12,21 +12,19 @@
//==========================================================================
// Framework include files
-#include "DD4hep/detail/DetectorInterna.h"
-#include "DD4hep/detail/ConditionsInterna.h"
-#include "DD4hep/detail/AlignmentsInterna.h"
-#include "DD4hep/AlignmentTools.h"
-#include "DD4hep/DetectorTools.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/World.h"
-#include "DD4hep/Detector.h"
-
-using namespace std;
+#include <DD4hep/detail/DetectorInterna.h>
+#include <DD4hep/detail/ConditionsInterna.h>
+#include <DD4hep/detail/AlignmentsInterna.h>
+#include <DD4hep/AlignmentTools.h>
+#include <DD4hep/DetectorTools.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/World.h>
+#include <DD4hep/Detector.h>
+
using namespace dd4hep;
-using dd4hep::Alignment;
namespace {
- static string s_empty_string;
+ static std::string s_empty_string;
}
/// Default constructor
@@ -38,26 +36,26 @@ DetElement::Processor::~Processor() {
}
/// Clone constructor
-DetElement::DetElement(Object* det_data, const string& det_name, const string& det_type)
+DetElement::DetElement(Object* det_data, const std::string& det_name, const std::string& det_type)
: Handle<DetElementObject>(det_data)
{
this->assign(det_data, det_name, det_type);
}
/// Constructor for a new subdetector element
-DetElement::DetElement(const string& det_name, const string& det_type, int det_id) {
+DetElement::DetElement(const std::string& det_name, const std::string& det_type, int det_id) {
assign(new Object(det_name,det_id), det_name, det_type);
ptr()->id = det_id;
}
/// Constructor for a new subdetector element
-DetElement::DetElement(const string& det_name, int det_id) {
+DetElement::DetElement(const std::string& det_name, int det_id) {
assign(new Object(det_name,det_id), det_name, "");
ptr()->id = det_id;
}
/// Constructor for a new subdetector element
-DetElement::DetElement(DetElement det_parent, const string& det_name, int det_id) {
+DetElement::DetElement(DetElement det_parent, const std::string& det_name, int det_id) {
assign(new Object(det_name,det_id), det_name, det_parent.type());
ptr()->id = det_id;
det_parent.add(*this);
@@ -84,7 +82,7 @@ void DetElement::removeAtUpdate(unsigned int typ, void* pointer) const {
}
/// Access to the full path to the placed object
-const string& DetElement::placementPath() const {
+const std::string& DetElement::placementPath() const {
Object* o = ptr();
if ( o ) {
if (o->placementPath.empty()) {
@@ -96,12 +94,12 @@ const string& DetElement::placementPath() const {
}
/// Access detector type (structure, tracker, calorimeter, etc.).
-string DetElement::type() const {
+std::string DetElement::type() const {
return m_element ? m_element->GetTitle() : "";
}
/// Set the type of the sensitive detector
-DetElement& DetElement::setType(const string& typ) {
+DetElement& DetElement::setType(const std::string& typ) {
access()->SetTitle(typ.c_str());
return *this;
}
@@ -156,7 +154,7 @@ int DetElement::level() const {
}
/// Access the full path of the detector element
-const string& DetElement::path() const {
+const std::string& DetElement::path() const {
Object* o = ptr();
if ( o ) {
if ( !o->path.empty() )
@@ -210,28 +208,28 @@ const DetElement::Children& DetElement::children() const {
}
/// Access to individual children by name
-DetElement DetElement::child(const string& child_name) const {
+DetElement DetElement::child(const std::string& child_name) const {
if (isValid()) {
const Children& c = ptr()->children;
Children::const_iterator i = c.find(child_name);
if ( i != c.end() ) return (*i).second;
- throw runtime_error("dd4hep: DetElement::child Unknown child with name: "+child_name);
+ throw std::runtime_error("dd4hep: DetElement::child Unknown child with name: "+child_name);
}
- throw runtime_error("dd4hep: DetElement::child: Self is not defined [Invalid Handle]");
+ throw std::runtime_error("dd4hep: DetElement::child: Self is not defined [Invalid Handle]");
}
/// Access to individual children by name. Have option to not throw an exception
-DetElement DetElement::child(const string& child_name, bool throw_if_not_found) const {
+DetElement DetElement::child(const std::string& child_name, bool throw_if_not_found) const {
if (isValid()) {
const Children& c = ptr()->children;
Children::const_iterator i = c.find(child_name);
if ( i != c.end() ) return (*i).second;
if ( throw_if_not_found ) {
- throw runtime_error("dd4hep: DetElement::child Unknown child with name: "+child_name);
+ throw std::runtime_error("dd4hep: DetElement::child Unknown child with name: "+child_name);
}
}
if ( throw_if_not_found ) {
- throw runtime_error("dd4hep: DetElement::child: Self is not defined [Invalid Handle]");
+ throw std::runtime_error("dd4hep: DetElement::child: Self is not defined [Invalid Handle]");
}
return DetElement();
}
@@ -249,24 +247,26 @@ DetElement DetElement::world() const {
}
/// Simple checking routine
-void DetElement::check(bool cond, const string& msg) const {
+void DetElement::check(bool cond, const std::string& msg) const {
if (cond) {
- throw runtime_error("dd4hep: " + msg);
+ throw std::runtime_error("dd4hep: " + msg);
}
}
/// Add a new child subdetector element
DetElement& DetElement::add(DetElement sdet) {
if (isValid()) {
- pair<Children::iterator, bool> r = object<Object>().children.emplace(sdet.name(), sdet);
+ auto r = object<Object>().children.emplace(sdet.name(), sdet);
if (r.second) {
sdet.access()->parent = *this;
return *this;
}
- throw runtime_error("dd4hep: DetElement::add: Element " + string(sdet.name()) +
- " is already present in path " + path() + " [Double-Insert]");
+ except("dd4hep",
+ "DetElement::add: Element %s is already present in path %s [Double-Insert]",
+ sdet.name(), this->path().c_str());
}
- throw runtime_error("dd4hep: DetElement::add: Self is not defined [Invalid Handle]");
+ except("dd4hep", "DetElement::add: Self is not defined [Invalid Handle]");
+ throw std::runtime_error("dd4hep: DetElement::add");
}
/// Clone (Deep copy) the DetElement structure
@@ -278,11 +278,11 @@ DetElement DetElement::clone(int flg) const {
return n;
}
-DetElement DetElement::clone(const string& new_name) const {
+DetElement DetElement::clone(const std::string& new_name) const {
return clone(new_name, access()->id);
}
-DetElement DetElement::clone(const string& new_name, int new_id) const {
+DetElement DetElement::clone(const std::string& new_name, int new_id) const {
Object* o = access();
Object* n = o->clone(new_id, COPY_PLACEMENT);
n->SetName(new_name.c_str());
@@ -290,21 +290,21 @@ DetElement DetElement::clone(const string& new_name, int new_id) const {
return n;
}
-pair<DetElement,Volume> DetElement::reflect(const string& new_name) const {
+std::pair<DetElement,Volume> DetElement::reflect(const std::string& new_name) const {
return reflect(new_name, access()->id);
}
-pair<DetElement,Volume> DetElement::reflect(const string& new_name, int new_id) const {
+std::pair<DetElement,Volume> DetElement::reflect(const std::string& new_name, int new_id) const {
return reflect(new_name, new_id, SensitiveDetector(0));
}
-pair<DetElement,Volume> DetElement::reflect(const string& new_name, int new_id, SensitiveDetector sd) const {
+std::pair<DetElement,Volume> DetElement::reflect(const std::string& new_name, int new_id, SensitiveDetector sd) const {
if ( placement().isValid() ) {
return m_element->reflect(new_name, new_id, sd);
}
except("DetElement","reflect: Only placed DetElement objects can be reflected: %s",
path().c_str());
- return make_pair(DetElement(),Volume());
+ return std::make_pair(DetElement(),Volume());
}
/// Access to the ideal physical volume of this detector element
@@ -335,7 +335,8 @@ DetElement& DetElement::setPlacement(const PlacedVolume& pv) {
}
return *this;
}
- throw runtime_error("dd4hep: DetElement::setPlacement: Placement is not defined [Invalid Handle]");
+ except("dd4hep", "DetElement::setPlacement: Placement is not defined [Invalid Handle]");
+ throw std::runtime_error("dd4hep: DetElement::add");
}
/// The cached VolumeID of this subdetector element
@@ -356,19 +357,19 @@ Solid DetElement::solid() const {
return volume()->GetShape();
}
-DetElement& DetElement::setVisAttributes(const Detector& description, const string& nam, const Volume& vol) {
+DetElement& DetElement::setVisAttributes(const Detector& description, const std::string& nam, const Volume& vol) {
vol.setVisAttributes(description, nam);
return *this;
}
-DetElement& DetElement::setRegion(const Detector& description, const string& nam, const Volume& vol) {
+DetElement& DetElement::setRegion(const Detector& description, const std::string& nam, const Volume& vol) {
if (!nam.empty()) {
vol.setRegion(description.region(nam));
}
return *this;
}
-DetElement& DetElement::setLimitSet(const Detector& description, const string& nam, const Volume& vol) {
+DetElement& DetElement::setLimitSet(const Detector& description, const std::string& nam, const Volume& vol) {
if (!nam.empty()) {
vol.setLimitSet(description.limitSet(nam));
}
@@ -377,15 +378,15 @@ DetElement& DetElement::setLimitSet(const Detector& description, const string& n
DetElement& DetElement::setAttributes(const Detector& description,
const Volume& vol,
- const string& region,
- const string& limits,
- const string& vis)
+ const std::string& region,
+ const std::string& limits,
+ const std::string& vis)
{
return setRegion(description, region, vol).setLimitSet(description, limits, vol).setVisAttributes(description, vis, vol);
}
/// Constructor
-SensitiveDetector::SensitiveDetector(const string& nam, const string& typ) {
+SensitiveDetector::SensitiveDetector(const std::string& nam, const std::string& typ) {
/*
<calorimeter ecut="0" eunit="MeV" hits_collection="EcalEndcapHits" name="EcalEndcap" verbose="0">
<global_grid_xy grid_size_x="3.5" grid_size_y="3.5"/>
@@ -398,13 +399,13 @@ SensitiveDetector::SensitiveDetector(const string& nam, const string& typ) {
}
/// Set the type of the sensitive detector
-SensitiveDetector& SensitiveDetector::setType(const string& typ) {
+SensitiveDetector& SensitiveDetector::setType(const std::string& typ) {
access()->SetTitle(typ.c_str());
return *this;
}
/// Access the type of the sensitive detector
-string SensitiveDetector::type() const {
+std::string SensitiveDetector::type() const {
return m_element ? m_element->GetTitle() : s_empty_string;
}
@@ -436,13 +437,13 @@ double SensitiveDetector::energyCutoff() const {
}
/// Assign the name of the hits collection
-SensitiveDetector& SensitiveDetector::setHitsCollection(const string& collection) {
+SensitiveDetector& SensitiveDetector::setHitsCollection(const std::string& collection) {
access()->hitsCollection = collection;
return *this;
}
/// Access the hits collection name
-const string& SensitiveDetector::hitsCollection() const {
+const std::string& SensitiveDetector::hitsCollection() const {
return access()->hitsCollection;
}
diff --git a/DDCore/src/DetectorData.cpp b/DDCore/src/DetectorData.cpp
index 87e8e344c61064425dcb293dcb799e165c439898..f2ba99d47aec489f8e5a217c25a2d131381573d5 100644
--- a/DDCore/src/DetectorData.cpp
+++ b/DDCore/src/DetectorData.cpp
@@ -12,24 +12,23 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Grammar.h"
-#include "DD4hep/DetectorData.h"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/detail/ObjectsInterna.h"
-#include "DD4hep/detail/DetectorInterna.h"
+#include <DD4hep/Grammar.h>
+#include <DD4hep/DetectorData.h>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/detail/ObjectsInterna.h>
+#include <DD4hep/detail/DetectorInterna.h>
// ROOT include files
-#include "TGeoManager.h"
-#include "TClassStreamer.h"
-#include "TDataMember.h"
-#include "TDataType.h"
-#include "TClass.h"
-#include "TROOT.h"
+#include <TGeoManager.h>
+#include <TClassStreamer.h>
+#include <TDataMember.h>
+#include <TDataType.h>
+#include <TClass.h>
+#include <TROOT.h>
namespace dd4hep { namespace detail { class DetectorImp; }}
-using namespace dd4hep::detail;
using namespace dd4hep;
namespace {
@@ -212,17 +211,17 @@ void DetectorData::destroyData(bool destroy_mgr) {
m_extensions.clear();
m_detectorParents.clear();
- destroyHandle(m_world);
- destroyHandle(m_field);
- destroyHandle(m_header);
- destroyHandles(m_readouts);
- destroyHandles(m_idDict);
- destroyHandles(m_limits);
- destroyHandles(m_regions);
- destroyHandles(m_sensitive);
- destroyHandles(m_display);
- destroyHandles(m_fields);
- destroyHandles(m_define);
+ detail::destroyHandle(m_world);
+ detail::destroyHandle(m_field);
+ detail::destroyHandle(m_header);
+ detail::destroyHandles(m_readouts);
+ detail::destroyHandles(m_idDict);
+ detail::destroyHandles(m_limits);
+ detail::destroyHandles(m_regions);
+ detail::destroyHandles(m_sensitive);
+ detail::destroyHandles(m_display);
+ detail::destroyHandles(m_fields);
+ detail::destroyHandles(m_define);
#if 0
for(const auto& def : m_define) {
auto c = def;
@@ -231,7 +230,7 @@ void DetectorData::destroyData(bool destroy_mgr) {
delete def.second.ptr();
}
#endif
- destroyHandle(m_volManager);
+ detail::destroyHandle(m_volManager);
m_properties.clear();
m_trackers.clear();
m_trackingVol.clear();
@@ -243,7 +242,7 @@ void DetectorData::destroyData(bool destroy_mgr) {
m_inhibitConstants = false;
if ( destroy_mgr ) {
gGeoManager = m_manager;
- deletePtr(m_manager);
+ detail::deletePtr(m_manager);
gGeoManager = 0;
}
else {
diff --git a/DDCore/src/DetectorHelper.cpp b/DDCore/src/DetectorHelper.cpp
index e0cc6ed7dfbb10fb3d02140db7d2a0102e2e0054..a0b10fb378e0f9fda3d592f31d89eb10bd22d162 100644
--- a/DDCore/src/DetectorHelper.cpp
+++ b/DDCore/src/DetectorHelper.cpp
@@ -12,17 +12,16 @@
//==========================================================================
// Framework include files
-#include "DD4hep/DetectorHelper.h"
+#include <DD4hep/DetectorHelper.h>
// ROOT include files
-#include "TGeoManager.h"
+#include <TGeoManager.h>
-using namespace std;
using namespace dd4hep;
/// Access the sensitive detector of a given subdetector (if the sub-detector is sensitive!)
SensitiveDetector DetectorHelper::sensitiveDetector(const std::string& detector) const {
- const string& det_name = detector;
+ const std::string& det_name = detector;
SensitiveDetector sensitive = ptr()->sensitiveDetector(det_name);
return sensitive;
}
@@ -61,7 +60,7 @@ Atom DetectorHelper::element(const std::string& nam) const {
TGeoElementTable* tab = mgr.GetElementTable();
TGeoElement* elt = tab->FindElement(nam.c_str());
if ( !elt ) {
- string n = nam;
+ std::string n = nam;
transform(n.begin(), n.end(), n.begin(), ::toupper);
elt = tab->FindElement(n.c_str()); // Check for IRON
if ( !elt ) {
@@ -81,7 +80,7 @@ Material DetectorHelper::material(const std::string& nam) const {
TGeoManager& mgr = access()->manager();
TGeoMedium* med = mgr.GetMedium(nam.c_str());
if ( !med ) {
- string n = nam;
+ std::string n = nam;
transform(n.begin(), n.end(), n.begin(), ::toupper);
med = mgr.GetMedium(n.c_str()); // Check for IRON
if ( !med ) {
diff --git a/DDCore/src/DetectorInterna.cpp b/DDCore/src/DetectorInterna.cpp
index 5af73f6c0a8267e27beb2146c1d080113e39ef12..428e87c9125ee0c0ed608ee35a559a29acd68a06 100644
--- a/DDCore/src/DetectorInterna.cpp
+++ b/DDCore/src/DetectorInterna.cpp
@@ -12,22 +12,22 @@
//==========================================================================
// Framework include files
-#include "DD4hep/detail/Handle.inl"
-#include "DD4hep/detail/DetectorInterna.h"
-#include "DD4hep/detail/ConditionsInterna.h"
-#include "DD4hep/detail/AlignmentsInterna.h"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/DetectorTools.h"
-#include "DD4hep/Printout.h"
-#include "TGeoVolume.h"
-#include "TGeoMatrix.h"
-#include "TGeoManager.h"
+#include <DD4hep/detail/Handle.inl>
+#include <DD4hep/detail/DetectorInterna.h>
+#include <DD4hep/detail/ConditionsInterna.h>
+#include <DD4hep/detail/AlignmentsInterna.h>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/DetectorTools.h>
+#include <DD4hep/Printout.h>
+
+#include <TGeoVolume.h>
+#include <TGeoMatrix.h>
+#include <TGeoManager.h>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
-typedef detail::tools::PlacementPath PlacementPath;
-typedef detail::tools::ElementPath ElementPath;
+
+using PlacementPath = detail::tools::PlacementPath;
+using ElementPath = detail::tools::ElementPath;
DD4HEP_INSTANTIATE_HANDLE_NAMED(DetElementObject);
DD4HEP_INSTANTIATE_HANDLE_NAMED(SensitiveDetectorObject);
@@ -84,9 +84,9 @@ DetElementObject::DetElementObject(const std::string& nam, int ident)
/// Internal object destructor: release extension object(s)
DetElementObject::~DetElementObject() {
- destroyHandles(children);
- destroyHandle (nominal);
- destroyHandle (survey);
+ detail::destroyHandles(children);
+ detail::destroyHandle (nominal);
+ detail::destroyHandle (survey);
placement.clear();
idealPlace.clear();
parent.clear();
@@ -135,7 +135,7 @@ DetElementObject* DetElementObject::clone(int new_id, int flg) const {
}
/// Reflect all volumes in a DetElement sub-tree and re-attach the placements
-pair<DetElement,Volume> DetElementObject::reflect(const std::string& new_name, int new_id, SensitiveDetector sd) {
+std::pair<DetElement,Volume> DetElementObject::reflect(const std::string& new_name, int new_id, SensitiveDetector sd) {
struct ChildMapper {
std::map<TGeoNode*,TGeoNode*> nodes;
void match(DetElement de_det, DetElement de_ref) const {
@@ -154,7 +154,7 @@ pair<DetElement,Volume> DetElementObject::reflect(const std::string& new_name, i
if ( nodes.find(n1) == nodes.end() ) {
TGeoVolume* v1 = n1->GetVolume();
TGeoVolume* v2 = n2->GetVolume();
- nodes.insert(make_pair(n1,n2));
+ nodes.insert(std::make_pair(n1,n2));
printout(DEBUG,"DetElement","reflect: Map %p --- %p ",n1,n2);
for(Int_t i=0; i<v1->GetNdaughters(); ++i)
map(v1->GetNode(i), v2->GetNode(i));
@@ -173,7 +173,7 @@ pair<DetElement,Volume> DetElementObject::reflect(const std::string& new_name, i
mapper.map(vol_det->GetNode(i), vol_ref->GetNode(i));
for(auto i=childrens_det.begin(), j=childrens_ref.begin(); i!=childrens_det.end(); ++i, ++j)
mapper.match((*i).second, (*j).second);
- return make_pair(det_ref,vol_ref);
+ return std::make_pair(det_ref,vol_ref);
}
/// Access to the world object. Only possible once the geometry is closed.
@@ -195,7 +195,7 @@ void DetElementObject::revalidate() {
DetElement det(this);
DetElement par(det.parent());
DetElement wrld = world();
- string place = det.placementPath();
+ std::string place = det.placementPath();
detail::tools::placementPath(par, this, par_path);
PlacedVolume node = detail::tools::findNode(wrld.placement(),place);
@@ -251,7 +251,7 @@ void DetElementObject::update(unsigned int tags, void* param) {
}
/// Initializing constructor
-WorldObject::WorldObject(Detector& _description, const string& nam)
+WorldObject::WorldObject(Detector& _description, const std::string& nam)
: DetElementObject(nam,0), description(&_description)
{
}
diff --git a/DDCore/src/DetectorLoad.cpp b/DDCore/src/DetectorLoad.cpp
index c103c54265adc91615722b479a04b596854a3635..cf464a4ddcf08ef2018d40d1c3b225f586d35500 100644
--- a/DDCore/src/DetectorLoad.cpp
+++ b/DDCore/src/DetectorLoad.cpp
@@ -12,18 +12,18 @@
//==========================================================================
// Framework include files
-#include "DD4hep/DetectorLoad.h"
-#include "DD4hep/Detector.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Plugins.h"
-#include "XML/XMLElements.h"
-#include "XML/DocumentHandler.h"
+#include <DD4hep/DetectorLoad.h>
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Plugins.h>
+#include <XML/XMLElements.h>
+#include <XML/DocumentHandler.h>
// C/C++ include files
#include <stdexcept>
#ifndef __TIXML__
-#include "xercesc/dom/DOMException.hpp"
+#include <xercesc/dom/DOMException.hpp>
namespace dd4hep {
namespace xml {
typedef xercesc::DOMException XmlException;
@@ -32,7 +32,6 @@ namespace dd4hep {
#endif
using namespace dd4hep;
-using namespace std;
/// Default constructor (protected, for sub-classes)
DetectorLoad::DetectorLoad(Detector* description) : m_detDesc(description) {
@@ -47,7 +46,7 @@ DetectorLoad::~DetectorLoad() {
}
/// Process XML unit and adopt all data from source structure.
-void DetectorLoad::processXML(const string& xmlfile, xml::UriReader* entity_resolver) {
+void DetectorLoad::processXML(const std::string& xmlfile, xml::UriReader* entity_resolver) {
try {
xml::DocumentHolder doc(xml::DocumentHandler().load(xmlfile,entity_resolver));
if ( doc ) {
@@ -57,21 +56,21 @@ void DetectorLoad::processXML(const string& xmlfile, xml::UriReader* entity_reso
return;
}
}
- throw runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " [Invalid XML ROOT handle]");
+ throw std::runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " [Invalid XML ROOT handle]");
}
catch (const xml::XmlException& e) {
- throw runtime_error(xml::_toString(e.msg) + "\ndd4hep: XML-DOM Exception while parsing " + xmlfile);
+ throw std::runtime_error(xml::_toString(e.msg) + "\ndd4hep: XML-DOM Exception while parsing " + xmlfile);
}
- catch (const exception& e) {
- throw runtime_error(string(e.what()) + "\ndd4hep: while parsing " + xmlfile);
+ catch (const std::exception& e) {
+ throw std::runtime_error(std::string(e.what()) + "\ndd4hep: while parsing " + xmlfile);
}
catch (...) {
- throw runtime_error("dd4hep: UNKNOWN exception while parsing " + xmlfile);
+ throw std::runtime_error("dd4hep: UNKNOWN exception while parsing " + xmlfile);
}
}
/// Process XML unit and adopt all data from source structure.
-void DetectorLoad::processXML(const xml::Handle_t& base, const string& xmlfile, xml::UriReader* entity_resolver) {
+void DetectorLoad::processXML(const xml::Handle_t& base, const std::string& xmlfile, xml::UriReader* entity_resolver) {
try {
xml::Strng_t xml(xmlfile);
xml::DocumentHolder doc(xml::DocumentHandler().load(base,xml,entity_resolver));
@@ -82,16 +81,16 @@ void DetectorLoad::processXML(const xml::Handle_t& base, const string& xmlfile,
return;
}
}
- throw runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " [Invalid XML ROOT handle]");
+ throw std::runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " [Invalid XML ROOT handle]");
}
catch (const xml::XmlException& e) {
- throw runtime_error(xml::_toString(e.msg) + "\ndd4hep: XML-DOM Exception while parsing " + xmlfile);
+ throw std::runtime_error(xml::_toString(e.msg) + "\ndd4hep: XML-DOM Exception while parsing " + xmlfile);
}
- catch (const exception& e) {
- throw runtime_error(string(e.what()) + "\ndd4hep: while parsing " + xmlfile);
+ catch (const std::exception& e) {
+ throw std::runtime_error(std::string(e.what()) + "\ndd4hep: while parsing " + xmlfile);
}
catch (...) {
- throw runtime_error("dd4hep: UNKNOWN exception while parsing " + xmlfile);
+ throw std::runtime_error("dd4hep: UNKNOWN exception while parsing " + xmlfile);
}
}
@@ -113,65 +112,65 @@ void DetectorLoad::processXMLString(const char* xmldata, xml::UriReader* entity_
}
}
}
- throw runtime_error("DetectorLoad::processXMLString: Invalid XML In-memory source [NULL]");
+ throw std::runtime_error("DetectorLoad::processXMLString: Invalid XML In-memory source [NULL]");
}
catch (const xml::XmlException& e) {
- throw runtime_error(xml::_toString(e.msg) + "\ndd4hep: XML-DOM Exception while parsing XML in-memory string.");
+ throw std::runtime_error(xml::_toString(e.msg) + "\ndd4hep: XML-DOM Exception while parsing XML in-memory string.");
}
- catch (const exception& e) {
- throw runtime_error(string(e.what()) + "\ndd4hep: while parsing XML in-memory string.");
+ catch (const std::exception& e) {
+ throw std::runtime_error(std::string(e.what()) + "\ndd4hep: while parsing XML in-memory string.");
}
catch (...) {
- throw runtime_error("dd4hep: UNKNOWN exception while parsing XML in-memory string.");
+ throw std::runtime_error("dd4hep: UNKNOWN exception while parsing XML in-memory string.");
}
}
/// Process a given DOM (sub-) tree
void DetectorLoad::processXMLElement(const std::string& xmlfile, const xml::Handle_t& xml_root) {
if ( xml_root.ptr() ) {
- string tag = xml_root.tag();
- string type = tag + "_XML_reader";
+ std::string tag = xml_root.tag();
+ std::string type = tag + "_XML_reader";
xml::Handle_t handle = xml_root;
long result = PluginService::Create<long>(type, m_detDesc, &handle);
if (0 == result) {
PluginDebug dbg;
result = PluginService::Create<long>(type, m_detDesc, &handle);
if ( 0 == result ) {
- throw runtime_error("dd4hep: Failed to locate plugin to interprete files of type"
- " \"" + tag + "\" - no factory:" + type + ". " + dbg.missingFactory(type));
+ throw std::runtime_error("dd4hep: Failed to locate plugin to interprete files of type"
+ " \"" + tag + "\" - no factory:" + type + ". " + dbg.missingFactory(type));
}
}
result = *(long*) result;
if (result != 1) {
- throw runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " with the plugin " + type);
+ throw std::runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " with the plugin " + type);
}
return;
}
- throw runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " [Invalid XML ROOT handle]");
+ throw std::runtime_error("dd4hep: Failed to parse the XML file " + xmlfile + " [Invalid XML ROOT handle]");
}
/// Process a given DOM (sub-) tree
void DetectorLoad::processXMLElement(const xml::Handle_t& xml_root, DetectorBuildType /* type */) {
if ( xml_root.ptr() ) {
- string tag = xml_root.tag();
- string type = tag + "_XML_reader";
+ std::string tag = xml_root.tag();
+ std::string type = tag + "_XML_reader";
xml::Handle_t handle = xml_root;
long result = PluginService::Create<long>(type, m_detDesc, &handle);
if (0 == result) {
PluginDebug dbg;
result = PluginService::Create<long>(type, m_detDesc, &handle);
if ( 0 == result ) {
- throw runtime_error("dd4hep: Failed to locate plugin to interprete files of type"
- " \"" + tag + "\" - no factory:"
- + type + ". " + dbg.missingFactory(type));
+ throw std::runtime_error("dd4hep: Failed to locate plugin to interprete files of type"
+ " \"" + tag + "\" - no factory:"
+ + type + ". " + dbg.missingFactory(type));
}
}
result = *(long*) result;
if (result != 1) {
- throw runtime_error("dd4hep: Failed to parse the XML element with tag "
- + tag + " with the plugin " + type);
+ throw std::runtime_error("dd4hep: Failed to parse the XML element with tag "
+ + tag + " with the plugin " + type);
}
return;
}
- throw runtime_error("dd4hep: Failed to parse the XML file [Invalid XML ROOT handle]");
+ throw std::runtime_error("dd4hep: Failed to parse the XML file [Invalid XML ROOT handle]");
}
diff --git a/DDCore/src/DetectorProcessor.cpp b/DDCore/src/DetectorProcessor.cpp
index a08741f43713537bf9dd2b3f57ed431060a2deab..ac68dc9029a2a873713a8617c310d32315b60749 100644
--- a/DDCore/src/DetectorProcessor.cpp
+++ b/DDCore/src/DetectorProcessor.cpp
@@ -12,9 +12,9 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Printout.h"
-#include "DD4hep/DetectorProcessor.h"
-#include "DD4hep/detail/ContainerHelpers.h"
+#include <DD4hep/Printout.h>
+#include <DD4hep/DetectorProcessor.h>
+#include <DD4hep/detail/ContainerHelpers.h>
using namespace dd4hep;
diff --git a/DDCore/src/DetectorSelector.cpp b/DDCore/src/DetectorSelector.cpp
index 40b2058ccbfbf42ef354cd8109a995510efddde5..8f72fa020ea07a864248bdb6b11019968404c8e3 100644
--- a/DDCore/src/DetectorSelector.cpp
+++ b/DDCore/src/DetectorSelector.cpp
@@ -12,33 +12,31 @@
//==========================================================================
// Framework include files
-#include "DD4hep/DetectorSelector.h"
-#include "DD4hep/Detector.h"
+#include <DD4hep/DetectorSelector.h>
+#include <DD4hep/Detector.h>
-using namespace std;
using namespace dd4hep;
/// Access a set of subdetectors according to the sensitive type.
-const DetectorSelector::Result&
-DetectorSelector::detectors(const string& type)
+const DetectorSelector::Result& DetectorSelector::detectors(const std::string& type)
{
return description.detectors(type);
}
/// Access a set of subdetectors according to several sensitive types.
DetectorSelector::Result
-DetectorSelector::detectors(const string& type1,
- const string& type2,
- const string& type3,
- const string& type4,
- const string& type5) {
- const string* types[] = { &type1, &type2, &type3, &type4, &type5 };
+DetectorSelector::detectors(const std::string& type1,
+ const std::string& type2,
+ const std::string& type3,
+ const std::string& type4,
+ const std::string& type5) {
+ const std::string* types[] = { &type1, &type2, &type3, &type4, &type5 };
Result result;
- for(size_t i=0; i<sizeof(types)/sizeof(types[0]); ++i) {
+ for( std::size_t i=0; i<sizeof(types)/sizeof(types[0]); ++i ) {
try {
if ( !types[i]->empty() ) {
- const vector<DetElement>& v = description.detectors(*(types[i]));
- result.insert(end(result),begin(v),end(v));
+ const std::vector<DetElement>& v = description.detectors(*(types[i]));
+ result.insert(std::end(result), std::begin(v), std::end(v));
}
}
catch(...) {}
@@ -55,7 +53,7 @@ DetectorSelector::detectors(unsigned int includeFlag, unsigned int excludeFlag )
const Detector::HandleMap& entries = description.detectors();
result.reserve( entries.size() ) ;
description.detectors(""); // Just to ensure the geometry is closed....
- for(const auto& i : entries ) {
+ for( const auto& i : entries ) {
DetElement det(i.second);
if ( det.parent().isValid() ) { // Exclude 'world'
//fixme: what to do with compounds - add their daughters ?
diff --git a/DDCore/src/DetectorTools.cpp b/DDCore/src/DetectorTools.cpp
index 61d84ec5b6d45142d188a2c62afab0c0533dfb0e..bee5e7c10b00b5cac04c3bffc21db97fca488b4a 100644
--- a/DDCore/src/DetectorTools.cpp
+++ b/DDCore/src/DetectorTools.cpp
@@ -13,17 +13,17 @@
// Framework include files
#define DETECTORTOOLS_CPP
-#include "DD4hep/DetectorTools.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Detector.h"
-#include "DD4hep/detail/DetectorInterna.h"
+#include <DD4hep/DetectorTools.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Detector.h>
+#include <DD4hep/detail/DetectorInterna.h>
// C/C++ include files
#include <stdexcept>
#include <memory>
// ROOT include files
-#include "TGeoMatrix.h"
+#include <TGeoMatrix.h>
/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
@@ -51,7 +51,6 @@ namespace dd4hep {
}}
}
-using namespace std;
using namespace dd4hep;
/// Find path between the child element and the parent element
@@ -62,7 +61,7 @@ bool detail::tools::isParentElement(DetElement parent, DetElement child) {
if ( par.ptr() == parent.ptr() ) return true;
}
}
- throw runtime_error("Search for parent detector element with invalid handles not allowed.");
+ throw std::runtime_error("Search for parent detector element with invalid handles not allowed.");
}
/// Find Child of PlacedVolume and assemble on the fly the path of PlacedVolumes
@@ -149,9 +148,9 @@ void detail::tools::elementPath(DetElement parent, DetElement child, ElementPath
return;
}
}
- throw runtime_error(string("The detector element ")+parent.name()+string(" is no parent of ")+child.name());
+ throw std::runtime_error(std::string("The detector element ")+parent.name()+std::string(" is no parent of ")+child.name());
}
- throw runtime_error("Search for parent detector element with invalid handles not allowed.");
+ throw std::runtime_error("Search for parent detector element with invalid handles not allowed.");
}
/// Collect detector elements placements to the top detector element (world) [fast, but may have holes!]
@@ -163,7 +162,7 @@ void detail::tools::elementPath(DetElement parent, DetElement element, Placement
}
if ( par.ptr() == parent.ptr() ) return;
}
- throw runtime_error(string("The detector element ")+parent.name()+string(" is no parent of ")+element.name());
+ throw std::runtime_error(std::string("The detector element ")+parent.name()+std::string(" is no parent of ")+element.name());
}
/// Collect detector elements placements to the top detector element (world) [fast, but may have holes!]
@@ -177,64 +176,64 @@ void detail::tools::elementPath(DetElement element, PlacementPath& det_nodes) {
}
/// Assemble the path of the PlacedVolume selection
-string detail::tools::elementPath(const PlacementPath& nodes, bool reverse) {
- string path = "";
+std::string detail::tools::elementPath(const PlacementPath& nodes, bool reverse) {
+ std::string path = "";
if ( reverse ) {
for(auto i=nodes.rbegin(); i != nodes.rend(); ++i)
- path += "/" + string((*i).name());
+ path += "/" + std::string((*i).name());
}
else {
for(auto i=begin(nodes); i != end(nodes); ++i)
- path += "/" + string((*i)->GetName());
+ path += "/" + std::string((*i)->GetName());
}
return path;
}
/// Assemble the path of the PlacedVolume selection
-string detail::tools::elementPath(const ElementPath& nodes, bool reverse) {
- string path = "";
+std::string detail::tools::elementPath(const ElementPath& nodes, bool reverse) {
+ std::string path = "";
if ( reverse ) {
for(ElementPath::const_reverse_iterator i=nodes.rbegin();i!=nodes.rend();++i)
- path += "/" + string((*i)->GetName());
+ path += "/" + std::string((*i)->GetName());
}
else {
for(ElementPath::const_iterator i=nodes.begin();i!=nodes.end();++i)
- path += "/" + string((*i)->GetName());
+ path += "/" + std::string((*i)->GetName());
}
return path;
}
/// Assemble the path of a particular detector element
-string detail::tools::elementPath(DetElement element) {
+std::string detail::tools::elementPath(DetElement element) {
ElementPath nodes;
elementPath(element,nodes);
return elementPath(nodes);
}
/// Find DetElement as child of the top level volume by its absolute path
-DetElement detail::tools::findElement(const Detector& description, const string& path) {
+DetElement detail::tools::findElement(const Detector& description, const std::string& path) {
return findDaughterElement(description.world(),path);
}
/// Find DetElement as child of a parent by its relative or absolute path
-DetElement detail::tools::findDaughterElement(DetElement parent, const string& subpath) {
+DetElement detail::tools::findDaughterElement(DetElement parent, const std::string& subpath) {
if ( parent.isValid() ) {
size_t idx = subpath.find('/',1);
if ( subpath[0] == '/' ) {
DetElement top = topElement(parent);
- if ( idx == string::npos ) return top;
+ if ( idx == std::string::npos ) return top;
return findDaughterElement(top,subpath.substr(idx+1));
}
- if ( idx == string::npos )
+ if ( idx == std::string::npos )
return parent.child(subpath);
- string name = subpath.substr(0,idx);
+ std::string name = subpath.substr(0,idx);
DetElement node = parent.child(name);
if ( node.isValid() ) {
return findDaughterElement(node,subpath.substr(idx+1));
}
- throw runtime_error("dd4hep: DetElement "+parent.path()+" has no child named:"+name+" [No such child]");
+ throw std::runtime_error("dd4hep: DetElement "+parent.path()+" has no child named:"+name+" [No such child]");
}
- throw runtime_error("dd4hep: Cannot determine child with path "+subpath+" from invalid parent [invalid handle]");
+ throw std::runtime_error("dd4hep: Cannot determine child with path "+subpath+" from invalid parent [invalid handle]");
}
/// Determine top level element (=world) for any element walking up the detector element tree
@@ -244,14 +243,14 @@ DetElement detail::tools::topElement(DetElement child) {
return topElement(child.parent());
return child;
}
- throw runtime_error("dd4hep: DetElement cannot determine top parent (world) [invalid handle]");
+ throw std::runtime_error("dd4hep: DetElement cannot determine top parent (world) [invalid handle]");
}
static void detail::tools::makePlacementPath(PlacementPath det_nodes, PlacementPath& all_nodes) {
for (size_t i = 0, n = det_nodes.size(); n > 0 && i < n-1; ++i) {
if (!findChildByName(det_nodes[i + 1], det_nodes[i], all_nodes)) {
- throw runtime_error("dd4hep: DetElement cannot determine placement path of "
- + string(det_nodes[i].name()) + " [internal error]");
+ throw std::runtime_error("dd4hep: DetElement cannot determine placement path of "
+ + std::string(det_nodes[i].name()) + " [internal error]");
}
}
if ( det_nodes.size() > 0 ) {
@@ -274,37 +273,36 @@ void detail::tools::placementPath(DetElement parent, DetElement element, Placeme
}
/// Assemble the path of the PlacedVolume selection
-string detail::tools::placementPath(DetElement element) {
+std::string detail::tools::placementPath(DetElement element) {
PlacementPath path;
placementPath(element,path);
return placementPath(path);
}
/// Assemble the path of the PlacedVolume selection
-string detail::tools::placementPath(const PlacementPath& nodes, bool reverse) {
- string path = "";
+std::string detail::tools::placementPath(const PlacementPath& nodes, bool reverse) {
+ std::string path = "";
if ( reverse ) {
for(PlacementPath::const_reverse_iterator i=nodes.rbegin();i!=nodes.rend();++i)
- path += "/" + string((*i)->GetName());
+ path += "/" + std::string((*i)->GetName());
}
else {
for(PlacementPath::const_iterator i=nodes.begin();i!=nodes.end();++i)
- path += "/" + string((*i)->GetName());
+ path += "/" + std::string((*i)->GetName());
}
return path;
}
/// Assemble the path of the PlacedVolume selection
-string detail::tools::placementPath(const vector<const TGeoNode*>& nodes, bool reverse) {
- string path = "";
+std::string detail::tools::placementPath(const std::vector<const TGeoNode*>& nodes, bool reverse) {
+ std::string path = "";
if ( reverse ) {
- for(vector<const TGeoNode*>::const_reverse_iterator i=nodes.rbegin();i!=nodes.rend();++i)
- path += "/" + string((*i)->GetName());
- }
- else {
- for(vector<const TGeoNode*>::const_iterator i=nodes.begin();i!=nodes.end();++i)
- path += "/" + string((*i)->GetName());
+ for(std::vector<const TGeoNode*>::const_reverse_iterator i=nodes.rbegin();i!=nodes.rend();++i)
+ path += "/" + std::string((*i)->GetName());
+ return path;
}
+ for( const auto* n : nodes )
+ path += "/" + std::string(n->GetName());
return path;
}
@@ -327,7 +325,7 @@ void detail::tools::placementTrafo(const PlacementPath& nodes, bool inverse, TGe
}
/// Find a given node in the hierarchy starting from the top node (absolute placement!)
-PlacedVolume detail::tools::findNode(PlacedVolume top_place, const string& place) {
+PlacedVolume detail::tools::findNode(PlacedVolume top_place, const std::string& place) {
TGeoNode* top = top_place.ptr();
const char* path = place.c_str();
// Check if a geometry path is valid without changing the state of the navigator.
@@ -377,16 +375,16 @@ PlacedVolume detail::tools::findNode(PlacedVolume top_place, const string& place
}
/// Convert VolumeID to string
-string detail::tools::toString(const PlacedVolume::VolIDs& ids) {
- stringstream log;
+std::string detail::tools::toString(const PlacedVolume::VolIDs& ids) {
+ std::stringstream log;
for( const auto& v : ids )
log << v.first << "=" << v.second << "; ";
return log.str();
}
/// Convert VolumeID to string
-string detail::tools::toString(const IDDescriptor& dsc, const PlacedVolume::VolIDs& ids, VolumeID code) {
- stringstream log;
+std::string detail::tools::toString(const IDDescriptor& dsc, const PlacedVolume::VolIDs& ids, VolumeID code) {
+ std::stringstream log;
for( const auto& id : ids ) {
const BitFieldElement* f = dsc.field(id.first);
VolumeID value = f->value(code);
@@ -396,14 +394,14 @@ string detail::tools::toString(const IDDescriptor& dsc, const PlacedVolume::VolI
}
/// Extract all the path elements from a path
-vector<string> detail::tools::pathElements(const string& path) {
- vector<string> result;
+std::vector<std::string> detail::tools::pathElements(const std::string& path) {
+ std::vector<std::string> result;
if ( !path.empty() ) {
- string tmp = path[0]=='/' ? path.substr(1) : path;
- for(size_t idx=tmp.find('/'); idx != string::npos; idx=tmp.find('/')) {
- string val = tmp.substr(0,idx);
+ std::string tmp = path[0]=='/' ? path.substr(1) : path;
+ for(size_t idx=tmp.find('/'); idx != std::string::npos; idx=tmp.find('/')) {
+ std::string val = tmp.substr(0,idx);
result.emplace_back(val);
- tmp = tmp.length()>idx ? tmp.substr(idx+1) : string();
+ tmp = tmp.length()>idx ? tmp.substr(idx+1) : std::string();
}
if ( !tmp.empty() ) {
result.emplace_back(tmp);
diff --git a/DDCore/src/Errors.cpp b/DDCore/src/Errors.cpp
index f23b4d4e11b0e03b6570c36a7aa48e1eb7d50008..a123328f46d99506faefdd61a8b199c722ca361a 100644
--- a/DDCore/src/Errors.cpp
+++ b/DDCore/src/Errors.cpp
@@ -13,7 +13,7 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Errors.h"
+#include <DD4hep/Errors.h>
// C/C++ includes
#include <cerrno>
diff --git a/DDCore/src/Exceptions.cpp b/DDCore/src/Exceptions.cpp
index 9237eed19516ff0ec1314b13a11e93de810d5793..e80f12b83ef8b9f9ec3aec22e419297ae8162296 100644
--- a/DDCore/src/Exceptions.cpp
+++ b/DDCore/src/Exceptions.cpp
@@ -12,18 +12,17 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Exceptions.h"
-#include "DD4hep/Primitives.h"
+#include <DD4hep/Exceptions.h>
+#include <DD4hep/Primitives.h>
-using namespace std;
using namespace dd4hep;
-string unrelated_type_error::msg(const type_info& typ1, const type_info& typ2, const string& text) {
- string m = "The types " + typeName(typ1) + " and " + typeName(typ2) + " are not related. " + text;
+std::string unrelated_type_error::msg(const std::type_info& typ1, const std::type_info& typ2, const std::string& text) {
+ std::string m = "The types " + typeName(typ1) + " and " + typeName(typ2) + " are not related. " + text;
return m;
}
-string unrelated_value_error::msg(const type_info& typ, const string& text) {
- string m = "The type " + typeName(typ) + " cannot be converted: " + text;
+std::string unrelated_value_error::msg(const std::type_info& typ, const std::string& text) {
+ std::string m = "The type " + typeName(typ) + " cannot be converted: " + text;
return m;
}
diff --git a/DDCore/src/ExtensionEntry.cpp b/DDCore/src/ExtensionEntry.cpp
index f22876858715c29e741510b61b87184d8e5c2788..82cc8f79c41799b8d55ef0afe30d643757de5126 100644
--- a/DDCore/src/ExtensionEntry.cpp
+++ b/DDCore/src/ExtensionEntry.cpp
@@ -12,8 +12,8 @@
//==========================================================================
// Framework include files
-#include "DD4hep/ExtensionEntry.h"
-#include "DD4hep/Printout.h"
+#include <DD4hep/ExtensionEntry.h>
+#include <DD4hep/Printout.h>
/// Callback on invalid call invokation
void dd4hep::ExtensionEntry::invalidCall(const char* tag) const {
diff --git a/DDCore/src/FieldTypes.cpp b/DDCore/src/FieldTypes.cpp
index f1e0b365d568db6f43216e487205b35ea2b686e9..16b94b58f4cd18493c7f770f8d8b68fe9d49ee69 100644
--- a/DDCore/src/FieldTypes.cpp
+++ b/DDCore/src/FieldTypes.cpp
@@ -11,11 +11,10 @@
//
//==========================================================================
-#include "DD4hep/FieldTypes.h"
-#include "DD4hep/detail/Handle.inl"
+#include <DD4hep/FieldTypes.h>
+#include <DD4hep/detail/Handle.inl>
#include <cmath>
-using namespace std;
using namespace dd4hep;
#ifndef INFINITY
@@ -159,7 +158,7 @@ void MultipoleField::fieldComponents(const double* pos, double* field) {
case 0: // Nothing, but still valid
break;
default: // Error condition
- throw runtime_error("Invalid multipole field definition!");
+ throw std::runtime_error("Invalid multipole field definition!");
}
Transform3D::Point f = this->rotation * Transform3D::Point(bx, by, B_z);
field[0] += f.X();
diff --git a/DDCore/src/Fields.cpp b/DDCore/src/Fields.cpp
index 7bc8efeb1b56b6dcefbaffed1a74c6771541a153..cc315453996927e6889052206efa3aab2fc181bc 100644
--- a/DDCore/src/Fields.cpp
+++ b/DDCore/src/Fields.cpp
@@ -11,12 +11,11 @@
//
//==========================================================================
-#include "DD4hep/Fields.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/detail/Handle.inl"
+#include <DD4hep/Fields.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/detail/Handle.inl>
-using namespace std;
using namespace dd4hep;
typedef CartesianField::Object CartesianFieldObject;
@@ -26,7 +25,7 @@ typedef OverlayedField::Object OverlayedFieldObject;
DD4HEP_INSTANTIATE_HANDLE(OverlayedFieldObject);
namespace {
- void calculate_combined_field(vector<CartesianField>& v, const Position& pos, double* field) {
+ void calculate_combined_field(std::vector<CartesianField>& v, const Position& pos, double* field) {
for (const auto& i : v ) i.value(pos, field);
}
}
@@ -90,7 +89,7 @@ OverlayedField::Object::~Object() {
}
/// Object constructor
-OverlayedField::OverlayedField(const string& nam) : Ref_t() {
+OverlayedField::OverlayedField(const std::string& nam) : Ref_t() {
auto* obj = new Object();
assign(obj, nam, "overlay_field");
obj->field_type = CartesianField::OVERLAY;
@@ -116,13 +115,13 @@ void OverlayedField::add(CartesianField field) {
bool isEle = field.ELECTRIC == (typ & field.ELECTRIC);
bool isMag = field.MAGNETIC == (typ & field.MAGNETIC);
if (isEle) {
- vector < CartesianField > &v = o->electric_components;
+ std::vector < CartesianField > &v = o->electric_components;
v.emplace_back(field);
o->field_type |= field.ELECTRIC;
o->electric = (v.size() == 1) ? field : CartesianField();
}
if (isMag) {
- vector < CartesianField > &v = o->magnetic_components;
+ std::vector < CartesianField > &v = o->magnetic_components;
v.emplace_back(field);
o->field_type |= field.MAGNETIC;
o->magnetic = (v.size() == 1) ? field : CartesianField();
diff --git a/DDCore/src/Filter.cpp b/DDCore/src/Filter.cpp
index ff46f738d253b129777cd85a9a46705703c6f946..11641b32798cd2e81ff24f1598d796c7d9b464f5 100644
--- a/DDCore/src/Filter.cpp
+++ b/DDCore/src/Filter.cpp
@@ -1,65 +1,82 @@
-#include "DD4hep/Filter.h"
+//==========================================================================
+// AIDA Detector description implementation
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+// RootDictionary.h
+//
+//
+// M.Frank
+//
+//==========================================================================
+// Framework include files
+#include <DD4hep/Filter.h>
+
+// C/C++ include files
#include <functional>
#include <regex>
#include <iostream>
-using namespace std;
-
namespace dd4hep {
+
namespace dd {
- bool isMatch(string_view node, string_view name) {
+ bool isMatch(std::string_view node, std::string_view name) {
if (!dd4hep::dd::isRegex(name)) {
return (name == node);
} else {
- regex pattern({name.data(), name.size()});
- return regex_match(begin(node), end(node), pattern);
+ std::regex pattern({name.data(), name.size()});
+ return std::regex_match(begin(node), end(node), pattern);
}
}
- bool compareEqual(string_view node, string_view name) { return (name == node); }
+ bool compareEqual(std::string_view node, std::string_view name) { return (name == node); }
- bool compareEqual(string_view node, regex pattern) {
- return regex_match(std::string(node.data(), node.size()), pattern);
+ bool compareEqual(std::string_view node, std::regex pattern) {
+ return std::regex_match(std::string(node.data(), node.size()), pattern);
}
bool compareEqualName(const std::string_view selection, const std::string_view name) {
return (!(dd4hep::dd::isRegex(selection)) ? dd4hep::dd::compareEqual(name, selection)
- : regex_match(name.begin(), name.end(), regex(std::string(selection))));
+ : std::regex_match(name.begin(), name.end(), std::regex(std::string(selection))));
}
bool compareEqualCopyNumber(std::string_view name, int copy) {
auto pos = name.rfind('[');
if (pos != name.npos) {
- if (std::stoi(std::string(name.substr(pos + 1, name.rfind(']')))) == copy) {
- return true;
- }
+ if (std::stoi(std::string(name.substr(pos + 1, name.rfind(']')))) == copy) {
+ return true;
+ }
}
return false;
}
- bool accepted(vector<std::regex> const& keys, string_view node) {
+ bool accepted(std::vector<std::regex> const& keys, std::string_view node) {
return (find_if(begin(keys), end(keys), [&](const auto& n) -> bool { return compareEqual(node, n); }) !=
end(keys));
}
bool accepted(const Filter* filter, std::string_view name) {
for(unsigned int i = 0; i < filter->isRegex.size(); i++ ) {
- if(!filter->isRegex[i]) {
- if(compareEqual(filter->skeys[i], name)) {
- return true;
- }
- } else {
- if(compareEqual(name, filter->keys[filter->index[i]])) {
- return true;
- }
- }
+ if(!filter->isRegex[i]) {
+ if(compareEqual(filter->skeys[i], name)) {
+ return true;
+ }
+ } else {
+ if(compareEqual(name, filter->keys[filter->index[i]])) {
+ return true;
+ }
+ }
}
return false;
}
- bool isRegex(string_view input) {
+ bool isRegex(std::string_view input) {
return (input.find(".") != std::string_view::npos) || (input.find("*") != std::string_view::npos);
}
@@ -67,19 +84,19 @@ namespace dd4hep {
return (input.find(":") != std::string_view::npos);
}
- string_view realTopName(string_view input) {
- string_view v = input;
+ std::string_view realTopName(std::string_view input) {
+ std::string_view v = input;
auto first = v.find_first_of("//");
- v.remove_prefix(min(first + 2, v.size()));
+ v.remove_prefix(std::min(first + 2, v.size()));
return v;
}
- vector<string_view> split(string_view str, const char* delims) {
- vector<string_view> ret;
+ std::vector<std::string_view> split(std::string_view str, const char* delims) {
+ std::vector<std::string_view> ret;
- string_view::size_type start = 0;
+ std::string_view::size_type start = 0;
auto pos = str.find_first_of(delims, start);
- while (pos != string_view::npos) {
+ while (pos != std::string_view::npos) {
if (pos != start) {
ret.emplace_back(str.substr(start, pos - start));
}
diff --git a/DDCore/src/GeoDictionary.h b/DDCore/src/GeoDictionary.h
index 95f4c496c2e7ba27706f75c4acd3c8ec39773667..00f5f1f350f12bea7cd190de121e700a390dea94 100644
--- a/DDCore/src/GeoDictionary.h
+++ b/DDCore/src/GeoDictionary.h
@@ -17,10 +17,10 @@
#define DDCORE_SRC_GEODICTIONARY_H
// Framework include files
-#include "DD4hep/Volumes.h"
-#include "DD4hep/Shapes.h"
-#include "DD4hep/VolumeProcessor.h"
-#include "DD4hep/detail/ShapesInterna.h"
+#include <DD4hep/Volumes.h>
+#include <DD4hep/Shapes.h>
+#include <DD4hep/VolumeProcessor.h>
+#include <DD4hep/detail/ShapesInterna.h>
// C/C++ include files
#include <vector>
diff --git a/DDCore/src/GeoHandler.cpp b/DDCore/src/GeoHandler.cpp
index 61a7b746afae180bef1d2d84ca5f32079ec84703..04941b671ea71e30a41bc0beacf40cd079f7b526 100644
--- a/DDCore/src/GeoHandler.cpp
+++ b/DDCore/src/GeoHandler.cpp
@@ -12,28 +12,27 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Detector.h"
-#include "DD4hep/GeoHandler.h"
-#include "DD4hep/detail/ObjectsInterna.h"
+#include <DD4hep/Detector.h>
+#include <DD4hep/GeoHandler.h>
+#include <DD4hep/detail/ObjectsInterna.h>
// ROOT includes
-#include "TGeoManager.h"
-#include "TGeoCompositeShape.h"
-#include "TGeoBoolNode.h"
-#include "TClass.h"
+#include <TGeoManager.h>
+#include <TGeoCompositeShape.h>
+#include <TGeoBoolNode.h>
+#include <TClass.h>
// C/C++ include files
#include <iostream>
-using namespace dd4hep::detail;
using namespace dd4hep;
-using namespace std;
namespace {
- void collectSolid(GeoHandler::GeometryInfo& geo,
- const string& name,
- const string& node,
- TGeoShape* shape,
+
+ void collectSolid(detail::GeoHandler::GeometryInfo& geo,
+ const std::string& name,
+ const std::string& node,
+ TGeoShape* shape,
TGeoMatrix* matrix)
{
if ( 0 == ::strncmp(shape->GetName(), "TGeo", 4) ) {
@@ -51,43 +50,43 @@ namespace {
}
/// Default constructor
-GeoHandler::GeoHandler() : m_propagateRegions(false) {
- m_data = new map<int,set<const TGeoNode*> >();
+detail::GeoHandler::GeoHandler() : m_propagateRegions(false) {
+ m_data = new std::map<int, std::set<const TGeoNode*> >();
}
/// Initializing constructor
-GeoHandler::GeoHandler(map<int,set<const TGeoNode*> >* ptr)
+detail::GeoHandler::GeoHandler(std::map<int, std::set<const TGeoNode*> >* ptr)
: m_propagateRegions(false), m_data(ptr) {
}
/// Default destructor
-GeoHandler::~GeoHandler() {
+detail::GeoHandler::~GeoHandler() {
if (m_data)
delete m_data;
m_data = nullptr;
}
-map<int,set<const TGeoNode*> >* GeoHandler::release() {
- map<int,set<const TGeoNode*> >* d = m_data;
+std::map<int, std::set<const TGeoNode*> >* detail::GeoHandler::release() {
+ std::map<int, std::set<const TGeoNode*> >* d = m_data;
m_data = nullptr;
return d;
}
/// Propagate regions. Returns the previous value
-bool GeoHandler::setPropagateRegions(bool value) {
+bool detail::GeoHandler::setPropagateRegions(bool value) {
bool old = m_propagateRegions;
m_propagateRegions = value;
return old;
}
-GeoHandler& GeoHandler::collect(DetElement element) {
+detail::GeoHandler& detail::GeoHandler::collect(DetElement element) {
DetElement par = element.parent();
- TGeoNode* par_node = par.isValid() ? par.placement().ptr() : nullptr;
+ TGeoNode* par_node = par.isValid() ? par.placement().ptr() : nullptr;
m_data->clear();
return i_collect(par_node, element.placement().ptr(), 0, Region(), LimitSet());
}
-GeoHandler& GeoHandler::collect(DetElement element, GeometryInfo& info) {
+detail::GeoHandler& detail::GeoHandler::collect(DetElement element, GeometryInfo& info) {
DetElement par = element.parent();
TGeoNode* par_node = par.isValid() ? par.placement().ptr() : nullptr;
m_data->clear();
@@ -125,16 +124,16 @@ GeoHandler& GeoHandler::collect(DetElement element, GeometryInfo& info) {
return *this;
}
-GeoHandler& GeoHandler::i_collect(const TGeoNode* /* parent */,
- const TGeoNode* current,
- int level, Region rg, LimitSet ls)
+detail::GeoHandler& detail::GeoHandler::i_collect(const TGeoNode* /* parent */,
+ const TGeoNode* current,
+ int level, Region rg, LimitSet ls)
{
TGeoVolume* volume = current->GetVolume();
- TObjArray* nodes = volume->GetNodes();
- int num_children = nodes ? nodes->GetEntriesFast() : 0;
- Volume vol(volume);
- Region region = vol.region();
- LimitSet limits = vol.limitSet();
+ TObjArray* nodes = volume->GetNodes();
+ int num_children = nodes ? nodes->GetEntriesFast() : 0;
+ Volume vol(volume);
+ Region region = vol.region();
+ LimitSet limits = vol.limitSet();
if ( m_propagateRegions ) {
if ( !region.isValid() && rg.isValid() ) {
@@ -157,26 +156,26 @@ GeoHandler& GeoHandler::i_collect(const TGeoNode* /* parent */,
}
/// Initializing constructor
-GeoScan::GeoScan(DetElement e) {
+detail::GeoScan::GeoScan(DetElement e) {
m_data = GeoHandler().collect(e).release();
}
/// Initializing constructor
-GeoScan::GeoScan(DetElement e, bool propagate) {
+detail::GeoScan::GeoScan(DetElement e, bool propagate) {
GeoHandler h;
h.setPropagateRegions(propagate);
m_data = h.collect(e).release();
}
/// Default destructor
-GeoScan::~GeoScan() {
+detail::GeoScan::~GeoScan() {
if (m_data)
delete m_data;
m_data = 0;
}
/// Work callback
-GeoScan& GeoScan::operator()() {
+detail::GeoScan& detail::GeoScan::operator()() {
return *this;
}
diff --git a/DDCore/src/GeometryTreeDump.cpp b/DDCore/src/GeometryTreeDump.cpp
index bb2fa7733513683ba6646f704419969d59571072..75c11625e157ba488b391ff7170b0c51a5b22686 100644
--- a/DDCore/src/GeometryTreeDump.cpp
+++ b/DDCore/src/GeometryTreeDump.cpp
@@ -12,39 +12,40 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Detector.h"
#include "GeometryTreeDump.h"
+#include <DD4hep/Detector.h>
+
// ROOT includes
-#include "TROOT.h"
-#include "TColor.h"
-#include "TGeoShape.h"
-#include "TGeoCone.h"
-#include "TGeoParaboloid.h"
-#include "TGeoPcon.h"
-#include "TGeoPgon.h"
-#include "TGeoSphere.h"
-#include "TGeoTorus.h"
-#include "TGeoTube.h"
-#include "TGeoTrd1.h"
-#include "TGeoTrd2.h"
-#include "TGeoArb8.h"
-#include "TGeoMatrix.h"
-#include "TGeoBoolNode.h"
-#include "TGeoCompositeShape.h"
-#include "TClass.h"
-#include "TGeoManager.h"
-#include "TMath.h"
+#include <TROOT.h>
+#include <TColor.h>
+#include <TGeoShape.h>
+#include <TGeoCone.h>
+#include <TGeoParaboloid.h>
+#include <TGeoPcon.h>
+#include <TGeoPgon.h>
+#include <TGeoSphere.h>
+#include <TGeoTorus.h>
+#include <TGeoTube.h>
+#include <TGeoTrd1.h>
+#include <TGeoTrd2.h>
+#include <TGeoArb8.h>
+#include <TGeoMatrix.h>
+#include <TGeoBoolNode.h>
+#include <TGeoCompositeShape.h>
+#include <TClass.h>
+#include <TGeoManager.h>
+#include <TMath.h>
+
+// C/C++ include files
#include <iostream>
-using namespace dd4hep::detail;
using namespace dd4hep;
-using namespace std;
namespace {
- string indent = "";
+ std::string indent = "";
/// Reference to output stream
- ostream& m_output = cout;
+ std::ostream& m_output = std::cout;
void getAngles(const Double_t* m, Double_t &phi, Double_t &theta, Double_t &psi) {
// Retreive Euler angles.
@@ -68,91 +69,91 @@ namespace {
}
/// Dump logical volume in GDML format to output stream
-void* GeometryTreeDump::handleVolume(const string& name, Volume vol) const {
+void* detail::GeometryTreeDump::handleVolume(const std::string& name, Volume vol) const {
VisAttr vis = vol.visAttributes();
TGeoShape* shape = vol->GetShape();
TGeoMedium* medium = vol->GetMedium();
int num = vol->GetNdaughters();
- m_output << "\t\t<volume name=\"" << name << "\">" << endl;
- m_output << "\t\t\t<solidref ref=\"" << shape->GetName() << "\"/>" << endl;
- m_output << "\t\t\t<materialref ref=\"" << medium->GetName() << "\"/>" << endl;
+ m_output << "\t\t<volume name=\"" << name << "\">" << std::endl;
+ m_output << "\t\t\t<solidref ref=\"" << shape->GetName() << "\"/>" << std::endl;
+ m_output << "\t\t\t<materialref ref=\"" << medium->GetName() << "\"/>" << std::endl;
if (vis.isValid()) {
- m_output << "\t\t\t<visref ref=\"" << vis.name() << "\"/>" << endl;
+ m_output << "\t\t\t<visref ref=\"" << vis.name() << "\"/>" << std::endl;
}
if (num > 0) {
for (int i = 0; i < num; ++i) {
TGeoNode* geo_nod = vol.ptr()->GetNode(vol->GetNode(i)->GetName());
TGeoVolume* geo_vol = geo_nod->GetVolume();
TGeoMatrix* geo_mat = geo_nod->GetMatrix();
- m_output << "\t\t\t<physvol>" << endl;
- m_output << "\t\t\t\t<volumeref ref=\"" << geo_vol->GetName() << "\"/>" << endl;
+ m_output << "\t\t\t<physvol>" << std::endl;
+ m_output << "\t\t\t\t<volumeref ref=\"" << geo_vol->GetName() << "\"/>" << std::endl;
if (geo_mat) {
if (geo_mat->IsTranslation()) {
- m_output << "\t\t\t\t<positionref ref=\"" << geo_nod->GetName() << "_pos\"/>" << endl;
+ m_output << "\t\t\t\t<positionref ref=\"" << geo_nod->GetName() << "_pos\"/>" << std::endl;
}
if (geo_mat->IsRotation()) {
- m_output << "\t\t\t\t<rotationref ref=\"" << geo_nod->GetName() << "_rot\"/>" << endl;
+ m_output << "\t\t\t\t<rotationref ref=\"" << geo_nod->GetName() << "_rot\"/>" << std::endl;
}
}
- m_output << "\t\t\t</physvol>" << endl;
+ m_output << "\t\t\t</physvol>" << std::endl;
}
}
- m_output << "\t\t</volume>" << endl;
+ m_output << "\t\t</volume>" << std::endl;
return 0;
}
/// Dump solid in GDML format to output stream
-void* GeometryTreeDump::handleSolid(const string& name, const TGeoShape* shape) const {
+void* detail::GeometryTreeDump::handleSolid(const std::string& name, const TGeoShape* shape) const {
if (shape) {
if (shape->IsA() == TGeoBBox::Class()) {
const TGeoBBox* sh = (const TGeoBBox*) shape;
m_output << "\t\t<box name=\"" << name << "_shape\" x=\"" << sh->GetDX() << "\" y=\"" << sh->GetDY() << "\" z=\""
- << sh->GetDZ() << "\" lunit=\"cm\"/>" << endl;
+ << sh->GetDZ() << "\" lunit=\"cm\"/>" << std::endl;
}
else if (shape->IsA() == TGeoTube::Class()) {
const TGeoTube* sh = (const TGeoTube*) shape;
m_output << "\t\t<tube name=\"" << name << "_shape\" rmin=\"" << sh->GetRmin() << "\" rmax=\"" << sh->GetRmax() << "\" z=\""
- << sh->GetDz() << "\" startphi=\"0.0\" deltaphi=\"360.0\" aunit=\"deg\" lunit=\"cm\"/>" << endl;
+ << sh->GetDz() << "\" startphi=\"0.0\" deltaphi=\"360.0\" aunit=\"deg\" lunit=\"cm\"/>" << std::endl;
}
else if (shape->IsA() == TGeoTubeSeg::Class()) {
const TGeoTubeSeg* sh = (const TGeoTubeSeg*) shape;
m_output << "\t\t<tube name=\"" << name << "_shape\" rmin=\"" << sh->GetRmin() << "\" rmax=\"" << sh->GetRmax() << "\" z=\""
<< sh->GetDz() << "\" startphi=\"" << sh->GetPhi1() << "\" deltaphi=\"" << sh->GetPhi2()
- << "\" aunit=\"deg\" lunit=\"cm\"/>" << endl;
+ << "\" aunit=\"deg\" lunit=\"cm\"/>" << std::endl;
}
else if (shape->IsA() == TGeoTrd1::Class()) {
const TGeoTrd1* sh = (const TGeoTrd1*) shape;
m_output << "\t\t<tube name=\"" << name << "_shape\" x1=\"" << sh->GetDx1() << "\" x2=\"" << sh->GetDx2() << "\" y1=\""
- << sh->GetDy() << "\" y2=\"" << sh->GetDy() << "\" z=\"" << sh->GetDz() << "\" lunit=\"cm\"/>" << endl;
+ << sh->GetDy() << "\" y2=\"" << sh->GetDy() << "\" z=\"" << sh->GetDz() << "\" lunit=\"cm\"/>" << std::endl;
}
else if (shape->IsA() == TGeoTrd2::Class()) {
const TGeoTrd2* sh = (const TGeoTrd2*) shape;
m_output << "\t\t<tube name=\"" << name << "_shape\" x1=\"" << sh->GetDx1() << "\" x2=\"" << sh->GetDx2() << "\" y1=\""
- << sh->GetDy1() << "\" y2=\"" << sh->GetDy2() << "\" z=\"" << sh->GetDz() << "\" lunit=\"cm\"/>" << endl;
+ << sh->GetDy1() << "\" y2=\"" << sh->GetDy2() << "\" z=\"" << sh->GetDz() << "\" lunit=\"cm\"/>" << std::endl;
}
else if (shape->IsA() == TGeoPgon::Class()) {
const TGeoPgon* sh = (const TGeoPgon*) shape;
m_output << "\t\t<polyhedra name=\"" << name << "_shape\" startphi=\"" << sh->GetPhi1() << "\" deltaphi=\"" << sh->GetDphi()
- << "\" numsides=\"" << sh->GetNedges() << "\" aunit=\"deg\" lunit=\"cm\">" << endl;
+ << "\" numsides=\"" << sh->GetNedges() << "\" aunit=\"deg\" lunit=\"cm\">" << std::endl;
for (int i = 0; i < sh->GetNz(); ++i) {
m_output << "\t\t\t<zplane z=\"" << sh->GetZ(i) << "\" rmin=\"" << sh->GetRmin(i) << "\" rmax=\"" << sh->GetRmax(i)
- << "\" lunit=\"cm\"/>" << endl;
+ << "\" lunit=\"cm\"/>" << std::endl;
}
- m_output << "\t\t</polyhedra>" << endl;
+ m_output << "\t\t</polyhedra>" << std::endl;
}
else if (shape->IsA() == TGeoPcon::Class()) {
const TGeoPcon* sh = (const TGeoPcon*) shape;
m_output << "\t\t<polycone name=\"" << name << "_shape\" startphi=\"" << sh->GetPhi1() << "\" deltaphi=\"" << sh->GetDphi()
- << "\" aunit=\"deg\" lunit=\"cm\">" << endl;
+ << "\" aunit=\"deg\" lunit=\"cm\">" << std::endl;
for (int i = 0; i < sh->GetNz(); ++i) {
m_output << "\t\t\t<zplane z=\"" << sh->GetZ(i) << "\" rmin=\"" << sh->GetRmin(i) << "\" rmax=\"" << sh->GetRmax(i)
- << "\" lunit=\"cm\"/>" << endl;
+ << "\" lunit=\"cm\"/>" << std::endl;
}
- m_output << "\t\t</polycone>" << endl;
+ m_output << "\t\t</polycone>" << std::endl;
}
else if (shape->IsA() == TGeoCompositeShape::Class()) {
- string nn = name;
+ std::string nn = name;
const TGeoCompositeShape* sh = (const TGeoCompositeShape*) shape;
const TGeoBoolNode* boolean = sh->GetBoolNode();
TGeoBoolNode::EGeoBoolType oper = boolean->GetBooleanOperator();
@@ -161,49 +162,49 @@ void* GeometryTreeDump::handleSolid(const string& name, const TGeoShape* shape)
handleSolid(name + "_right", boolean->GetRightShape());
if (oper == TGeoBoolNode::kGeoSubtraction)
- m_output << "\t\t<subtraction name=\"" << nn << "\">" << endl;
+ m_output << "\t\t<subtraction name=\"" << nn << "\">" << std::endl;
else if (oper == TGeoBoolNode::kGeoUnion)
- m_output << "\t\t<union name=\"" << nn << "\">" << endl;
+ m_output << "\t\t<union name=\"" << nn << "\">" << std::endl;
else if (oper == TGeoBoolNode::kGeoIntersection)
- m_output << "\t\t<intersection name=\"" << nn << "\">" << endl;
+ m_output << "\t\t<intersection name=\"" << nn << "\">" << std::endl;
- m_output << "\t\t\t<first ref=\"" << nn << "_left\"/>" << endl;
- m_output << "\t\t\t<second ref=\"" << nn << "_right\"/>" << endl;
+ m_output << "\t\t\t<first ref=\"" << nn << "_left\"/>" << std::endl;
+ m_output << "\t\t\t<second ref=\"" << nn << "_right\"/>" << std::endl;
indent = "\t";
handleTransformation("", boolean->GetRightMatrix());
indent = "";
if (oper == TGeoBoolNode::kGeoSubtraction)
- m_output << "\t\t</subtraction>" << endl;
+ m_output << "\t\t</subtraction>" << std::endl;
else if (oper == TGeoBoolNode::kGeoUnion)
- m_output << "\t\t</union>" << endl;
+ m_output << "\t\t</union>" << std::endl;
else if (oper == TGeoBoolNode::kGeoIntersection)
- m_output << "\t\t</intersection>" << endl;
+ m_output << "\t\t</intersection>" << std::endl;
}
else {
- cerr << "Failed to handle unknwon solid shape:" << shape->IsA()->GetName() << endl;
+ std::cerr << "Failed to handle unknwon solid shape:" << shape->IsA()->GetName() << std::endl;
}
}
return 0;
}
/// Dump structure information in GDML format to output stream
-void GeometryTreeDump::handleStructure(const std::set<Volume>& volset) const {
- m_output << "\t<structure>" << endl;
+void detail::GeometryTreeDump::handleStructure(const std::set<Volume>& volset) const {
+ m_output << "\t<structure>" << std::endl;
for (const auto& vol : volset)
handleVolume(vol->GetName(), vol);
- m_output << "\t</structure>" << endl;
+ m_output << "\t</structure>" << std::endl;
}
/// Dump single volume transformation in GDML format to output stream
-void* GeometryTreeDump::handleTransformation(const string& name, const TGeoMatrix* mat) const {
+void* detail::GeometryTreeDump::handleTransformation(const std::string& name, const TGeoMatrix* mat) const {
if (mat) {
if (mat->IsTranslation()) {
const Double_t* f = mat->GetTranslation();
m_output << indent << "\t\t<position ";
if (!name.empty())
m_output << "name=\"" << name << "_pos\" ";
- m_output << "x=\"" << f[0] << "\" " << "y=\"" << f[1] << "\" " << "z=\"" << f[2] << "\" unit=\"cm\"/>" << endl;
+ m_output << "x=\"" << f[0] << "\" " << "y=\"" << f[1] << "\" " << "z=\"" << f[2] << "\" unit=\"cm\"/>" << std::endl;
}
if (mat->IsRotation()) {
const Double_t* matrix = mat->GetRotationMatrix();
@@ -212,42 +213,42 @@ void* GeometryTreeDump::handleTransformation(const string& name, const TGeoMatri
m_output << indent << "\t\t<rotation ";
if (!name.empty())
m_output << "name=\"" << name << "_rot\" ";
- m_output << "x=\"" << theta << "\" " << "y=\"" << psi << "\" " << "z=\"" << phi << "\" unit=\"deg\"/>" << endl;
+ m_output << "x=\"" << theta << "\" " << "y=\"" << psi << "\" " << "z=\"" << phi << "\" unit=\"deg\"/>" << std::endl;
}
}
return 0;
}
/// Dump Transformations in GDML format to output stream
-void GeometryTreeDump::handleTransformations(const std::vector<std::pair<std::string, TGeoMatrix*> >& trafos) const {
- m_output << "\t<define>" << endl;
- for (const auto& t : trafos )
+void detail::GeometryTreeDump::handleTransformations(const std::vector<std::pair<std::string, TGeoMatrix*> >& trafos) const {
+ m_output << "\t<define>" << std::endl;
+ for ( const auto& t : trafos )
handleTransformation(t.first, t.second);
- m_output << "\t</define>" << endl;
+ m_output << "\t</define>" << std::endl;
}
/// Dump all solids in GDML format to output stream
-void GeometryTreeDump::handleSolids(const std::set<TGeoShape*>& solids) const {
- m_output << "\t<solids>" << endl;
- for (const auto sh : solids )
+void detail::GeometryTreeDump::handleSolids(const std::set<TGeoShape*>& solids) const {
+ m_output << "\t<solids>" << std::endl;
+ for ( const auto sh : solids )
handleSolid(sh->GetName(), sh);
- m_output << "\t</solids>" << endl;
+ m_output << "\t</solids>" << std::endl;
}
/// Dump all constants in GDML format to output stream
-void GeometryTreeDump::handleDefines(const Detector::HandleMap& defs) const {
- m_output << "\t<define>" << endl;
- for (const auto& def : defs )
+void detail::GeometryTreeDump::handleDefines(const Detector::HandleMap& defs) const {
+ m_output << "\t<define>" << std::endl;
+ for ( const auto& def : defs )
m_output << "\t\t<constant name=\"" << def.second->name << "\" value=\"" << def.second->type << "\" />"
- << endl;
- m_output << "\t</define>" << endl;
+ << std::endl;
+ m_output << "\t</define>" << std::endl;
}
/// Dump all visualisation specs in Detector format to output stream
-void GeometryTreeDump::handleVisualisation(const Detector::HandleMap&) const {
+void detail::GeometryTreeDump::handleVisualisation(const Detector::HandleMap&) const {
}
-static string _path = "";
+static std::string _path = "";
static void dumpStructure(PlacedVolume pv, int level) {
TGeoNode* current = pv.ptr();
TGeoVolume* volume = current->GetVolume();
@@ -290,7 +291,7 @@ static void dumpDetectors(DetElement parent, int level) {
_path = _path.substr(0, _path.length() - 1 - strlen(parent.name()));
}
-void GeometryTreeDump::create(DetElement top) {
+void detail::GeometryTreeDump::create(DetElement top) {
dumpDetectors(top, 0);
dumpStructure(top.placement(), 0);
}
diff --git a/DDCore/src/GeometryTreeDump.h b/DDCore/src/GeometryTreeDump.h
index 02fe94f86602a7be536ffd21283bfd38b7150a8a..1f76989a51e165a2cb855a418944eef90d0005fa 100644
--- a/DDCore/src/GeometryTreeDump.h
+++ b/DDCore/src/GeometryTreeDump.h
@@ -14,11 +14,15 @@
#ifndef DDCORE_SRC_GEOMETRYTREEDUMP_H
#define DDCORE_SRC_GEOMETRYTREEDUMP_H
-#include "DD4hep/Detector.h"
-#include "DD4hep/GeoHandler.h"
+// Framework include files
+#include <DD4hep/Detector.h>
+#include <DD4hep/GeoHandler.h>
+
+// C/C++ include files
#include <set>
#include <map>
#include <vector>
+
class TGeoVolume;
class TGeoNode;
diff --git a/DDCore/src/GlobalAlignment.cpp b/DDCore/src/GlobalAlignment.cpp
index 89cfc54fb9fbb436ac556271625e41dfe5ce38cd..b97658a606de967b9ec4447a6876ff3c1dccf863 100644
--- a/DDCore/src/GlobalAlignment.cpp
+++ b/DDCore/src/GlobalAlignment.cpp
@@ -12,17 +12,15 @@
//==========================================================================
// Framework include files
-#include "DD4hep/GlobalAlignment.h"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/MatrixHelpers.h"
-#include "DD4hep/Printout.h"
+#include <DD4hep/GlobalAlignment.h>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/MatrixHelpers.h>
+#include <DD4hep/Printout.h>
// ROOT include files
-#include "TGeoMatrix.h"
-#include "TGeoManager.h"
+#include <TGeoMatrix.h>
+#include <TGeoManager.h>
-
-using namespace std;
using namespace dd4hep;
using namespace dd4hep::align;
@@ -30,14 +28,14 @@ namespace {
struct CheckHandle {
CheckHandle(const GlobalAlignment& a) {
if ( a.isValid() ) return;
- throw runtime_error("dd4hep: Attempt to access invalid alignment object. [Invalid Handle]");
+ except("dd4hep:GlobalAlignment", "Attempt to access invalid alignment object. [Invalid Handle]");
}
~CheckHandle() {}
};
}
/// Initializing constructor to create a new object
-GlobalAlignment::GlobalAlignment(const string& path) {
+GlobalAlignment::GlobalAlignment(const std::string& path) {
//cout << "GlobalAlignment: path=" << path << endl;
m_element = new TGeoPhysicalNode(path.c_str());
}
@@ -59,8 +57,9 @@ PlacedVolume GlobalAlignment::nodePlacement(int level) const {
CheckHandle verify_handle(*this);
TGeoNode* n = ptr()->GetNode(level);
if ( n ) return n;
- throw runtime_error("dd4hep: The object chain of "+string(placement().name())+
- " is too short. [Invalid index]");
+ except("dd4hep:GlobalAlignment",
+ "The object chain of %s is too short. [Invalid index]", placement().name());
+ return {};
}
/// Access the placement of the mother of this node
@@ -70,7 +69,9 @@ PlacedVolume GlobalAlignment::motherPlacement(int level_up) const {
if ( ind >= 0 ) {
return ptr()->GetMother(level_up);
}
- throw runtime_error("dd4hep: This object "+string(placement().name())+" has not enough mothers. [Invalid index]");
+ except("dd4hep:GlobalAlignment",
+ "This object %s has not enough mothers. [Invalid index]", placement().name());
+ return {};
}
/// Access the currently applied alignment/placement matrix
diff --git a/DDCore/src/Grammar.cpp b/DDCore/src/Grammar.cpp
index 12a6498c0b69f13e1a3b34634f72f6cca4960a2d..5b1c9a26b0a32789aa7e9cdd8178a22d00ae16f3 100644
--- a/DDCore/src/Grammar.cpp
+++ b/DDCore/src/Grammar.cpp
@@ -12,15 +12,15 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Printout.h"
-#include "DD4hep/Primitives.h"
-#include "DD4hep/Exceptions.h"
-#include "DD4hep/Grammar.h"
-#include "Evaluator/Evaluator.h"
+#include <DD4hep/Printout.h>
+#include <DD4hep/Primitives.h>
+#include <DD4hep/Exceptions.h>
+#include <DD4hep/Grammar.h>
+#include <Evaluator/Evaluator.h>
// ROOT include files
-#include "TDataType.h"
-#include "TROOT.h"
+#include <TDataType.h>
+#include <TROOT.h>
// C/C++ include files
#include <algorithm>
diff --git a/DDCore/src/GrammarTypes.cpp b/DDCore/src/GrammarTypes.cpp
index e3c20a286994f3c0da10d9bae4a36f38384bb06c..df20d760d746c7afb6e4f9e5e0610012663fb40a 100644
--- a/DDCore/src/GrammarTypes.cpp
+++ b/DDCore/src/GrammarTypes.cpp
@@ -14,9 +14,9 @@
// Framework include files
#include <DD4hep/GrammarParsed.h>
-#include "Math/Point3D.h"
-#include "Math/Vector4D.h"
-#include "Math/Vector3D.h"
+#include <Math/Point3D.h>
+#include <Math/Vector4D.h>
+#include <Math/Vector3D.h>
#ifndef DD4HEP_PARSERS_NO_ROOT
diff --git a/DDCore/src/GrammarTypesUnparsed.cpp b/DDCore/src/GrammarTypesUnparsed.cpp
index ed94cb39bed5e548fe779bd887f234660182c99d..42db6d6388d304b608b8fc3eea764ffff85b378f 100644
--- a/DDCore/src/GrammarTypesUnparsed.cpp
+++ b/DDCore/src/GrammarTypesUnparsed.cpp
@@ -12,7 +12,7 @@
//==========================================================================
// Framework include files
-#include "DD4hep/GrammarUnparsed.h"
+#include <DD4hep/GrammarUnparsed.h>
// C/C++ include files
#include <any>
diff --git a/DDCore/src/Handle.cpp b/DDCore/src/Handle.cpp
index c947af98398687f65bb47a92e01f6919f2287586..2fa5b4b1b2ff2e902cc7821fc5073d3af091c047 100644
--- a/DDCore/src/Handle.cpp
+++ b/DDCore/src/Handle.cpp
@@ -36,7 +36,6 @@ namespace {
}
using namespace dd4hep;
-using namespace dd4hep::detail;
namespace {
diff --git a/DDCore/src/IDDescriptor.cpp b/DDCore/src/IDDescriptor.cpp
index 4c163d1390250224bbcb88a42213ad5d23dbf34c..0b0d494e660304cc6db2c8dde8290f96f0f34cb8 100644
--- a/DDCore/src/IDDescriptor.cpp
+++ b/DDCore/src/IDDescriptor.cpp
@@ -11,21 +11,23 @@
//
//==========================================================================
+// Framework include files
#include "DD4hep/IDDescriptor.h"
#include "DD4hep/detail/Handle.inl"
#include "DD4hep/detail/ObjectsInterna.h"
#include "DD4hep/InstanceCount.h"
#include "DD4hep/Volumes.h"
#include "DD4hep/Printout.h"
+
+// C/C++ include files
#include <stdexcept>
#include <cstdlib>
#include <cmath>
-using namespace std;
+
using namespace dd4hep;
-using namespace dd4hep::detail;
namespace {
- void _construct(IDDescriptor::Object* o, const string& dsc) {
+ void _construct(IDDescriptor::Object* o, const std::string& dsc) {
BitFieldCoder& bf = o->decoder;
o->fieldIDs.clear();
o->fieldMap.clear();
@@ -39,23 +41,23 @@ namespace {
}
/// Initializing constructor
-IDDescriptor::IDDescriptor(const string& nam, const string& description) {
+IDDescriptor::IDDescriptor(const std::string& nam, const std::string& description) {
Object* obj = new Object(description);
assign(obj, nam, "iddescriptor");
_construct(obj, description);
}
/// Re-build object in place
-void IDDescriptor::rebuild(const string& description) {
+void IDDescriptor::rebuild(const std::string& description) {
Object* p = ptr();
- string dsc = description;
+ std::string dsc = description;
p->decoder.~BitFieldCoder();
new(&p->decoder) BitFieldCoder(dsc);
_construct(p, dsc);
}
-/// Acces string representation
-string IDDescriptor::toString() const {
+/// Acces std::string representation
+std::string IDDescriptor::toString() const {
if ( isValid() ) {
return m_element->GetName();
}
@@ -77,7 +79,8 @@ const IDDescriptor::FieldIDs& IDDescriptor::ids() const {
if ( isValid() ) {
return data<Object>()->fieldIDs;
}
- throw runtime_error("dd4hep: Attempt to access an invalid IDDescriptor object.");
+ except("IDDescriptor","dd4hep: Attempt to access an invalid IDDescriptor object.");
+ throw std::runtime_error("dd4hep"); // Never called. Simply make the compiler happy!
}
/// Access the fieldmap container
@@ -85,18 +88,19 @@ const IDDescriptor::FieldMap& IDDescriptor::fields() const {
if ( isValid() ) {
return data<Object>()->fieldMap;
}
- throw runtime_error("dd4hep: Attempt to access an invalid IDDescriptor object.");
+ except("IDDescriptor","dd4hep: Attempt to access an invalid IDDescriptor object.");
+ throw std::runtime_error("dd4hep"); // Never called. Simply make the compiler happy!
}
/// Get the field descriptor of one field by name
-const BitFieldElement* IDDescriptor::field(const string& field_name) const {
+const BitFieldElement* IDDescriptor::field(const std::string& field_name) const {
const FieldMap& fm = fields(); // This already checks the object validity
for (const auto& i : fm )
if (i.first == field_name)
return i.second;
except("IDDescriptor","dd4hep: %s: This ID descriptor has no field with the name: %s",
name(),field_name.c_str());
- throw runtime_error("dd4hep"); // Never called. Simply make the compiler happy!
+ throw std::runtime_error("dd4hep"); // Never called. Simply make the compiler happy!
}
/// Get the field descriptor of one field by its identifier
@@ -106,14 +110,14 @@ const BitFieldElement* IDDescriptor::field(size_t identifier) const {
}
/// Get the field identifier of one field by name
-size_t IDDescriptor::fieldID(const string& field_name) const {
+std::size_t IDDescriptor::fieldID(const std::string& field_name) const {
const FieldIDs& fm = ids(); // This already checks the object validity
for (const auto& i : fm )
if (i.second == field_name)
return i.first;
except("IDDescriptor","dd4hep: %s: This ID descriptor has no field with the name: %s",
name(),field_name.c_str());
- throw runtime_error("dd4hep"); // Never called. Simply make the compiler happy!
+ throw std::runtime_error("dd4hep"); // Never called. Simply make the compiler happy!
}
/// Compute the submask for a given set of volume IDs
@@ -158,34 +162,36 @@ VolumeID IDDescriptor::encode_reverse(const std::vector<std::pair<std::string, i
/// Decode volume IDs and return filled descriptor with all fields
void IDDescriptor::decodeFields(VolumeID vid,
- vector<pair<const BitFieldElement*, VolumeID> >& flds) const
+ std::vector<std::pair<const BitFieldElement*, VolumeID> >& flds) const
{
- const vector<BitFieldElement>& v = access()->decoder.fields();
+ const std::vector<BitFieldElement>& v = access()->decoder.fields();
flds.clear();
for (auto& f : v )
flds.emplace_back(&f, f.value(vid));
}
/// Decode volume IDs and return string reprensentation for debugging purposes
-string IDDescriptor::str(VolumeID vid) const {
- const vector<BitFieldElement>& v = access()->decoder.fields();
- stringstream str;
+std::string IDDescriptor::str(VolumeID vid) const {
+ const std::vector<BitFieldElement>& v = access()->decoder.fields();
+ std::stringstream str;
for (auto& f : v )
- str << f.name() << ":" << setw(4) << setfill('0') << hex << right << f.value(vid)
- << left << dec << " ";
- return str.str().substr(0,str.str().length()-1);
+ str << f.name() << ":" << std::setw(4) << std::setfill('0')
+ << std::hex << std::right << f.value(vid)
+ << std::left << std::dec << " ";
+ return str.str().substr(0, str.str().length()-1);
}
/// Decode volume IDs and return string reprensentation for debugging purposes
-string IDDescriptor::str(VolumeID vid, VolumeID mask) const {
- const vector<BitFieldElement>& v = access()->decoder.fields();
- stringstream str;
+std::string IDDescriptor::str(VolumeID vid, VolumeID mask) const {
+ const std::vector<BitFieldElement>& v = access()->decoder.fields();
+ std::stringstream str;
for (auto& f : v ) {
if ( 0 == (mask&f.mask()) ) continue;
- str << f.name() << ":" << setw(4) << setfill('0') << hex << right << f.value(vid)
- << left << dec << " ";
+ str << f.name() << ":" << std::setw(4) << std::setfill('0')
+ << std::hex << std::right << f.value(vid)
+ << std::left << std::dec << " ";
}
- return str.str().substr(0,str.str().length()-1);
+ return str.str().substr(0, str.str().length()-1);
}
/// Access the BitFieldCoder object
diff --git a/DDCore/src/IOV.cpp b/DDCore/src/IOV.cpp
index 4949639b08b479222d27a2a6281f44f40e9b8d37..88a89e9e04aed756b4d26534efb8e25e8d52afb0 100644
--- a/DDCore/src/IOV.cpp
+++ b/DDCore/src/IOV.cpp
@@ -12,16 +12,15 @@
//==========================================================================
// Framework includes
-#include "DD4hep/IOV.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Primitives.h"
+#include <DD4hep/IOV.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Primitives.h>
// C/C++ include files
#include <climits>
#include <iomanip>
#include <cstring>
-using namespace std;
using namespace dd4hep;
#if __cplusplus == 201402
@@ -139,7 +138,7 @@ void IOV::move(IOV& from) {
}
/// Create string representation of the IOV
-string IOV::str() const {
+std::string IOV::str() const {
char text[256];
if ( iovType ) {
/// Need the long(x) casts for compatibility with Apple MAC
@@ -152,8 +151,8 @@ string IOV::str() const {
char c_since[64], c_until[64];
static constexpr const Key_value_type nil = 0;
static const Key_value_type max_time = detail::makeTime(2099,12,31,24,59,59);
- time_t since = std::min(std::max(keyData.first, nil), max_time);
- time_t until = std::min(std::max(keyData.second,nil), max_time);
+ std::time_t since = std::min(std::max(keyData.first, nil), max_time);
+ std::time_t until = std::min(std::max(keyData.second,nil), max_time);
struct tm* tm_since = ::gmtime_r(&since,&time_buff);
struct tm* tm_until = ::gmtime_r(&until,&time_buff);
if ( nullptr == tm_since || nullptr == tm_until ) {
@@ -164,7 +163,7 @@ string IOV::str() const {
::strftime(c_until,sizeof(c_until),"%d-%m-%Y %H:%M:%S", tm_until);
::snprintf(text,sizeof(text),"%s(%u):[%s - %s]",
iovType->name.c_str(), iovType->type,
- c_since, c_until);
+ c_since, c_until);
}
else {
::snprintf(text,sizeof(text),"%s(%u):[%ld-%ld]",
diff --git a/DDCore/src/InstanceCount.cpp b/DDCore/src/InstanceCount.cpp
index 74a0f93201344c8d4238c8e8a0c3f4ae616302f1..e0d68a955b5f1b8487993ec36f77e54f17cdaa6b 100644
--- a/DDCore/src/InstanceCount.cpp
+++ b/DDCore/src/InstanceCount.cpp
@@ -12,9 +12,9 @@
//==========================================================================
/// Framework include files
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/Handle.h"
-#include "DD4hep/Memory.h"
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/Handle.h>
+#include <DD4hep/Memory.h>
/// C/C++ include files
#include <iostream>
@@ -32,13 +32,13 @@ namespace {
typedef InstanceCount::Counter COUNT;
typedef std::map<const std::type_info*, COUNT*> TypeCounter;
typedef std::map<const std::string*, COUNT*> StringCounter;
- static bool s_trace_instances = ::getenv("DD4HEP_TRACE") != 0;
- static dd4hep_ptr<TypeCounter> s_typCounts(new TypeCounter());
- static dd4hep_ptr<StringCounter> s_strCounts(new StringCounter());
- static InstanceCount::Counter s_nullCount;
- static InstanceCount::Counter s_thisCount;
- static InstanceCount s_counter;
- inline TypeCounter& types() {
+ static bool s_trace_instances = ::getenv("DD4HEP_TRACE") != 0;
+ static dd4hep_ptr<TypeCounter> s_typCounts(new TypeCounter());
+ static dd4hep_ptr<StringCounter> s_strCounts(new StringCounter());
+ static InstanceCount::Counter s_nullCount;
+ static InstanceCount::Counter s_thisCount;
+ static InstanceCount s_counter;
+ inline TypeCounter& types() {
return *(s_typCounts.get());
}
inline StringCounter& strings() {
diff --git a/DDCore/src/MatrixHelpers.cpp b/DDCore/src/MatrixHelpers.cpp
index d7e7ce92865d1b3e364d47e08c157add02a2a47b..6c698bdcde81bc8abb5a620a037264a3bfe9cb6b 100644
--- a/DDCore/src/MatrixHelpers.cpp
+++ b/DDCore/src/MatrixHelpers.cpp
@@ -12,8 +12,8 @@
//==========================================================================
// Framework include files
-#include "DD4hep/MatrixHelpers.h"
-#include "DD4hep/DD4hepUnits.h"
+#include <DD4hep/MatrixHelpers.h>
+#include <DD4hep/DD4hepUnits.h>
#ifdef DD4HEP_USE_GEANT4_UNITS
#define MM_2_CM 1.0
@@ -22,7 +22,7 @@
#endif
// ROOT includes
-#include "TGeoMatrix.h"
+#include <TGeoMatrix.h>
TGeoIdentity* dd4hep::detail::matrix::_identity() {
return gGeoIdentity;
diff --git a/DDCore/src/MultiSegmentation.cpp b/DDCore/src/MultiSegmentation.cpp
index 7cc357cdce91f83fa36be5fc4ffa239dae1bac10..e06dc799d9f9da224a7a85c8aec8551983a933c7 100644
--- a/DDCore/src/MultiSegmentation.cpp
+++ b/DDCore/src/MultiSegmentation.cpp
@@ -12,12 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/MultiSegmentation.h"
-#include "DDSegmentation/MultiSegmentation.h"
+#include <DD4hep/MultiSegmentation.h>
+#include <DDSegmentation/MultiSegmentation.h>
-// C/C++ include files
-
-using namespace std;
using namespace dd4hep;
/// access the field name used to discriminate sub-segmentations
@@ -43,8 +40,8 @@ Position MultiSegmentation::position(const CellID& id) const {
/// determine the cell ID based on the position
dd4hep::CellID MultiSegmentation::cellID(const Position& local,
- const Position& global,
- const VolumeID& volID) const
+ const Position& global,
+ const VolumeID& volID) const
{
return access()->implementation->cellID(local, global, volID);
}
@@ -58,6 +55,6 @@ dd4hep::CellID MultiSegmentation::cellID(const Position& local,
-# size in x
-# size in y
*/
-vector<double> MultiSegmentation::cellDimensions(const CellID& id) const {
+std::vector<double> MultiSegmentation::cellDimensions(const CellID& id) const {
return access()->implementation->cellDimensions(id);
}
diff --git a/DDCore/src/NamedObject.cpp b/DDCore/src/NamedObject.cpp
index 80d53634eb0a399dcccd8d5dd598fd6e3c8bd5e5..7d60da0af136311d5e308d2dcad83db1666fbba6 100644
--- a/DDCore/src/NamedObject.cpp
+++ b/DDCore/src/NamedObject.cpp
@@ -12,26 +12,23 @@
//==========================================================================
// Framework includes
-#include "DD4hep/NamedObject.h"
-#include "DD4hep/detail/Handle.inl"
-#include "TNamed.h"
-
-using namespace std;
-using namespace dd4hep;
-using namespace dd4hep::detail;
+#include <DD4hep/NamedObject.h>
+#include <DD4hep/detail/Handle.inl>
+#include <TNamed.h>
namespace dd4hep {
template <> const char* Handle<NamedObject>::name() const {
return this->m_element ? this->m_element->name.c_str() : "";
}
template <> void
- Handle<NamedObject>::assign(NamedObject* p, const string& n, const string& t){
+ Handle<NamedObject>::assign(NamedObject* p, const std::string& n, const std::string& t){
m_element = p;
p->name = n;
p->type = t;
}
}
-template class dd4hep::Handle<NamedObject>;
+template class dd4hep::Handle<dd4hep::NamedObject>;
+using namespace dd4hep;
/// Initializing constructor
NamedObject::NamedObject(const char* nam, const char* typ)
diff --git a/DDCore/src/NoSegmentation.cpp b/DDCore/src/NoSegmentation.cpp
index 7b226f90f54b6210029d82853bc051402cb59ca4..cc2ce343009812f85391b2e20cc2d63750c646cf 100644
--- a/DDCore/src/NoSegmentation.cpp
+++ b/DDCore/src/NoSegmentation.cpp
@@ -12,12 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/NoSegmentation.h"
-#include "DDSegmentation/NoSegmentation.h"
+#include <DD4hep/NoSegmentation.h>
+#include <DDSegmentation/NoSegmentation.h>
-// C/C++ include files
-
-using namespace std;
using namespace dd4hep;
Position NoSegmentation::position(const CellID& id) const {
@@ -26,8 +23,8 @@ Position NoSegmentation::position(const CellID& id) const {
/// determine the cell ID based on the position
dd4hep::CellID NoSegmentation::cellID(const Position& local,
- const Position& global,
- const VolumeID& volID) const
+ const Position& global,
+ const VolumeID& volID) const
{
return access()->implementation->cellID(local, global, volID);
}
diff --git a/DDCore/src/ObjectExtensions.cpp b/DDCore/src/ObjectExtensions.cpp
index 3a5969bf1695f439ce2d46d0a4b2d6ab32c7917b..9979aca9198ff361c2fa081dbd72a84d7a048088 100644
--- a/DDCore/src/ObjectExtensions.cpp
+++ b/DDCore/src/ObjectExtensions.cpp
@@ -17,10 +17,6 @@
#include "DD4hep/Primitives.h"
#include "DD4hep/Printout.h"
-// C/C++ include files
-#include <stdexcept>
-
-using namespace std;
using namespace dd4hep;
namespace {
@@ -31,7 +27,7 @@ namespace {
}
/// Default constructor
-ObjectExtensions::ObjectExtensions(const type_info& /* parent_type */) {
+ObjectExtensions::ObjectExtensions(const std::type_info& /* parent_type */) {
InstanceCount::increment(this);
}
@@ -59,7 +55,7 @@ void ObjectExtensions::clear(bool destroy) {
}
/// Copy object extensions from another object
-void ObjectExtensions::copyFrom(const map<unsigned long long int,ExtensionEntry*>& ext, void* arg) {
+void ObjectExtensions::copyFrom(const std::map<unsigned long long int,ExtensionEntry*>& ext, void* arg) {
for( const auto& i : ext ) {
extensions[i.first] = i.second->clone(arg);
}
@@ -79,7 +75,7 @@ void* ObjectExtensions::addExtension(unsigned long long int key, ExtensionEntry*
except("ObjectExtensions::addExtension","Invalid extension object for key %016llX!",key);
}
except("ObjectExtensions::addExtension","Invalid extension entry for key %016llX!",key);
- return 0;
+ return nullptr;
}
/// Remove an existing extension object from the instance
@@ -95,7 +91,7 @@ void* ObjectExtensions::removeExtension(unsigned long long int key, bool destroy
return ptr;
}
except("ObjectExtensions::removeExtension","The object of type %016llX is not present.",key);
- return 0;
+ return nullptr;
}
/// Access an existing extension object from the detector element
@@ -104,8 +100,8 @@ void* ObjectExtensions::extension(unsigned long long int key) const {
if (j != extensions.end()) {
return (*j).second->object();
}
- string msg = format("ObjectExtensions::extension","The object has no extension of type %016llX.",key);
- throw runtime_error(msg);
+ except("ObjectExtensions::extension","The object has no extension of type %016llX.",key);
+ return nullptr;
}
/// Access an existing extension object from the detector element
@@ -116,6 +112,6 @@ void* ObjectExtensions::extension(unsigned long long int key, bool alert) const
}
else if ( !alert )
return 0;
- string msg = format("ObjectExtensions::extension","The object has no extension of type %016llX.",key);
- throw runtime_error(msg);
+ except("ObjectExtensions::extension","The object has no extension of type %016llX.",key);
+ return nullptr;
}
diff --git a/DDCore/src/ObjectsInterna.cpp b/DDCore/src/ObjectsInterna.cpp
index 76e788bf2b961f3f2521e71d2900cd4c95852cfa..04008b158c3e17ba7b9c7ace1738fffc833f304d 100644
--- a/DDCore/src/ObjectsInterna.cpp
+++ b/DDCore/src/ObjectsInterna.cpp
@@ -18,9 +18,8 @@
#include <DD4hep/detail/SegmentationsInterna.h>
#include <TROOT.h>
-using namespace std;
+
using namespace dd4hep;
-using namespace dd4hep::detail;
DD4HEP_INSTANTIATE_HANDLE_NAMED(VisAttrObject);
@@ -55,7 +54,7 @@ ConstantObject::ConstantObject() {
}
/// Standard constructor
-ConstantObject::ConstantObject(const string& nam, const string& val, const string& typ)
+ConstantObject::ConstantObject(const std::string& nam, const std::string& val, const std::string& typ)
: NamedObject(nam.c_str(), val.c_str()) {
dataType = typ;
InstanceCount::increment(this);
diff --git a/DDCore/src/OpaqueData.cpp b/DDCore/src/OpaqueData.cpp
index 36fa8189e3756960e129b3e9fed8fda284024aad..26a27a810c8adbf851b05d9e612b2fd31794c588 100644
--- a/DDCore/src/OpaqueData.cpp
+++ b/DDCore/src/OpaqueData.cpp
@@ -12,47 +12,46 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Printout.h"
-#include "DD4hep/Primitives.h"
-#include "DD4hep/OpaqueData.h"
-#include "DD4hep/InstanceCount.h"
+#include <DD4hep/Printout.h>
+#include <DD4hep/Primitives.h>
+#include <DD4hep/OpaqueData.h>
+#include <DD4hep/InstanceCount.h>
// C/C++ header files
#include <cstring>
-using namespace std;
using namespace dd4hep;
/// Create data block from string representation
-bool OpaqueData::fromString(const string& rep) {
+bool OpaqueData::fromString(const std::string& rep) {
if ( pointer && grammar ) {
return grammar->fromString(pointer,rep);
}
- throw runtime_error("Opaque data block is unbound. Cannot parse string representation.");
+ throw std::runtime_error("Opaque data block is unbound. Cannot parse string representation.");
}
/// Create string representation of the data block
-string OpaqueData::str() const {
+std::string OpaqueData::str() const {
if ( pointer && grammar ) {
return grammar->str(pointer);
}
- throw runtime_error("Opaque data block is unbound. Cannot create string representation.");
+ throw std::runtime_error("Opaque data block is unbound. Cannot create string representation.");
}
/// Access type id of the condition
-const type_info& OpaqueData::typeInfo() const {
+const std::type_info& OpaqueData::typeInfo() const {
if ( pointer && grammar ) {
return grammar->type();
}
- throw runtime_error("Opaque data block is unbound. Cannot determine type information!");
+ throw std::runtime_error("Opaque data block is unbound. Cannot determine type information!");
}
/// Access type name of the condition data block
-const string& OpaqueData::dataType() const {
+const std::string& OpaqueData::dataType() const {
if ( pointer && grammar ) {
return grammar->type_name();
}
- throw runtime_error("Opaque data block is unbound. Cannot determine type information!");
+ throw std::runtime_error("Opaque data block is unbound. Cannot determine type information!");
}
/// Standard initializing constructor
@@ -71,7 +70,7 @@ OpaqueDataBlock::OpaqueDataBlock(const OpaqueDataBlock& c)
}
else {
except("OpaqueDataBlock","Grammar type %s does not support object copy. Operation not allowed.",
- this->grammar->type_name().c_str());
+ this->grammar->type_name().c_str());
}
InstanceCount::increment(this);
}
@@ -103,10 +102,10 @@ OpaqueDataBlock& OpaqueDataBlock::operator=(const OpaqueDataBlock& c) {
type = c.type;
grammar = 0;
if ( c.grammar ) {
- if ( !c.grammar->specialization.copy ) {
- except("OpaqueDataBlock","Grammar type %s does not support object copy. Operation not allowed.",
- c.grammar->type_name().c_str());
- }
+ if ( !c.grammar->specialization.copy ) {
+ except("OpaqueDataBlock","Grammar type %s does not support object copy. Operation not allowed.",
+ c.grammar->type_name().c_str());
+ }
bind(c.grammar);
grammar->specialization.copy(pointer,c.pointer);
return *this;
@@ -180,5 +179,5 @@ void* OpaqueDataBlock::bind(void* ptr, size_t size, const BasicGrammar* g) {
return 0;
}
-#include "DD4hep/GrammarUnparsed.h"
+#include <DD4hep/GrammarUnparsed.h>
static auto s_registry = GrammarRegistry::pre_note<OpaqueDataBlock>(1);
diff --git a/DDCore/src/OpaqueDataBinder.cpp b/DDCore/src/OpaqueDataBinder.cpp
index 4f22152fb984f45f71061791159b33070571f616..f9d2a2a6e8583c24c993a1bc3a189ad544784735 100644
--- a/DDCore/src/OpaqueDataBinder.cpp
+++ b/DDCore/src/OpaqueDataBinder.cpp
@@ -12,9 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/OpaqueDataBinder.h"
-#include "DD4hep/Conditions.h"
-#include "DD4hep/detail/ConditionsInterna.h"
+#include <DD4hep/OpaqueDataBinder.h>
+#include <DD4hep/Conditions.h>
+#include <DD4hep/detail/ConditionsInterna.h>
// C/C++ include files
#include <set>
@@ -22,30 +22,27 @@
#include <list>
#include <vector>
-using namespace std;
-
namespace {
- using namespace dd4hep::detail;
-
+
/// Helper class to bind string values to C++ data objects (primitive or complex)
- template <typename T, typename Q> bool __bind__(const ValueBinder&, T& object, const string& val, const Q*)
- { object.template bind<Q>(val); return true; }
+ template <typename T, typename Q> bool __bind__(const dd4hep::detail::ValueBinder&, T& object, const std::string& val, const Q*)
+ { object.template bind<Q>(val); return true; }
/// Helper class to bind string values to a STL vector of data objects (primitive or complex)
- template <typename T, typename Q> bool __bind__(const VectorBinder&, T& object, const string& val, const Q*)
- { object.template bind<vector<Q> >(val); return true; }
+ template <typename T, typename Q> bool __bind__(const dd4hep::detail::VectorBinder&, T& object, const std::string& val, const Q*)
+ { object.template bind<std::vector<Q> >(val); return true; }
/// Helper class to bind string values to a STL list of data objects (primitive or complex)
- template <typename T, typename Q> bool __bind__(const ListBinder&, T& object, const string& val, const Q*)
- { object.template bind<list<Q> >(val); return true; }
+ template <typename T, typename Q> bool __bind__(const dd4hep::detail::ListBinder&, T& object, const std::string& val, const Q*)
+ { object.template bind<std::list<Q> >(val); return true; }
/// Helper class to bind string values to a STL set of data objects (primitive or complex)
- template <typename T, typename Q> bool __bind__(const SetBinder&, T& object, const string& val, const Q*)
- { object.template bind<set<Q> >(val); return true; }
+ template <typename T, typename Q> bool __bind__(const dd4hep::detail::SetBinder&, T& object, const std::string& val, const Q*)
+ { object.template bind<std::set<Q> >(val); return true; }
/// Helper class to bind STL map objects
- template <typename T, typename Q> bool __bind__(const MapBinder&, T& object, const Q*)
- { object.template bind<Q>(); return true; }
+ template <typename T, typename Q> bool __bind__(const dd4hep::detail::MapBinder&, T& object, const Q*)
+ { object.template bind<Q>(); return true; }
}
@@ -57,7 +54,7 @@ namespace dd4hep {
/// Binding function for scalar items. See the implementation function for the concrete instantiations
template <typename BINDER, typename T>
- bool OpaqueDataBinder::bind(const BINDER& b, T& object, const string& typ, const string& val) {
+ bool OpaqueDataBinder::bind(const BINDER& b, T& object, const std::string& typ, const std::string& val) {
#if defined(DD4HEP_HAVE_ALL_PARSERS)
if ( typ.substr(0,4) == "char" )
return __bind__(b,object,val,Primitive<char>::null_pointer());
@@ -87,49 +84,49 @@ namespace dd4hep {
else if ( typ.substr(0,6) == "double" )
return __bind__(b,object,val,Primitive<double>::null_pointer());
else if ( typ.substr(0,6) == "string" )
- return __bind__(b,object,val,Primitive<string>::null_pointer());
+ return __bind__(b,object,val,Primitive<std::string>::null_pointer());
else if ( typ == "std::string" )
- return __bind__(b,object,val,Primitive<string>::null_pointer());
+ return __bind__(b,object,val,Primitive<std::string>::null_pointer());
else if ( typ == "Histo1D" )
- return __bind__(b,object,val,Primitive<string>::null_pointer());
+ return __bind__(b,object,val,Primitive<std::string>::null_pointer());
else if ( typ == "Histo2D" )
- return __bind__(b,object,val,Primitive<string>::null_pointer());
+ return __bind__(b,object,val,Primitive<std::string>::null_pointer());
else
printout(INFO,"OpaqueDataBinder","++ Unknown conditions parameter type:%s val:%s",typ.c_str(),val.c_str());
- return __bind__(b,object,val,Primitive<string>::null_pointer());
+ return __bind__(b,object,val,Primitive<std::string>::null_pointer());
}
template bool OpaqueDataBinder::bind<ValueBinder,OpaqueDataBlock>( const ValueBinder& b, OpaqueDataBlock& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<VectorBinder,OpaqueDataBlock>( const VectorBinder& b, OpaqueDataBlock& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<ListBinder,OpaqueDataBlock>( const ListBinder& b, OpaqueDataBlock& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<SetBinder,OpaqueDataBlock>( const SetBinder& b, OpaqueDataBlock& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<ValueBinder,Condition>( const ValueBinder& b, Condition& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<VectorBinder,Condition>( const VectorBinder& b, Condition& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<ListBinder,Condition>( const ListBinder& b, Condition& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
template bool OpaqueDataBinder::bind<SetBinder,Condition>( const SetBinder& b, Condition& object,
- const string& typ, const string& val);
+ const std::string& typ, const std::string& val);
/// Binding function for sequences (unmapped STL containers)
template <typename T>
- bool OpaqueDataBinder::bind_sequence(T& object, const string& typ, const string& val)
+ bool OpaqueDataBinder::bind_sequence(T& object, const std::string& typ, const std::string& val)
{
- size_t idx = typ.find('[');
- size_t idq = typ.find(']');
- string value_type = typ.substr(idx+1,idq-idx-1);
+ std::size_t idx = typ.find('[');
+ std::size_t idq = typ.find(']');
+ std::string value_type = typ.substr(idx+1,idq-idx-1);
if ( typ.substr(0,6) == "vector" )
return bind(VectorBinder(), object, value_type, val);
else if ( typ.substr(0,4) == "list" )
return bind(ListBinder(), object, value_type, val);
else if ( typ.substr(0,3) == "set" )
return bind(SetBinder(), object, value_type, val);
- else if ( idx == string::npos && idq == string::npos )
+ else if ( idx == std::string::npos && idq == std::string::npos )
return bind(ValueBinder(), object, value_type, val);
return false;
}
@@ -138,10 +135,10 @@ namespace dd4hep {
static void emplace_map_item(const BINDER&,
OBJECT& object,
const KEY& k,
- const string& val,
+ const std::string& val,
const VAL*)
{
- typedef map<KEY,VAL> map_t;
+ typedef std::map<KEY,VAL> map_t;
map_t& m = object.template get<map_t>();
VAL v;
if ( !BasicGrammar::instance<VAL>().fromString(&v, val) ) {
@@ -153,9 +150,9 @@ namespace dd4hep {
template<typename BINDER, typename OBJECT, typename KEY>
static void emplace_map_key(const BINDER& b,
OBJECT& object,
- const string& key_val,
- const string& val_type,
- const string& val,
+ const std::string& key_val,
+ const std::string& val_type,
+ const std::string& val,
const KEY*)
{
KEY key;
@@ -174,27 +171,27 @@ namespace dd4hep {
else if ( val_type.substr(0,6) == "double" )
emplace_map_item(b, object, key, val, (double*)0);
else if ( val_type.substr(0,6) == "string" )
- emplace_map_item(b, object, key, val, (string*)0);
+ emplace_map_item(b, object, key, val, (std::string*)0);
else if ( val_type == "std::string" )
- emplace_map_item(b, object, key, val, (string*)0);
+ emplace_map_item(b, object, key, val, (std::string*)0);
else {
printout(INFO,"Param","++ Unknown conditions parameter type:%s data:%s",
val_type.c_str(),val.c_str());
- emplace_map_item(b, object, key, val, (string*)0);
+ emplace_map_item(b, object, key, val, (std::string*)0);
}
}
template<typename BINDER, typename OBJECT, typename KEY, typename VAL>
static void emplace_map_pair(const BINDER&,
OBJECT& object,
- const string& data,
+ const std::string& data,
const KEY*,
const VAL*)
{
- typedef map<KEY,VAL> map_t;
- pair<KEY,VAL> entry;
+ typedef std::map<KEY,VAL> map_t;
+ std::pair<KEY,VAL> entry;
map_t& m = object.template get<map_t>();
- if ( !BasicGrammar::instance<pair<KEY,VAL> >().fromString(&entry,data) ) {
+ if ( !BasicGrammar::instance<std::pair<KEY,VAL> >().fromString(&entry,data) ) {
except("OpaqueDataBinder","++ Failed to convert conditions map entry.");
}
m.emplace(entry);
@@ -203,8 +200,8 @@ namespace dd4hep {
template<typename BINDER, typename OBJECT, typename KEY>
static void emplace_map_data(const BINDER& b,
OBJECT& object,
- const string& val_type,
- const string& pair_data,
+ const std::string& val_type,
+ const std::string& pair_data,
const KEY*)
{
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
@@ -221,59 +218,59 @@ namespace dd4hep {
else if ( val_type.substr(0,6) == "double" )
emplace_map_pair(b, object, pair_data, (KEY*)0, (double*)0);
else if ( val_type.substr(0,6) == "string" )
- emplace_map_pair(b, object, pair_data, (KEY*)0, (string*)0);
+ emplace_map_pair(b, object, pair_data, (KEY*)0, (std::string*)0);
else if ( val_type == "std::string" )
- emplace_map_pair(b, object, pair_data, (KEY*)0, (string*)0);
+ emplace_map_pair(b, object, pair_data, (KEY*)0, (std::string*)0);
else {
printout(INFO,"Param","++ Unknown conditions parameter type:%s data:%s",
val_type.c_str(),pair_data.c_str());
- emplace_map_pair(b, object, pair_data, (KEY*)0, (string*)0);
+ emplace_map_pair(b, object, pair_data, (KEY*)0, (std::string*)0);
}
}
template<typename BINDER, typename OBJECT, typename KEY>
- static void bind_mapping(const BINDER& b, const string& val_type, OBJECT& object, const KEY*) {
+ static void bind_mapping(const BINDER& b, const std::string& val_type, OBJECT& object, const KEY*) {
if ( val_type.substr(0,3) == "int" )
- __bind__(b,object, (map<KEY,int>*)0);
+ __bind__(b,object, (std::map<KEY,int>*)0);
#if defined(DD4HEP_HAVE_ALL_PARSERS)
else if ( val_type.substr(0,12) == "unsigned int" )
- __bind__(b,object, (map<KEY,unsigned int>*)0);
+ __bind__(b,object, (std::map<KEY,unsigned int>*)0);
else if ( val_type.substr(0,4) == "char" )
- __bind__(b,object, (map<KEY,char>*)0);
+ __bind__(b,object, (std::map<KEY,char>*)0);
else if ( val_type.substr(0,13) == "unsigned char" )
- __bind__(b,object, (map<KEY,unsigned char>*)0);
+ __bind__(b,object, (std::map<KEY,unsigned char>*)0);
else if ( val_type.substr(0,5) == "short" )
- __bind__(b,object, (map<KEY,short>*)0);
+ __bind__(b,object, (std::map<KEY,short>*)0);
else if ( val_type.substr(0,14) == "unsigned short" )
- __bind__(b,object, (map<KEY,unsigned short>*)0);
+ __bind__(b,object, (std::map<KEY,unsigned short>*)0);
else if ( val_type.substr(0,13) == "unsigned long" )
- __bind__(b,object, (map<KEY,unsigned long>*)0);
+ __bind__(b,object, (std::map<KEY,unsigned long>*)0);
#else
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
else if ( val_type.substr(0,4) == "char" )
- __bind__(b,object, (map<KEY,int>*)0);
+ __bind__(b,object, (std::map<KEY,int>*)0);
else if ( val_type.substr(0,5) == "short" )
- __bind__(b,object, (map<KEY,int>*)0);
+ __bind__(b,object, (std::map<KEY,int>*)0);
#endif
else if ( val_type.substr(0,4) == "long" )
- __bind__(b,object, (map<KEY,long>*)0);
+ __bind__(b,object, (std::map<KEY,long>*)0);
else if ( val_type.substr(0,5) == "float" )
- __bind__(b,object, (map<KEY,float>*)0);
+ __bind__(b,object, (std::map<KEY,float>*)0);
else if ( val_type.substr(0,6) == "double" )
- __bind__(b,object, (map<KEY,double>*)0);
+ __bind__(b,object, (std::map<KEY,double>*)0);
else if ( val_type.substr(0,6) == "string" )
- __bind__(b,object, (map<KEY,string>*)0);
+ __bind__(b,object, (std::map<KEY,std::string>*)0);
else if ( val_type == "std::string" )
- __bind__(b,object, (map<KEY,string>*)0);
+ __bind__(b,object, (std::map<KEY,std::string>*)0);
else {
- __bind__(b,object, (map<KEY,string>*)0);
+ __bind__(b,object, (std::map<KEY,std::string>*)0);
}
}
/// Binding function for STL maps
template <typename BINDER, typename OBJECT>
bool OpaqueDataBinder::bind_map(const BINDER& b, OBJECT& object,
- const string& key_type, const string& val_type) {
+ const std::string& key_type, const std::string& val_type) {
// Short and char is not part of the standard dictionaries. Fall back to 'int'.
if ( key_type.substr(0,3) == "int" )
bind_mapping(b, val_type, object, Primitive<int>::null_pointer());
@@ -290,12 +287,12 @@ namespace dd4hep {
bind_mapping(b, val_type, object, Primitive<double>::null_pointer());
#endif
else if ( key_type.substr(0,6) == "string" )
- bind_mapping(b, val_type, object, Primitive<string>::null_pointer());
+ bind_mapping(b, val_type, object, Primitive<std::string>::null_pointer());
else if ( key_type == "std::string" )
- bind_mapping(b, val_type, object, Primitive<string>::null_pointer());
+ bind_mapping(b, val_type, object, Primitive<std::string>::null_pointer());
else {
printout(INFO,"OpaqueDataBinder","++ Unknown MAP-conditions key-type:%s",key_type.c_str());
- bind_mapping(b, val_type, object, Primitive<string>::null_pointer());
+ bind_mapping(b, val_type, object, Primitive<std::string>::null_pointer());
}
return true;
}
@@ -303,8 +300,8 @@ namespace dd4hep {
/// Filling function for STL maps.
template <typename BINDER, typename OBJECT>
bool OpaqueDataBinder::insert_map(const BINDER& b, OBJECT& object,
- const string& key_type, const string& key,
- const string& val_type, const string& val)
+ const std::string& key_type, const std::string& key,
+ const std::string& val_type, const std::string& val)
{
if ( key_type.substr(0,3) == "int" )
emplace_map_key(b, object, key, val_type, val, Primitive<int>::null_pointer());
@@ -322,12 +319,12 @@ namespace dd4hep {
emplace_map_key(b, object, key, val_type, val, Primitive<double>::null_pointer());
#endif
else if ( key_type.substr(0,6) == "string" )
- emplace_map_key(b, object, key, val_type, val, Primitive<string>::null_pointer());
+ emplace_map_key(b, object, key, val_type, val, Primitive<std::string>::null_pointer());
else if ( key_type == "std::string" )
- emplace_map_key(b, object, key, val_type, val, Primitive<string>::null_pointer());
+ emplace_map_key(b, object, key, val_type, val, Primitive<std::string>::null_pointer());
else {
printout(INFO,"OpaqueDataBinder","++ Unknown MAP-conditions key-type:%s",key_type.c_str());
- emplace_map_key(b, object, key, val_type, val, Primitive<string>::null_pointer());
+ emplace_map_key(b, object, key, val_type, val, Primitive<std::string>::null_pointer());
}
return true;
}
@@ -354,43 +351,43 @@ namespace dd4hep {
emplace_map_data(b, object, val_type, pair_data, Primitive<double>::null_pointer());
#endif
else if ( key_type.substr(0,6) == "string" )
- emplace_map_data(b, object, val_type, pair_data, Primitive<string>::null_pointer());
+ emplace_map_data(b, object, val_type, pair_data, Primitive<std::string>::null_pointer());
else if ( key_type == "std::string" )
- emplace_map_data(b, object, val_type, pair_data, Primitive<string>::null_pointer());
+ emplace_map_data(b, object, val_type, pair_data, Primitive<std::string>::null_pointer());
else {
printout(INFO,"OpaqueDataBinder","++ Unknown MAP-conditions key-type:%s",key_type.c_str());
- emplace_map_data(b, object, val_type, pair_data, Primitive<string>::null_pointer());
+ emplace_map_data(b, object, val_type, pair_data, Primitive<std::string>::null_pointer());
}
return true;
}
- template bool OpaqueDataBinder::bind_sequence<OpaqueDataBlock>(OpaqueDataBlock& object,const string& typ,const string& val);
+ template bool OpaqueDataBinder::bind_sequence<OpaqueDataBlock>(OpaqueDataBlock& object,const std::string& typ,const std::string& val);
template bool OpaqueDataBinder::bind_map<MapBinder,OpaqueDataBlock>( const MapBinder& b, OpaqueDataBlock& object,
- const string& typ,const string& val);
+ const std::string& typ,const std::string& val);
template bool OpaqueDataBinder::insert_map<MapBinder,OpaqueDataBlock>( const MapBinder& b, OpaqueDataBlock& object,
- const string& key_type, const string& key,
- const string& val_type, const string& val);
+ const std::string& key_type, const std::string& key,
+ const std::string& val_type, const std::string& val);
template bool OpaqueDataBinder::insert_map<MapBinder,OpaqueDataBlock>( const MapBinder& b, OpaqueDataBlock& object,
- const string& key_type, const string& val_type,
- const string& pair_data);
+ const std::string& key_type, const std::string& val_type,
+ const std::string& pair_data);
/// Instantiation for Conditions:
template bool OpaqueDataBinder::bind_sequence<Condition>( Condition& object,
- const string& typ,const string& val);
+ const std::string& typ,const std::string& val);
/// Conditions binding function for STL maps
template <> bool OpaqueDataBinder::bind_map(const MapBinder& b, Condition& object,
- const string& key_type, const string& val_type)
+ const std::string& key_type, const std::string& val_type)
{ return bind_map(b, object->data, key_type, val_type); }
/// Conditions: Filling function for STL maps.
template <> bool OpaqueDataBinder::insert_map(const MapBinder& b, Condition& object,
- const string& key_type, const string& key,
- const string& val_type, const string& val)
+ const std::string& key_type, const std::string& key,
+ const std::string& val_type, const std::string& val)
{ return insert_map(b, object->data, key_type, key, val_type, val); }
/// Conditions: Filling function for STL maps.
template <> bool OpaqueDataBinder::insert_map(const MapBinder& b, Condition& object,
- const string& key_type, const string& val_type, const string& pair_data)
+ const std::string& key_type, const std::string& val_type, const std::string& pair_data)
{ return insert_map(b, object->data, key_type, val_type, pair_data); }
}
}
diff --git a/DDCore/src/OpticalSurfaceManagerInterna.cpp b/DDCore/src/OpticalSurfaceManagerInterna.cpp
index 2da6cb6dc4a12341384a7c93191738e711ba66e9..4dc0697a80141a7a0311672466a52029590f7ee4 100644
--- a/DDCore/src/OpticalSurfaceManagerInterna.cpp
+++ b/DDCore/src/OpticalSurfaceManagerInterna.cpp
@@ -12,14 +12,13 @@
//==========================================================================
// Framework include files
-#include "DD4hep/detail/OpticalSurfaceManagerInterna.h"
-#include "DD4hep/detail/Handle.inl"
+#include <DD4hep/detail/OpticalSurfaceManagerInterna.h>
+#include <DD4hep/detail/Handle.inl>
// C/C++ includes
#include <sstream>
#include <iomanip>
-using namespace std;
using namespace dd4hep;
using detail::OpticalSurfaceManagerObject;
diff --git a/DDCore/src/PluginTester.cpp b/DDCore/src/PluginTester.cpp
index f3df7da4512621b2626f6fcec88043e037f68723..3d90357bdae50047de18eb5b94c1a0756862eb17 100644
--- a/DDCore/src/PluginTester.cpp
+++ b/DDCore/src/PluginTester.cpp
@@ -12,9 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/PluginTester.h"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/Primitives.h"
+#include <DD4hep/PluginTester.h>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/Primitives.h>
// C/C++ include files
#include <stdexcept>
@@ -22,7 +22,9 @@
using namespace dd4hep;
namespace {
+
static int s_extensionID = 0;
+
PluginTester::ExtensionMap* extensionContainer(const std::type_info& typ) {
static std::map<const std::type_info*, PluginTester::ExtensionMap> s_map;
PluginTester::ExtensionMap& m = s_map[&typ];
diff --git a/DDCore/src/Plugins.cpp b/DDCore/src/Plugins.cpp
index 1e53d00e793813a1b4fbd3da2f31ba4f75c9fb30..30de1a2c0ec3f9824097032ab2dbdd2a2f700f4c 100644
--- a/DDCore/src/Plugins.cpp
+++ b/DDCore/src/Plugins.cpp
@@ -12,10 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Plugins.h"
+#include <DD4hep/Plugins.h>
#include <cstdlib>
-using namespace std;
using namespace dd4hep;
namespace {
@@ -85,10 +84,10 @@ namespace {
if ( !fp.fptr.ptr ) fp.fptr.ptr = ::dlsym(0, entry);
#endif
if ( 0 == fp.fptr.ptr ) {
- string err = "dd4hep:PluginService: Failed to access symbol "
- "\""+string(entry)+"\" in plugin library "+string(plugin)+
- " ["+string(::strerror(errno))+"]";
- throw runtime_error(err);
+ std::string err = "dd4hep:PluginService: Failed to access symbol "
+ "\""+std::string(entry)+"\" in plugin library "+std::string(plugin)+
+ " ["+std::string(::strerror(errno))+"]";
+ throw std::runtime_error(err);
}
return fp.fptr.fcn;
}
@@ -118,7 +117,7 @@ namespace {
_guard._handle = handle = ::dlopen(plugin_name, RTLD_LAZY | RTLD_GLOBAL);
}
if ( !handle ) {
- throw runtime_error("Failed to load plugin manager library: "+string(plugin_name));
+ throw std::runtime_error("Failed to load plugin manager library: "+std::string(plugin_name));
}
#else
if ( 0 != gSystem->Load(plugin_name) ) {}
@@ -145,9 +144,9 @@ PluginDebug::~PluginDebug() noexcept(false) {
}
/// Helper to check factory existence
-string PluginDebug::missingFactory(const string& name) const {
- string factoryname = "Create("+name+")";
- string msg = "\t\tNo factory with name " + factoryname + " for type " + name + " found.\n"
+std::string PluginDebug::missingFactory(const std::string& name) const {
+ std::string factoryname = "Create("+name+")";
+ std::string msg = "\t\tNo factory with name " + factoryname + " for type " + name + " found.\n"
"\t\tPlease check library load path and/or plugin factory name.";
return msg;
}
@@ -174,7 +173,7 @@ void PluginService::print_bad_cast(const std::string& id,
const char* msg) {
bool dbg = PluginInterface::instance().getDebug();
if ( dbg ) {
- stringstream str;
+ std::stringstream str;
str << "Factory requested: " << id << " (" << typeid(signature).name() << ") :" << msg;
printout(ERROR,"PluginService","%s", str.str().c_str());
str.str("");
diff --git a/DDCore/src/PolarGridRPhi.cpp b/DDCore/src/PolarGridRPhi.cpp
index 0bddb1fb2cebfa1c25a149e13d552a323b581926..16c6ffae76834f6315295c89dbf613720461a88b 100644
--- a/DDCore/src/PolarGridRPhi.cpp
+++ b/DDCore/src/PolarGridRPhi.cpp
@@ -12,12 +12,11 @@
//==========================================================================
// Framework include files
-#include "DD4hep/PolarGridRPhi.h"
-#include "DDSegmentation/PolarGridRPhi.h"
+#include <DD4hep/PolarGridRPhi.h>
+#include <DDSegmentation/PolarGridRPhi.h>
// C/C++ include files
-using namespace std;
using namespace dd4hep;
/// determine the position based on the cell ID
@@ -74,12 +73,12 @@ void PolarGridRPhi::setGridSizePhi(double cellSize) const {
}
/// access the field name used for R
-const string& PolarGridRPhi::fieldNameR() const {
+const std::string& PolarGridRPhi::fieldNameR() const {
return access()->implementation->fieldNameR();
}
/// access the field name used for Phi
-const string& PolarGridRPhi::fieldNamePhi() const {
+const std::string& PolarGridRPhi::fieldNamePhi() const {
return access()->implementation->fieldNamePhi();
}
@@ -92,6 +91,6 @@ const string& PolarGridRPhi::fieldNamePhi() const {
-# size in x
-# size in z
*/
-vector<double> PolarGridRPhi::cellDimensions(const CellID& id) const {
+std::vector<double> PolarGridRPhi::cellDimensions(const CellID& id) const {
return access()->implementation->cellDimensions(id);
}
diff --git a/DDCore/src/PolarGridRPhi2.cpp b/DDCore/src/PolarGridRPhi2.cpp
index b2976fabaecf0658431092f249eae2d23ec14ef2..4846800261ca997fe1723c191efadc4c8ef4288b 100644
--- a/DDCore/src/PolarGridRPhi2.cpp
+++ b/DDCore/src/PolarGridRPhi2.cpp
@@ -12,12 +12,11 @@
//==========================================================================
// Framework include files
-#include "DD4hep/PolarGridRPhi2.h"
-#include "DDSegmentation/PolarGridRPhi2.h"
+#include <DD4hep/PolarGridRPhi2.h>
+#include <DDSegmentation/PolarGridRPhi2.h>
// C/C++ include files
-using namespace std;
using namespace dd4hep;
/// determine the position based on the cell ID
@@ -34,12 +33,12 @@ dd4hep::CellID PolarGridRPhi2::cellID(const Position& local,
}
/// access the grid size in R
-vector<double> PolarGridRPhi2::gridRValues() const {
+std::vector<double> PolarGridRPhi2::gridRValues() const {
return access()->implementation->gridRValues();
}
/// access the grid size in Phi
-vector<double> PolarGridRPhi2::gridPhiValues() const {
+std::vector<double> PolarGridRPhi2::gridPhiValues() const {
return access()->implementation->gridPhiValues();
}
/// set the grid Boundaries in R
@@ -83,12 +82,12 @@ void PolarGridRPhi2::setOffsetPhi(double offset) const {
}
/// access the field name used for R
-const string& PolarGridRPhi2::fieldNameR() const {
+const std::string& PolarGridRPhi2::fieldNameR() const {
return access()->implementation->fieldNameR();
}
/// access the field name used for Phi
-const string& PolarGridRPhi2::fieldNamePhi() const {
+const std::string& PolarGridRPhi2::fieldNamePhi() const {
return access()->implementation->fieldNamePhi();
}
@@ -101,6 +100,6 @@ const string& PolarGridRPhi2::fieldNamePhi() const {
-# size in x
-# size in z
*/
-vector<double> PolarGridRPhi2::cellDimensions(const CellID& id) const {
+std::vector<double> PolarGridRPhi2::cellDimensions(const CellID& id) const {
return access()->implementation->cellDimensions(id);
}
diff --git a/DDCore/src/Primitives.cpp b/DDCore/src/Primitives.cpp
index 98439f8e9a5a03d593ed02b18216c9ea2d6c7188..98cf5b70fce1711924f58390fbd096722e77b11e 100644
--- a/DDCore/src/Primitives.cpp
+++ b/DDCore/src/Primitives.cpp
@@ -12,9 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Primitives.h"
-#include "DD4hep/Exceptions.h"
-#include "DD4hep/Printout.h"
+#include <DD4hep/Primitives.h>
+#include <DD4hep/Exceptions.h>
+#include <DD4hep/Printout.h>
// C/C++ include files
#include <cstring>
diff --git a/DDCore/src/Printout.cpp b/DDCore/src/Printout.cpp
index b1669e3b2cbf914555f2ad1bcaa3e7e9b6bbb57b..68f289090a9b84e819e3b4a00777dcb570b117c0 100644
--- a/DDCore/src/Printout.cpp
+++ b/DDCore/src/Printout.cpp
@@ -12,7 +12,7 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Printout.h"
+#include <DD4hep/Printout.h>
// C/C++ include files
#include <mutex>
@@ -21,6 +21,7 @@
#include <sstream>
#include <iostream>
#include <stdexcept>
+
// Disable some diagnostics for ROOT dictionaries
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wvarargs"
diff --git a/DDCore/src/PropertyDictionary.h b/DDCore/src/PropertyDictionary.h
index 7a7ce2b54e3113644c32bc23f6ca8d52fc965eb0..95848f62c28404ed42c6f71d9062d436eb755520 100644
--- a/DDCore/src/PropertyDictionary.h
+++ b/DDCore/src/PropertyDictionary.h
@@ -17,7 +17,7 @@
#define DDCORE_SRC_PROPERTYDICTIONARY_H
// Framework include files
-#include "DD4hep/ComponentProperties.h"
+#include <DD4hep/ComponentProperties.h>
// C/C++ include files
#include <vector>
diff --git a/DDCore/src/Readout.cpp b/DDCore/src/Readout.cpp
index ec3e861578e9ca61bbc11e5435d16b13e7bccbfa..db3cde906d99cd7e9d4f9d32230287b14d92477d 100644
--- a/DDCore/src/Readout.cpp
+++ b/DDCore/src/Readout.cpp
@@ -12,17 +12,16 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Readout.h"
-#include "DD4hep/detail/SegmentationsInterna.h"
-#include "DD4hep/detail/ObjectsInterna.h"
-#include "DD4hep/detail/Handle.inl"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/DD4hepUnits.h"
-#include "DD4hep/Detector.h"
+#include <DD4hep/Readout.h>
+#include <DD4hep/detail/SegmentationsInterna.h>
+#include <DD4hep/detail/ObjectsInterna.h>
+#include <DD4hep/detail/Handle.inl>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/DD4hepUnits.h>
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
/// Copy constructor
HitCollection::HitCollection(const HitCollection& c)
@@ -31,7 +30,7 @@ HitCollection::HitCollection(const HitCollection& c)
}
/// Initializing constructor
-HitCollection::HitCollection(const string& n, const string& k, long k_min, long k_max)
+HitCollection::HitCollection(const std::string& n, const std::string& k, long k_min, long k_max)
: name(n), key(k), key_min(k_min), key_max(k_max)
{
}
@@ -48,7 +47,7 @@ HitCollection& HitCollection::operator=(const HitCollection& c) {
}
/// Initializing constructor to create a new object
-Readout::Readout(const string& nam) {
+Readout::Readout(const std::string& nam) {
assign(new ReadoutObject(), nam, "readout");
}
@@ -58,12 +57,13 @@ size_t Readout::numCollections() const {
Object& ro = object<Object>();
return ro.hits.size();
}
- throw runtime_error("dd4hep: Readout::numCollections: Cannot access object data [Invalid Handle]");
+ except("dd4hep::Readout","numCollections: Cannot access object data [Invalid Handle]");
+ throw std::runtime_error("dd4hep: Readout");
}
/// Access names of hit collections
-vector<string> Readout::collectionNames() const {
- vector<string> colls;
+std::vector<std::string> Readout::collectionNames() const {
+ std::vector<std::string> colls;
if ( isValid() ) {
Object& ro = object<Object>();
if ( !ro.hits.empty() ) {
@@ -72,12 +72,13 @@ vector<string> Readout::collectionNames() const {
}
return colls;
}
- throw runtime_error("dd4hep: Readout::collectionsNames: Cannot access object data [Invalid Handle]");
+ except("dd4hep::Readout", "collectionsNames: Cannot access object data [Invalid Handle]");
+ throw std::runtime_error("dd4hep: Readout");
}
/// Access hit collectionsy
-vector<const HitCollection*> Readout::collections() const {
- vector<const HitCollection*> colls;
+std::vector<const HitCollection*> Readout::collections() const {
+ std::vector<const HitCollection*> colls;
if ( isValid() ) {
Object& ro = object<Object>();
if ( !ro.hits.empty() ) {
@@ -86,7 +87,8 @@ vector<const HitCollection*> Readout::collections() const {
}
return colls;
}
- throw runtime_error("dd4hep: Readout::collections: Cannot access object data [Invalid Handle]");
+ except("dd4hep::Readout", "collections: Cannot access object data [Invalid Handle]");
+ throw std::runtime_error("dd4hep: Readout");
}
/// Assign IDDescription to readout structure
@@ -102,7 +104,8 @@ void Readout::setIDDescriptor(const Ref_t& new_descriptor) const {
return;
}
}
- throw runtime_error("dd4hep: Readout::setIDDescriptor: Cannot assign ID descriptor [Invalid Handle]");
+ except("dd4hep::Readout", "setIDDescriptor: Cannot assign ID descriptor [Invalid Handle]");
+ throw std::runtime_error("dd4hep: Readout");
}
/// Access IDDescription structure
@@ -123,7 +126,8 @@ void Readout::setSegmentation(const Segmentation& seg) const {
return;
}
}
- throw runtime_error("dd4hep: Readout::setSegmentation: Cannot assign segmentation [Invalid Handle]");
+ except("dd4hep::Readout", "setSegmentation: Cannot assign segmentation [Invalid Handle]");
+ throw std::runtime_error("dd4hep: Readout");
}
/// Access segmentation structure
diff --git a/DDCore/src/RootDictionary.h b/DDCore/src/RootDictionary.h
index 432c312ca08ff75b1fc43de9d5710504dc1e2dcd..f44211b85778db01ec96bff5e00d33a6cb5e64ee 100644
--- a/DDCore/src/RootDictionary.h
+++ b/DDCore/src/RootDictionary.h
@@ -17,34 +17,34 @@
#define DDCORE_SRC_ROOTDICTIONARY_H
// Framework include files
-#include "Evaluator/Evaluator.h"
-#include "DD4hep/DD4hepRootPersistency.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Grammar.h"
-#include "DD4hep/detail/ObjectsInterna.h"
-#include "DD4hep/detail/DetectorInterna.h"
-#include "DD4hep/detail/ConditionsInterna.h"
-#include "DD4hep/detail/AlignmentsInterna.h"
-#include "DD4hep/detail/VolumeManagerInterna.h"
-
-#include "DD4hep/World.h"
-#include "DD4hep/DD4hepUI.h"
-#include "DD4hep/Callback.h"
-#include "DD4hep/Conditions.h"
-#include "DD4hep/Alignments.h"
-#include "DD4hep/FieldTypes.h"
-#include "DD4hep/DD4hepUnits.h"
-#include "DD4hep/DetectorData.h"
-#include "DD4hep/DetectorProcessor.h"
-#include "DD4hep/ComponentProperties.h"
-#include "DD4hep/DetectorImp.h"
+#include <Evaluator/Evaluator.h>
+#include <DD4hep/DD4hepRootPersistency.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Grammar.h>
+#include <DD4hep/detail/ObjectsInterna.h>
+#include <DD4hep/detail/DetectorInterna.h>
+#include <DD4hep/detail/ConditionsInterna.h>
+#include <DD4hep/detail/AlignmentsInterna.h>
+#include <DD4hep/detail/VolumeManagerInterna.h>
+
+#include <DD4hep/World.h>
+#include <DD4hep/DD4hepUI.h>
+#include <DD4hep/Callback.h>
+#include <DD4hep/Conditions.h>
+#include <DD4hep/Alignments.h>
+#include <DD4hep/FieldTypes.h>
+#include <DD4hep/DD4hepUnits.h>
+#include <DD4hep/DetectorData.h>
+#include <DD4hep/DetectorProcessor.h>
+#include <DD4hep/ComponentProperties.h>
+#include <DD4hep/DetectorImp.h>
// C/C++ include files
#include <vector>
#include <map>
#include <string>
-#include "TRint.h"
+#include <TRint.h>
namespace dd4hep {
namespace cond {}
@@ -825,7 +825,7 @@ template class dd4hep::Handle<TNamed>;
#pragma link C++ function dd4hep::toStringMesh(const TGeoShape*, int);
#pragma link C++ function dd4hep::toStringMesh(dd4hep::PlacedVolume, int);
-#include "DD4hep/ConditionsData.h"
+#include <DD4hep/ConditionsData.h>
#pragma link C++ class dd4hep::cond::ClientData+;
#pragma link C++ class dd4hep::cond::AbstractMap+;
#pragma link C++ class dd4hep::cond::AbstractMap::Params+;
diff --git a/DDCore/src/SegmentationDictionary.h b/DDCore/src/SegmentationDictionary.h
index 761a5bb3f07d79b9fff2ed60fa9947419b36c8b7..8a710cf095e3e5e3190c34a64e54090063902a0d 100644
--- a/DDCore/src/SegmentationDictionary.h
+++ b/DDCore/src/SegmentationDictionary.h
@@ -20,31 +20,31 @@
#define __HAVE_DDSEGMENTATION__
// -------------------------------------------------------------------------
#ifdef __HAVE_DDSEGMENTATION__
-#include "DDSegmentation/Segmentation.h"
-#include "DDSegmentation/NoSegmentation.h"
-#include "DDSegmentation/CartesianGrid.h"
-#include "DDSegmentation/CartesianGridXY.h"
-#include "DDSegmentation/CartesianGridXYZ.h"
-#include "DDSegmentation/CartesianGridXZ.h"
-#include "DDSegmentation/CartesianGridYZ.h"
-#include "DDSegmentation/CartesianStripX.h"
-#include "DDSegmentation/CartesianStripY.h"
-#include "DDSegmentation/CartesianStripZ.h"
-#include "DDSegmentation/CylindricalSegmentation.h"
-#include "DDSegmentation/GridPhiEta.h"
-#include "DDSegmentation/GridRPhiEta.h"
-#include "DDSegmentation/MegatileLayerGridXY.h"
-#include "DDSegmentation/MultiSegmentation.h"
-#include "DDSegmentation/NoSegmentation.h"
-#include "DDSegmentation/PolarGrid.h"
-#include "DDSegmentation/PolarGridRPhi2.h"
-#include "DDSegmentation/PolarGridRPhi.h"
-#include "DDSegmentation/ProjectiveCylinder.h"
+#include <DDSegmentation/Segmentation.h>
+#include <DDSegmentation/NoSegmentation.h>
+#include <DDSegmentation/CartesianGrid.h>
+#include <DDSegmentation/CartesianGridXY.h>
+#include <DDSegmentation/CartesianGridXYZ.h>
+#include <DDSegmentation/CartesianGridXZ.h>
+#include <DDSegmentation/CartesianGridYZ.h>
+#include <DDSegmentation/CartesianStripX.h>
+#include <DDSegmentation/CartesianStripY.h>
+#include <DDSegmentation/CartesianStripZ.h>
+#include <DDSegmentation/CylindricalSegmentation.h>
+#include <DDSegmentation/GridPhiEta.h>
+#include <DDSegmentation/GridRPhiEta.h>
+#include <DDSegmentation/MegatileLayerGridXY.h>
+#include <DDSegmentation/MultiSegmentation.h>
+#include <DDSegmentation/NoSegmentation.h>
+#include <DDSegmentation/PolarGrid.h>
+#include <DDSegmentation/PolarGridRPhi2.h>
+#include <DDSegmentation/PolarGridRPhi.h>
+#include <DDSegmentation/ProjectiveCylinder.h>
-#include "DDSegmentation/SegmentationParameter.h"
-#include "DDSegmentation/TiledLayerGridXY.h"
-#include "DDSegmentation/TiledLayerSegmentation.h"
-#include "DDSegmentation/WaferGridXY.h"
+#include <DDSegmentation/SegmentationParameter.h>
+#include <DDSegmentation/TiledLayerGridXY.h>
+#include <DDSegmentation/TiledLayerSegmentation.h>
+#include <DDSegmentation/WaferGridXY.h>
typedef dd4hep::DDSegmentation::VolumeID VolumeID;
typedef dd4hep::DDSegmentation::CellID CellID;
diff --git a/DDCore/src/Segmentations.cpp b/DDCore/src/Segmentations.cpp
index a58df7bf26d3bfb7598b0496d11714ab19fd1bbf..55a4d3bacc307667f97f5d72277935589d40e721 100644
--- a/DDCore/src/Segmentations.cpp
+++ b/DDCore/src/Segmentations.cpp
@@ -12,27 +12,25 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Segmentations.h"
-#include "DD4hep/InstanceCount.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Plugins.h"
-#include "DD4hep/detail/Handle.inl"
-#include "DD4hep/detail/SegmentationsInterna.h"
+#include <DD4hep/Segmentations.h>
+#include <DD4hep/InstanceCount.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Plugins.h>
+#include <DD4hep/detail/Handle.inl>
+#include <DD4hep/detail/SegmentationsInterna.h>
// C/C++ include files
#include <iostream>
#include <stdexcept>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
DD4HEP_INSTANTIATE_HANDLE_UNNAMED(SegmentationObject);
/// Constructor to used when creating a new object
-Segmentation::Segmentation(const string& typ, const string& nam, const BitFieldCoder* dec) : Handle<Object>()
+Segmentation::Segmentation(const std::string& typ, const std::string& nam, const BitFieldCoder* dec) : Handle<Object>()
{
- string seg_type = "segmentation_constructor__"+typ;
+ std::string seg_type = "segmentation_constructor__"+typ;
SegmentationObject* obj = PluginService::Create<SegmentationObject*>(seg_type, dec);
if ( obj != 0 ) {
assign(obj, nam, typ);
@@ -122,56 +120,56 @@ Handle<SensitiveDetectorObject> Segmentation::sensitive() const {
return access()->sensitive;
}
-#include "DDSegmentation/NoSegmentation.h"
+#include <DDSegmentation/NoSegmentation.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::NoSegmentation);
-#include "DDSegmentation/CartesianGrid.h"
+#include <DDSegmentation/CartesianGrid.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGrid);
-#include "DDSegmentation/CartesianGridXY.h"
+#include <DDSegmentation/CartesianGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridXY);
-#include "DDSegmentation/CartesianGridXZ.h"
+#include <DDSegmentation/CartesianGridXZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridXZ);
-#include "DDSegmentation/CartesianGridYZ.h"
+#include <DDSegmentation/CartesianGridYZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridYZ);
-#include "DDSegmentation/CartesianGridXYZ.h"
+#include <DDSegmentation/CartesianGridXYZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridXYZ);
-#include "DDSegmentation/CartesianStripX.h"
+#include <DDSegmentation/CartesianStripX.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianStripX);
-#include "DDSegmentation/CartesianStripY.h"
+#include <DDSegmentation/CartesianStripY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianStripY);
-#include "DDSegmentation/CartesianStripZ.h"
+#include <DDSegmentation/CartesianStripZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianStripZ);
-#include "DDSegmentation/TiledLayerGridXY.h"
+#include <DDSegmentation/TiledLayerGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::TiledLayerGridXY);
-#include "DDSegmentation/MegatileLayerGridXY.h"
+#include <DDSegmentation/MegatileLayerGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::MegatileLayerGridXY);
-#include "DDSegmentation/WaferGridXY.h"
+#include <DDSegmentation/WaferGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::WaferGridXY);
-#include "DDSegmentation/PolarGridRPhi.h"
+#include <DDSegmentation/PolarGridRPhi.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::PolarGridRPhi);
-#include "DDSegmentation/PolarGridRPhi2.h"
+#include <DDSegmentation/PolarGridRPhi2.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::PolarGridRPhi2);
-#include "DDSegmentation/GridPhiEta.h"
+#include <DDSegmentation/GridPhiEta.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::GridPhiEta);
-#include "DDSegmentation/GridRPhiEta.h"
+#include <DDSegmentation/GridRPhiEta.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::GridRPhiEta);
-#include "DDSegmentation/ProjectiveCylinder.h"
+#include <DDSegmentation/ProjectiveCylinder.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::ProjectiveCylinder);
-#include "DDSegmentation/MultiSegmentation.h"
+#include <DDSegmentation/MultiSegmentation.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::MultiSegmentation);
diff --git a/DDCore/src/SegmentationsInterna.cpp b/DDCore/src/SegmentationsInterna.cpp
index 88edfed21bf56584e738e7454d92656d7f8ef70d..c94e3f013ca7a14cd26b0a342c0cb4326d2f35b5 100644
--- a/DDCore/src/SegmentationsInterna.cpp
+++ b/DDCore/src/SegmentationsInterna.cpp
@@ -12,12 +12,11 @@
//==========================================================================
// Framework include files
-#include "DD4hep/detail/SegmentationsInterna.h"
-#include "DD4hep/InstanceCount.h"
+#include <DD4hep/detail/SegmentationsInterna.h>
+#include <DD4hep/InstanceCount.h>
#include "DDSegmentation/Segmentation.h"
-using namespace std;
using namespace dd4hep;
/// Standard constructor
@@ -37,26 +36,26 @@ SegmentationObject::~SegmentationObject() {
}
/// Access the encoding string
-string SegmentationObject::fieldDescription() const {
+std::string SegmentationObject::fieldDescription() const {
return segmentation->fieldDescription();
}
/// Access the segmentation name
-const string& SegmentationObject::name() const {
+const std::string& SegmentationObject::name() const {
return segmentation->name();
}
/// Set the segmentation name
-void SegmentationObject::setName(const string& value) {
+void SegmentationObject::setName(const std::string& value) {
segmentation->setName(value);
}
/// Access the segmentation type
-const string& SegmentationObject::type() const {
+const std::string& SegmentationObject::type() const {
return segmentation->type();
}
/// Access the description of the segmentation
-const string& SegmentationObject::description() const {
+const std::string& SegmentationObject::description() const {
return segmentation->description();
}
@@ -71,7 +70,7 @@ void SegmentationObject::setDecoder(const BitFieldCoder* ptr_decoder) const {
}
/// Access to parameter by name
-DDSegmentation::Parameter SegmentationObject::parameter(const string& parameterName) const {
+DDSegmentation::Parameter SegmentationObject::parameter(const std::string& parameterName) const {
return segmentation->parameter(parameterName);
}
diff --git a/DDCore/src/ShapeUtilities.cpp b/DDCore/src/ShapeUtilities.cpp
index 11c89c214417f2c1c25d43827949661222760076..db78b58b5abc2a00e6a338bf7d9c8d88f1d9de46 100644
--- a/DDCore/src/ShapeUtilities.cpp
+++ b/DDCore/src/ShapeUtilities.cpp
@@ -376,7 +376,7 @@ namespace dd4hep {
TGeoArb8* sh = get_ptr<TGeoArb8>(shape);
struct _V { double xy[8][2]; } *vtx = (_V*)sh->GetVertices();
std::vector<double> pars { sh->GetDz() };
- for ( size_t i=0; i<8; ++i ) {
+ for ( std::size_t i=0; i<8; ++i ) {
pars.emplace_back(vtx->xy[i][0]);
pars.emplace_back(vtx->xy[i][1]);
}
@@ -504,7 +504,7 @@ namespace dd4hep {
cout << "dimensions: [" << PSEUDOTRAP_TAG << "]" << endl
<< right_matrix->GetTitle() << endl;
#endif
- for(size_t i=0; i<7; ++i) {
+ for(std::size_t i=0; i<7; ++i) {
double val;
params >> val;
pars.emplace_back(val);
@@ -521,7 +521,7 @@ namespace dd4hep {
std::stringstream params(right_matrix->GetTitle());
std::vector<double> pars;
pars.reserve(8);
- for(size_t i=0; i<8; ++i) {
+ for(std::size_t i=0; i<8; ++i) {
double val;
params >> val;
pars.emplace_back(val);
@@ -638,7 +638,7 @@ namespace dd4hep {
if ( params.size() < 3 ) {
invalidSetDimensionCall(sh,params);
}
- size_t nz = size_t(params[2]);
+ std::size_t nz = std::size_t(params[2]);
if ( params.size() != 3 + 3*nz ) {
invalidSetDimensionCall(sh,params);
}
@@ -762,7 +762,7 @@ namespace dd4hep {
}
template <> void set_dimensions(TGeoPgon* sh, const std::vector<double>& params) {
auto pars = params;
- if ( params.size() < 4 || params.size() != 4 + 3*size_t(params[3]) ) {
+ if ( params.size() < 4 || params.size() != 4 + 3*std::size_t(params[3]) ) {
invalidSetDimensionCall(sh,params);
}
pars[0] /= units::deg;
@@ -771,7 +771,7 @@ namespace dd4hep {
}
template <> void set_dimensions(TGeoXtru* sh, const std::vector<double>& params) {
auto pars = params;
- if ( params.size() < 1 || params.size() != 1 + 4*size_t(params[0]) ) {
+ if ( params.size() < 1 || params.size() != 1 + 4*std::size_t(params[0]) ) {
invalidSetDimensionCall(sh,params);
}
Solid(sh)._setDimensions(&pars[0]);
@@ -817,7 +817,7 @@ namespace dd4hep {
int num_vtx = params[0];
int num_facet = params[1];
std::vector<TessellatedSolid::Vertex> vertices;
- size_t i_par = 1;
+ std::size_t i_par = 1;
printout(DEBUG,"TessellatedSolid","+++ Loading %d vertices, %d facets",num_vtx, num_facet);
for (int i=0; i<num_vtx; ++i) {
double x = params[++i_par];
diff --git a/DDCore/src/ShapesInterna.cpp b/DDCore/src/ShapesInterna.cpp
index 30da0c302e1e77c9954fc0e9d027fe96b414f5fc..0de4dc74c86d4d7046e20dacea52addc3a14313f 100644
--- a/DDCore/src/ShapesInterna.cpp
+++ b/DDCore/src/ShapesInterna.cpp
@@ -12,15 +12,14 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Printout.h"
-#include "DD4hep/detail/ShapesInterna.h"
+#include <DD4hep/Printout.h>
+#include <DD4hep/detail/ShapesInterna.h>
// C/C++ include files
#include <climits>
#include <iomanip>
#include <cstdio>
-using namespace std;
using namespace dd4hep;
ClassImp(dd4hep::TwistedTubeObject)
diff --git a/DDCore/src/SpecParRegistry.cpp b/DDCore/src/SpecParRegistry.cpp
index 062c5dde649bb77563d2f8fd0d40808cb3850b30..276b4310faa825984259218c94ea6912991683c2 100644
--- a/DDCore/src/SpecParRegistry.cpp
+++ b/DDCore/src/SpecParRegistry.cpp
@@ -1,25 +1,40 @@
-#include "DD4hep/SpecParRegistry.h"
-#include "DD4hep/Detector.h"
+//==========================================================================
+// AIDA Detector description implementation
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+// Author : M.Frank
+//
+//==========================================================================
+
+// Framework includes
+#include <DD4hep/SpecParRegistry.h>
+#include <DD4hep/Detector.h>
+
+// C/C++ include files
#include <algorithm>
-using namespace std;
using namespace dd4hep;
-string_view SpecPar::strValue(const string& key) const {
+std::string_view SpecPar::strValue(const std::string& key) const {
auto const& item = spars.find(key);
if (item == end(spars))
- return string_view();
+ return std::string_view();
return *begin(item->second);
}
-bool SpecPar::hasValue(const string& key) const {
+bool SpecPar::hasValue(const std::string& key) const {
if (numpars.find(key) != end(numpars))
return true;
else
return false;
}
-bool SpecPar::hasPath(const string& path) const {
+bool SpecPar::hasPath(const std::string& path) const {
auto result = std::find(std::begin(paths), std::end(paths), path);
if (result != end(paths))
return true;
@@ -28,7 +43,7 @@ bool SpecPar::hasPath(const string& path) const {
}
template <>
-std::vector<double> SpecPar::value<std::vector<double>>(const string& key) const {
+std::vector<double> SpecPar::value<std::vector<double>>(const std::string& key) const {
std::vector<double> result;
auto const& nitem = numpars.find(key);
@@ -47,7 +62,7 @@ std::vector<double> SpecPar::value<std::vector<double>>(const string& key) const
}
template <>
-std::vector<int> SpecPar::value<std::vector<int>>(const string& key) const {
+std::vector<int> SpecPar::value<std::vector<int>>(const std::string& key) const {
std::vector<int> result;
auto const& nitem = numpars.find(key);
@@ -66,7 +81,7 @@ std::vector<int> SpecPar::value<std::vector<int>>(const string& key) const {
}
template <>
-std::vector<std::string> SpecPar::value<std::vector<std::string>>(const string& key) const {
+std::vector<std::string> SpecPar::value<std::vector<std::string>>(const std::string& key) const {
std::vector<std::string> result;
auto const& nitem = numpars.find(key);
@@ -86,7 +101,7 @@ std::vector<std::string> SpecPar::value<std::vector<std::string>>(const string&
return result;
}
-double SpecPar::dblValue(const string& key) const {
+double SpecPar::dblValue(const std::string& key) const {
auto const& item = numpars.find(key);
if (item == end(numpars))
return 0;
diff --git a/DDCore/src/SurfaceInstaller.cpp b/DDCore/src/SurfaceInstaller.cpp
index 29f778cda7ca737a715cca19508a7699263ac29d..32a9a82fe46053955912a79e26fa8513fd0ced7b 100644
--- a/DDCore/src/SurfaceInstaller.cpp
+++ b/DDCore/src/SurfaceInstaller.cpp
@@ -12,18 +12,13 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Shapes.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/SurfaceInstaller.h"
-
-// C/C++ include files
-#include <stdexcept>
+#include <DD4hep/Shapes.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/SurfaceInstaller.h>
// ROOT includes
-#include "TClass.h"
+#include <TClass.h>
-using namespace std;
-using namespace dd4hep;
using namespace dd4hep;
typedef DetElement::Children _C;
@@ -33,30 +28,30 @@ SurfaceInstaller::SurfaceInstaller(Detector& description, int argc, char** argv)
: m_detDesc(description), m_det(), m_stopScanning(false)
{
if ( argc > 0 ) {
- string det_name = argv[0];
- string n = det_name[0] == '-' ? det_name.substr(1) : det_name;
+ std::string det_name = argv[0];
+ std::string n = det_name[0] == '-' ? det_name.substr(1) : det_name;
m_det = description.detector(n);
if ( !m_det.isValid() ) {
- stringstream err;
+ std::stringstream err;
err << "The subdetector " << det_name << " is not known to the geometry.";
printout(INFO,"SurfaceInstaller",err.str().c_str());
- throw runtime_error(err.str());
+ except(det_name, err.str());
}
- printout(INFO,m_det.name(),"+++ Processing SurfaceInstaller for subdetector: '%s'",m_det.name());
+ printout(INFO,m_det.name(), "+++ Processing SurfaceInstaller for subdetector: '%s'",m_det.name());
return;
}
- throw runtime_error("The plugin takes at least one argument. No argument supplied");
+ except("SurfaceInstaller", "The plugin takes at least one argument. No argument supplied");
}
/// Indicate error message and throw exception
void SurfaceInstaller::invalidInstaller(const std::string& msg) const {
const char* det = m_det.isValid() ? m_det.name() : "<UNKNOWN>";
- string typ = m_det.isValid() ? m_det.type() : string("<UNKNOWN>");
+ std::string typ = m_det.isValid() ? m_det.type() : std::string("<UNKNOWN>");
printout(FATAL,"SurfaceInstaller","+++ Surfaces for: %s",det);
printout(FATAL,"SurfaceInstaller","+++ %s.",msg.c_str());
printout(FATAL,"SurfaceInstaller","+++ You sure you apply the correct plugin to generate");
printout(FATAL,"SurfaceInstaller","+++ surfaces for a detector of type %s",typ.c_str());
- throw std::runtime_error("+++ Failed to install Surfaces to detector "+string(det));
+ except("SurfaceInstaller", "+++ Failed to install Surfaces to detector "+std::string(det));
}
/// Shortcut to access the parent detectorelement's volume
@@ -78,19 +73,19 @@ const double* SurfaceInstaller::placementTranslation(DetElement component) cons
/// Printout volume information
void SurfaceInstaller::install(DetElement component, PlacedVolume pv) {
if ( pv.volume().isSensitive() ) {
- stringstream log;
- PlacementPath all_nodes;
- ElementPath det_elts;
+ std::stringstream log;
+ PlacementPath all_nodes;
+ ElementPath det_elts;
detail::tools::elementPath(component,det_elts);
detail::tools::placementPath(component,all_nodes);
- string elt_path = detail::tools::elementPath(det_elts);
- string node_path = detail::tools::placementPath(all_nodes);
+ std::string elt_path = detail::tools::elementPath(det_elts);
+ std::string node_path = detail::tools::placementPath(all_nodes);
log << "Lookup " << " Detector[" << det_elts.size() << "]: " << elt_path;
- printout(INFO,m_det.name(),log.str());
+ printout(INFO,m_det.name(), log.str());
log.str("");
log << " " << " Places[" << all_nodes.size() << "]: " << node_path;
- printout(INFO,m_det.name(),log.str());
+ printout(INFO,m_det.name(), log.str());
log.str("");
log << " " << " detail::matrix[" << all_nodes.size() << "]: ";
for(PlacementPath::const_reverse_iterator i=all_nodes.rbegin(); i!=all_nodes.rend(); ++i) {
@@ -116,7 +111,7 @@ void SurfaceInstaller::install(DetElement component, PlacedVolume pv) {
printout(INFO,m_det.name(),log.str());
return;
}
- cout << component.name() << ": " << pv.name() << endl;
+ std::cout << component.name() << ": " << pv.name() << std::endl;
}
/// Scan through tree of volume placements
diff --git a/DDCore/src/VolumeManager.cpp b/DDCore/src/VolumeManager.cpp
index b6dba694eb82b3decb20556436071502fe413a16..db083f369a498bccfc7728a2c212cf08e3e1ac71 100644
--- a/DDCore/src/VolumeManager.cpp
+++ b/DDCore/src/VolumeManager.cpp
@@ -12,13 +12,13 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Detector.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/MatrixHelpers.h"
-#include "DD4hep/detail/Handle.inl"
-#include "DD4hep/detail/ObjectsInterna.h"
-#include "DD4hep/detail/DetectorInterna.h"
-#include "DD4hep/detail/VolumeManagerInterna.h"
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/MatrixHelpers.h>
+#include <DD4hep/detail/Handle.inl>
+#include <DD4hep/detail/ObjectsInterna.h>
+#include <DD4hep/detail/DetectorInterna.h>
+#include <DD4hep/detail/VolumeManagerInterna.h>
// C/C++ includes
#include <set>
@@ -26,7 +26,6 @@
#include <sstream>
#include <iomanip>
-using namespace std;
using namespace dd4hep;
using namespace dd4hep::detail;
@@ -44,19 +43,19 @@ namespace dd4hep {
* \version 1.0
*/
class VolumeManager_Populator {
- typedef vector<TGeoNode*> Chain;
- typedef PlacedVolume::VolIDs VolIDs;
- typedef pair<VolumeID, VolumeID> Encoding;
+ typedef std::vector<TGeoNode*> Chain;
+ typedef PlacedVolume::VolIDs VolIDs;
+ typedef std::pair<VolumeID, VolumeID> Encoding;
/// Reference to the Detector instance
- const Detector& m_detDesc;
+ const Detector& m_detDesc;
/// Reference to the volume manager to be populated
- VolumeManager m_volManager;
+ VolumeManager m_volManager;
/// Set of already added entries
- set<VolumeID> m_entries;
+ std::set<VolumeID> m_entries;
/// Debug flag
- bool m_debug = false;
+ bool m_debug = false;
/// Node counter
- size_t m_numNodes = 0;
+ std::size_t m_numNodes = 0;
public:
/// Default constructor
@@ -157,7 +156,7 @@ namespace dd4hep {
}
else {
except("VolumeManager",
- "Invalid not instrumented placement:"+string(daughter->GetName())+
+ "Invalid not instrumented placement:"+std::string(daughter->GetName())+
" [Internal error -- bad detector constructor]");
}
if ( compound ) {
@@ -219,7 +218,7 @@ namespace dd4hep {
volume_id |= ((f->value(val << off) << off)&msk);
mask |= msk;
}
- return make_pair(volume_id, mask);
+ return std::make_pair(volume_id, mask);
}
/// Compute the encoding for a set of VolIDs within a readout descriptor
static Encoding encoding(const IDDescriptor iddesc, const VolIDs& ids) {
@@ -233,7 +232,7 @@ namespace dd4hep {
volume_id |= ((f->value(val << off) << off)&msk);
mask |= msk;
}
- return make_pair(volume_id, mask);
+ return std::make_pair(volume_id, mask);
}
void add_entry(SensitiveDetector sd, DetElement parent, DetElement e,
@@ -242,7 +241,7 @@ namespace dd4hep {
if ( sd.isValid() ) {
if (m_entries.find(code.first) == m_entries.end()) {
Readout ro = sd.readout();
- string sd_name = sd.name();
+ std::string sd_name = sd.name();
DetElement sub_detector = m_detDesc.detector(sd_name);
VolumeManager section = m_volManager.addSubdetector(sub_detector, ro);
@@ -258,7 +257,7 @@ namespace dd4hep {
if ( context->flag ) {
detail::VolumeManagerContextExtension* ext = (detail::VolumeManagerContextExtension*)context;
ext->placement = PlacedVolume(n);
- for (size_t i = nodes.size(); i > 1; --i) { // Omit the placement of the parent DetElement
+ for (std::size_t i = nodes.size(); i > 1; --i) { // Omit the placement of the parent DetElement
TGeoMatrix* m = nodes[i-1]->GetMatrix();
ext->toElement.MultiplyLeft(m);
}
@@ -283,7 +282,7 @@ namespace dd4hep {
bool sensitive = pv.volume().isSensitive();
//if ( !sensitive ) return;
- stringstream log;
+ std::stringstream log;
log << m_entries.size() << ": Detector: " << e.path()
<< " id:" << volumeID(code.first)
<< " Nodes(" << int(nodes.size()) << "):" << ro.idSpec().str(code.first,code.second);
@@ -393,9 +392,9 @@ void VolumeManagerContext::worldToLocal(const double world[3], double local[3])
}
/// Initializing constructor to create a new object
-VolumeManager::VolumeManager(const Detector& description, const string& nam, DetElement elt, Readout ro, int flags) {
+VolumeManager::VolumeManager(const Detector& description, const std::string& nam, DetElement elt, Readout ro, int flags) {
printout(INFO, "VolumeManager", " - populating volume ids - be patient ..." );
- size_t node_count = 0;
+ std::size_t node_count = 0;
Object* obj_ptr = new Object();
assign(obj_ptr, nam, "VolumeManager");
if (elt.isValid()) {
@@ -430,26 +429,26 @@ VolumeManager VolumeManager::addSubdetector(DetElement det, Readout ro) {
if (isValid()) {
Object& o = _data();
if (!det.isValid()) {
- throw runtime_error("dd4hep: VolumeManager::addSubdetector: Only valid subdetectors "
- "are allowed. [Invalid DetElement]");
+ throw std::runtime_error("dd4hep: VolumeManager::addSubdetector: Only valid subdetectors "
+ "are allowed. [Invalid DetElement]");
}
auto i = o.subdetectors.find(det);
if (i == o.subdetectors.end()) {
- string det_name = det.name();
+ std::string det_name = det.name();
// First check all pre-conditions
if (!ro.isValid()) {
- throw runtime_error("dd4hep: VolumeManager::addSubdetector: Only subdetectors with a "
- "valid readout descriptor are allowed. [Invalid DetElement:" + det_name + "]");
+ throw std::runtime_error("dd4hep: VolumeManager::addSubdetector: Only subdetectors with a "
+ "valid readout descriptor are allowed. [Invalid DetElement:" + det_name + "]");
}
PlacedVolume pv = det.placement();
if (!pv.isValid()) {
- throw runtime_error("dd4hep: VolumeManager::addSubdetector: Only subdetectors with a "
- "valid placement are allowed. [Invalid DetElement:" + det_name + "]");
+ throw std::runtime_error("dd4hep: VolumeManager::addSubdetector: Only subdetectors with a "
+ "valid placement are allowed. [Invalid DetElement:" + det_name + "]");
}
auto vit = pv.volIDs().find("system");
if (vit == pv.volIDs().end()) {
- throw runtime_error("dd4hep: VolumeManager::addSubdetector: Only subdetectors with "
- "valid placement VolIDs are allowed. [Invalid DetElement:" + det_name + "]");
+ throw std::runtime_error("dd4hep: VolumeManager::addSubdetector: Only subdetectors with "
+ "valid placement VolIDs are allowed. [Invalid DetElement:" + det_name + "]");
}
i = o.subdetectors.emplace(det, VolumeManager(det,ro)).first;
@@ -457,8 +456,8 @@ VolumeManager VolumeManager::addSubdetector(DetElement det, Readout ro) {
VolumeManager mgr = (*i).second;
const BitFieldElement* field = ro.idSpec().field(id.first);
if (!field) {
- throw runtime_error("dd4hep: VolumeManager::addSubdetector: IdDescriptor of " +
- string(det.name()) + " has no field " + id.first);
+ throw std::runtime_error("dd4hep: VolumeManager::addSubdetector: IdDescriptor of " +
+ std::string(det.name()) + " has no field " + id.first);
}
Object& mo = mgr._data();
mo.top = o.top;
@@ -472,8 +471,8 @@ VolumeManager VolumeManager::addSubdetector(DetElement det, Readout ro) {
}
return (*i).second;
}
- throw runtime_error("dd4hep: VolumeManager::addSubdetector: "
- "Failed to add subdetector section. [Invalid Manager Handle]");
+ throw std::runtime_error("dd4hep: VolumeManager::addSubdetector: "
+ "Failed to add subdetector section. [Invalid Manager Handle]");
}
/// Access the volume manager by cell id
@@ -487,11 +486,11 @@ VolumeManager VolumeManager::subdetector(VolumeID id) const {
if ( sys_id == mo.sysID )
return j.second;
}
- throw runtime_error("dd4hep: VolumeManager::subdetector(VolID): "
- "Attempt to access unknown subdetector section.");
+ throw std::runtime_error("dd4hep: VolumeManager::subdetector(VolID): "
+ "Attempt to access unknown subdetector section.");
}
- throw runtime_error("dd4hep: VolumeManager::subdetector(VolID): "
- "Cannot assign ID descriptor [Invalid Manager Handle]");
+ throw std::runtime_error("dd4hep: VolumeManager::subdetector(VolID): "
+ "Cannot assign ID descriptor [Invalid Manager Handle]");
}
/// Access the top level detector element
@@ -499,7 +498,7 @@ DetElement VolumeManager::detector() const {
if (isValid()) {
return _data().detector;
}
- throw runtime_error("dd4hep: VolumeManager::detector: Cannot access DetElement [Invalid Handle]");
+ throw std::runtime_error("dd4hep: VolumeManager::detector: Cannot access DetElement [Invalid Handle]");
}
/// Access IDDescription structure
@@ -509,7 +508,7 @@ IDDescriptor VolumeManager::idSpec() const {
/// Register physical volume with the manager (normally: section manager)
bool VolumeManager::adoptPlacement(VolumeID sys_id, VolumeManagerContext* context) {
- stringstream err;
+ std::stringstream err;
Object& o = _data();
VolumeID vid = context->identifier;
VolumeID mask = context->mask;
@@ -521,53 +520,53 @@ bool VolumeManager::adoptPlacement(VolumeID sys_id, VolumeManagerContext* contex
<< " id:" << (void*)vid
<< " pv:" << pv.name()
<< " Sensitive:" << yes_no(pv.volume().isSensitive())
- << endl;
+ << std::endl;
goto Fail;
}
if ( i == o.volumes.end()) {
o.volumes[vid] = context;
o.detMask |= mask;
- err << "Inserted new volume:" << setw(6) << left << o.volumes.size()
+ err << "Inserted new volume:" << std::setw(6) << std::left << o.volumes.size()
<< " Ptr:" << (void*) pv.ptr()
<< " [" << pv.name() << "]"
- << " id:" << setw(16) << hex << right << setfill('0') << vid << dec << setfill(' ')
- << " mask:" << setw(16) << hex << right << setfill('0') << mask << dec << setfill(' ')
- << " Det:" << setw(4) << hex << right << setfill('0') << context->element.volumeID()
- << " / " << setw(4) << sys_id << dec << setfill(' ') << ": " << context->element.path();
+ << " id:" << std::setw(16) << std::hex << std::right << std::setfill('0') << vid << std::dec << std::setfill(' ')
+ << " mask:" << std::setw(16) << std::hex << std::right << std::setfill('0') << mask << std::dec << std::setfill(' ')
+ << " Det:" << std::setw(4) << std::hex << std::right << std::setfill('0') << context->element.volumeID()
+ << " / " << std::setw(4) << sys_id << std::dec << std::setfill(' ') << ": " << context->element.path();
printout(VERBOSE, "VolumeManager", err.str().c_str());
//printout(ALWAYS, "VolumeManager", err.str().c_str());
return true;
}
err << "+++ Attempt to register duplicate"
- << " id:" << setw(16) << hex << right << setfill('0') << vid << dec << setfill(' ')
- << " mask:" << setw(16) << hex << right << setfill('0') << mask << dec << setfill(' ')
+ << " id:" << std::setw(16) << std::hex << std::right << std::setfill('0') << vid << std::dec << std::setfill(' ')
+ << " mask:" << std::setw(16) << std::hex << std::right << std::setfill('0') << mask << std::dec << std::setfill(' ')
<< " to detector " << o.detector.name()
<< " ptr:" << (void*) pv.ptr()
<< " Name:" << pv.name()
<< " Sensitive:" << yes_no(pv.volume().isSensitive())
- << endl;
+ << std::endl;
printout(ERROR, "VolumeManager", "%s", err.str().c_str());
err.str("");
context = (*i).second;
//pv = context->placement;
err << " !!!!! +++ Clashing"
- << " id:" << setw(16) << hex << right << setfill('0') << vid << dec << setfill(' ')
- << " mask:" << setw(16) << hex << right << setfill('0') << mask << dec << setfill(' ')
+ << " id:" << std::setw(16) << std::hex << std::right << std::setfill('0') << vid << std::dec << std::setfill(' ')
+ << " mask:" << std::setw(16) << std::hex << std::right << std::setfill('0') << mask << std::dec << std::setfill(' ')
<< " to detector " << o.detector.name()
<< " ptr:" << (void*) pv.ptr()
<< " Name:" << pv.name()
<< " Sensitive:" << yes_no(pv.volume().isSensitive())
- << endl;
+ << std::endl;
Fail:
printout(ERROR, "VolumeManager", "%s", err.str().c_str());
- // throw runtime_error(err.str());
+ // throw std::runtime_error(err.str());
return false;
}
/// Register physical volume with the manager (normally: section manager)
bool VolumeManager::adoptPlacement(VolumeManagerContext* context) {
- stringstream err;
+ std::stringstream err;
if ( isValid() ) {
Object& o = _data();
if ( context ) {
@@ -692,25 +691,25 @@ std::ostream& dd4hep::operator<<(std::ostream& os, const VolumeManager& mgr) {
bool isTop = top == &o;
//bool hasTop = (o.flags & VolumeManager::ONE) == VolumeManager::ONE;
//bool isSdet = (o.flags & VolumeManager::TREE) == VolumeManager::TREE && top != &o;
- string prefix(isTop ? "" : "++ ");
+ std::string prefix(isTop ? "" : "++ ");
os << prefix << (isTop ? "TOP Level " : "Secondary ") << "Volume manager:"
<< &o << " " << o.detector.name() << " IDD:"
<< o.id.toString() << " SysID:" << (void*) o.sysID << " "
<< o.managers.size() << " subsections " << o.volumes.size()
<< " placements ";
if (!(o.managers.empty() && o.volumes.empty()))
- os << endl;
+ os << std::endl;
for ( const auto& i : o.volumes ) {
const VolumeManagerContext* c = i.second;
os << prefix
- << "Element:" << setw(32) << left << c->element.path()
- //<< " pv:" << setw(32) << left << c->placement().name()
- << " id:" << setw(18) << left << (void*) c->identifier
- << " mask:" << setw(18) << left << (void*) c->mask
- << endl;
+ << "Element:" << std::setw(32) << std::left << c->element.path()
+ //<< " pv:" << std::setw(32) << std::left << c->placement().name()
+ << " id:" << std::setw(18) << std::left << (void*) c->identifier
+ << " mask:" << std::setw(18) << std::left << (void*) c->mask
+ << std::endl;
}
for( const auto& i : o.managers )
- os << prefix << i.second << endl;
+ os << prefix << i.second << std::endl;
return os;
}
diff --git a/DDCore/src/VolumeProcessor.cpp b/DDCore/src/VolumeProcessor.cpp
index 79b50d6639ce55abaa379bb4abbadf64d0a8daf5..f31847bf0f4a490452e370010397cf2d60bf83a7 100644
--- a/DDCore/src/VolumeProcessor.cpp
+++ b/DDCore/src/VolumeProcessor.cpp
@@ -12,8 +12,8 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Printout.h"
-#include "DD4hep/VolumeProcessor.h"
+#include <DD4hep/Printout.h>
+#include <DD4hep/VolumeProcessor.h>
using namespace dd4hep;
diff --git a/DDCore/src/Volumes.cpp b/DDCore/src/Volumes.cpp
index 775545a6d3beaf68a76944b0bdac8d7405a1eedb..20b5bbf34a118a82bd3a91e657811134778e6156 100644
--- a/DDCore/src/Volumes.cpp
+++ b/DDCore/src/Volumes.cpp
@@ -40,9 +40,7 @@
#include <sstream>
#include <iomanip>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
/*
* The section below uses the new ROOT features using user extensions to volumes
@@ -71,17 +69,17 @@ namespace {
return o;
}
- TGeoVolume* _createTGeoVolume(const string& name, TGeoShape* s, TGeoMedium* m) {
+ TGeoVolume* _createTGeoVolume(const std::string& name, TGeoShape* s, TGeoMedium* m) {
geo_volume_t* e = new geo_volume_t(name.c_str(),s,m);
e->SetUserExtension(new Volume::Object());
return e;
}
- TGeoVolume* _createTGeoVolumeAssembly(const string& name) {
+ TGeoVolume* _createTGeoVolumeAssembly(const std::string& name) {
geo_assembly_t* e = new geo_assembly_t(name.c_str()); // It is important to use the correct constructor!!
e->SetUserExtension(new Assembly::Object());
return e;
}
- TGeoVolumeMulti* _createTGeoVolumeMulti(const string& name, TGeoMedium* medium) {
+ TGeoVolumeMulti* _createTGeoVolumeMulti(const std::string& name, TGeoMedium* medium) {
TGeoVolumeMulti* e = new TGeoVolumeMulti(name.c_str(), medium);
e->SetUserExtension(new VolumeMulti::Object());
return e;
@@ -89,7 +87,7 @@ namespace {
PlacedVolume::Object* _data(const PlacedVolume& v) {
PlacedVolume::Object* o = _userExtension(v);
if (o) return o;
- throw runtime_error("dd4hep: Attempt to access invalid handle of type: PlacedVolume");
+ throw std::runtime_error("dd4hep: Attempt to access invalid handle of type: PlacedVolume");
}
/// Accessor to the data part of the Volume
Volume::Object* _data(const Volume& v, bool throw_exception = true) {
@@ -99,7 +97,7 @@ namespace {
return o;
else if (!throw_exception)
return nullptr;
- throw runtime_error("dd4hep: Attempt to access invalid handle of type: PlacedVolume");
+ throw std::runtime_error("dd4hep: Attempt to access invalid handle of type: PlacedVolume");
}
class VolumeImport {
@@ -107,7 +105,7 @@ namespace {
void setShapeTitle(TGeoVolume* vol) {
if ( vol ) {
TGeoShape* sh = vol->GetShape();
- string tag = get_shape_tag(sh);
+ std::string tag = get_shape_tag(sh);
sh->SetTitle(tag.c_str());
}
}
@@ -216,7 +214,7 @@ namespace {
return nullptr;
}
map.Add(v, vol);
- string nam;
+ std::string nam;
if (newname && newname[0]) {
nam = newname;
vol->SetName(newname);
@@ -395,8 +393,8 @@ void PlacedVolumeExtension::Release() const {
}
/// Lookup volume ID
-vector<PlacedVolumeExtension::VolID>::const_iterator
-PlacedVolumeExtension::VolIDs::find(const string& name) const {
+std::vector<PlacedVolumeExtension::VolID>::const_iterator
+PlacedVolumeExtension::VolIDs::find(const std::string& name) const {
for (Base::const_iterator i = this->Base::begin(); i != this->Base::end(); ++i)
if (name == (*i).first)
return i;
@@ -404,8 +402,8 @@ PlacedVolumeExtension::VolIDs::find(const string& name) const {
}
/// Insert a new value into the volume ID container
-std::pair<vector<PlacedVolumeExtension::VolID>::iterator, bool>
-PlacedVolumeExtension::VolIDs::insert(const string& name, int value) {
+std::pair<std::vector<PlacedVolumeExtension::VolID>::iterator, bool>
+PlacedVolumeExtension::VolIDs::insert(const std::string& name, int value) {
Base::iterator i = this->Base::begin();
for (; i != this->Base::end(); ++i)
if (name == (*i).first)
@@ -419,12 +417,12 @@ PlacedVolumeExtension::VolIDs::insert(const string& name, int value) {
}
/// String representation for debugging
-string PlacedVolumeExtension::VolIDs::str() const {
- stringstream str;
- str << hex;
+std::string PlacedVolumeExtension::VolIDs::str() const {
+ std::stringstream str;
+ str << std::hex;
for(const auto& i : *this ) {
- str << i.first << "=" << setw(4) << right
- << setfill('0') << i.second << setfill(' ') << " ";
+ str << i.first << "=" << std::setw(4) << std::right
+ << std::setfill('0') << i.second << std::setfill(' ') << " ";
}
return str.str();
}
@@ -484,7 +482,7 @@ const PlacedVolume::VolIDs& PlacedVolume::volIDs() const {
}
/// Add identifier
-PlacedVolume& PlacedVolume::addPhysVolID(const string& nam, int value) {
+PlacedVolume& PlacedVolume::addPhysVolID(const std::string& nam, int value) {
auto* o = _data(*this);
if ( !o->params ) {
o->volIDs.emplace_back(nam, value);
@@ -523,15 +521,15 @@ Position PlacedVolume::position() const {
}
/// String dump
-string PlacedVolume::toString() const {
- stringstream str;
+std::string PlacedVolume::toString() const {
+ std::stringstream str;
Object* obj = _data(*this);
str << m_element->GetName() << ": vol='" << m_element->GetVolume()->GetName()
<< "' mat:'" << m_element->GetMatrix()->GetName()
<< "' volID[" << obj->volIDs.size() << "] ";
for (VolIDs::const_iterator i = obj->volIDs.begin(); i != obj->volIDs.end(); ++i)
str << (*i).first << "=" << (*i).second << " ";
- str << ends;
+ str << std::ends;
return str.str();
}
@@ -613,23 +611,23 @@ void VolumeExtension::Release() const {
}
/// Constructor to be used when creating a new geometry tree.
-Volume::Volume(const string& nam) {
+Volume::Volume(const std::string& nam) {
m_element = _createTGeoVolume(nam,0,0);
}
/// Constructor to be used when creating a new geometry tree.
-Volume::Volume(const string& nam, const string& title) {
+Volume::Volume(const std::string& nam, const std::string& title) {
m_element = _createTGeoVolume(nam,0,0);
m_element->SetTitle(title.c_str());
}
/// Constructor to be used when creating a new geometry tree. Also sets materuial and solid attributes
-Volume::Volume(const string& nam, const Solid& sol, const Material& mat) {
+Volume::Volume(const std::string& nam, const Solid& sol, const Material& mat) {
m_element = _createTGeoVolume(nam, sol.ptr(), mat.ptr());
}
/// Constructor to be used when creating a new geometry tree. Also sets materuial and solid attributes
-Volume::Volume(const string& nam, const string& title, const Solid& sol, const Material& mat) {
+Volume::Volume(const std::string& nam, const std::string& title, const Solid& sol, const Material& mat) {
m_element = _createTGeoVolume(nam, sol.ptr(), mat.ptr());
m_element->SetTitle(title.c_str());
}
@@ -711,7 +709,7 @@ bool Volume::isAssembly() const {
}
/// Divide volume into subsections (See the ROOT manuloa for details)
-Volume Volume::divide(const string& divname, int iaxis, int ndiv,
+Volume Volume::divide(const std::string& divname, int iaxis, int ndiv,
double start, double step, int numed, const char* option) {
TGeoVolume* p = m_element;
if ( p ) {
@@ -740,7 +738,7 @@ PlacedVolume _addNode(TGeoVolume* par, TGeoVolume* daughter, int id, TGeoMatrix*
except("dd4hep","Volume: Attempt to place volume without placement matrix.");
}
if ( transform != detail::matrix::_identity() ) {
- string nam = string(daughter->GetName()) + "_placement";
+ std::string nam = std::string(daughter->GetName()) + "_placement";
transform->SetName(nam.c_str());
}
TGeoShape* shape = daughter->GetShape();
@@ -796,7 +794,7 @@ PlacedVolume _addNode(TGeoVolume* par, Volume daughter, int copy_nr, const Rotat
double elements[9];
rot3D.GetComponents(elements);
r.SetMatrix(elements);
- auto matrix = make_unique<TGeoCombiTrans>(TGeoTranslation(0,0,0),r);
+ auto matrix = std::make_unique<TGeoCombiTrans>(TGeoTranslation(0,0,0),r);
return _addNode(par, daughter, copy_nr, matrix.release());
}
@@ -809,7 +807,7 @@ PlacedVolume _addNode(TGeoVolume* par, Volume daughter, int copy_nr, const Trans
tr.GetTranslation(pos3D);
rot3D.GetComponents(elements);
r.SetMatrix(elements);
- auto matrix = make_unique<TGeoCombiTrans>(TGeoTranslation(pos3D.x(), pos3D.y(), pos3D.z()),r);
+ auto matrix = std::make_unique<TGeoCombiTrans>(TGeoTranslation(pos3D.x(), pos3D.y(), pos3D.z()),r);
return _addNode(par, daughter, copy_nr, matrix.release());
}
@@ -1094,16 +1092,16 @@ PlacedVolume Volume::paramVolume3D(const Transform3D& start,
}
/// Set the volume's option value
-const Volume& Volume::setOption(const string& opt) const {
+const Volume& Volume::setOption(const std::string& opt) const {
if ( isValid() ) {
m_element->SetOption(opt.c_str());
return *this;
}
- throw runtime_error("dd4hep: Attempt to access invalid handle of type: PlacedVolume");
+ throw std::runtime_error("dd4hep: Attempt to access invalid handle of type: PlacedVolume");
}
/// Access the volume's option value
-string Volume::option() const {
+std::string Volume::option() const {
return m_element->GetOption();
}
@@ -1115,9 +1113,9 @@ const Volume& Volume::setMaterial(const Material& mat) const {
m_element->SetMedium(medium);
return *this;
}
- throw runtime_error("dd4hep: Volume: Medium " + string(mat.name()) + " is not registered with geometry manager.");
+ throw std::runtime_error("dd4hep: Volume: Medium " + std::string(mat.name()) + " is not registered with geometry manager.");
}
- throw runtime_error("dd4hep: Volume: Attempt to assign invalid material.");
+ throw std::runtime_error("dd4hep: Volume: Attempt to assign invalid material.");
}
/// Access to the Volume material
@@ -1190,7 +1188,7 @@ const Volume& Volume::setVisAttributes(const VisAttr& attr) const {
}
/// Set Visualization attributes to the volume
-const Volume& Volume::setVisAttributes(const Detector& description, const string& nam) const {
+const Volume& Volume::setVisAttributes(const Detector& description, const std::string& nam) const {
if (!nam.empty()) {
VisAttr attr = description.visAttributes(nam);
setVisAttributes(attr);
@@ -1199,7 +1197,7 @@ const Volume& Volume::setVisAttributes(const Detector& description, const string
}
/// Attach attributes to the volume
-const Volume& Volume::setAttributes(const Detector& description, const string& rg, const string& ls, const string& vis) const {
+const Volume& Volume::setAttributes(const Detector& description, const std::string& rg, const std::string& ls, const std::string& vis) const {
if (!rg.empty())
setRegion(description.region(rg));
if (!ls.empty())
@@ -1241,7 +1239,7 @@ Box Volume::boundingBox() const {
}
/// Set the regional attributes to the volume
-const Volume& Volume::setRegion(const Detector& description, const string& nam) const {
+const Volume& Volume::setRegion(const Detector& description, const std::string& nam) const {
if (!nam.empty()) {
return setRegion(description.region(nam));
}
@@ -1260,7 +1258,7 @@ Region Volume::region() const {
}
/// Set the limits to the volume
-const Volume& Volume::setLimitSet(const Detector& description, const string& nam) const {
+const Volume& Volume::setLimitSet(const Detector& description, const std::string& nam) const {
if (!nam.empty()) {
return setLimitSet(description.limitSet(nam));
}
@@ -1302,7 +1300,7 @@ bool Volume::hasProperties() const {
}
/// Add Volume property (name-value pair)
-void Volume::addProperty(const string& nam, const string& val) const {
+void Volume::addProperty(const std::string& nam, const std::string& val) const {
auto* o = _data(*this);
if ( !o->properties ) {
o->properties = new TList();
@@ -1318,7 +1316,7 @@ void Volume::addProperty(const string& nam, const string& val) const {
}
/// Access property value. Returns default_value if the property is not present
-string Volume::getProperty(const string& nam, const string& default_val) const {
+std::string Volume::getProperty(const std::string& nam, const std::string& default_val) const {
const auto* o = _data(*this);
if ( !o->properties ) {
return default_val;
@@ -1329,12 +1327,12 @@ string Volume::getProperty(const string& nam, const string& default_val) const
}
/// Constructor to be used when creating a new assembly object
-Assembly::Assembly(const string& nam) {
+Assembly::Assembly(const std::string& nam) {
m_element = _createTGeoVolumeAssembly(nam);
}
/// Constructor to be used when creating a new multi-volume object
-VolumeMulti::VolumeMulti(const string& nam, Material mat) {
+VolumeMulti::VolumeMulti(const std::string& nam, Material mat) {
m_element = _createTGeoVolumeMulti(nam, mat.ptr());
}
@@ -1354,11 +1352,11 @@ void VolumeMulti::verifyVolumeMulti() {
}
/// Output mesh vertices to string
-string dd4hep::toStringMesh(PlacedVolume place, int prec) {
+std::string dd4hep::toStringMesh(PlacedVolume place, int prec) {
Volume vol = place->GetVolume();
TGeoMatrix* mat = place->GetMatrix();
Solid sol = vol.solid();
- stringstream os;
+ std::stringstream os;
struct _numbering {
double adjust(double value) const {
if ( std::abs(value) < TGeoShape::Tolerance() )
@@ -1369,7 +1367,7 @@ string dd4hep::toStringMesh(PlacedVolume place, int prec) {
if ( vol->IsA() == TGeoVolumeAssembly::Class() ) {
for(int i=0; i<vol->GetNdaughters(); ++i) {
- os << toStringMesh(vol->GetNode(i), prec) << endl;
+ os << toStringMesh(vol->GetNode(i), prec) << std::endl;
}
return os.str();
}
@@ -1380,36 +1378,36 @@ string dd4hep::toStringMesh(PlacedVolume place, int prec) {
Double_t* points = new Double_t[3*nvert];
sol->SetPoints(points);
- os << setw(16) << left << sol->IsA()->GetName()
- << " " << nvert << " Mesh-points:" << endl;
- os << setw(16) << left << sol->IsA()->GetName() << " " << sol->GetName()
+ os << std::setw(16) << std::left << sol->IsA()->GetName()
+ << " " << nvert << " Mesh-points:" << std::endl;
+ os << std::setw(16) << std::left << sol->IsA()->GetName() << " " << sol->GetName()
<< " N(mesh)=" << sol->GetNmeshVertices()
- << " N(vert)=" << nvert << " N(seg)=" << nsegs << " N(pols)=" << npols << endl;
+ << " N(vert)=" << nvert << " N(seg)=" << nsegs << " N(pols)=" << npols << std::endl;
for(int i=0; i<nvert; ++i) {
Double_t* p = points + 3*i;
Double_t global[3], local[3] = {p[0], p[1], p[2]};
mat->LocalToMaster(local, global);
- os << setw(16) << left << sol->IsA()->GetName() << " " << setw(3) << left << i
- << " Local (" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(local[0])
- << ", " << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(local[1])
- << ", " << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(local[2])
- << ") Global (" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(global[0])
- << ", " << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(global[1])
- << ", " << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(global[2])
- << ")" << endl;
+ os << std::setw(16) << std::left << sol->IsA()->GetName() << " " << std::setw(3) << std::left << i
+ << " Local (" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(local[0])
+ << ", " << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(local[1])
+ << ", " << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(local[2])
+ << ") Global (" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(global[0])
+ << ", " << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(global[1])
+ << ", " << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(global[2])
+ << ")" << std::endl;
}
Box box = sol;
const Double_t* org = box->GetOrigin();
- os << setw(16) << left << sol->IsA()->GetName()
+ os << std::setw(16) << std::left << sol->IsA()->GetName()
<< " Bounding box: "
- << " dx=" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(box->GetDX())
- << " dy=" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(box->GetDY())
- << " dz=" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(box->GetDZ())
- << " Origin: x=" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(org[0])
- << " y=" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(org[1])
- << " z=" << setw(7) << setprecision(prec) << fixed << right << _vertex.adjust(org[2])
- << endl;
+ << " dx=" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(box->GetDX())
+ << " dy=" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(box->GetDY())
+ << " dz=" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(box->GetDZ())
+ << " Origin: x=" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(org[0])
+ << " y=" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(org[1])
+ << " z=" << std::setw(7) << std::setprecision(prec) << std::fixed << std::right << _vertex.adjust(org[2])
+ << std::endl;
/// -------------------- DONE --------------------
delete [] points;
diff --git a/DDCore/src/WaferGridXY.cpp b/DDCore/src/WaferGridXY.cpp
index a555856883b4f41c77134d18051214256c74730e..769cfaa01b7e27021e6d573d224f8b5f115089ab 100644
--- a/DDCore/src/WaferGridXY.cpp
+++ b/DDCore/src/WaferGridXY.cpp
@@ -12,12 +12,9 @@
//==========================================================================
// Framework include files
-#include "DD4hep/WaferGridXY.h"
-#include "DDSegmentation/WaferGridXY.h"
+#include <DD4hep/WaferGridXY.h>
+#include <DDSegmentation/WaferGridXY.h>
-// C/C++ include files
-
-using namespace std;
using namespace dd4hep;
/// determine the position based on the cell ID
@@ -63,12 +60,12 @@ double WaferGridXY::waferOffsetY(int inGroup, int inWafer) const {
}
/// access the field name used for X
-const string& WaferGridXY::fieldNameX() const {
+const std::string& WaferGridXY::fieldNameX() const {
return access()->implementation->fieldNameX();
}
/// access the field name used for Y
-const string& WaferGridXY::fieldNameY() const {
+const std::string& WaferGridXY::fieldNameY() const {
return access()->implementation->fieldNameY();
}
@@ -81,6 +78,6 @@ const string& WaferGridXY::fieldNameY() const {
-# size in x
-# size in y
*/
-vector<double> WaferGridXY::cellDimensions(const CellID& id) const {
+std::vector<double> WaferGridXY::cellDimensions(const CellID& id) const {
return access()->implementation->cellDimensions(id);
}
diff --git a/DDCore/src/World.cpp b/DDCore/src/World.cpp
index c847b9715ae2f0b5f9b4633e3bcf132baca93fb4..d9af1013350f64a503d25673471bfca13f96638e 100644
--- a/DDCore/src/World.cpp
+++ b/DDCore/src/World.cpp
@@ -12,8 +12,8 @@
//==========================================================================
// Framework include files
-#include "DD4hep/World.h"
-#include "DD4hep/detail/DetectorInterna.h"
+#include <DD4hep/World.h>
+#include <DD4hep/detail/DetectorInterna.h>
/// Access the detector descrion tree
dd4hep::Detector& dd4hep::World::detectorDescription() const {
diff --git a/DDCore/src/plugins/CodeGenerator.cpp b/DDCore/src/plugins/CodeGenerator.cpp
index 2143587c8bfb193b89e73d23114f0cd220c524cc..bc120a404604eebda944d04d1781820d23c6543a 100644
--- a/DDCore/src/plugins/CodeGenerator.cpp
+++ b/DDCore/src/plugins/CodeGenerator.cpp
@@ -10,17 +10,17 @@
// Author : M.Frank
//
//==========================================================================
-#include "DD4hep/Factories.h"
-#include "DD4hep/Shapes.h"
-#include "DD4hep/Volumes.h"
-#include "DD4hep/Detector.h"
-#include "DD4hep/DetElement.h"
-#include "DD4hep/MatrixHelpers.h"
-#include "DD4hep/DD4hepUnits.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Path.h"
-#include "DD4hep/detail/ObjectsInterna.h"
-#include "DD4hep/detail/DetectorInterna.h"
+#include <DD4hep/Factories.h>
+#include <DD4hep/Shapes.h>
+#include <DD4hep/Volumes.h>
+#include <DD4hep/Detector.h>
+#include <DD4hep/DetElement.h>
+#include <DD4hep/MatrixHelpers.h>
+#include <DD4hep/DD4hepUnits.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Path.h>
+#include <DD4hep/detail/ObjectsInterna.h>
+#include <DD4hep/detail/DetectorInterna.h>
// C/C++ include files
#include <stdexcept>
@@ -29,15 +29,15 @@
#include <fstream>
// ROOT includes
-#include "TClass.h"
-#include "TGeoMatrix.h"
-#include "TGeoBoolNode.h"
-#include "TGeoCompositeShape.h"
+#include <TClass.h>
+#include <TGeoMatrix.h>
+#include <TGeoBoolNode.h>
+#include <TGeoCompositeShape.h>
-using namespace std;
using namespace dd4hep;
namespace {
+
std::string prefix = "\t";
std::string sep(",");
@@ -55,18 +55,18 @@ namespace {
Detector& detector;
Actor(Detector& d) : detector(d) {}
~Actor() = default;
- ostream& handleHeader (ostream& log);
- ostream& handleTrailer (ostream& log);
- ostream& handleSolid (ostream& log, const TGeoShape* sh);
- ostream& handleMatrix (ostream& log, TGeoMatrix* mat);
- ostream& handleMaterial (ostream& log, TGeoMedium* mat);
- ostream& handlePlacement(ostream& log, TGeoNode* parent, TGeoNode* node);
- ostream& handleStructure(ostream& log, DetElement parent, DetElement de);
+ std::ostream& handleHeader (std::ostream& log);
+ std::ostream& handleTrailer (std::ostream& log);
+ std::ostream& handleSolid (std::ostream& log, const TGeoShape* sh);
+ std::ostream& handleMatrix (std::ostream& log, TGeoMatrix* mat);
+ std::ostream& handleMaterial (std::ostream& log, TGeoMedium* mat);
+ std::ostream& handlePlacement(std::ostream& log, TGeoNode* parent, TGeoNode* node);
+ std::ostream& handleStructure(std::ostream& log, DetElement parent, DetElement de);
};
typedef void* pvoid_t;
- ostream& newline(ostream& log) {
- return log << endl << prefix;
+ std::ostream& newline(std::ostream& log) {
+ return log << std::endl << prefix;
}
template <typename T> const void* pointer(const Handle<T>& h) {
return h.ptr();
@@ -74,59 +74,59 @@ namespace {
template <typename T> const void* pointer(const T* h) {
return h;
}
- template <typename T> inline string obj_name(const string& pref, const T* ptr) {
- stringstream name;
+ template <typename T> inline std::string obj_name(const std::string& pref, const T* ptr) {
+ std::stringstream name;
name << pref << "_" << pointer(ptr);
return name.str();
}
- ostream& Actor::handleHeader (ostream& log) {
- log << "#include \"TClass.h\"" << endl
- << "#include \"TGeoNode.h\"" << endl
- << "#include \"TGeoExtension.h\"" << endl
- << "#include \"TGeoShapeAssembly.h\"" << endl
- << "#include \"TGeoMedium.h\"" << endl
- << "#include \"TGeoVolume.h\"" << endl
- << "#include \"TGeoShape.h\"" << endl
- << "#include \"TGeoPhysicalNode.h\"" << endl
- << "#include \"TGeoCone.h\"" << endl
- << "#include \"TGeoParaboloid.h\"" << endl
- << "#include \"TGeoPgon.h\"" << endl
- << "#include \"TGeoPcon.h\"" << endl
- << "#include \"TGeoSphere.h\"" << endl
- << "#include \"TGeoArb8.h\"" << endl
- << "#include \"TGeoTrd1.h\"" << endl
- << "#include \"TGeoTrd2.h\"" << endl
- << "#include \"TGeoTube.h\"" << endl
- << "#include \"TGeoEltu.h\"" << endl
- << "#include \"TGeoXtru.h\"" << endl
- << "#include \"TGeoHype.h\"" << endl
- << "#include \"TGeoTorus.h\"" << endl
- << "#include \"TGeoHalfSpace.h\"" << endl
- << "#include \"TGeoCompositeShape.h\"" << endl
- << "#include \"TGeoShapeAssembly.h\"" << endl
- << "#include \"TGeoMatrix.h\"" << endl
- << "#include \"TGeoBoolNode.h\"" << endl
- << "#include \"TGeoCompositeShape.h\"" << endl
- << "#include \"TGeoManager.h\"" << endl << endl
- << "#include \"DD4hep/Factories.h\"" << endl
- << "#include \"DD4hep/Shapes.h\"" << endl
- << "#include \"DD4hep/Volumes.h\"" << endl
- << "#include \"DD4hep/Detector.h\"" << endl
- << "#include \"DD4hep/DetElement.h\"" << endl
- << "#include \"DD4hep/MatrixHelpers.h\"" << endl
- << "#include \"DD4hep/DD4hepUnits.h\"" << endl
- << "#include \"DD4hep/Printout.h\"" << endl
- << "#include \"DD4hep/Path.h\"" << endl
- << "#include \"DD4hep/detail/ObjectsInterna.h\"" << endl
- << "#include \"DD4hep/detail/DetectorInterna.h\"" << endl
- << "#include <vector>" << endl
- << "#include <map>" << endl
- << "#include <set>" << endl << endl << endl;
- log << "using namespace std;" << endl;
- log << "using namespace dd4hep;" << endl;
- log << "extern PlacedVolume _addNode(TGeoVolume* par, TGeoVolume* daughter, int id, TGeoMatrix* transform);" << endl;
+ std::ostream& Actor::handleHeader (std::ostream& log) {
+ log << "#include \"TClass.h\"" << std::endl
+ << "#include \"TGeoNode.h\"" << std::endl
+ << "#include \"TGeoExtension.h\"" << std::endl
+ << "#include \"TGeoShapeAssembly.h\"" << std::endl
+ << "#include \"TGeoMedium.h\"" << std::endl
+ << "#include \"TGeoVolume.h\"" << std::endl
+ << "#include \"TGeoShape.h\"" << std::endl
+ << "#include \"TGeoPhysicalNode.h\"" << std::endl
+ << "#include \"TGeoCone.h\"" << std::endl
+ << "#include \"TGeoParaboloid.h\"" << std::endl
+ << "#include \"TGeoPgon.h\"" << std::endl
+ << "#include \"TGeoPcon.h\"" << std::endl
+ << "#include \"TGeoSphere.h\"" << std::endl
+ << "#include \"TGeoArb8.h\"" << std::endl
+ << "#include \"TGeoTrd1.h\"" << std::endl
+ << "#include \"TGeoTrd2.h\"" << std::endl
+ << "#include \"TGeoTube.h\"" << std::endl
+ << "#include \"TGeoEltu.h\"" << std::endl
+ << "#include \"TGeoXtru.h\"" << std::endl
+ << "#include \"TGeoHype.h\"" << std::endl
+ << "#include \"TGeoTorus.h\"" << std::endl
+ << "#include \"TGeoHalfSpace.h\"" << std::endl
+ << "#include \"TGeoCompositeShape.h\"" << std::endl
+ << "#include \"TGeoShapeAssembly.h\"" << std::endl
+ << "#include \"TGeoMatrix.h\"" << std::endl
+ << "#include \"TGeoBoolNode.h\"" << std::endl
+ << "#include \"TGeoCompositeShape.h\"" << std::endl
+ << "#include \"TGeoManager.h\"" << std::endl << std::endl
+ << "#include \"DD4hep/Factories.h\"" << std::endl
+ << "#include \"DD4hep/Shapes.h\"" << std::endl
+ << "#include \"DD4hep/Volumes.h\"" << std::endl
+ << "#include \"DD4hep/Detector.h\"" << std::endl
+ << "#include \"DD4hep/DetElement.h\"" << std::endl
+ << "#include \"DD4hep/MatrixHelpers.h\"" << std::endl
+ << "#include \"DD4hep/DD4hepUnits.h\"" << std::endl
+ << "#include \"DD4hep/Printout.h\"" << std::endl
+ << "#include \"DD4hep/Path.h\"" << std::endl
+ << "#include \"DD4hep/detail/ObjectsInterna.h\"" << std::endl
+ << "#include \"DD4hep/detail/DetectorInterna.h\"" << std::endl
+ << "#include <vector>" << std::endl
+ << "#include <map>" << std::endl
+ << "#include <set>" << std::endl << std::endl << std::endl;
+ log << "using namespace std;" << std::endl;
+ log << "using namespace dd4hep;" << std::endl;
+ log << "extern PlacedVolume _addNode(TGeoVolume* par, TGeoVolume* daughter, int id, TGeoMatrix* transform);" << std::endl;
log << "namespace {" << newline
<< "\t struct CodeGeo {" << newline
@@ -143,8 +143,8 @@ namespace {
<< "\t\t void add_vis(Detector& d, VisAttr& v) {" << newline
<< "\t\t try { d.add(v); } catch(...) {}" << newline
<< "\t\t }" << newline
- << "\t };" << endl
- << "}" << endl << endl << endl;
+ << "\t };" << std::endl
+ << "}" << std::endl << std::endl << std::endl;
log << "TGeoVolume* CodeGeo::load_geometry() {" << newline;
const auto& constants = detector.constants();
@@ -177,8 +177,8 @@ namespace {
for(const auto& o : limits) {
LimitSet ls = o.second;
log << "{ LimitSet ls(string(\"" << ls.name() << "\")); " << newline;
- const set<Limit>& lims = ls.limits();
- const set<Limit>& cuts = ls.cuts();
+ const std::set<Limit>& lims = ls.limits();
+ const std::set<Limit>& cuts = ls.cuts();
for(const auto& l : lims) {
log << " { Limit l; l.particles = \"" << l.particles << "\";"
<< " l.name = \"" << l.name << "\";"
@@ -257,7 +257,7 @@ namespace {
return log;
}
- ostream& Actor::handleTrailer (ostream& log) {
+ std::ostream& Actor::handleTrailer (std::ostream& log) {
log << "static long generate_dd4hep(Detector& detector, int, char**) {" << newline
<< "CodeGeo gen(detector);" << newline
<< "TGeoVolume* vol_top = gen.load_geometry();" << newline
@@ -271,19 +271,19 @@ namespace {
<< "gen.load_structure();" << newline;
}
log << "return 1;"
- << endl << "}" << endl << endl
+ << std::endl << "}" << std::endl << std::endl
<< "DECLARE_APPLY(DD4hep_Run_" << function << ", generate_dd4hep)"
- << endl;
+ << std::endl;
return log;
}
- ostream& Actor::handleStructure(ostream& log, DetElement parent, DetElement de) {
+ std::ostream& Actor::handleStructure(std::ostream& log, DetElement parent, DetElement de) {
if ( de.isValid() && detelements.find(de) == detelements.end() ) {
- string name = obj_name("de", de.ptr());
+ std::string name = obj_name("de", de.ptr());
detelements.emplace(de,name);
if ( !parent.isValid() ) {
- cout << "No parent: " << de.path() << " " << pointer(de) << " " << pointer(detector.world()) << endl;
- log << endl
+ std::cout << "No parent: " << de.path() << " " << pointer(de) << " " << pointer(detector.world()) << std::endl;
+ log << std::endl
<< "DetElement CodeGeo::load_structure() {" << newline;
}
else {
@@ -297,7 +297,7 @@ namespace {
log << "\t de.setPlacement(placements[" << pointer(de.placement()) << "]);" << newline;
}
else {
- cout << "Placement od DetElement " << de.path() << " Is not valid! [Ignored]" << endl;
+ std::cout << "Placement od DetElement " << de.path() << " Is not valid! [Ignored]" << std::endl;
}
log << "\t structure[" << pointer(de) << "] = de; " << newline
<< "}" << newline;
@@ -306,20 +306,20 @@ namespace {
handleStructure(log, de, d.second);
}
if ( !parent.isValid() ) {
- log << "return structure[" << pointer(de) << "];" << endl
- << "}" << endl << endl;
+ log << "return structure[" << pointer(de) << "];" << std::endl
+ << "}" << std::endl << std::endl;
}
}
return log;
}
- ostream& Actor::handlePlacement(ostream& log, TGeoNode* parent, TGeoNode* node) {
+ std::ostream& Actor::handlePlacement(std::ostream& log, TGeoNode* parent, TGeoNode* node) {
if ( node && placements.find(node) == placements.end() ) {
PlacedVolume pv(node);
TGeoVolume* vol = node->GetVolume();
TGeoMatrix* mat = node->GetMatrix();
- string name = obj_name("vol", vol);
+ std::string name = obj_name("vol", vol);
placements.emplace(node,name);
handleMatrix(log, mat);
@@ -374,16 +374,16 @@ namespace {
handlePlacement(log, node, daughter);
}
if ( !parent ) {
- log << "return volumes[" << pointer(vol) << "];" << endl
- << "}" << endl << endl << endl;
+ log << "return volumes[" << pointer(vol) << "];" << std::endl
+ << "}" << std::endl << std::endl << std::endl;
}
}
return log;
}
- ostream& Actor::handleMaterial(ostream& log, TGeoMedium* medium) {
+ std::ostream& Actor::handleMaterial(std::ostream& log, TGeoMedium* medium) {
if ( medium && materials.find(medium) == materials.end() ) {
- string name = obj_name("material",medium);
+ std::string name = obj_name("material",medium);
materials.emplace(medium,name);
TGeoMaterial* material = medium->GetMaterial();
log << "{" << newline
@@ -404,9 +404,9 @@ namespace {
return log;
}
- ostream& Actor::handleMatrix(ostream& log, TGeoMatrix* mat) {
+ std::ostream& Actor::handleMatrix(std::ostream& log, TGeoMatrix* mat) {
if ( mat && matrices.find(mat) == matrices.end() ) {
- string name = obj_name("matrix",mat);
+ std::string name = obj_name("matrix",mat);
log << "{" << newline
<< "\t TGeoHMatrix* mat = new TGeoHMatrix(\"" << mat->GetName() << "\");" << newline
<< "\t matrices[" << pointer(mat) << "] = mat;" << newline;
@@ -445,8 +445,8 @@ namespace {
}
/// Pretty print of solid attributes
- ostream& Actor::handleSolid(ostream& log, const TGeoShape* shape) {
- string name = obj_name("solid", shape);
+ std::ostream& Actor::handleSolid(std::ostream& log, const TGeoShape* shape) {
+ std::string name = obj_name("solid", shape);
if ( shapes.find(shape) != shapes.end() ) {
return log;
@@ -623,7 +623,7 @@ namespace {
else if (cl == TGeoXtru::Class()) {
Solid sol(shape);
const TGeoXtru* sh = (const TGeoXtru*) shape;
- vector<double> pars = sol.dimensions();
+ std::vector<double> pars = sol.dimensions();
log << "double param[] = {" << newline;
for( size_t i=0; i < pars.size(); ++i )
log << pars[i] << ((i+1<pars.size()) ? ',' : ' ');
@@ -662,7 +662,7 @@ namespace {
}
static long generate_cxx(Detector& description, int argc, char** argv) {
- string output;
+ std::string output;
Actor actor(description);
for(int i=0; i<argc; ++i) {
@@ -679,19 +679,19 @@ static long generate_cxx(Detector& description, int argc, char** argv) {
else if ( c == 's' )
actor.dump_structure = true;
else {
- cout <<
+ std::cout <<
"Usage: -plugin DD4hep_CxxRootGenerator -arg [-arg] \n"
" -output <string> Set output file for generated code. Default: stdout \n"
" -help Show thi help message \n"
- "\tArguments given: " << arguments(argc,argv) << endl << flush;
+ "\tArguments given: " << arguments(argc,argv) << std::endl << std::flush;
::exit(EINVAL);
}
}
- unique_ptr<ofstream> out;
- ostream* os = &cout;
+ std::unique_ptr<std::ofstream> out;
+ std::ostream* os = &std::cout;
if ( !output.empty() ) {
Path path(output);
- out.reset(new ofstream(path.c_str()));
+ out.reset(new std::ofstream(path.c_str()));
if ( !out->good() ) {
out.reset();
except("CxxRootGenerator",
@@ -700,7 +700,7 @@ static long generate_cxx(Detector& description, int argc, char** argv) {
}
os = out.get();
actor.function = path.filename();
- if ( actor.function.rfind('.') != string::npos )
+ if ( actor.function.rfind('.') != std::string::npos )
actor.function = actor.function.substr(0, actor.function.rfind('.'));
printout(INFO, "CxxRootGenerator",
"++ Dump generated code to output files: %s [function: %s()]",
diff --git a/DDCore/src/plugins/DetElementConfig.cpp b/DDCore/src/plugins/DetElementConfig.cpp
index 5b1d50fc6600c22cc255dd08052387fac2d49117..9358c20b32dd2659d11c119feaf3d77e49d528e2 100644
--- a/DDCore/src/plugins/DetElementConfig.cpp
+++ b/DDCore/src/plugins/DetElementConfig.cpp
@@ -42,7 +42,7 @@ namespace {
std::size_t count = 0;
bool propagate = det == detector.world() ? false: x_det.attr<bool>(_U(propagate), false);
if ( xml_dim_t x_vol = x_det.child(_U(volume), false) ) {
- count += xml::configVolume(detector, x_vol, det.volume(), propagate, false);
+ count += xml::configVolume(detector, x_vol, det.volume(), propagate, false);
}
PrintLevel lvl = x_det.attr<xml::Attribute>(_U(debug), nullptr) ? ALWAYS : DEBUG;
printout(lvl, "DetElementConfig", "++ Applied %ld settings to %s", count, path.c_str());
@@ -69,6 +69,7 @@ namespace {
}
} // End namespace dd4hep
+
/// Instantiate factory
DECLARE_XML_PLUGIN(DD4hep_DetElementConfig, configure_detelement)
/// Instantiate factory
diff --git a/DDCore/src/plugins/DetElementVolumeIDs.cpp b/DDCore/src/plugins/DetElementVolumeIDs.cpp
index 644c2e5c9ec60096d5dc90414502ef0de2cc25ed..a237f9bc0cb46a394274ce31324740ec305de2ba 100644
--- a/DDCore/src/plugins/DetElementVolumeIDs.cpp
+++ b/DDCore/src/plugins/DetElementVolumeIDs.cpp
@@ -54,11 +54,11 @@ namespace dd4hep {
/// Scan a single physical volume and look for sensitive elements below
std::size_t scanPhysicalVolume(DetElement& parent,
- DetElement e,
- PlacedVolume pv,
- Encoding parent_encoding,
- SensitiveDetector& sd,
- PlacementPath& chain);
+ DetElement e,
+ PlacedVolume pv,
+ Encoding parent_encoding,
+ SensitiveDetector& sd,
+ PlacementPath& chain);
public:
/// Default constructor
DetElementVolumeIDs(const Detector& description);
@@ -104,29 +104,29 @@ namespace {
std::string detector = "/world";
for(int i = 0; i < argc && argv[i]; ++i) {
if ( 0 == ::strncmp("-detector",argv[i],4) )
- detector = argv[++i];
+ detector = argv[++i];
else {
- std::cout <<
- "Usage: -plugin DD4hep_DetElementVolumeIDs -arg [-arg] \n\n"
- " -detector <string> Top level DetElement path. Default: '/world' \n"
- " -help Print this help output \n"
- " Arguments given: " << arguments(argc,argv) << std::endl << std::flush;
- ::exit(EINVAL);
+ std::cout <<
+ "Usage: -plugin DD4hep_DetElementVolumeIDs -arg [-arg] \n\n"
+ " -detector <string> Top level DetElement path. Default: '/world' \n"
+ " -help Print this help output \n"
+ " Arguments given: " << arguments(argc,argv) << std::endl << std::flush;
+ ::exit(EINVAL);
}
}
DetElement element = description.world();
if ( detector != "/world" ) {
element = detail::tools::findElement(description,detector);
if ( !element.isValid() ) {
- except("DD4hep_DetElementVolumeIDs","+++ Invalid DetElement path: %s",detector.c_str());
+ except("DD4hep_DetElementVolumeIDs","+++ Invalid DetElement path: %s",detector.c_str());
}
}
DetElementVolumeIDs mgr(description);
auto count = mgr.populate(element);
if ( count == 0 ) {
except("DD4hep_DetElementVolumeIDs",
- "+++ NO volume identifiers assigned to DetElement %s. %s",
- "Something went wrong!",detector.c_str());
+ "+++ NO volume identifiers assigned to DetElement %s. %s",
+ "Something went wrong!",detector.c_str());
}
return count > 0 ? 1 : 0;
}
@@ -169,22 +169,22 @@ std::size_t DetElementVolumeIDs::populate(DetElement det) {
entries.clear();
if ( !pv.isValid() ) {
except("DetElementVolumeIDs",
- "+++ Top level DetElement %s has no valid placement. %s",
- "[Something awfully wrong]", det.path().c_str());
+ "+++ Top level DetElement %s has no valid placement. %s",
+ "[Something awfully wrong]", det.path().c_str());
}
if ( det == m_detDesc.world() ) {
for (const auto& i : det.children() ) {
DetElement de = i.second;
pv = de.placement();
if (pv.isValid()) {
- PlacementPath chain;
- Encoding coding { 0, 0 };
- SensitiveDetector sd (0);
- count += scanPhysicalVolume(de, de, pv, coding, sd, chain);
- continue;
+ PlacementPath chain;
+ Encoding coding { 0, 0 };
+ SensitiveDetector sd (0);
+ count += scanPhysicalVolume(de, de, pv, coding, sd, chain);
+ continue;
}
printout(WARNING, "DetElementVolumeIDs", "++ Detector element %s of type %s has no placement.",
- de.name(), de.type().c_str());
+ de.name(), de.type().c_str());
}
printout(INFO, "DetElementVolumeIDs", "++ Assigned %ld volume identifiers to DetElements.", count);
return count;
@@ -192,8 +192,8 @@ std::size_t DetElementVolumeIDs::populate(DetElement det) {
SensitiveDetector sd = m_detDesc.sensitiveDetector(det.name());
if ( !pv.volIDs().empty() && !sd.isValid() ) {
except("DetElementVolumeIDs",
- "+++ No sensitive detector available for top level DetElement %s.",
- det.path().c_str());
+ "+++ No sensitive detector available for top level DetElement %s.",
+ det.path().c_str());
}
PlacementPath chain;
count += scanPhysicalVolume(det, det, pv, encoding, sd, chain);
@@ -204,11 +204,11 @@ std::size_t DetElementVolumeIDs::populate(DetElement det) {
/// Scan a single physical volume and look for sensitive elements below
std::size_t
DetElementVolumeIDs::scanPhysicalVolume(DetElement& parent,
- DetElement e,
- PlacedVolume pv,
- Encoding parent_encoding,
- SensitiveDetector& sd,
- PlacementPath& chain)
+ DetElement e,
+ PlacedVolume pv,
+ Encoding parent_encoding,
+ SensitiveDetector& sd,
+ PlacementPath& chain)
{
TGeoNode* node = pv.ptr();
std::size_t count = 0;
@@ -226,81 +226,81 @@ DetElementVolumeIDs::scanPhysicalVolume(DetElement& parent,
}
else if ( !sd.isValid() ) {
if ( is_sensitive )
- sd = vol.sensitiveDetector();
+ sd = vol.sensitiveDetector();
else if ( (parent->flag&DetElement::Object::HAVE_SENSITIVE_DETECTOR) )
- sd = m_detDesc.sensitiveDetector(parent.name());
+ sd = m_detDesc.sensitiveDetector(parent.name());
else if ( (e->flag&DetElement::Object::HAVE_SENSITIVE_DETECTOR) )
- sd = m_detDesc.sensitiveDetector(e.name());
+ sd = m_detDesc.sensitiveDetector(e.name());
}
chain.emplace_back(node);
if ( sd.isValid() && !pv_ids.empty() ) {
Readout ro = sd.readout();
if ( ro.isValid() ) {
- vol_encoding = update_encoding(ro.idSpec(), pv_ids, parent_encoding);
- have_encoding = true;
+ vol_encoding = update_encoding(ro.idSpec(), pv_ids, parent_encoding);
+ have_encoding = true;
}
else {
- printout(WARNING, "DetElementVolumeIDs",
- "%s: Strange constellation volume %s is sensitive, but has no readout! sd:%p",
- parent.name(), pv.volume().name(), sd.ptr());
+ printout(WARNING, "DetElementVolumeIDs",
+ "%s: Strange constellation volume %s is sensitive, but has no readout! sd:%p",
+ parent.name(), pv.volume().name(), sd.ptr());
}
}
for (int idau = 0, ndau = node->GetNdaughters(); idau < ndau; ++idau) {
TGeoNode* daughter = node->GetDaughter(idau);
PlacedVolume place_dau(daughter);
if ( place_dau.data() ) {
- DetElement de_dau;
- /// Check if this particular volume is the placement of one of the
- /// children of this detector element. If the daughter placement is also
- /// a detector child, then we must reset the node chain.
- for( const auto& de : e.children() ) {
- if ( de.second.placement().ptr() == daughter ) {
- de_dau = de.second;
- break;
- }
- }
- if ( de_dau.isValid() ) {
- PlacementPath dau_chain;
- count += scanPhysicalVolume(parent, de_dau, place_dau, vol_encoding, sd, dau_chain);
- }
- else { // there may be several layers of volumes between mother-child of DE
- count += scanPhysicalVolume(parent, e, place_dau, vol_encoding, sd, chain);
- }
+ DetElement de_dau;
+ /// Check if this particular volume is the placement of one of the
+ /// children of this detector element. If the daughter placement is also
+ /// a detector child, then we must reset the node chain.
+ for( const auto& de : e.children() ) {
+ if ( de.second.placement().ptr() == daughter ) {
+ de_dau = de.second;
+ break;
+ }
+ }
+ if ( de_dau.isValid() ) {
+ PlacementPath dau_chain;
+ count += scanPhysicalVolume(parent, de_dau, place_dau, vol_encoding, sd, dau_chain);
+ }
+ else { // there may be several layers of volumes between mother-child of DE
+ count += scanPhysicalVolume(parent, e, place_dau, vol_encoding, sd, chain);
+ }
}
else {
- except("DetElementVolumeIDs",
- "Invalid not instrumented placement: %s %s", daughter->GetName(),
- " [Internal error -- bad detector constructor]");
+ except("DetElementVolumeIDs",
+ "Invalid not instrumented placement: %s %s", daughter->GetName(),
+ " [Internal error -- bad detector constructor]");
}
/// For compounds the upper level sensitive detector does not exist,
/// because there are multiple at lower layers
if ( compound ) {
- sd = SensitiveDetector(0);
+ sd = SensitiveDetector(0);
}
}
if ( sd.isValid() ) {
if ( !have_encoding && !compound ) {
- printout(ERROR, "DetElementVolumeIDs",
- "Element %s: Missing SD encoding. Volume manager won't work!",
- e.path().c_str());
+ printout(ERROR, "DetElementVolumeIDs",
+ "Element %s: Missing SD encoding. Volume manager won't work!",
+ e.path().c_str());
}
if ( is_sensitive || count > 0 ) {
- // Either this layer is sensitive of a layer below.
- if ( node == e.placement().ptr() ) {
- // These here are placement nodes, which at the same time are DetElement placements
- // 1) We recuperate volumes from lower levels by reusing the subdetector
- // This only works if there is exactly one sensitive detector per subdetector!
- // 2) DetElements in the upper hierarchy of the sensitive also get a volume id,
- // and the volume is registered. (to be discussed)
- //
- e.object<DetElement::Object>().volumeID = vol_encoding.identifier;
- }
- // Collect all sensitive volumes, which belong to the next DetElement
- if ( entries.find(e) == entries.end()) {
- entries[e].emplace_back(vol_encoding);
- ++numberOfNodes;
- }
- ++count;
+ // Either this layer is sensitive of a layer below.
+ if ( node == e.placement().ptr() ) {
+ // These here are placement nodes, which at the same time are DetElement placements
+ // 1) We recuperate volumes from lower levels by reusing the subdetector
+ // This only works if there is exactly one sensitive detector per subdetector!
+ // 2) DetElements in the upper hierarchy of the sensitive also get a volume id,
+ // and the volume is registered. (to be discussed)
+ //
+ e.object<DetElement::Object>().volumeID = vol_encoding.identifier;
+ }
+ // Collect all sensitive volumes, which belong to the next DetElement
+ if ( entries.find(e) == entries.end()) {
+ entries[e].emplace_back(vol_encoding);
+ ++numberOfNodes;
+ }
+ ++count;
}
}
chain.pop_back();
diff --git a/DDCore/src/plugins/DetectorCheck.cpp b/DDCore/src/plugins/DetectorCheck.cpp
index 2add900955f4eb47a87d874151cd1d51c1a5e46b..53b251e68e1f7da2d52063c0b76f535cb3e8527b 100644
--- a/DDCore/src/plugins/DetectorCheck.cpp
+++ b/DDCore/src/plugins/DetectorCheck.cpp
@@ -12,24 +12,22 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Detector.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Factories.h"
-#include "DD4hep/IDDescriptor.h"
-#include "DD4hep/VolumeManager.h"
-#include "DD4hep/DetectorTools.h"
-#include "DD4hep/MatrixHelpers.h"
-#include "DD4hep/AlignmentsNominalMap.h"
-#include "DD4hep/detail/VolumeManagerInterna.h"
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Factories.h>
+#include <DD4hep/IDDescriptor.h>
+#include <DD4hep/VolumeManager.h>
+#include <DD4hep/DetectorTools.h>
+#include <DD4hep/MatrixHelpers.h>
+#include <DD4hep/AlignmentsNominalMap.h>
+#include <DD4hep/detail/VolumeManagerInterna.h>
// C/C++ include files
#include <stdexcept>
#include <algorithm>
#include <cstdlib>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
/// Namespace for the AIDA detector description toolkit
namespace dd4hep { namespace detail { namespace tools {
@@ -65,8 +63,8 @@ namespace {
/// Helper to scan volume ids
struct FND {
- const string& test;
- FND(const string& c) : test(c) {}
+ const std::string& test;
+ FND(const std::string& c) : test(c) {}
bool operator()(const VolIDs::value_type& c) const { return c.first == test; }
};
struct counters {
@@ -74,9 +72,9 @@ namespace {
size_t errors { 0 };
void reset() { elements = errors = 0; }
counters& operator+=(const counters& c) {
- elements += c.elements;
- errors += c.errors;
- return *this;
+ elements += c.elements;
+ errors += c.errors;
+ return *this;
}
};
@@ -173,10 +171,10 @@ void DetectorCheck::execute(DetElement sdet, size_t depth) {
else {
m_current_sensitive = description.sensitiveDetector(m_det.name());
if ( !m_current_sensitive.isValid() ) {
- printout(ERROR, m_name,
- "The sensitive detector of subdetector %s "
- "is not known to the geometry.", m_det.name());
- return;
+ printout(ERROR, m_name,
+ "The sensitive detector of subdetector %s "
+ "is not known to the geometry.", m_det.name());
+ return;
}
m_current_iddesc = m_current_sensitive.readout().idSpec();
}
@@ -232,31 +230,31 @@ void DetectorCheck::execute(DetElement sdet, size_t depth) {
if ( check_structure ) {
printout(count_struct.errors > 0 ? ERROR : ALWAYS,
- m_name, "+++ %s: Checked %10ld structure elements. Num.Errors:%6ld (structure test)",
- tag_fail(count_struct.errors), count_struct.elements, count_struct.errors);
+ m_name, "+++ %s: Checked %10ld structure elements. Num.Errors:%6ld (structure test)",
+ tag_fail(count_struct.errors), count_struct.elements, count_struct.errors);
}
if ( check_geometry ) {
if ( check_sensitive ) {
printout(count_geo_sens.errors > 0 ? ERROR : ALWAYS,
- m_name, "+++ %s: Checked %10ld sensitive elements. Num.Errors:%6ld (geometry test)",
- tag_fail(count_geo_sens.errors), count_geo_sens.elements, count_geo_sens.errors);
+ m_name, "+++ %s: Checked %10ld sensitive elements. Num.Errors:%6ld (geometry test)",
+ tag_fail(count_geo_sens.errors), count_geo_sens.elements, count_geo_sens.errors);
}
printout(count_geo.errors > 0 ? ERROR : ALWAYS,
- m_name, "+++ %s: Checked %10ld placements. Num.Errors:%6ld (geometry test)",
- tag_fail(count_geo.errors), count_geo.elements, count_geo.errors);
+ m_name, "+++ %s: Checked %10ld placements. Num.Errors:%6ld (geometry test)",
+ tag_fail(count_geo.errors), count_geo.elements, count_geo.errors);
}
if ( check_volmgr ) {
if ( check_sensitive ) {
printout(count_volmgr_sens.errors > 0 ? ERROR : ALWAYS,
- m_name, "+++ %s: Checked %10ld sensitive elements. Num.Errors:%6ld (phys.VolID test)",
- tag_fail(count_volmgr_sens.errors), count_volmgr_sens.elements, count_volmgr_sens.errors);
+ m_name, "+++ %s: Checked %10ld sensitive elements. Num.Errors:%6ld (phys.VolID test)",
+ tag_fail(count_volmgr_sens.errors), count_volmgr_sens.elements, count_volmgr_sens.errors);
}
printout(count_volmgr_place.errors > 0 ? ERROR : ALWAYS,
- m_name, "+++ %s: Checked %10ld sensitive placements. Num.Errors:%6ld (phys.VolID test)",
- tag_fail(count_volmgr_place.errors), count_volmgr_sens.elements, count_volmgr_place.errors);
+ m_name, "+++ %s: Checked %10ld sensitive placements. Num.Errors:%6ld (phys.VolID test)",
+ tag_fail(count_volmgr_place.errors), count_volmgr_sens.elements, count_volmgr_place.errors);
}
printout(ALWAYS, m_name, "+++ %s: Checked a total of %11ld elements. Num.Errors:%6ld (Some elements checked twice)",
- tag_fail(total.errors), total.elements, total.errors);
+ tag_fail(total.errors), total.elements, total.errors);
}
/// Check DetElement integrity
@@ -276,7 +274,7 @@ bool DetectorCheck::checkDetElement(const std::string& path, DetElement detector
}
if ( detector.path() != path ) {
printout(ERROR, m_name, "Invalid DetElement [path mismatch]: %s <> %s",
- de_path, path.c_str());
+ de_path, path.c_str());
++m_struct_counters.errors;
}
if ( !detector.parent().isValid() && detector.world() != detector ) {
@@ -303,7 +301,7 @@ bool DetectorCheck::checkDetElement(const std::string& path, DetElement detector
if ( count > 1 ) {
DetElement par = detector.parent();
printout(ERROR, m_name, "DetElement %s parent: %s is placed %ld times! Only single placement allowed.",
- de_path, par.isValid() ? par.path().c_str() : "", m_structure_elements[detector]);
+ de_path, par.isValid() ? par.path().c_str() : "", m_structure_elements[detector]);
++m_struct_counters.errors;
}
Alignment ideal = detector.nominal();
@@ -322,9 +320,9 @@ bool DetectorCheck::checkDetElement(const std::string& path, DetElement detector
}
}
printout(nerrs != m_struct_counters.errors ? ERROR : INFO, m_name,
- "DetElement %s [%s] parent: %s placement: %s [%s] volume: %s",
- path.c_str(), yes_no(det_valid), yes_no(parent_valid), yes_no(det_place_valid),
- yes_no(place_valid), yes_no(vol_valid));
+ "DetElement %s [%s] parent: %s placement: %s [%s] volume: %s",
+ path.c_str(), yes_no(det_valid), yes_no(parent_valid), yes_no(det_place_valid),
+ yes_no(place_valid), yes_no(vol_valid));
return nerrs == m_struct_counters.errors;
}
@@ -350,7 +348,7 @@ bool DetectorCheck::checkDetElementTree(const std::string& path, DetElement dete
if ( de.parent().isValid() && de.parent() != detector ) {
printout(ERROR, m_name, "Invalid DetElement [Parent mismatch]: %s", de.path().c_str());
printout(ERROR, m_name, " apparent parent: %s structural parent: %s",
- de.parent().path().c_str(), detector.path().c_str());
+ de.parent().path().c_str(), detector.path().c_str());
++m_struct_counters.errors;
}
/// Invalid daughter elements will be detectoed in there:
@@ -419,8 +417,8 @@ void DetectorCheck::checkVolumeTree(DetElement detector, PlacedVolume pv) {
/// Check if there is a new parent at the next level:
for ( const auto& c : detector.children() ) {
if ( c.second.placement() == place ) {
- de = c.second;
- break;
+ de = c.second;
+ break;
}
}
checkVolumeTree(de, place);
@@ -433,7 +431,7 @@ void DetectorCheck::checkVolumeTree(DetElement detector, PlacedVolume pv) {
/// Check volume integrity
void DetectorCheck::checkManagerSingleVolume(DetElement detector, PlacedVolume pv, const VolIDs& child_ids, const Chain& chain) {
- stringstream err, log;
+ std::stringstream err, log;
VolumeID det_vol_id = detector.volumeID();
VolumeID vid = det_vol_id;
DetElement top_sdet, det_elem;
@@ -466,7 +464,7 @@ void DetectorCheck::checkManagerSingleVolume(DetElement detector, PlacedVolume p
++m_place_counters.errors;
}
else if ( !detail::tools::isParentElement(detector,det_elem) ) {
- // This is sort of a bit wischi-waschi....
+ // This is sort of a bit wischi-waschi....
err << "VolumeMgrTest: Wrong associated detector element vid=" << volumeID(vid)
<< " got " << det_elem.path() << " (" << (void*)det_elem.ptr() << ") "
<< " instead of " << detector.path() << " (" << (void*)detector.ptr() << ")"
@@ -480,30 +478,30 @@ void DetectorCheck::checkManagerSingleVolume(DetElement detector, PlacedVolume p
}
}
}
- catch(const exception& ex) {
+ catch(const std::exception& ex) {
err << "Lookup " << pv.name() << " id:" << volumeID(vid)
<< " path:" << detector.path() << " error:" << ex.what();
++m_place_counters.errors;
}
if ( pv.volume().isSensitive() || (0 != det_vol_id) ) {
- string id_desc;
- log << "Volume:" << setw(50) << left << pv.name();
+ std::string id_desc;
+ log << "Volume:" << std::setw(50) << std::left << pv.name();
if ( pv.volume().isSensitive() ) {
IDDescriptor dsc = SensitiveDetector(pv.volume().sensitiveDetector()).readout().idSpec();
log << " IDDesc:" << (char*)(dsc.ptr() == m_current_iddesc.ptr() ? "OK " : "BAD");
if ( dsc.ptr() != m_current_iddesc.ptr() ) ++m_place_counters.errors;
}
else {
- log << setw(11) << " ";
+ log << std::setw(11) << " ";
}
id_desc = m_current_iddesc.str(vid);
- log << " [" << char(pv.volume().isSensitive() ? 'S' : 'N') << "] " << right
+ log << " [" << char(pv.volume().isSensitive() ? 'S' : 'N') << "] " << std::right
<< " vid:" << volumeID(vid)
<< " " << id_desc;
if ( !err.str().empty() ) {
printout(ERROR, m_det.name(),err.str()+" "+log.str());
- //throw runtime_error(err.str());
+ //throw std::runtime_error(err.str());
return;
}
id_desc = m_current_iddesc.str(det_elem.volumeID());
@@ -549,7 +547,7 @@ void DetectorCheck::checkManagerSingleVolume(DetElement detector, PlacedVolume p
/// Check nominal and DetElement trafos for pointer equality:
if ( &det_elem.nominal().worldTransformation() != &m_volMgr.worldTransformation(m_mapping,det_elem.volumeID()) )
{
- printout(ERROR, m_det.name(), "DETELEMENT_PERSISTENCY FAILED: World transformation have DIFFERET pointer!");
+ printout(ERROR, m_det.name(), "DETELEMENT_PERSISTENCY FAILED: World transformation have DIFFERET pointer!");
++m_place_counters.errors;
}
@@ -585,7 +583,7 @@ void DetectorCheck::checkManagerSingleVolume(DetElement detector, PlacedVolume p
}
}
}
- catch(const exception& ex) {
+ catch(const std::exception& ex) {
err << "Matrix " << pv.name() << " id:" << volumeID(vid)
<< " path:" << detector.path() << " error:" << ex.what();
++m_place_counters.errors;
@@ -596,7 +594,7 @@ void DetectorCheck::checkManagerSingleVolume(DetElement detector, PlacedVolume p
/// Walk through tree of detector elements
void DetectorCheck::checkManagerVolumeTree(DetElement detector, PlacedVolume pv, VolIDs ids, const Chain& chain,
- size_t depth, size_t mx_depth)
+ size_t depth, size_t mx_depth)
{
if ( depth <= mx_depth ) {
const TGeoNode* current = pv.ptr();
@@ -611,15 +609,15 @@ void DetectorCheck::checkManagerVolumeTree(DetElement detector, PlacedVolume pv,
Chain child_chain(chain);
DetElement de = detector;
if ( is_world ) {
- /// Check if there is a new parent at the next level:
- for ( const auto& c : detector.children() ) {
- if ( c.second.placement() == place ) {
- de = c.second;
- break;
- }
- }
- m_current_detector = de;
- get_current_sensitive_detector();
+ /// Check if there is a new parent at the next level:
+ for ( const auto& c : detector.children() ) {
+ if ( c.second.placement() == place ) {
+ de = c.second;
+ break;
+ }
+ }
+ m_current_detector = de;
+ get_current_sensitive_detector();
}
place.access(); // Test validity
child_chain.emplace_back(place);
@@ -657,7 +655,7 @@ void DetectorCheck::help(int argc,char** argv) {
/// Action routine to execute the test
long DetectorCheck::run(Detector& description,int argc,char** argv) {
- string name;
+ std::string name;
bool volmgr = false;
bool geometry = false;
bool structure = false;
diff --git a/DDCore/src/plugins/DetectorChecksum.cpp b/DDCore/src/plugins/DetectorChecksum.cpp
index 0415aeb5f2911d02a38651a6f9e189c5d3e8bf8d..0a3f42f3552f01eb72244388b9adabb222c08ff7 100644
--- a/DDCore/src/plugins/DetectorChecksum.cpp
+++ b/DDCore/src/plugins/DetectorChecksum.cpp
@@ -29,6 +29,7 @@
#include <TColor.h>
#include <TGeoBoolNode.h>
#include <TGeoSystemOfUnits.h>
+
// C/C++ include files
#include <iostream>
#include <sstream>
@@ -38,9 +39,10 @@
#include <cfenv>
using namespace dd4hep;
-using namespace dd4hep::detail;
+using DetectorChecksum = dd4hep::detail::DetectorChecksum;
namespace {
+
bool is_volume(const TGeoVolume* volume) {
Volume v(volume);
return v.data() != 0;
diff --git a/DDCore/src/plugins/DetectorFields.cpp b/DDCore/src/plugins/DetectorFields.cpp
index 87bc563196548a7f4b85d723cc46ce98706bbf04..040c47c7aed75fcd0eb76c00ea165c14fbf65f33 100644
--- a/DDCore/src/plugins/DetectorFields.cpp
+++ b/DDCore/src/plugins/DetectorFields.cpp
@@ -12,10 +12,12 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Printout.h"
-#include "DD4hep/FieldTypes.h"
-#include "DD4hep/MatrixHelpers.h"
-#include "DD4hep/DetFactoryHelper.h"
+#include <DD4hep/Printout.h>
+#include <DD4hep/FieldTypes.h>
+#include <DD4hep/MatrixHelpers.h>
+#include <DD4hep/DetFactoryHelper.h>
+
+// C/C++ include files
#include <cmath>
using namespace dd4hep;
diff --git a/DDCore/src/plugins/DetectorHelperTest.cpp b/DDCore/src/plugins/DetectorHelperTest.cpp
index 556490130c2405eaa36fb1977d5c9332e4a0a874..c9c2305cc7c6889b5c2fba02a3a414afcace7d0c 100644
--- a/DDCore/src/plugins/DetectorHelperTest.cpp
+++ b/DDCore/src/plugins/DetectorHelperTest.cpp
@@ -12,19 +12,16 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Detector.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Factories.h"
-#include "DD4hep/DetectorHelper.h"
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Factories.h>
+#include <DD4hep/DetectorHelper.h>
// C/C++ include files
#include <stdexcept>
#include <algorithm>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
-
namespace {
diff --git a/DDCore/src/plugins/Geant4XML.cpp b/DDCore/src/plugins/Geant4XML.cpp
index 3720c0c8373ea457addf56fc6e2901880d50b278..7fc993cbac797c3c45c9bd3f487589c0a62e85ab 100644
--- a/DDCore/src/plugins/Geant4XML.cpp
+++ b/DDCore/src/plugins/Geant4XML.cpp
@@ -11,24 +11,23 @@
//
//==========================================================================
-#include "XML/Conversions.h"
-#include "DD4hep/DetFactoryHelper.h"
+#include <XML/Conversions.h>
+#include <DD4hep/DetFactoryHelper.h>
namespace dd4hep {
struct Geant4;
class GdmlFile;
class Property;
class SensitiveDetector;
-}
-using namespace dd4hep;
-namespace dd4hep {
template <> void Converter<Geant4>::operator()(xml_h e) const;
template <> void Converter<GdmlFile>::operator()(xml_h e) const;
template <> void Converter<Property>::operator()(xml_h e) const;
template <> void Converter<SensitiveDetector>::operator()(xml_h e) const;
}
+using namespace dd4hep;
+
template <> void Converter<Geant4>::operator()(xml_h element) const {
xml_elt_t compact(element);
//xml_coll_t(compact,_U(includes) ).for_each(_U(gdmlFile), Converter<GdmlFile>(description,param));
diff --git a/DDCore/src/plugins/GeometryWalk.cpp b/DDCore/src/plugins/GeometryWalk.cpp
index d6d38d72ad0e883b2399f3ac0e04d5b6a3ea7a7d..55177b0a4b87dbcbf35b8db46850d76bd55519b9 100644
--- a/DDCore/src/plugins/GeometryWalk.cpp
+++ b/DDCore/src/plugins/GeometryWalk.cpp
@@ -12,26 +12,24 @@
//==========================================================================
// Framework include files
-#include "DD4hep/Detector.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Factories.h"
-#include "DD4hep/IDDescriptor.h"
-#include "DD4hep/VolumeManager.h"
-#include "DD4hep/DetectorTools.h"
-//#include "DD4hep/DetectorAlignment.h"
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Factories.h>
+#include <DD4hep/IDDescriptor.h>
+#include <DD4hep/VolumeManager.h>
+#include <DD4hep/DetectorTools.h>
// C/C++ include files
#include <stdexcept>
#include <algorithm>
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
-typedef detail::tools::ElementPath ElementPath;
-typedef detail::tools::PlacementPath PlacementPath;
+using ElementPath = detail::tools::ElementPath;
+using PlacementPath = detail::tools::PlacementPath;
namespace {
+
/** @class GeometryWalk
*
* Test the volume manager by scanning the sensitive
@@ -43,8 +41,8 @@ namespace {
struct GeometryWalk {
/// Helper to scan volume ids
struct FND {
- const string& test;
- FND(const string& c) : test(c) {}
+ const std::string& test;
+ FND(const std::string& c) : test(c) {}
bool operator()(const PlacedVolume::VolIDs::value_type& c) const { return c.first == test; }
};
VolumeManager m_mgr;
@@ -69,35 +67,35 @@ typedef DetElement::Children _C;
GeometryWalk::GeometryWalk(Detector& description, DetElement sdet) : m_det(sdet) {
m_mgr = description.volumeManager();
if ( !m_det.isValid() ) {
- stringstream err;
+ std::stringstream err;
err << "The subdetector " << m_det.name() << " is not known to the geometry.";
printout(INFO,"GeometryWalk",err.str().c_str());
- throw runtime_error(err.str());
+ throw std::runtime_error(err.str());
}
walk(m_det,PlacedVolume::VolIDs());
}
/// Printout volume information
void GeometryWalk::print(DetElement e, PlacedVolume pv, const PlacedVolume::VolIDs& /* child_ids */) const {
- stringstream log;
+ std::stringstream log;
PlacementPath all_nodes;
ElementPath det_elts;
detail::tools::elementPath(e,det_elts);
detail::tools::placementPath(e,all_nodes);
- string elt_path = detail::tools::elementPath(det_elts);
- string node_path = detail::tools::placementPath(all_nodes);
- log << "Lookup " << left << setw(32) << pv.name() << " Detector[" << det_elts.size() << "]: " << elt_path;
+ std::string elt_path = detail::tools::elementPath(det_elts);
+ std::string node_path = detail::tools::placementPath(all_nodes);
+ log << "Lookup " << std::left << std::setw(32) << pv.name() << " Detector[" << det_elts.size() << "]: " << elt_path;
printout(INFO,m_det.name(),log.str());
log.str("");
- log << " " << left << setw(32) << " " << " Places[" << all_nodes.size() << "]: " << node_path;
+ log << " " << std::left << std::setw(32) << " " << " Places[" << all_nodes.size() << "]: " << node_path;
printout(INFO,m_det.name(),log.str());
log.str("");
- log << " " << left << setw(32) << " " << " detail::matrix[" << all_nodes.size() << "]: ";
+ log << " " << std::left << std::setw(32) << " " << " detail::matrix[" << all_nodes.size() << "]: ";
for(PlacementPath::const_iterator i=all_nodes.begin(); i!=all_nodes.end(); ++i) {
log << (void*)((*i)->GetMatrix()) << " ";
if ( i+1 == all_nodes.end() ) log << "( -> " << (*i)->GetName() << ")";
}
- printout(INFO,m_det.name(),log.str());
+ printout(INFO, m_det.name(), log.str());
}
/// Walk through tree of volume placements
@@ -114,20 +112,20 @@ void GeometryWalk::walk(DetElement e, PlacedVolume::VolIDs ids) const {
/// Action routine to execute the test
long GeometryWalk::run(Detector& description,int argc,char** argv) {
- cout << "++ Processing plugin....GeometryWalker.." << endl;
+ std::cout << "++ Processing plugin....GeometryWalker.." << std::endl;
DetElement world = description.world();
for(int in=1; in < argc; ++in) {
- string name = argv[in]+1;
+ std::string name = argv[in]+1;
if ( name == "all" || name == "All" || name == "ALL" ) {
const _C& children = world.children();
for (_C::const_iterator i=children.begin(); i!=children.end(); ++i) {
DetElement sdet = (*i).second;
- cout << "++ Processing subdetector: " << sdet.name() << endl;
+ std::cout << "++ Processing subdetector: " << sdet.name() << std::endl;
GeometryWalk test(description, sdet);
}
return 1;
}
- cout << "++ Processing subdetector: " << name << endl;
+ std::cout << "++ Processing subdetector: " << name << std::endl;
GeometryWalk test(description, description.detector(name));
}
return 1;
diff --git a/DDCore/src/plugins/JsonProcessor.cpp b/DDCore/src/plugins/JsonProcessor.cpp
index d147e612874f8a9385a09299add1c681e2eb7ce0..df149c060d8888de0725906188c1f93f25476856 100644
--- a/DDCore/src/plugins/JsonProcessor.cpp
+++ b/DDCore/src/plugins/JsonProcessor.cpp
@@ -46,11 +46,9 @@ namespace {
class detector;
}
-using namespace std;
using namespace dd4hep;
-using namespace dd4hep::detail;
-static void setChildTitles(const pair<string, DetElement>& e) {
+static void setChildTitles(const std::pair<std::string, DetElement>& e) {
DetElement parent = e.second.parent();
const DetElement::Children& children = e.second.children();
if (::strlen(e.second->GetTitle()) == 0) {
@@ -65,10 +63,10 @@ namespace dd4hep {
/// This is the identical converter as it is used for the XML compact!
template <> void Converter<detector>::operator()(json_h element) const {
- string type = element.attr<string>(_U(type));
- string name = element.attr<string>(_U(name));
- string name_match = ":" + name + ":";
- string type_match = ":" + type + ":";
+ std::string type = element.attr<std::string>(_U(type));
+ std::string name = element.attr<std::string>(_U(name));
+ std::string name_match = ":" + name + ":";
+ std::string type_match = ":" + type + ":";
try {
json_attr_t attr_par = element.attr_nothrow(_U(parent));
@@ -76,7 +74,7 @@ template <> void Converter<detector>::operator()(json_h element) const {
// We have here a nested detector. If the mother volume is not yet registered
// it must be done here, so that the detector constructor gets the correct answer from
// the call to Detector::pickMotherVolume(DetElement).
- string par_name = element.attr<string>(attr_par);
+ std::string par_name = element.attr<std::string>(attr_par);
DetElement parent_detector = description.detector(par_name);
if ( !parent_detector.isValid() ) {
except("Compact","Failed to access valid parent detector of %s",name.c_str());
@@ -87,9 +85,9 @@ template <> void Converter<detector>::operator()(json_h element) const {
SensitiveDetector sd;
Segmentation seg;
if ( attr_ro ) {
- Readout ro = description.readout(element.attr<string>(attr_ro));
+ Readout ro = description.readout(element.attr<std::string>(attr_ro));
if (!ro.isValid()) {
- throw runtime_error("No Readout structure present for detector:" + name);
+ throw std::runtime_error("No Readout structure present for detector:" + name);
}
seg = ro.segmentation();
sd = SensitiveDetector(name, "sensitive");
@@ -100,7 +98,7 @@ template <> void Converter<detector>::operator()(json_h element) const {
Handle<NamedObject> sens = sd;
DetElement det(PluginService::Create<NamedObject*>(type, &description, &element, &sens));
if (det.isValid()) {
- setChildTitles(make_pair(name, det));
+ setChildTitles(std::make_pair(name, det));
if ( sd.isValid() ) {
det->flag |= DetElement::Object::HAVE_SENSITIVE_DETECTOR;
}
@@ -116,18 +114,18 @@ template <> void Converter<detector>::operator()(json_h element) const {
if (!det.isValid()) {
PluginDebug dbg;
PluginService::Create<NamedObject*>(type, &description, &element, &sens);
- throw runtime_error("Failed to execute subdetector creation plugin. " + dbg.missingFactory(type));
+ throw std::runtime_error("Failed to execute subdetector creation plugin. " + dbg.missingFactory(type));
}
description.addDetector(det);
return;
}
- catch (const exception& e) {
+ catch (const std::exception& e) {
printout(ERROR, "Compact", "++ FAILED to convert subdetector: %s: %s", name.c_str(), e.what());
- terminate();
+ std::terminate();
}
catch (...) {
printout(ERROR, "Compact", "++ FAILED to convert subdetector: %s: %s", name.c_str(), "UNKNONW Exception");
- terminate();
+ std::terminate();
}
}
@@ -140,8 +138,8 @@ static long handle_json(Detector& description, int argc, char** argv) {
"\n");
exit(EINVAL);
}
- string file = argv[0];
- if ( file[0] != '/' ) file = string(argv[1]) + "/" + file;
+ std::string file = argv[0];
+ if ( file[0] != '/' ) file = std::string(argv[1]) + "/" + file;
printout(INFO,"JsonProcessor","++ Processing JSON input: %s",file.c_str());
json::DocumentHolder doc(json::DocumentHandler().load(file.c_str()));
diff --git a/DDCore/src/plugins/LCDD2Output.cpp b/DDCore/src/plugins/LCDD2Output.cpp
index b5f5dbcd02be00bfa5e85302810631c2632a565e..ee7b10b18729e24fe38265db2ae60d57424b6c87 100644
--- a/DDCore/src/plugins/LCDD2Output.cpp
+++ b/DDCore/src/plugins/LCDD2Output.cpp
@@ -11,51 +11,56 @@
//
//==========================================================================
+// Framework includes
#include "XML/Conversions.h"
#include "DD4hep/Detector.h"
#include "DD4hep/Objects.h"
#include "DD4hep/Printout.h"
#include "DD4hep/IDDescriptor.h"
+// ROOT includes
#include "TMap.h"
#include "TROOT.h"
#include "TColor.h"
#include "TGeoMatrix.h"
#include "TGeoManager.h"
+
+/// C/C++ include files
#include <iostream>
#include <iomanip>
-using namespace std;
+/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
- using namespace detail;
void dumpNode(TGeoNode* n, int level) {
TGeoMatrix* mat = n->GetMatrix();
TGeoVolume* vol = n->GetVolume();
TGeoMedium* med = vol->GetMedium();
- TGeoShape* shape = vol->GetShape();
- TObjArray* nodes = vol->GetNodes();
+ TGeoShape* shape = vol->GetShape();
+ TObjArray* nodes = vol->GetNodes();
for (int i = 0; i < level; ++i)
- cout << " ";
- cout << " ++Node:|" << n->GetName() << "| ";
- cout << " Volume: " << vol->GetName() << " material:" << med->GetName() << " shape:" << shape->GetName() << endl;
+ std::cout << " ";
+ std::cout << " ++Node:|" << n->GetName() << "| ";
+ std::cout << " Volume: " << vol->GetName() << " material:" << med->GetName()
+ << " shape:" << shape->GetName() << std::endl;
for (int i = 0; i < level; ++i)
- cout << " ";
+ std::cout << " ";
const Double_t* tr = mat->GetTranslation();
- cout << " matrix:|" << mat->GetName() << "|" << mat->IsTranslation() << mat->IsRotation() << mat->IsScale()
- << " tr:x=" << tr[0] << " y=" << tr[1] << " z=" << tr[2];
+ std::cout << " matrix:|" << mat->GetName()
+ << "|" << mat->IsTranslation() << mat->IsRotation() << mat->IsScale()
+ << " tr:x=" << tr[0] << " y=" << tr[1] << " z=" << tr[2];
if (mat->IsRotation()) {
Double_t theta, phi, psi;
TGeoRotation rot(*mat);
rot.GetAngles(phi, theta, psi);
- cout << " rot: theta:" << theta << " phi:" << phi << " psi:" << psi;
+ std::cout << " rot: theta:" << theta << " phi:" << phi << " psi:" << psi;
}
- cout << endl;
+ std::cout << std::endl;
PlacedVolume plv(n);
for (int i = 0; i < level; ++i)
- cout << " ";
- cout << " volume:" << plv.toString();
- cout << endl;
+ std::cout << " ";
+ std::cout << " volume:" << plv.toString();
+ std::cout << std::endl;
TIter next(nodes);
TGeoNode *geoNode;
while ((geoNode = (TGeoNode *) next())) {
@@ -69,8 +74,8 @@ namespace dd4hep {
TGeoShape* shape = vol->GetShape();
for (int i = 0; i < level; ++i)
- cout << " ";
- cout << "++Volume: " << vol->GetName() << " material:" << med->GetName() << " shape:" << shape->GetName() << endl;
+ std::cout << " ";
+ std::cout << "++Volume: " << vol->GetName() << " material:" << med->GetName() << " shape:" << shape->GetName() << std::endl;
TIter next(nodes);
TGeoNode *geoNode;
while ((geoNode = (TGeoNode *) next())) {
diff --git a/DDCore/src/plugins/LCDDConverter.cpp b/DDCore/src/plugins/LCDDConverter.cpp
index c0afbe2c22ff43e7219da4a60cdc6cfa55b4ff6d..e7dccbea8d1436398b498dee8fd854bdf67df155 100644
--- a/DDCore/src/plugins/LCDDConverter.cpp
+++ b/DDCore/src/plugins/LCDDConverter.cpp
@@ -12,52 +12,54 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Plugins.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/Volumes.h"
-#include "DD4hep/FieldTypes.h"
-#include "DD4hep/DD4hepUnits.h"
-#include "DD4hep/Segmentations.h"
-#include "DD4hep/detail/ObjectsInterna.h"
-#include "DD4hep/detail/DetectorInterna.h"
-#include "XML/DocumentHandler.h"
#include "LCDDConverter.h"
+#include <DD4hep/Plugins.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/Volumes.h>
+#include <DD4hep/FieldTypes.h>
+#include <DD4hep/DD4hepUnits.h>
+#include <DD4hep/Segmentations.h>
+#include <DD4hep/detail/ObjectsInterna.h>
+#include <DD4hep/detail/DetectorInterna.h>
+#include <XML/DocumentHandler.h>
// ROOT includes
-#include "TROOT.h"
-#include "TColor.h"
-#include "TGeoShape.h"
-
-#include "TGeoArb8.h"
-#include "TGeoBoolNode.h"
-#include "TGeoCompositeShape.h"
-#include "TGeoCone.h"
-#include "TGeoEltu.h"
-#include "TGeoHype.h"
-#include "TGeoMatrix.h"
-#include "TGeoParaboloid.h"
-#include "TGeoPara.h"
-#include "TGeoPcon.h"
-#include "TGeoPgon.h"
-#include "TGeoShapeAssembly.h"
-#include "TGeoSphere.h"
-#include "TGeoTorus.h"
-#include "TGeoTrd1.h"
-#include "TGeoTrd2.h"
-#include "TGeoTube.h"
-#include "TGeoScaledShape.h"
-
-#include "TGeoNode.h"
-#include "TClass.h"
-#include "TMath.h"
+#include <TROOT.h>
+#include <TColor.h>
+#include <TGeoShape.h>
+
+#include <TGeoArb8.h>
+#include <TGeoBoolNode.h>
+#include <TGeoCompositeShape.h>
+#include <TGeoCone.h>
+#include <TGeoEltu.h>
+#include <TGeoHype.h>
+#include <TGeoMatrix.h>
+#include <TGeoParaboloid.h>
+#include <TGeoPara.h>
+#include <TGeoPcon.h>
+#include <TGeoPgon.h>
+#include <TGeoShapeAssembly.h>
+#include <TGeoSphere.h>
+#include <TGeoTorus.h>
+#include <TGeoTrd1.h>
+#include <TGeoTrd2.h>
+#include <TGeoTube.h>
+#include <TGeoScaledShape.h>
+
+#include <TGeoNode.h>
+#include <TClass.h>
+#include <TMath.h>
+
+/// C/C++ include files
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
-using namespace dd4hep::detail;
using namespace dd4hep;
-using namespace std;
+using namespace dd4hep::detail;
+
namespace {
typedef Position XYZRotation;
@@ -86,8 +88,8 @@ namespace {
c = 0;
}
XYZRotation rr(a, b, c);
- cout << " X:" << a << " " << rr.X() << " Y:" << b << " " << rr.Y() << " Z:" << c << " " << rr.Z()
- << " lx:" << r[0] << " ly:" << r[4] << " lz:" << r[8] << endl;
+ std::cout << " X:" << a << " " << rr.X() << " Y:" << b << " " << rr.Y() << " Z:" << c << " " << rr.Z()
+ << " lx:" << r[0] << " ly:" << r[4] << " lz:" << r[8] << std::endl;
return XYZRotation(a, b, c);
}
#endif
@@ -100,9 +102,9 @@ namespace {
return node.data() != 0;
}
- string genName(const string& n) { return n; }
- string genName(const string& n, const void* ptr) {
- string nn = genName(n);
+ std::string genName(const std::string& n) { return n; }
+ std::string genName(const std::string& n, const void* ptr) {
+ std::string nn = genName(n);
char text[32];
::snprintf(text,sizeof(text),"%p",ptr);
nn += "_";
@@ -111,11 +113,11 @@ namespace {
}
}
-void LCDDConverter::GeometryInfo::check(const string& name, const TNamed* _n, map<string, const TNamed*>& _m) const {
- map<string, const TNamed*>::const_iterator i = _m.find(name);
+void LCDDConverter::GeometryInfo::check(const std::string& name, const TNamed* _n, std::map<std::string, const TNamed*>& _m) const {
+ std::map<std::string, const TNamed*>::const_iterator i = _m.find(name);
if (i != _m.end()) {
const char* isa = _n ? _n->IsA()->GetName() : (*i).second ? (*i).second->IsA()->GetName() : "Unknown";
- cout << isa << "(position): duplicate entry with name:" << name << " " << (void*) _n << " " << (void*) (*i).second << endl;
+ std::cout << isa << "(position): duplicate entry with name:" << name << " " << (void*) _n << " " << (void*) (*i).second << std::endl;
}
_m.insert(make_pair(name, _n));
}
@@ -132,7 +134,7 @@ LCDDConverter::~LCDDConverter() {
}
/// Dump element in GDML format to output stream
-xml_h LCDDConverter::handleElement(const string& /* name */, Atom element) const {
+xml_h LCDDConverter::handleElement(const std::string& /* name */, Atom element) const {
GeometryInfo& geo = data();
xml_h e = geo.xmlElements[element];
if (!e) {
@@ -155,7 +157,7 @@ xml_h LCDDConverter::handleElement(const string& /* name */, Atom element) const
}
/// Dump material in GDML format to output stream
-xml_h LCDDConverter::handleMaterial(const string& name, Material medium) const {
+xml_h LCDDConverter::handleMaterial(const std::string& name, Material medium) const {
GeometryInfo& geo = data();
xml_h mat = geo.xmlMaterials[medium];
if (!mat) {
@@ -184,7 +186,7 @@ xml_h LCDDConverter::handleMaterial(const string& name, Material medium) const {
}
for (int i = 0, n = mix->GetNelements(); i < n; i++) {
TGeoElement *elt = mix->GetElement(i);
- //string formula = elt->GetTitle() + string("_elm");
+ //std::string formula = elt->GetTitle() + std::string("_elm");
if (nmix) {
mat.append(obj = xml_elt_t(geo.doc, _U(composite)));
obj.setAttr(_U(n), nmix[i]);
@@ -216,7 +218,7 @@ xml_h LCDDConverter::handleMaterial(const string& name, Material medium) const {
}
/// Dump solid in GDML format to output stream
-xml_h LCDDConverter::handleSolid(const string& name, const TGeoShape* shape) const {
+xml_h LCDDConverter::handleSolid(const std::string& name, const TGeoShape* shape) const {
GeometryInfo& geo = data();
SolidMap::iterator sit = geo.xmlSolids.find(shape);
if (!shape) {
@@ -236,7 +238,7 @@ xml_h LCDDConverter::handleSolid(const string& name, const TGeoShape* shape) con
xml_h solid(0);
xml_h zplane(0);
TClass* isa = shape->IsA();
- string shape_name = shape->GetName(); //genName(shape->GetName(),shape);
+ std::string shape_name = shape->GetName(); //genName(shape->GetName(),shape);
geo.checkShape(name, shape);
if (isa == TGeoBBox::Class()) {
const TGeoBBox* sh = (const TGeoBBox*) shape;
@@ -501,10 +503,10 @@ xml_h LCDDConverter::handleSolid(const string& name, const TGeoShape* shape) con
xml_h right = handleSolid(rs->GetName(), rs);
xml_h first_solid(0), second_solid(0);
if (!left) {
- throw runtime_error("G4Converter: No left Detector Solid present for composite shape:" + name);
+ throw std::runtime_error("G4Converter: No left Detector Solid present for composite shape:" + name);
}
if (!right) {
- throw runtime_error("G4Converter: No right Detector Solid present for composite shape:" + name);
+ throw std::runtime_error("G4Converter: No right Detector Solid present for composite shape:" + name);
}
//specific case!
@@ -545,8 +547,8 @@ xml_h LCDDConverter::handleSolid(const string& name, const TGeoShape* shape) con
solid = xml_elt_t(geo.doc,_U(intersection));
xml_h obj;
- string lnam = left.attr<string>(_U(name));
- string rnam = right.attr<string>(_U(name));
+ std::string lnam = left.attr<std::string>(_U(name));
+ std::string rnam = right.attr<std::string>(_U(name));
geo.doc_solids.append(solid);
solid.append(first_solid = xml_elt_t(geo.doc, _U(first)));
@@ -591,8 +593,8 @@ xml_h LCDDConverter::handleSolid(const string& name, const TGeoShape* shape) con
}
}
if (!solid) {
- string err = "Failed to handle unknown solid shape:" + name + " of type " + string(shape->IsA()->GetName());
- throw runtime_error(err);
+ std::string err = "Failed to handle unknown solid shape:" + name + " of type " + std::string(shape->IsA()->GetName());
+ throw std::runtime_error(err);
}
return data().xmlSolids[shape] = solid;
}
@@ -605,7 +607,7 @@ xml_h LCDDConverter::handlePosition(const std::string& name, const TGeoMatrix* t
if (!pos) {
const double* tr = trafo->GetTranslation();
if (tr[0] != 0.0 || tr[1] != 0.0 || tr[2] != 0.0) {
- string gen_name = genName(name,trafo);
+ std::string gen_name = genName(name,trafo);
geo.checkPosition(gen_name, trafo);
geo.doc_define.append(pos = xml_elt_t(geo.doc, _U(position)));
pos.setAttr(_U(name), gen_name);
@@ -639,7 +641,7 @@ xml_h LCDDConverter::handleRotation(const std::string& name, const TGeoMatrix* t
if (!rot) {
XYZRotation r = getXYZangles(trafo->GetRotationMatrix());
if (!(r.X() == 0.0 && r.Y() == 0.0 && r.Z() == 0.0)) {
- string gen_name = genName(name,trafo);
+ std::string gen_name = genName(name,trafo);
geo.checkRotation(gen_name, trafo);
geo.doc_define.append(rot = xml_elt_t(geo.doc, _U(rotation)));
rot.setAttr(_U(name), gen_name);
@@ -667,13 +669,13 @@ xml_h LCDDConverter::handleRotation(const std::string& name, const TGeoMatrix* t
}
/// Dump logical volume in GDML format to output stream
-xml_h LCDDConverter::handleVolume(const string& /* name */, Volume volume) const {
+xml_h LCDDConverter::handleVolume(const std::string& /* name */, Volume volume) const {
GeometryInfo& geo = data();
xml_h vol = geo.xmlVolumes[volume];
if (!vol) {
const TGeoVolume* v = volume;
Volume _v(v);
- string n = genName(v->GetName(),v);
+ std::string n = genName(v->GetName(),v);
TGeoMedium* medium = v->GetMedium();
TGeoShape* sh = v->GetShape();
xml_ref_t sol = handleSolid(sh->GetName(), sh);
@@ -685,15 +687,15 @@ xml_h LCDDConverter::handleVolume(const string& /* name */, Volume volume) const
}
else {
if (!sol)
- throw runtime_error("G4Converter: No Detector Solid present for volume:" + n);
+ throw std::runtime_error("G4Converter: No Detector Solid present for volume:" + n);
else if (!m)
- throw runtime_error("G4Converter: No Detector material present for volume:" + n);
+ throw std::runtime_error("G4Converter: No Detector material present for volume:" + n);
vol = xml_elt_t(geo.doc, _U(volume));
vol.setAttr(_U(name), n);
if (m) {
- string mat_name = medium->GetName();
- xml_ref_t med = handleMaterial(mat_name, Material(medium));
+ std::string mat_name = medium->GetName();
+ xml_ref_t med = handleMaterial(mat_name, Material(medium));
vol.setRef(_U(materialref), med.name());
}
vol.setRef(_U(solidref), sol.name());
@@ -734,7 +736,7 @@ xml_h LCDDConverter::handleVolume(const string& /* name */, Volume volume) const
}
/// Dump logical volume in GDML format to output stream
-xml_h LCDDConverter::handleVolumeVis(const string& /* name */, const TGeoVolume* volume) const {
+xml_h LCDDConverter::handleVolumeVis(const std::string& /* name */, const TGeoVolume* volume) const {
GeometryInfo& geo = data();
xml_h vol = geo.xmlVolumes[volume];
if (!vol) {
@@ -755,7 +757,7 @@ xml_h LCDDConverter::handleVolumeVis(const string& /* name */, const TGeoVolume*
}
/// Dump logical volume in GDML format to output stream
-void LCDDConverter::collectVolume(const string& /* name */, const TGeoVolume* volume) const {
+void LCDDConverter::collectVolume(const std::string& /* name */, const TGeoVolume* volume) const {
Volume v(volume);
if ( is_volume(volume) ) {
GeometryInfo& geo = data();
@@ -774,11 +776,11 @@ void LCDDConverter::collectVolume(const string& /* name */, const TGeoVolume* vo
}
}
-void LCDDConverter::checkVolumes(const string& /* name */, Volume v) const {
- string n = v.name()+_toString(v.ptr(),"_%p");
+void LCDDConverter::checkVolumes(const std::string& /* name */, Volume v) const {
+ std::string n = v.name()+_toString(v.ptr(),"_%p");
NameSet::const_iterator i = m_checkNames.find(n);
if (i != m_checkNames.end()) {
- stringstream str;
+ std::stringstream str;
str << "++ CheckVolumes: Volume " << n << " ";
if (is_volume(v.ptr())) {
SensitiveDetector sd = v.sensitiveDetector();
@@ -790,7 +792,7 @@ void LCDDConverter::checkVolumes(const string& /* name */, Volume v) const {
str << "with VisAttrs " << vis.name() << " ";
}
}
- str << "has duplicate entries." << endl;
+ str << "has duplicate entries." << std::endl;
printout(ERROR,"LCDDConverter",str.str().c_str());
return;
}
@@ -798,7 +800,7 @@ void LCDDConverter::checkVolumes(const string& /* name */, Volume v) const {
}
/// Dump volume placement in GDML format to output stream
-xml_h LCDDConverter::handlePlacement(const string& name,PlacedVolume node) const {
+xml_h LCDDConverter::handlePlacement(const std::string& name,PlacedVolume node) const {
GeometryInfo& geo = data();
xml_h place = geo.xmlPlacements[node];
if (!place) {
@@ -834,7 +836,7 @@ xml_h LCDDConverter::handlePlacement(const string& name,PlacedVolume node) const
geo.xmlPlacements[node] = place;
}
else {
- cout << "Attempt to DOUBLE-place physical volume:" << name << " No:" << node->GetNumber() << endl;
+ std::cout << "Attempt to DOUBLE-place physical volume:" << name << " No:" << node->GetNumber() << std::endl;
}
return place;
}
@@ -862,8 +864,8 @@ xml_h LCDDConverter::handleLimitSet(const std::string& /* name */, LimitSet lim)
if (!xml) {
geo.doc_limits.append(xml = xml_elt_t(geo.doc, _U(limitset)));
xml.setAttr(_U(name), lim.name());
- const set<Limit>& obj = lim.limits();
- for (set<Limit>::const_iterator i = obj.begin(); i != obj.end(); ++i) {
+ const std::set<Limit>& obj = lim.limits();
+ for (std::set<Limit>::const_iterator i = obj.begin(); i != obj.end(); ++i) {
xml_h x = xml_elt_t(geo.doc, _U(limit));
const Limit& l = *i;
xml.append(x);
@@ -882,13 +884,13 @@ xml_h LCDDConverter::handleSegmentation(Segmentation seg) const {
xml_h xml;
if (seg.isValid()) {
typedef DDSegmentation::Parameters _P;
- string typ = seg.type();
+ std::string typ = seg.type();
_P p = seg.parameters();
xml = xml_elt_t(data().doc, Unicode(typ));
for (_P::const_iterator i = p.begin(); i != p.end(); ++i) {
const _P::value_type& v = *i;
if (v->name() == "lunit") {
- string val = v->value() == _toDouble("mm") ? "mm" : v->value() == _toDouble("cm") ? "cm" :
+ std::string val = v->value() == _toDouble("mm") ? "mm" : v->value() == _toDouble("cm") ? "cm" :
v->value() == _toDouble("m") ? "m" : v->value() == _toDouble("micron") ? "micron" :
v->value() == _toDouble("nanometer") ? "namometer" : "??";
xml.setAttr(Unicode(v->name()), Unicode(val));
@@ -910,7 +912,7 @@ xml_h LCDDConverter::handleSegmentation(Segmentation seg) const {
}
/// Convert the geometry type SensitiveDetector into the corresponding Detector object(s).
-xml_h LCDDConverter::handleSensitive(const string& /* name */, SensitiveDetector sd) const {
+xml_h LCDDConverter::handleSensitive(const std::string& /* name */, SensitiveDetector sd) const {
GeometryInfo& geo = data();
xml_h sensdet = geo.xmlSensDets[sd];
if (!sensdet) {
@@ -971,7 +973,7 @@ xml_h LCDDConverter::handleIdSpec(const std::string& name, IDDescriptor id_spec)
}
/// Convert the geometry visualisation attributes to the corresponding Detector object(s).
-xml_h LCDDConverter::handleVis(const string& /* name */, VisAttr attr) const {
+xml_h LCDDConverter::handleVis(const std::string& /* name */, VisAttr attr) const {
GeometryInfo& geo = data();
xml_h vis = geo.xmlVis[attr];
if (!vis) {
@@ -1010,7 +1012,7 @@ xml_h LCDDConverter::handleField(const std::string& /* name */, OverlayedField f
xml_h field = geo.xmlFields[f];
if (!field) {
Handle<NamedObject> fld(f);
- string type = f->GetTitle();
+ std::string type = f->GetTitle();
field = xml_elt_t(geo.doc, Unicode(type));
field.setAttr(_U(name), f->GetName());
fld = PluginService::Create<NamedObject*>(type + "_Convert2Detector", &m_detDesc, &field, &fld);
@@ -1019,8 +1021,8 @@ xml_h LCDDConverter::handleField(const std::string& /* name */, OverlayedField f
if (!fld.isValid()) {
PluginDebug dbg;
PluginService::Create<NamedObject*>(type + "_Convert2Detector", &m_detDesc, &field, &fld);
- throw runtime_error("Failed to locate plugin to convert electromagnetic field:"
- + string(f->GetName()) + " of type " + type + ". "
+ throw std::runtime_error("Failed to locate plugin to convert electromagnetic field:"
+ + std::string(f->GetName()) + " of type " + type + ". "
+ dbg.missingFactory(type));
}
geo.doc_fields.append(field);
@@ -1030,11 +1032,11 @@ xml_h LCDDConverter::handleField(const std::string& /* name */, OverlayedField f
/// Handle the geant 4 specific properties
void LCDDConverter::handleProperties(Detector::Properties& prp) const {
- map<string, string> processors;
+ std::map<std::string, std::string> processors;
static int s_idd = 9999999;
- string id;
+ std::string id;
for (Detector::Properties::const_iterator i = prp.begin(); i != prp.end(); ++i) {
- const string& nam = (*i).first;
+ const std::string& nam = (*i).first;
const Detector::PropertyValues& vals = (*i).second;
if (nam.substr(0, 6) == "geant4") {
Detector::PropertyValues::const_iterator id_it = vals.find("id");
@@ -1049,25 +1051,25 @@ void LCDDConverter::handleProperties(Detector::Properties& prp) const {
processors.insert(make_pair(id, nam));
}
}
- for (map<string, string>::const_iterator i = processors.begin(); i != processors.end(); ++i) {
+ for (std::map<std::string, std::string>::const_iterator i = processors.begin(); i != processors.end(); ++i) {
const GeoHandler* ptr = this;
- string nam = (*i).second;
+ std::string nam = (*i).second;
const Detector::PropertyValues& vals = prp[nam];
- string type = vals.find("type")->second;
- string tag = type + "_Geant4_action";
+ std::string type = vals.find("type")->second;
+ std::string tag = type + "_Geant4_action";
long result = PluginService::Create<long>(tag, &m_detDesc, ptr, &vals);
if (0 == result) {
PluginDebug dbg;
result = PluginService::Create<long>(tag, &m_detDesc, ptr, &vals);
if (0 == result) {
- throw runtime_error("Failed to locate plugin to interprete files of type"
+ throw std::runtime_error("Failed to locate plugin to interprete files of type"
" \"" + tag + "\" - no factory:" + type + ". " +
dbg.missingFactory(tag));
}
}
result = *(long*) result;
if (result != 1) {
- throw runtime_error("Failed to invoke the plugin " + tag + " of type " + type);
+ throw std::runtime_error("Failed to invoke the plugin " + tag + " of type " + type);
}
printout(INFO,"","+++ Executed Successfully Detector setup module %s.",type.c_str());
}
@@ -1097,7 +1099,7 @@ void LCDDConverter::handleHeader() const {
template <typename O, typename C, typename F> void handle(const O* o, const C& c, F pmf) {
for (typename C::const_iterator i = c.begin(); i != c.end(); ++i) {
- string n = (*i)->GetName();
+ std::string n = (*i)->GetName();
(o->*pmf)(n, *i);
}
}
@@ -1116,7 +1118,7 @@ template <typename O, typename C, typename F> void handleRMap(const O* o, const
xml_doc_t LCDDConverter::createGDML(DetElement top) {
Detector& description = m_detDesc;
if (!top.isValid()) {
- throw runtime_error("Attempt to call createGDML with an invalid geometry!");
+ throw std::runtime_error("Attempt to call createGDML with an invalid geometry!");
}
GeometryInfo& geo = *(m_dataPtr = new GeometryInfo);
m_data->clear();
@@ -1171,7 +1173,7 @@ xml_doc_t LCDDConverter::createGDML(DetElement top) {
/// Create geometry conversion
xml_doc_t LCDDConverter::createVis(DetElement top) {
if (!top.isValid()) {
- throw runtime_error("Attempt to call createDetector with an invalid geometry!");
+ throw std::runtime_error("Attempt to call createDetector with an invalid geometry!");
}
GeometryInfo& geo = *(m_dataPtr = new GeometryInfo);
@@ -1196,7 +1198,7 @@ xml_doc_t LCDDConverter::createVis(DetElement top) {
xml_doc_t LCDDConverter::createDetector(DetElement top) {
Detector& description = m_detDesc;
if (!top.isValid()) {
- throw runtime_error("Attempt to call createDetector with an invalid geometry!");
+ throw std::runtime_error("Attempt to call createDetector with an invalid geometry!");
}
GeometryInfo& geo = *(m_dataPtr = new GeometryInfo);
@@ -1306,12 +1308,12 @@ static long create_visASCII(Detector& description, int /* argc */, char** argv)
LCDDConverter wr(description);
/* xml_doc_t doc = */ wr.createVis(description.world());
LCDDConverter::GeometryInfo& geo = wr.data();
- map<string, xml_comp_t> vis_map;
+ std::map<std::string, xml_comp_t> vis_map;
for (xml_coll_t c(geo.doc_display, _U(vis)); c; ++c)
vis_map.insert(make_pair(xml_comp_t(c).nameStr(), xml_comp_t(c)));
const char* sep = ";";
- ofstream os(argv[0]);
+ std::ofstream os(argv[0]);
for (xml_coll_t c(geo.doc_structure, _U(volume)); c; ++c) {
xml_comp_t vol = c;
xml_comp_t ref = c.child(_U(visref));
@@ -1321,9 +1323,9 @@ static long create_visASCII(Detector& description, int /* argc */, char** argv)
<< "visible:" << vis.visible() << sep << "r:"
<< col.R() << sep << "g:" << col.G() << sep << "b:" << col.B() << sep
<< "alpha:" << col.alpha() << sep << "line_style:"
- << vis.attr < string > (_U(line_style)) << sep
- << "drawing_style:" << vis.attr < string> (_U(drawing_style)) << sep
- << "show_daughters:" << vis.show_daughters() << sep << endl;
+ << vis.attr < std::string > (_U(line_style)) << sep
+ << "drawing_style:" << vis.attr < std::string> (_U(drawing_style)) << sep
+ << "show_daughters:" << vis.show_daughters() << sep << std::endl;
}
os.close();
return 1;
diff --git a/DDCore/src/plugins/PluginInvoker.cpp b/DDCore/src/plugins/PluginInvoker.cpp
index 58564c34102cd193ebaa417715168c263ff82ea3..8a4fde542755d923208514505a7c8336e4da0173 100644
--- a/DDCore/src/plugins/PluginInvoker.cpp
+++ b/DDCore/src/plugins/PluginInvoker.cpp
@@ -12,19 +12,17 @@
//==========================================================================
// Framework includes
-#include "DD4hep/Detector.h"
-#include "DD4hep/Printout.h"
-#include "XML/Conversions.h"
-#include "XML/XMLElements.h"
-#include "XML/DocumentHandler.h"
-#include "DD4hep/DetFactoryHelper.h"
+#include <DD4hep/Detector.h>
+#include <DD4hep/Printout.h>
+#include <XML/Conversions.h>
+#include <XML/XMLElements.h>
+#include <XML/DocumentHandler.h>
+#include <DD4hep/DetFactoryHelper.h>
// C/C++ include files
#include <stdexcept>
-/*
- * dd4hep namespace declaration
- */
+/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
namespace {
@@ -47,9 +45,8 @@ namespace dd4hep {
template <> void Converter<plugin>::operator()(xml_h element) const;
template <> void Converter<dd4hep::arg>::operator()(xml_h element) const;
}
-using namespace std;
+
using namespace dd4hep;
-using namespace dd4hep::detail;
/** Convert arg objects
*
@@ -59,8 +56,8 @@ using namespace dd4hep::detail;
*/
template <> void Converter<dd4hep::arg>::operator()(xml_h e) const {
xml_comp_t c(e);
- string val = c.valueStr();
- vector<string>* args = (vector<string>*)param;
+ std::string val = c.valueStr();
+ std::vector<std::string>* args = (std::vector<std::string>*)param;
args->emplace_back(val);
}
@@ -72,13 +69,13 @@ template <> void Converter<dd4hep::arg>::operator()(xml_h e) const {
*/
template <> void Converter<plugin>::operator()(xml_h e) const {
xml_comp_t c(e);
- string nam = c.nameStr();
- vector<string> args;
- vector<const char*> cargs;
+ std::string nam = c.nameStr();
+ std::vector<std::string> args;
+ std::vector<const char*> cargs;
//args.emplace_back("plugin:"+nam);
xml_coll_t(e,"arg").for_each(Converter<dd4hep::arg>(description,&args));
- for(vector<string>::const_iterator i=args.begin(); i!=args.end();++i)
+ for(std::vector<std::string>::const_iterator i=args.begin(); i!=args.end();++i)
cargs.emplace_back((*i).c_str());
printout(INFO,"ConverterPlugin","+++ Now executing plugin:%s [%d args]",nam.c_str(),int(cargs.size()));
description.apply(nam.c_str(),int(cargs.size()),(char**)&cargs[0]);
@@ -93,20 +90,20 @@ template <> void Converter<plugin>::operator()(xml_h e) const {
template <> void Converter<include_file>::operator()(xml_h element) const {
xml::DocumentHolder doc(xml::DocumentHandler().load(element, element.attr_value(_U(ref))));
xml_h node = doc.root();
- string tag = node.tag();
+ std::string tag = node.tag();
if ( tag == "plugin" )
Converter<plugin>(description,param)(node);
else if ( tag == "plugins" )
Converter<plugins>(description,param)(node);
else
- throw runtime_error("Undefined tag name in XML structure:"+tag+" XML parsing abandoned.");
+ throw std::runtime_error("Undefined tag name in XML structure:"+tag+" XML parsing abandoned.");
}
/** Convert plugins objects
*
- * @author M.Frank
- * @version 1.0
- * @date 01/04/2014
+ * \author M.Frank
+ * \version 1.0
+ * \date 01/04/2014
*/
template <> void Converter<plugins>::operator()(xml_h e) const {
xml_coll_t(e, _U(define)).for_each(_U(constant), Converter<Constant>(description,param));
diff --git a/DDCore/src/plugins/ReadoutSegmentations.cpp b/DDCore/src/plugins/ReadoutSegmentations.cpp
index 578c3bfbbcd4ec2f8bf79c51beca278712a873fe..edfd47aea896bb9b5eb4655ed463e3489df0830e 100644
--- a/DDCore/src/plugins/ReadoutSegmentations.cpp
+++ b/DDCore/src/plugins/ReadoutSegmentations.cpp
@@ -12,8 +12,8 @@
//==========================================================================
// Framework includes
-#include "DD4hep/detail/SegmentationsInterna.h"
-#include "DD4hep/Factories.h"
+#include <DD4hep/detail/SegmentationsInterna.h>
+#include <DD4hep/Factories.h>
using namespace dd4hep;
using namespace dd4hep::DDSegmentation;
@@ -25,59 +25,59 @@ namespace {
}
}
-#include "DDSegmentation/NoSegmentation.h"
+#include <DDSegmentation/NoSegmentation.h>
DECLARE_SEGMENTATION(NoSegmentation,create_segmentation<dd4hep::DDSegmentation::NoSegmentation>)
-#include "DDSegmentation/CartesianGridXY.h"
+#include <DDSegmentation/CartesianGridXY.h>
DECLARE_SEGMENTATION(CartesianGridXY,create_segmentation<dd4hep::DDSegmentation::CartesianGridXY>)
-#include "DDSegmentation/CartesianGridXZ.h"
+#include <DDSegmentation/CartesianGridXZ.h>
DECLARE_SEGMENTATION(CartesianGridXZ,create_segmentation<dd4hep::DDSegmentation::CartesianGridXZ>)
-#include "DDSegmentation/CartesianGridYZ.h"
+#include <DDSegmentation/CartesianGridYZ.h>
DECLARE_SEGMENTATION(CartesianGridYZ,create_segmentation<dd4hep::DDSegmentation::CartesianGridYZ>)
-#include "DDSegmentation/CartesianGridXYZ.h"
+#include <DDSegmentation/CartesianGridXYZ.h>
DECLARE_SEGMENTATION(CartesianGridXYZ,create_segmentation<dd4hep::DDSegmentation::CartesianGridXYZ>)
-#include "DDSegmentation/CartesianGridXYStaggered.h"
+#include <DDSegmentation/CartesianGridXYStaggered.h>
DECLARE_SEGMENTATION(CartesianGridXYStaggered,dd4hep::create_segmentation<dd4hep::DDSegmentation::CartesianGridXYStaggered>)
-#include "DDSegmentation/CartesianStripX.h"
+#include <DDSegmentation/CartesianStripX.h>
DECLARE_SEGMENTATION(CartesianStripX,create_segmentation<dd4hep::DDSegmentation::CartesianStripX>)
-#include "DDSegmentation/CartesianStripY.h"
+#include <DDSegmentation/CartesianStripY.h>
DECLARE_SEGMENTATION(CartesianStripY,create_segmentation<dd4hep::DDSegmentation::CartesianStripY>)
-#include "DDSegmentation/CartesianStripZ.h"
+#include <DDSegmentation/CartesianStripZ.h>
DECLARE_SEGMENTATION(CartesianStripZ,create_segmentation<dd4hep::DDSegmentation::CartesianStripZ>)
-#include "DDSegmentation/TiledLayerGridXY.h"
+#include <DDSegmentation/TiledLayerGridXY.h>
DECLARE_SEGMENTATION(TiledLayerGridXY,create_segmentation<dd4hep::DDSegmentation::TiledLayerGridXY>)
-#include "DDSegmentation/MegatileLayerGridXY.h"
+#include <DDSegmentation/MegatileLayerGridXY.h>
DECLARE_SEGMENTATION(MegatileLayerGridXY,create_segmentation<dd4hep::DDSegmentation::MegatileLayerGridXY>)
-#include "DDSegmentation/WaferGridXY.h"
+#include <DDSegmentation/WaferGridXY.h>
DECLARE_SEGMENTATION(WaferGridXY,create_segmentation<dd4hep::DDSegmentation::WaferGridXY>)
-#include "DDSegmentation/PolarGridRPhi.h"
+#include <DDSegmentation/PolarGridRPhi.h>
DECLARE_SEGMENTATION(PolarGridRPhi,create_segmentation<dd4hep::DDSegmentation::PolarGridRPhi>)
-#include "DDSegmentation/GridPhiEta.h"
+#include <DDSegmentation/GridPhiEta.h>
DECLARE_SEGMENTATION(GridPhiEta,create_segmentation<dd4hep::DDSegmentation::GridPhiEta>)
-#include "DDSegmentation/GridRPhiEta.h"
+#include <DDSegmentation/GridRPhiEta.h>
DECLARE_SEGMENTATION(GridRPhiEta,create_segmentation<dd4hep::DDSegmentation::GridRPhiEta>)
-#include "DDSegmentation/PolarGridRPhi2.h"
+#include <DDSegmentation/PolarGridRPhi2.h>
DECLARE_SEGMENTATION(PolarGridRPhi2,create_segmentation<dd4hep::DDSegmentation::PolarGridRPhi2>)
-#include "DDSegmentation/ProjectiveCylinder.h"
+#include <DDSegmentation/ProjectiveCylinder.h>
DECLARE_SEGMENTATION(ProjectiveCylinder,create_segmentation<dd4hep::DDSegmentation::ProjectiveCylinder>)
-#include "DDSegmentation/MultiSegmentation.h"
+#include <DDSegmentation/MultiSegmentation.h>
DECLARE_SEGMENTATION(MultiSegmentation,create_segmentation<dd4hep::DDSegmentation::MultiSegmentation>)
-#include "DDSegmentation/HexGrid.h"
+#include <DDSegmentation/HexGrid.h>
DECLARE_SEGMENTATION(HexGrid,create_segmentation<dd4hep::DDSegmentation::HexGrid>)
diff --git a/DDCore/src/plugins/StandardPlugins.cpp b/DDCore/src/plugins/StandardPlugins.cpp
index c39a628e707be2da810b0fadcb35b9bad6c501fd..78fff1386b6189b882f8e359ea81af12fb6a37bb 100644
--- a/DDCore/src/plugins/StandardPlugins.cpp
+++ b/DDCore/src/plugins/StandardPlugins.cpp
@@ -48,8 +48,8 @@
using namespace dd4hep;
using namespace dd4hep::detail;
-
namespace {
+
struct ProcessorArgs {
bool use = false;
int start = 0, end = 0, argc = 0, count=0;
@@ -1711,7 +1711,7 @@ DECLARE_APPLY(DD4hep_DetectorTypes,detectortype_cache)
* \version 1.0
* \date 01/04/2014
*/
-#include "DD4hep/SurfaceInstaller.h"
+#include <DD4hep/SurfaceInstaller.h>
typedef SurfaceInstaller TestSurfacesPlugin;
DECLARE_SURFACE_INSTALLER(TestSurfaces,TestSurfacesPlugin)
@@ -1723,7 +1723,7 @@ DECLARE_SURFACE_INSTALLER(TestSurfaces,TestSurfacesPlugin)
* \version 1.0
* \date 01/04/2014
*/
-#include "DD4hep/PluginTester.h"
+#include <DD4hep/PluginTester.h>
static long install_plugin_tester(Detector& description, int , char** ) {
PluginTester* test = description.extension<PluginTester>(false);
if ( !test ) {
diff --git a/DDCore/src/plugins/VisDensityProcessor.cpp b/DDCore/src/plugins/VisDensityProcessor.cpp
index 6679d181571df88650476145dad796661c7fc354..0e79a76e0623728e3efea7c7155d945bef176af4 100644
--- a/DDCore/src/plugins/VisDensityProcessor.cpp
+++ b/DDCore/src/plugins/VisDensityProcessor.cpp
@@ -14,8 +14,9 @@
#define DD4HEP_DDCORE_VISDENSITYPROCESSOR_H
// Framework include files
-#include "DD4hep/VolumeProcessor.h"
+#include <DD4hep/VolumeProcessor.h>
+/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
/// DD4hep DetElement creator for the CMS geometry.
@@ -59,14 +60,13 @@ namespace dd4hep {
//
//==========================================================================
-//#include "DD4hep/VisDensityProcessor.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/DetectorTools.h"
-#include "DD4hep/DetectorHelper.h"
-#include "DD4hep/DetFactoryHelper.h"
+//#include <DD4hep/VisDensityProcessor.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/DetectorTools.h>
+#include <DD4hep/DetectorHelper.h>
+#include <DD4hep/DetFactoryHelper.h>
#include <sstream>
-using namespace std;
using namespace dd4hep;
/// Initializing constructor
@@ -124,7 +124,7 @@ static void* create_object(Detector& description, int argc, char** argv) {
continue;
}
else if ( ::strncmp(argv[i],"-name",4) == 0 ) {
- string name = argv[++i];
+ std::string name = argv[++i];
proc->name = name;
continue;
}
@@ -132,13 +132,13 @@ static void* create_object(Detector& description, int argc, char** argv) {
proc->show = true;
continue;
}
- cout <<
+ std::cout <<
"Usage: DD4hep_VisDensityProcessor -arg [-arg] \n"
" -vis <name> Set the visualization attribute for inactive materials\n"
" -min-vis <name> Set the visualization attribute for inactive materials\n"
" -min-density <number> Minimal density to show the volume. \n"
" -show Print setup to output device (stdout) \n"
- "\tArguments given: " << arguments(argc,argv) << endl << flush;
+ "\tArguments given: " << arguments(argc,argv) << std::endl << std::flush;
::exit(EINVAL);
}
}
diff --git a/DDCore/src/plugins/VisProcessor.cpp b/DDCore/src/plugins/VisProcessor.cpp
index 654e681ffbba8b3223881b3866074beec4f62953..f16a6a360cd5188c4d36e6cf9cb6db45df9cbcc2 100644
--- a/DDCore/src/plugins/VisProcessor.cpp
+++ b/DDCore/src/plugins/VisProcessor.cpp
@@ -13,9 +13,10 @@
#ifndef DD4HEP_DDCORE_VISMATERIALPROCESSOR_H
#define DD4HEP_DDCORE_VISMATERIALPROCESSOR_H
-// Framework include files
-#include "DD4hep/VolumeProcessor.h"
+/// Framework include files
+#include <DD4hep/VolumeProcessor.h>
+/// Namespace for the AIDA detector description toolkit
namespace dd4hep {
@@ -66,14 +67,16 @@ namespace dd4hep {
//
//==========================================================================
-//#include "DD4hep/VisMaterialProcessor.h"
-#include "DD4hep/Printout.h"
-#include "DD4hep/DetectorTools.h"
-#include "DD4hep/DetectorHelper.h"
-#include "DD4hep/DetFactoryHelper.h"
+/// Framework include files
+//#include <DD4hep/VisMaterialProcessor.h>
+#include <DD4hep/Printout.h>
+#include <DD4hep/DetectorTools.h>
+#include <DD4hep/DetectorHelper.h>
+#include <DD4hep/DetFactoryHelper.h>
+
+/// C/C++ include files
#include <sstream>
-using namespace std;
using namespace dd4hep;
namespace {
@@ -212,20 +215,20 @@ static void* create_object(Detector& description, int argc, char** argv) {
continue;
}
else if ( ::strncmp(argv[i],"-fraction",3) == 0 ) {
- stringstream str(argv[++i]);
+ std::stringstream str(argv[++i]);
if ( str.good() ) {
str >> proc->fraction;
if ( !str.fail() ) continue;
}
}
else if ( ::strncmp(argv[i],"-path",4) == 0 ) {
- string path = argv[++i];
- DetElement de = detail::tools::findElement(description,path);
+ std::string path = argv[++i];
+ DetElement de = detail::tools::findElement(description,path);
if ( de.isValid() ) continue;
printout(ERROR,"VisMaterialProcessor","++ Invalid DetElement path: %s",path.c_str());
}
else if ( ::strncmp(argv[i],"-name",4) == 0 ) {
- string name = argv[++i];
+ std::string name = argv[++i];
proc->name = name;
continue;
}
@@ -233,7 +236,7 @@ static void* create_object(Detector& description, int argc, char** argv) {
proc->show = true;
continue;
}
- cout <<
+ std::cout <<
"Usage: DD4hep_VisMaterialProcessor -arg [-arg] \n"
" -vis-active <name> Set the visualization attribute for active materials\n"
" -vis-inactive <name> Set the visualization attribute for inactive materials\n"
@@ -246,7 +249,7 @@ static void* create_object(Detector& description, int argc, char** argv) {
" -fraction <double> Set the fraction above which the active elment content\n"
" defines an active volume. \n"
" -show Print setup to output device (stdout) \n"
- "\tArguments given: " << arguments(argc,argv) << endl << flush;
+ "\tArguments given: " << arguments(argc,argv) << std::endl << std::flush;
::exit(EINVAL);
}
}