AutoPositionerTool.cc

Go to the documentation of this file.

#include "AutoPositionerTool.h"

#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/MsgStream.h"

#include "DetDesc/LVolume.h"
#include "DetDesc/PVolume.h"
#include "DetDesc/SolidBase.h"
#include "DetDesc/DetectorElement.h"
#include "DetDesc/IGeometryInfo.h"
#include "GaudiKernel/Point3DTypes.h"
#include "GaudiKernel/Transform3DTypes.h"

#include <string>

AutoPositionerTool::AutoPositionerTool(const std::string& type,
                                       const std::string& name,
                                       const IInterface* parent)
  : GaudiTool(type, name, parent)
  , m_detSvc(0)
  , m_coordSvc(0)
{
  declareProperty("PhysicalVolume",m_physVolName="",
                  "Name of the physical volume to add to geometry");
  declareProperty("LogicalVolume",m_logVolName="",
                  "Name of the logical volume to associate with the physical");
  declareProperty("CoordinateDetElem",m_coordDetElemPath="",
                  "Name of the detector element used for coordinates");
  declareProperty("Position",m_position=std::vector<double>(3,0.),
                  "Position of the new volume in the parent coordinates");
  double identity[] = {1., 0., 0., 
                       0., 1., 0.,
                       0., 0., 1.};
  declareProperty("Rotation",m_rotation=std::vector<double>(identity,
                                                            identity+9),
                  "Rotation of the new volume in the parent coordinates");
  declareProperty("Element",m_detElemName="",
                  "Name of the detector element to place in the TDS");
  declareProperty("ElementPath",m_detElemPath="/dd/Structure/DayaBay",
                  "Path for the new detector element in the TDS");
  declareProperty("SubDetectorElements",
                  m_subDetElements=std::vector< std::vector<std::string> >(),
                  "Information for defining additional daughter detector elements");
}

AutoPositionerTool::~AutoPositionerTool()
{
}

StatusCode AutoPositionerTool::initialize()
{
    this->GaudiTool::initialize();

    debug() << "AutoPositionerTool::initialize()" << endreq;
    StatusCode sc = service("DetectorDataSvc",m_detSvc,true);
    if (sc.isFailure()) return sc;

    sc = service("CoordSysSvc",m_coordSvc,true);
    if (sc.isFailure()) return sc;

    return sc;
}

StatusCode AutoPositionerTool::reinitialize()
{
    return StatusCode::SUCCESS;
}

StatusCode AutoPositionerTool::finalize()
{
    m_detSvc->release();
    m_coordSvc->release();
    return this->GaudiTool::finalize();
}

StatusCode AutoPositionerTool::queryInterface(const InterfaceID& riid, 
                                              void** ppvInterface)
{
  StatusCode sc = StatusCode::FAILURE;
  if (ppvInterface) {
    *ppvInterface = 0;
    
    if (IPositionerTool::interfaceID().versionMatch(riid)) {
      *ppvInterface = static_cast<IPositionerTool*>(this);
      sc = StatusCode::SUCCESS;
      addRef();
    }
    else sc = GaudiTool::queryInterface( riid, ppvInterface );    
  }
  return sc;
}



