DetElement.cpp

Go to the documentation of this file.

//==========================================================================
//  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 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/Detector.h>
#include <DD4hep/World.h>
 
using namespace dd4hep;
    
namespace {
  static std::string s_empty_string;
}
 
DetElement::Processor::Processor()   {
}
 
DetElement::Processor::~Processor()   {
}
 
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);
}
 
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;
}
 
DetElement::DetElement(const std::string& det_name, int det_id) {
  assign(new Object(det_name,det_id), det_name, "");
  ptr()->id = 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);
}
 
void* DetElement::addExtension(ExtensionEntry* e) const  {
  return access()->addExtension(e->hash64(), e);
}
 
void* DetElement::extension(unsigned long long int k, bool alert) const {
  return access()->extension(k, alert);
}
 
void DetElement::i_addUpdateCall(unsigned int callback_type, const Callback& callback)  const  {
  access()->updateCalls.emplace_back(callback,callback_type);
}
 
void DetElement::removeAtUpdate(unsigned int typ, void* pointer)  const {
  access()->removeAtUpdate(typ,pointer);
}
 
const std::string& DetElement::placementPath() const {
  Object* o = ptr();
  if ( o ) {
    if (o->placementPath.empty()) {
      o->placementPath = detail::tools::placementPath(*this);
    }
    return o->placementPath;
  }
  return s_empty_string;
}
 
std::string DetElement::type() const {
  return m_element ? m_element->GetTitle() : "";
}
 
DetElement& DetElement::setType(const std::string& typ) {
  access()->SetTitle(typ.c_str());
  return *this;
}
 
unsigned int DetElement::typeFlag() const {
  return m_element ? m_element->typeFlag :  0 ;
}
 
DetElement& DetElement::setTypeFlag(unsigned int types) {
  access()->typeFlag = types ;
  return *this;
}
 
namespace {
  static void make_path(DetElement::Object* o)   {
    DetElement par = o->parent;
    if ( par.isValid() )  {
      o->path = par.path() + "/" + o->name;
      if ( o->level < 0 ) o->level = par.level() + 1;
    }
    else {
      o->path = "/" + o->name;
      o->level = 0;
    }
    o->key = dd4hep::detail::hash32(o->path);
  }
}
 
unsigned int DetElement::key()  const   {
  Object* o = ptr();
  if ( o )  {
    if ( o->key != 0 )
      return o->key;
    make_path(o);
    return o->key;
  }
  return 0;
}
 
int DetElement::level()  const   {
  Object* o = ptr();
  if ( o )  {
    if ( o->level >= 0 )
      return o->level;
    make_path(o);
    return o->level;
  }
  return -1;
}
 
const std::string& DetElement::path() const {
  Object* o = ptr();
  if ( o ) {
    if ( !o->path.empty() )
      return o->path;
    make_path(o);
    return o->path;
  }
  return s_empty_string;
}
 
int DetElement::id() const {
  return access()->id;
}
 
bool DetElement::combineHits() const {
  return access()->combineHits != 0;
}
 
DetElement& DetElement::setCombineHits(bool value, SensitiveDetector& sens) {
  access()->combineHits = value;
  if (sens.isValid())
    sens.setCombineHits(value);
  return *this;
}
 
Alignment DetElement::nominal() const   {
  Object* o = access();
  if ( !o->nominal.isValid() )   {
    o->nominal = AlignmentCondition("nominal");
    o->nominal->values().detector = *this;
    //o->flag |= Object::HAVE_WORLD_TRAFO;
    //o->flag |= Object::HAVE_PARENT_TRAFO;
    dd4hep::detail::tools::computeIdeal(o->nominal);
  }
  return o->nominal;
}
 
Alignment DetElement::survey() const  {
  Object* o = access();
  if ( !o->survey.isValid() )   {
    o->survey = AlignmentCondition("survey");
    dd4hep::detail::tools::copy(nominal(), o->survey);
  }
  return o->survey;
}
 
const DetElement::Children& DetElement::children() const {
  return access()->children;
}
 
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 std::runtime_error("dd4hep: DetElement::child Unknown child with name: "+child_name);
  }
  throw std::runtime_error("dd4hep: DetElement::child: Self is not defined [Invalid Handle]");
}
 
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 std::runtime_error("dd4hep: DetElement::child Unknown child with name: "+child_name);
    }
  }
  if ( throw_if_not_found )   {
    throw std::runtime_error("dd4hep: DetElement::child: Self is not defined [Invalid Handle]");
  }
  return DetElement();
}
 
DetElement DetElement::parent() const {
  Object* o = ptr();
  return (o) ? o->parent : DetElement();
}
 
DetElement DetElement::world()  const   {
  Object* o = ptr();
  return (o) ? o->world() : World();
}
 
void DetElement::check(bool cond, const std::string& msg) const {
  if (cond) {
    throw std::runtime_error("dd4hep: " + msg);
  }
}
 
DetElement& DetElement::add(DetElement sdet) {
  if (isValid()) {
    auto r = object<Object>().children.emplace(sdet.name(), sdet);
    if (r.second) {
      sdet.access()->parent = *this;
      return *this;
    }
    except("dd4hep",
           "DetElement::add: Element %s is already present in path %s [Double-Insert]",
           sdet.name(), this->path().c_str());
  }
  except("dd4hep", "DetElement::add: Self is not defined [Invalid Handle]");
  throw std::runtime_error("dd4hep: DetElement::add");
}
 
