Detector.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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/objects/DetectorInterna.h"
#include "DD4hep/objects/ConditionsInterna.h"
#include "DD4hep/objects/AlignmentsInterna.h"
#include "DD4hep/AlignmentTools.h"
#include "DD4hep/DetectorTools.h"
#include "DD4hep/World.h"
#include "DD4hep/LCDD.h"

using namespace std;
using namespace DD4hep::Geometry;
using DD4hep::Alignments::Alignment;

namespace {
  static string s_empty_string;
}

DetElement::Processor::Processor()   {
}

DetElement::Processor::~Processor()   {
}

DetElement::DetElement(Object* det_data, const string& det_name, const string& det_type)
  : RefObject(det_data)
{
  this->assign(det_data, det_name, det_type);
}

DetElement::DetElement(const string& det_name, const string& det_type, int det_id) {
  assign(new Object(det_name,det_id), det_name, det_type);
  ptr()->id = det_id;
}

DetElement::DetElement(const 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 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::i_addExtension(void* ext_ptr, const type_info& info, copy_t ctor, destruct_t dtor) const {
  return access()->addExtension(ext_ptr, info, ObjectExtensions::copy_t(ctor), dtor);
}

void* DetElement::i_extension(const type_info& info) const {
  return access()->extension(info);
}

void DetElement::i_addUpdateCall(unsigned int callback_type, const Callback& callback)  const  {
  access()->updateCalls.push_back(make_pair(callback,callback_type));
}

void DetElement::removeAtUpdate(unsigned int typ, void* pointer)  const {
  access()->removeAtUpdate(typ,pointer);
}

const string& DetElement::placementPath() const {
  Object* o = ptr();
  if ( o ) {
    if (o->placementPath.empty()) {
      o->placementPath = DetectorTools::placementPath(*this);
    }
    return o->placementPath;
  }
  return s_empty_string;
}

string DetElement::type() const {
  return m_element ? m_element->GetTitle() : "";
}

DetElement& DetElement::setType(const string& typ) {
  Object* o = access();
  o->SetTitle(typ.c_str());
  return *this;
}

unsigned int DetElement::typeFlag() const {
  return m_element ? m_element->typeFlag :  0 ;
}

DetElement& DetElement::setTypeFlag(unsigned int types) {
  Object* o = access();
  o->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::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 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 = Alignment("nominal");
    o->nominal->detector = *this;
    DD4hep::Alignments::AlignmentTools::computeIdeal(o->nominal);
  }
  return o->nominal;
}

Alignment DetElement::survey() const  {
  Object* o = access();
  if ( !o->survey.isValid() )   {
    o->survey = Alignment("survey");
    DD4hep::Alignments::AlignmentTools::copy(nominal(), o->survey);
  }
  return o->survey;
}

const DetElement::Children& DetElement::children() const {
  return access()->children;
}

DetElement DetElement::child(const string& child_name) const {
  if (isValid()) {
    const Children& c = ptr()->children;
    Children::const_iterator i = c.find(child_name);
    return i == c.end() ? DetElement() : (*i).second;
  }
  return DetElement();
}

DetElement DetElement::parent() const {
  Object* o = ptr();
  return (o) ? o->parent : 0;
}

DetElement DetElement::world()  const   {
  Object* o = ptr();
  return (o) ? o->world() : 0;
}

bool DetElement::hasConditions()  const   {
  Object* o = access();
  if ( o->conditions.isValid() && !o->conditions->keys.empty() ) 
    return true;
  return false;
}

bool DetElement::hasAlignments()  const   {
  Object* o = access();
  if ( o->alignments.isValid() && !o->alignments->keys.empty() ) 
    return true;
  return false;
}

void DetElement::check(bool cond, const string& msg) const {
  if (cond) {
    throw runtime_error("DD4hep: " + msg);
  }
}

