Geant4PlacementParameterisation.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/Volumes.h>
#include <DD4hep/Printout.h>
#include <DDG4/Geant4Helpers.h>
#include <DDG4/Geant4PlacementParameterisation.h>
 
// Geant4 include files
#include <G4Transform3D.hh>
 
dd4hep::sim::Geant4PlacementParameterisation::Geant4PlacementParameterisation(PlacedVolume pv)
  : G4VPVParameterisation(), m_placement(pv), m_params(*pv.data()->params)
{
  G4Transform3D tr;
  auto& dim = m_dimensions;
  g4Transform(m_params.start, m_start.delta);
  m_start.translation = m_start.delta.getTranslation();
  
  g4Transform(m_params.trafo1D.first, tr);
  dim.emplace_back(Dimension(tr, m_params.trafo1D.second));
 
  m_have_rotation  = false;
  m_have_rotation |= !dim.back().delta.getRotation().isIdentity();
  m_num_cells      = m_params.trafo1D.second;
  if ( m_params.trafo2D.second > 0 )   {
    g4Transform(m_params.trafo2D.first, tr);
    dim.emplace_back(Dimension(tr, m_params.trafo2D.second));
    m_have_rotation |= !dim.back().delta.getRotation().isIdentity();
    m_num_cells     *= m_params.trafo2D.second;
  }
  if ( m_params.trafo3D.second > 0 )   {
    g4Transform(m_params.trafo3D.first, tr);
    dim.emplace_back(Dimension(tr, m_params.trafo3D.second));
    m_have_rotation |= !dim.back().delta.getRotation().isIdentity();
    m_num_cells     *= m_params.trafo3D.second;
  }
  // Set axis for pure 1D translation along a single Cartesian axis
  if ( !m_have_rotation && dim.size() == 1 ) {
    const G4ThreeVector& t = dim[0].translation;
    if      ( t.x() != 0.0 && t.y() == 0.0 && t.z() == 0.0 )  m_axis = kXAxis;
    else if ( t.x() == 0.0 && t.y() != 0.0 && t.z() == 0.0 )  m_axis = kYAxis;
    else if ( t.x() == 0.0 && t.y() == 0.0 && t.z() != 0.0 )  m_axis = kZAxis;
  }
  if ( m_have_rotation )    {
    auto callback = std::bind(&Geant4PlacementParameterisation::operator(),
                              this, std::placeholders::_1);
    if ( dim.size() == 1 )
      generate_placements(m_start.delta,
                          dim[0].delta, dim[0].count, callback);
    else if ( dim.size() == 2 )
      generate_placements(m_start.delta,
                          dim[0].delta, dim[0].count,
                          dim[1].delta, dim[1].count, callback);
    else if ( dim.size() == 3 )
      generate_placements(m_start.delta,
                          dim[0].delta, dim[0].count,
                          dim[1].delta, dim[1].count,
                          dim[2].delta, dim[2].count, callback);
  }
}
 
std::size_t dd4hep::sim::Geant4PlacementParameterisation::count()  const   {
  return m_num_cells;
}
 
void dd4hep::sim::Geant4PlacementParameterisation::operator()(const G4Transform3D& transform)   {
  this->m_translations.emplace_back(transform.getTranslation());
  if ( this->m_have_rotation )   {
    G4RotationMatrix rot = transform.inverse().getRotation();
    this->m_rotations.emplace_back(rot);
  }
}
 
void dd4hep::sim::Geant4PlacementParameterisation::ComputeTransformation(const G4int copy, G4VPhysicalVolume *pv) const  {
  const auto& dim = m_dimensions;
  std::size_t nd  = dim.size();
  if ( !m_have_rotation )    {
    G4ThreeVector tra = m_start.translation;
    if ( nd >= 1 )   {
      std::size_t d1 = 0;
      if (nd == 1) d1 = copy;
      else if (nd >= 2) d1 = copy%dim[1].count;
      tra = tra + (dim[0].translation * d1);
    }
    if ( nd >= 2 )   {
      std::size_t d2 = 0;
      if (nd == 2) d2 = copy / dim[0].count;
      else if (nd >= 3 ) d2 = copy%dim[2].count / dim[0].count;
      tra = tra + (dim[1].translation * d2);
    }
    if ( nd >= 3 )   {
      std::size_t d3 = 0;
      if ( nd == 3 ) d3 = copy / (dim[0].count*dim[1].count);
      tra = tra + (dim[2].translation * d3);
    }
    pv->SetTranslation(tra);
    return;
  }
  G4RotationMatrix& rot = m_rotations.at(copy);
  pv->SetTranslation(m_translations.at(copy));
  pv->SetRotation(&rot);
}