DetElement DetElement::clone(int flg) const   {
  Object* o = access();
  Object* n = o->clone(o->id, flg);
  n->SetName(o->GetName());
  n->SetTitle(o->GetTitle());
  return n;
}
 
DetElement DetElement::clone(const std::string& new_name) const {
  return clone(new_name, access()->id);
}
 
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());
  n->SetTitle(o->GetTitle());
  return n;
}
 
std::pair<DetElement,Volume> DetElement::reflect(const std::string& new_name) const {
  return reflect(new_name, access()->id);
}
 
std::pair<DetElement,Volume> DetElement::reflect(const std::string& new_name, int new_id) const {
  return reflect(new_name, new_id, SensitiveDetector(0));
}
 
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 std::make_pair(DetElement(),Volume());
}
 
PlacedVolume DetElement::idealPlacement() const    {
  if (isValid()) {
    Object& o = object<Object>();
    return o.idealPlace;
  }
  return PlacedVolume();
}
 
PlacedVolume DetElement::placement() const {
  if (isValid()) {
    Object& o = object<Object>();
    return o.placement;
  }
  return PlacedVolume();
}
 
DetElement& DetElement::setPlacement(const PlacedVolume& pv) {
  if (pv.isValid()) {
    Object* o = access();
    o->placement = pv;
    if ( !o->idealPlace.isValid() )  {
      o->idealPlace = pv;
    }
    return *this;
  }
  except("dd4hep", "DetElement::setPlacement: Placement is not defined [Invalid Handle]");
  throw std::runtime_error("dd4hep: DetElement::add");
}
 
dd4hep::VolumeID DetElement::volumeID() const   {
  if (isValid()) {
    return object<Object>().volumeID;
  }
  return 0;
}
 
Volume DetElement::volume() const {
  return access()->placement.volume();
}
 
Solid DetElement::solid() const    {
  return volume()->GetShape();
}
 
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 std::string& nam, const Volume& vol) {
  if (!nam.empty()) {
    vol.setRegion(description.region(nam));
  }
  return *this;
}
 
DetElement& DetElement::setLimitSet(const Detector& description, const std::string& nam, const Volume& vol) {
  if (!nam.empty()) {
    vol.setLimitSet(description.limitSet(nam));
  }
  return *this;
}
 
DetElement& DetElement::setAttributes(const Detector& description,
                                      const Volume& vol,
                                      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);
}
 
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"/>
    <idspecref ref="EcalEndcapHits"/>
    </calorimeter>
  */
  assign(new Object(nam), nam, typ);
  object<Object>().ecut = 0e0;
  object<Object>().verbose = 0;
}
 
SensitiveDetector& SensitiveDetector::setType(const std::string& typ) {
  access()->SetTitle(typ.c_str());
  return *this;
}
 
std::string SensitiveDetector::type() const {
  return m_element ? m_element->GetTitle() : s_empty_string;
}
 
SensitiveDetector& SensitiveDetector::setReadout(Readout ro) {
  access()->readout = ro;
  return *this;
}
 
Readout SensitiveDetector::readout() const {
  return access()->readout;
}
 
IDDescriptor SensitiveDetector::idSpec() const {
  return readout().idSpec();
}
 
SensitiveDetector& SensitiveDetector::setEnergyCutoff(double value) {
  access()->ecut = value;
  return *this;
}
 
double SensitiveDetector::energyCutoff() const {
  return access()->ecut;
}
 
SensitiveDetector& SensitiveDetector::setHitsCollection(const std::string& collection) {
  access()->hitsCollection = collection;
  return *this;
}
 
const std::string& SensitiveDetector::hitsCollection() const {
  return access()->hitsCollection;
}
 
SensitiveDetector& SensitiveDetector::setVerbose(bool value) {
  int v = value ? 1 : 0;
  access()->verbose = v;
  return *this;
}
 
bool SensitiveDetector::verbose() const {
  return access()->verbose == 1;
}
 
SensitiveDetector& SensitiveDetector::setCombineHits(bool value) {
  int v = value ? 1 : 0;
  access()->combineHits = v;
  return *this;
}
 
bool SensitiveDetector::combineHits() const {
  return access()->combineHits == 1;
}
 
SensitiveDetector& SensitiveDetector::setRegion(Region reg) {
  access()->region = reg;
  return *this;
}
 
Region SensitiveDetector::region() const {
  return access()->region;
}
 
SensitiveDetector& SensitiveDetector::setLimitSet(LimitSet ls) {
  access()->limits = ls;
  return *this;
}
 
LimitSet SensitiveDetector::limits() const {
  return access()->limits;
}
 
void* SensitiveDetector::addExtension(unsigned long long int k,ExtensionEntry* e)  const
{
  return access()->addExtension(k,e);
}
 
void* SensitiveDetector::extension(unsigned long long int k) const {
  return access()->extension(k);
}
 
void* SensitiveDetector::extension(unsigned long long int k, bool alert) const {
  return access()->extension(k, alert);
}