DetElement& DetElement::add(DetElement sdet) {
  if (isValid()) {
    pair<Children::iterator, bool> r = object<Object>().children.insert(make_pair(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]");
  }
  throw runtime_error("DD4hep: DetElement::add: Self is not defined [Invalid Handle]");
}

DetElement DetElement::clone(const string& new_name) const {
  Object* o = access();
  return DetElement(o->clone(o->id, COPY_NONE), new_name, o->GetTitle());
}

DetElement DetElement::clone(const string& new_name, int new_id) const {
  Object* o = access();
  return DetElement(o->clone(new_id, COPY_NONE), new_name, o->GetTitle());
}

PlacedVolume DetElement::placement() const {
  if (isValid()) {
    Object& o = object<Object>();
    if (o.placement.isValid()) {
      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;
  }
  throw runtime_error("DD4hep: DetElement::setPlacement: Placement is not defined [Invalid Handle]");
}

DD4hep::VolumeID DetElement::volumeID() const   {
  if (isValid()) {
    return object<Object>().volumeID;
  }
  return 0;
}

Volume DetElement::volume() const {
  return access()->placement.volume();
}

DetElement& DetElement::setVisAttributes(const LCDD& lcdd, const string& nam, const Volume& vol) {
  vol.setVisAttributes(lcdd, nam);
  return *this;
}

DetElement& DetElement::setRegion(const LCDD& lcdd, const string& nam, const Volume& vol) {
  if (!nam.empty()) {
    vol.setRegion(lcdd.region(nam));
  }
  return *this;
}

DetElement& DetElement::setLimitSet(const LCDD& lcdd, const string& nam, const Volume& vol) {
  if (!nam.empty()) {
    vol.setLimitSet(lcdd.limitSet(nam));
  }
  return *this;
}

DetElement& DetElement::setAttributes(const LCDD& lcdd, const Volume& vol, const string& region, const string& limits,
                                      const string& vis) {
  return setRegion(lcdd, region, vol).setLimitSet(lcdd, limits, vol).setVisAttributes(lcdd, vis, vol);
}
#if 0
DetElement& DetElement::setReference(DetElement reference) {
  Object& o = object<Object>();
  if (o.referenceTrafo) {
    delete o.referenceTrafo;
    o.referenceTrafo = 0;
  }
  object<Object>().reference = reference;
  return *this;
}

const TGeoHMatrix& DetElement::referenceTransformation() const   {
  return access()->referenceTransformation();
}

bool DetElement::localToReference(const Position& local, Position& global) const {
  // If the path is unknown an exception will be thrown inside referenceTransformation() !
  Double_t master_point[3] = { 0, 0, 0 }, local_point[3] = { local.X(), local.Y(), local.Z() };
  referenceTransformation().LocalToMaster(local_point, master_point);
  global.SetCoordinates(master_point);
  return true;
}

bool DetElement::referenceToLocal(const Position& global, Position& local) const {
  // If the path is unknown an exception will be thrown inside referenceTransformation() !
  Double_t master_point[3] = { global.X(), global.Y(), global.Z() }, local_point[3] = { 0, 0, 0 };
  referenceTransformation().MasterToLocal(master_point, local_point);
  local.SetCoordinates(local_point);
  return true;
}
#endif

const TGeoHMatrix& DetElement::worldTransformation() const   {
  return access()->worldTransformation();
}

const TGeoHMatrix& DetElement::parentTransformation() const   {
  return access()->parentTransformation();
}

bool DetElement::localToWorld(const Position& local, Position& global) const {
  Double_t master_point[3] = { 0, 0, 0 }, local_point[3] = { local.X(), local.Y(), local.Z() };
  // If the path is unknown an exception will be thrown inside worldTransformation() !
  worldTransformation().LocalToMaster(local_point, master_point);
  global.SetCoordinates(master_point);
  return true;
}

bool DetElement::localToParent(const Position& local, Position& global) const {
  // If the path is unknown an exception will be thrown inside parentTransformation() !
  Double_t master_point[3] = { 0, 0, 0 }, local_point[3] = { local.X(), local.Y(), local.Z() };
  parentTransformation().LocalToMaster(local_point, master_point);
  global.SetCoordinates(master_point);
  return true;
}

bool DetElement::worldToLocal(const Position& global, Position& local) const {
  // If the path is unknown an exception will be thrown inside worldTransformation() !
  Double_t master_point[3] = { global.X(), global.Y(), global.Z() }, local_point[3] = { 0, 0, 0 };
  worldTransformation().MasterToLocal(master_point, local_point);
  local.SetCoordinates(local_point);
  return true;
}

bool DetElement::parentToLocal(const Position& global, Position& local) const {
  // If the path is unknown an exception will be thrown inside parentTransformation() !
  Double_t master_point[3] = { global.X(), global.Y(), global.Z() }, local_point[3] = { 0, 0, 0 };
  parentTransformation().MasterToLocal(master_point, local_point);
  local.SetCoordinates(local_point);
  return true;
}

SensitiveDetector::SensitiveDetector(const string& nam, const 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 string& typ) {
  access()->SetTitle(typ.c_str());
  return *this;
}

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;
}

SensitiveDetector& SensitiveDetector::setEnergyCutoff(double value) {
  access()->ecut = value;
  return *this;
}

double SensitiveDetector::energyCutoff() const {
  return access()->ecut;
}

SensitiveDetector& SensitiveDetector::setHitsCollection(const string& collection) {
  access()->hitsCollection = collection;
  return *this;
}

const 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::i_addExtension(void* ext_ptr, const type_info& info, destruct_t dtor)  {
  return access()->addExtension(ext_ptr, info, dtor);
}

void* SensitiveDetector::i_extension(const type_info& info) const {
  return access()->extension(info);
}