GlobalDetectorAlignment.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 <DDAlign/GlobalDetectorAlignment.h>
#include <DD4hep/DetectorTools.h>
#include <DD4hep/InstanceCount.h>
#include <DD4hep/MatrixHelpers.h>
#include <DD4hep/Printout.h>
#include <DD4hep/detail/Handle.inl>
#include <DD4hep/detail/DetectorInterna.h>
 
// ROOT include files
#include <TGeoMatrix.h>
#include <TGeoManager.h>
 
#ifdef __GNUC__    // Disable some diagnostics.
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
using LevelElements = std::vector<std::pair<int,dd4hep::DetElement> >;
using namespace dd4hep::align;
using dd4hep::printout;
using dd4hep::INFO;
 
namespace dd4hep {
 
  namespace align {
 
 
    class GlobalAlignmentData : public NamedObject  {
    public:
      GlobalAlignment              global;
      std::vector<GlobalAlignment> volume_alignments;
      
    public:
      GlobalAlignmentData(const std::string& path)
        : NamedObject(path, "global-alignment")
      {
        this->global = GlobalAlignment( path );
      }
      virtual ~GlobalAlignmentData()  {
        detail::destroyHandle( this->global );
      }
    };
  }   /* End namespace Aligments               */
}     /* End namespace dd4hep                  */
 
DD4HEP_INSTANTIATE_HANDLE_NAMED(GlobalAlignmentData);
 
namespace {
 
  static bool s_GlobalDetectorAlignment_debug = true;
 
  GlobalAlignment _align(const GlobalAlignment& a, TGeoHMatrix* transform, bool check, double overlap) {
    TGeoPhysicalNode* node = a.ptr();
    if ( node )  {
      TGeoMatrix* mm = node->GetNode()->GetMatrix();
      bool dbg = GlobalDetectorAlignment::debug();
      if ( dbg )  {
        printout( INFO, "Alignment", "DELTA matrix of %s", node->GetName() );
        transform->Print();
        printout( INFO, "Alignment", "OLD matrix of %s", node->GetName() );
        mm->Print();
      }
      std::vector<dd4hep::PlacedVolume> places;
      for( int i = 0; i < node->GetLevel(); ++i )
        places.emplace_back( node->GetNode(i+1) );
 
      transform->MultiplyLeft(mm); // orig * delta
      node->Align( transform, 0, check, overlap );
      if ( dbg )  {
        printout( INFO, "Alignment", "NEW matrix of %s", node->GetName() );
        node->GetNode()->GetMatrix()->Print();
      }
      TGeoVolume* oldm;
      dd4hep::PlacedVolume pv = node->GetNode(0);
      dd4hep::Volume       v  = pv->GetVolume();
      std::string          path = "/";
 
      dbg = false;
      // dbg = true;
      path += pv->GetName();
      for( int i = 0; i < node->GetLevel(); ++i )  {
        pv = node->GetNode( i+1 );
        if ( nullptr == pv->GetUserExtension() )  {
          pv->SetUserExtension( places[i]->GetUserExtension() );
        }
        oldm = pv->GetMotherVolume();
        if( dbg )  {
          path += "/";
          path += pv->GetName();
          if( oldm != v.ptr() )  {
            printout(dd4hep::ALWAYS, "GlobalAlignment",
                     // "+++ Mother relationship broken after alignment: %s  place: %p volume: %p mother volume: old: %p new: %p",
                     "+++ Fix mother relationship after alignment: %s  place: %p volume: %p mother volume: old: %p new: %p",
                     path.c_str(), (void*)pv.ptr(), (void*)pv->GetVolume(), (void*)oldm, (void*)v.ptr() );
          }
        }
        pv->SetMotherVolume( v.ptr() );
        v = pv->GetVolume();
        for( int idau = 0; idau < v->GetNdaughters(); ++idau )  {
          TGeoNode* dau = v->GetNode( idau );
          if( v.ptr() != dau->GetMotherVolume() )  {
            dau->SetMotherVolume( v );
            if( dbg )  {
              oldm = dau->GetMotherVolume();
              if( oldm != v.ptr() )  {
                printout(dd4hep::ALWAYS, "GlobalAlignment",
                         // "+++ Mother relationship broken after alignment: %s/%s  place: %p volume: %p mother volume: old: %p --> new: %p",
                         "+++ Fix mother relationship after alignment: %s/%s  place: %p volume: %p "
                         "mother volume: old: %p --> new: %p",
                         path.c_str(), dau->GetName(), (void*)dau, (void*)dau->GetVolume(),
                         (void*)oldm, (void*)v.ptr());
              }
            }
          }
        }
        if ( nullptr == v->GetUserExtension() )  {
          v->SetUserExtension( places[i].volume()->GetUserExtension() );
        }
      }
      return GlobalAlignment(node);
    }
    dd4hep::except("GlobalDetectorAlignment", "Cannot align non existing physical node. [Invalid Handle]");
    return { };
  }
  