StatusCode AutoPositionerTool::placeVolume()
{

  // Find placement detector element based on coordinate volume
  IDetectorElement* coordDetElem = getDet<IDetectorElement>(m_coordDetElemPath);
  if(!coordDetElem){
    error() << "AutoPositionerTool::placeVolume(): "
            << "could not find detector element at: " << m_coordDetElemPath
            << endreq;
    return StatusCode::FAILURE;
  }

  // Find global coordinates of new volume
  Gaudi::XYZPoint referencePosition(m_position[0],m_position[1],m_position[2]);
  Gaudi::XYZPoint globalPosition = 
    coordDetElem->geometry()->toGlobal( referencePosition );

  info() << "Using " << coordDetElem->name() 
         << " as reference system for placement of " << m_detElemName 
         << " at local position " << referencePosition 
         << " and global position " << globalPosition << endreq;

  // Find parent detector element
  IDetectorElement* parentDetElem = m_coordSvc->belongsToDE(globalPosition);
  if(!parentDetElem){
    error() << "AutoPositionerTool::placeVolume(): "
            << "could not find detector element at global position: " 
            << globalPosition << endreq;
    return StatusCode::FAILURE;
  }
  info() << "Using " << parentDetElem->name() 
         << " as supporting element for placement of " 
         << m_detElemName << endreq;

  // Find parent logical volume and relative path
  //IGeometryInfo* parentGeometry = 
  //  parentDetElem->geometry()->belongsTo(globalPosition, -1);
  //std::string npath;
  IGeometryInfo* startGeom = parentDetElem->geometry();
  ILVolume::PVolumePath pvPath;
  StatusCode sc = 
    parentDetElem->geometry()->fullGeoInfoForPoint(globalPosition, -1,
                                                   startGeom, pvPath);
  if(!sc.isSuccess()){
    error() << "AutoPositionerTool::placeVolume(): "
            << "could not find parent geometry at global position: " 
            << globalPosition << endreq;
    return StatusCode::FAILURE;
  }
  info() << "FullGeoInfoForPoint: " << startGeom->lvolumeName() << endreq;
  ILVolume::PVolumePath::iterator pvPathIter, pvPathEnd = pvPath.end();
  std::string npath;
  std::string parentLVolName = startGeom->lvolumeName();
  for(pvPathIter = pvPath.begin(); pvPathIter != pvPathEnd; pvPathIter++){
    parentLVolName = (*pvPathIter)->lvolumeName();
    if( npath.size() > 0 ) npath.append( "/" );
    npath.append( (*pvPathIter)->name() );
    info() << "  npath: " << npath << endreq;
  }
  if( npath.size() > 0 ){
    error() << "Parent volume " << parentLVolName 
            << " must have a defined detector element."
            << " Please define a detector element, and then you can place "
            <<  m_logVolName << " inside." << endreq;
    return StatusCode::FAILURE;
  }
  info() << "Using " << parentLVolName 
         << " as parent volume for placement of " << m_logVolName << endreq;
  IGeometryInfo* parentGeometry = parentDetElem->geometry();

  // Find parent logical volume for physical volume
  SmartDataPtr<LVolume> parentLogVol(m_detSvc, parentLVolName);
  if(!parentLogVol){
    error() << "AutoPositionerTool::placeVolume(): "
            << "could not find parent volume of name: " << parentLVolName
            << endreq;
    return StatusCode::FAILURE;
  }

  // Check if physical volume already exists in parent logical volume
  bool pvolumeExists = false;
  ILVolume::PVolumes::const_iterator pvIter = parentLogVol->pvBegin();
  for(;pvIter != parentLogVol->pvEnd(); pvIter++){
    if((*pvIter)->name() == m_physVolName){
      warning() << "AutoPositionerTool::placeVolume(): "
                << "physical volume " << m_physVolName
                << " already exists in parent volume " << parentLVolName
                << endreq;
      pvolumeExists = true;
      break;
    }
  }

  if( !pvolumeExists ){
    // Place physical volume
    // Find placement coordinates in local parent volume
    Gaudi::XYZPoint localPosition = parentGeometry->toLocal( globalPosition );
    Gaudi::XYZPoint parGlobalPosition = 
      parentGeometry->toGlobal( Gaudi::XYZPoint(0.,0.,0.) );
    info() << "Parent Global position is " << parGlobalPosition << endreq;
    info() << "CoordRef Global position is " << globalPosition << endreq;
    info() << "Difference is " << parGlobalPosition - globalPosition << endreq;
    info() << "Placing " << m_detElemName 
           << " at " << localPosition << " in parent volume " 
           << parentLVolName<< endreq;

    // Check if point is inside
    if( parentLogVol->isInside(localPosition) ){
      info() << "Yep, position " << localPosition
             << "is inside " << parentLVolName<< endreq;
    }else{
      info() << "Ack!  Position " << localPosition
             << "is not inside " << parentLVolName << endreq;
    }      

    {
      const SolidBase* solid = dynamic_cast<const SolidBase*>(parentLogVol->solid());
      info() << "X-extent: " << solid->xMin() << " " << solid->xMax() << endreq;
      info() << "Y-extent: " << solid->yMin() << " " << solid->yMax() << endreq;
      info() << "Z-extent: " << solid->zMin() << " " << solid->zMax() << endreq;
    }
    {
      SmartDataPtr<LVolume> logVol(m_detSvc, m_logVolName);
      const SolidBase* solid = dynamic_cast<const SolidBase*>(logVol->solid());
      info() << "X-extent: " << solid->xMin() << " " << solid->xMax() << endreq;
      info() << "Y-extent: " << solid->yMin() << " " << solid->yMax() << endreq;
      info() << "Z-extent: " << solid->zMin() << " " << solid->zMax() << endreq;
    }

    // Create the physical volume
    Gaudi::Rotation3D rotation(m_rotation.begin(), m_rotation.end());
    IPVolume* pv = 
      parentLogVol->createPVolume(m_physVolName, m_logVolName,
                                  Gaudi::Transform3D(rotation, Gaudi::XYZVector(localPosition)).Inverse() );
  
    if( 0 == pv ) {
      error() << "AutoPositionerTool::placeVolume(): "
              << "could not create volume: " << m_physVolName
              << endreq;
      return StatusCode::FAILURE;
    }
  }

  if(m_detElemName != ""){
    // Add the corresponding detector element if a name is provided
    std::string pvPath = npath;
    if(pvPath.size() > 0) npath.append( "/" );
    pvPath.append( m_physVolName );

    sc = addDetectorElement(m_detElemName, m_detElemPath, m_logVolName,
                            parentDetElem->name(), pvPath);
    if( !sc.isSuccess() ) return sc; 

    // Add any sub-detector elements below the current detector element
    std::vector< std::vector<std::string> >::iterator sdIter, 
      sdEnd = m_subDetElements.end(); 
    for(sdIter = m_subDetElements.begin(); sdIter != sdEnd; sdIter++){
      std::vector<std::string> fields = *sdIter;
      if( fields.size() != 4 ){
        error() << "Wrong number of sub-detector element fields: " 
                << fields.size() << endreq;
        for(int fieldIdx=0; fieldIdx<fields.size(); fieldIdx++){
          error() << "  Field " << fieldIdx << ": " << fields[fieldIdx] 
                  <<endreq;
        }
        return StatusCode::FAILURE;
      }
      std::string subDetElemName = fields[0];
      std::string support = fields[1];
      std::string logVolName = fields[2];
      std::string subPvPath = fields[3];
      sc = addDetectorElement(subDetElemName, m_detElemPath, logVolName,
                              support, subPvPath);
      if( !sc.isSuccess() ) return sc; 
    }
  }

  return sc;
}

StatusCode AutoPositionerTool::addDetectorElement(std::string detElemName,
                                                  std::string detElemPath, 
                                                  std::string logVolName, 
                                                  std::string support, 
                                                  std::string npath){
  // Add the detector element for existing geometry
  info() << "Using " << support 
         << " as support path for placement of " << detElemName
         << " at path " << detElemPath << endreq;  
  DetectorElement* detElem = new DetectorElement;
  StatusCode sc = m_detSvc->registerObject( detElemPath, detElemName, detElem);
  if( sc.isFailure() ){
    error() << "Failed to register object with support / name: " 
            << support << " / " << detElemName << endreq;
    return sc;
  }
  info() << "Using physical path " << npath 
         << "relative to support " << support
         << " for placement of " << logVolName << endreq;  
  detElem->createGeometryInfo( logVolName, support, npath);
  return sc;
}