Segmentations.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/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 dd4hep;
 
DD4HEP_INSTANTIATE_HANDLE_UNNAMED(SegmentationObject);
 
Segmentation::Segmentation(const std::string& typ, const std::string& nam, const BitFieldCoder* dec) : Handle<Object>()
{
  std::string seg_type = "segmentation_constructor__"+typ;
  SegmentationObject* obj = PluginService::Create<SegmentationObject*>(seg_type, dec);
  if ( obj != 0 )  {
    assign(obj, nam, typ);
    if ( !nam.empty() ) obj->setName(nam);
    return;
  }
  // This is fatal and cannot be recovered. We need to throw an exception here.
  except("Segmentation","FAILED to create segmentation: %s. [Missing factory]",typ.c_str());
}
 
const char* Segmentation::name() const {
  return access()->name().c_str();
}
 
std::string Segmentation::type() const {
  return access()->type();
}
 
bool Segmentation::useForHitPosition() const {
  return access()->useForHitPosition != 0;
}
 
DDSegmentation::Parameters Segmentation::parameters() const {
  return access()->parameters();
}
 
DDSegmentation::Parameter  Segmentation::parameter(const std::string& parameterName) const   {
  return access()->parameter(parameterName);
}
 
Position Segmentation::position(const CellID& cell) const {
  return Position(access()->segmentation->position(cell));
}
 
CellID Segmentation::cellID(const Position& localPosition, const Position& globalPosition, const CellID & volID) const {
  return access()->segmentation->cellID(localPosition, globalPosition, volID);
}
 
VolumeID Segmentation::volumeID(const CellID& cell) const   {
  return access()->segmentation->volumeID(cell);
}
 
void Segmentation::neighbours(const CellID& cell, std::set<CellID>& nb) const  {
  access()->segmentation->neighbours(cell, nb);
}
 
std::vector<double> Segmentation::cellDimensions(const CellID& cell) const  {
  return access()->segmentation->cellDimensions(cell);
}
 
DDSegmentation::Segmentation* Segmentation::segmentation() const  {
  return access()->segmentation;
}
 
const BitFieldCoder* Segmentation::decoder()  const {
  return access()->segmentation->decoder();
}
 
void Segmentation::setDecoder(const BitFieldCoder* decode) const  {
  access()->segmentation->setDecoder(decode);
}
 
Handle<DetElementObject> Segmentation::detector() const  {
  return access()->detector;
}
 
Handle<SensitiveDetectorObject> Segmentation::sensitive() const  {
  return access()->sensitive;
}
 
#include <DDSegmentation/NoSegmentation.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::NoSegmentation);
 
#include <DDSegmentation/CartesianGrid.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGrid);
 
#include <DDSegmentation/CartesianGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridXY);
 
#include <DDSegmentation/CartesianGridXZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridXZ);
 
#include <DDSegmentation/CartesianGridYZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridYZ);
 
#include <DDSegmentation/CartesianGridUV.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridUV);
 
#include <DDSegmentation/CartesianGridXYZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianGridXYZ);
 
#include <DDSegmentation/CartesianStripX.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianStripX);
 
#include <DDSegmentation/CartesianStripY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianStripY);
 
#include <DDSegmentation/CartesianStripZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CartesianStripZ);
 
#include <DDSegmentation/TiledLayerGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::TiledLayerGridXY);
 
#include <DDSegmentation/MegatileLayerGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::MegatileLayerGridXY);
 
#include <DDSegmentation/WaferGridXY.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::WaferGridXY);
 
#include <DDSegmentation/PolarGridRPhi.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::PolarGridRPhi);
 
#include <DDSegmentation/PolarGridRPhi2.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::PolarGridRPhi2);
 
#include <DDSegmentation/GridPhiEta.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::GridPhiEta);
 
#include <DDSegmentation/GridRPhiEta.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::GridRPhiEta);
 
#include <DDSegmentation/ProjectiveCylinder.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::ProjectiveCylinder);
 
#include <DDSegmentation/MultiSegmentation.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::MultiSegmentation);
 
#include <DDSegmentation/CylindricalGridPhiZ.h>
DD4HEP_INSTANTIATE_SEGMENTATION_HANDLE(DDSegmentation::CylindricalGridPhiZ);