  GlobalAlignment _alignment(const GlobalDetectorAlignment& det)  {
    dd4hep::DetElement::Object& e = det._data();
    if ( !e.global_alignment.isValid() )  {
      std::string path   = dd4hep::detail::tools::placementPath(det);
      e.global_alignment = dd4hep::Ref_t(new GlobalAlignmentData(path));
    }
    dd4hep::Handle<GlobalAlignmentData> h(e.global_alignment);
    if ( h.isValid() && h->global.isValid() )  {
      return h->global;
    }
    dd4hep::except("GlobalDetectorAlignment", "Cannot access global alignment data. [Invalid Handle]");
    return { };
  }
 
  void _dumpParentElements(GlobalDetectorAlignment& det, LevelElements& elements)   {
    int level = 0;
    dd4hep::detail::tools::PlacementPath nodes;
    dd4hep::detail::tools::ElementPath   det_nodes;
    dd4hep::detail::tools::placementPath(det, nodes);
    dd4hep::detail::tools::elementPath(det, det_nodes);
    dd4hep::detail::tools::PlacementPath::const_reverse_iterator j=nodes.rbegin();
    dd4hep::detail::tools::ElementPath::const_reverse_iterator   k=det_nodes.rbegin();
    for(; j!=nodes.rend(); ++j, ++level)  {
      //cout << "(" << level << ") " << (void*)((*j).ptr())
      //           << " " << string((*j)->GetName()) << " ";
      if ( ::strcmp((*j).ptr()->GetName(), (*k).placement().ptr()->GetName()) )  {
        //cout << "[DE]";
        elements.emplace_back(level, *k);
        ++k;
      }
      else  {
        //elements.emplace_back(level,DetElement());
      }
      //std::cout << " ";
    }
    //std::cout << std::endl;
  }
}
 
GlobalDetectorAlignment::GlobalDetectorAlignment(DetElement e)
  : DetElement(std::move(e))
{
}
 
GlobalDetectorAlignment::GlobalDetectorAlignment(DetElement&& e)
  : DetElement(std::move(e))
{
}
 
bool GlobalDetectorAlignment::debug()   {
  return s_GlobalDetectorAlignment_debug;
}
 
bool GlobalDetectorAlignment::debug(bool value)   {
  bool tmp = s_GlobalDetectorAlignment_debug;
  s_GlobalDetectorAlignment_debug = value;
  return tmp;
}
 
void GlobalDetectorAlignment::collectNodes(std::vector<PlacedVolume>& nodes)   {
  detail::tools::placementPath(*this, nodes);
}
 
GlobalAlignment GlobalDetectorAlignment::alignment() const   {
  return _alignment(*this);
}
 
std::vector<GlobalAlignment>& GlobalDetectorAlignment::volumeAlignments()  {
  Handle<GlobalAlignmentData> h(_data().global_alignment);
  return h->volume_alignments;
}
 
const std::vector<GlobalAlignment>& GlobalDetectorAlignment::volumeAlignments() const   {
  Handle<GlobalAlignmentData> h(_data().global_alignment);
  return h->volume_alignments;
}
 
GlobalAlignment GlobalDetectorAlignment::align(const Position& pos, bool chk, double overlap) {
  return align(detail::matrix::_transform(pos), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const RotationZYX& rot, bool chk, double overlap) {
  return align(detail::matrix::_transform(rot), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const Position& pos, const RotationZYX& rot, bool chk, double overlap) {
  return align(detail::matrix::_transform(pos, rot), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const Transform3D& transform, bool chk, double overlap)  {
  return align(detail::matrix::_transform(transform), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(TGeoHMatrix* matrix, bool chk, double overlap)  {
  return _align(_alignment(*this), matrix, chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const std::string& elt_path, const Position& pos, bool chk, double overlap) {
  return align(elt_path,detail::matrix::_transform(pos), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const std::string& elt_path, const RotationZYX& rot, bool chk, double overlap) {
  return align(elt_path,detail::matrix::_transform(rot), chk, overlap);
}
 
GlobalAlignment 
GlobalDetectorAlignment::align(const std::string& elt_path, const Position& pos, const RotationZYX& rot, bool chk, double overlap) {
  return align(elt_path,detail::matrix::_transform(pos, rot), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const std::string& elt_path, const Transform3D& transform, bool chk, double overlap)  {
  return align(elt_path,detail::matrix::_transform(transform), chk, overlap);
}
 
GlobalAlignment GlobalDetectorAlignment::align(const std::string& elt_path, TGeoHMatrix* matrix, bool chk, double overlap)  {
  if ( elt_path.empty() )
    return _align(_alignment(*this), matrix, chk, overlap);
  else if ( elt_path == placementPath() )
    return _align(_alignment(*this), matrix, chk, overlap);
  else if ( elt_path[0] == '/' )   {
    GlobalAlignment a(elt_path);
    volumeAlignments().emplace_back(a);
    return _align(a, matrix, chk, overlap);
  }
  GlobalAlignment a(placementPath() + '/' + elt_path);
  volumeAlignments().emplace_back(a);
  return _align(a, matrix, chk, overlap);
}