DDAlgoArguments.cc

Go to the documentation of this file.

#include "DD4hep/Path.h"
#include "DD4hep/Printout.h"
#include "DD4hep/Detector.h"
#include "DD4hep/BasicGrammar.h"
#include "DetectorDescription/DDCMS/interface/DDAlgoArguments.h"

#include <TClass.h>

#include <stdexcept>

using namespace std;
using namespace cms;
using namespace dd4hep;

//
// Helpers to create 3D rotation matrix from angles
//
dd4hep::Rotation3D
cms::makeRotation3D( double thetaX, double phiX,
             double thetaY, double phiY,
             double thetaZ, double phiZ) {
  dd4hep::Position posX( sin( thetaX ) * cos( phiX ),
             sin( thetaX ) * sin( phiX ),
             cos( thetaX ));
  dd4hep::Position posY( sin( thetaY ) * cos( phiY ),
             sin( thetaY ) * sin( phiY ),
             cos( thetaY ));
  dd4hep::Position posZ( sin( thetaZ ) * cos( phiZ ),
             sin( thetaZ ) * sin( phiZ ),
             cos( thetaZ ));
  dd4hep::Rotation3D rotation( posX, posY, posZ );

  return rotation;
}

// makes sure that the RotationMatrix built is
// LEFT-handed coordinate system (i.e. reflected)
dd4hep::Rotation3D
cms::makeRotReflect( double thetaX, double phiX,
             double thetaY, double phiY,
             double thetaZ, double phiZ ) {
  // define 3 unit std::vectors forming the new left-handed axes
  DD3Vector x( cos( phiX ) * sin( thetaX ), sin( phiX ) * sin( thetaX ), cos( thetaX ));
  DD3Vector y( cos( phiY ) * sin( thetaY ), sin( phiY ) * sin( thetaY ), cos( thetaY ));
  DD3Vector z( cos( phiZ ) * sin( thetaZ ), sin( phiZ ) * sin( thetaZ ), cos( thetaZ ));

  constexpr double tol = 1.0e-3; // Geant4 compatible
  double check = ( x.Cross( y )).Dot( z ); // in case of a LEFT-handed orthogonal system this must be -1
  if( abs( 1. + check ) > tol ) {
    except("DD4CMS","+++ FAILED to construct Rotation is not LEFT-handed!");
  }

  dd4hep::Rotation3D rotation( x.x(), y.x(), z.x(),
                   x.y(), y.y(), z.y(),
                   x.z(), y.z(), z.z());  
  return rotation;
}

dd4hep::Rotation3D
cms::makeRotation3D( dd4hep::Rotation3D rotation, const std::string& axis, double angle )
{
  switch( hash( axis ))
  {
    case hash("x"):
      rotation = dd4hep::RotationX( angle );
      break;
    case hash("y"):
      rotation = dd4hep::RotationY( angle );
      break;
    case hash("z"):
      rotation = dd4hep::RotationZ( angle );
      break;
    default:
      throw std::runtime_error( "Axis is not valid." );
  }
  return rotation;
}

DDAlgoArguments::DDAlgoArguments( cms::DDParsingContext& ctxt, xml_h elt )
  : context( ctxt ),
    element( elt )
{
  name = xml_dim_t( element ).nameStr();
}

string
DDAlgoArguments::parentName() const {
  cms::DDNamespace n( context );
  xml_dim_t e( element );
  string val = n.realName(xml_dim_t(e.child(DD_CMU(rParent))).nameStr());
  return val;
}

string DDAlgoArguments::childName()  const   {
  cms::DDNamespace n(context);
  return n.realName(value<string>("ChildName"));
}

bool DDAlgoArguments::find(const string& nam)  const   {
  for(xml_coll_t p(element,_U(star)); p; ++p)  {
    string n = p.attr<string>(_U(name));
    if ( n == nam )  {
      return true;
    }
  }
  return false;
}

xml_h DDAlgoArguments::rawArgument(const string& nam)  const   {
  for(xml_coll_t p(element,_U(star)); p; ++p)  {
    string n = p.attr<string>(_U(name));
    if ( n == nam )  {
      return std::move( p );
    }
  }
  except("DD4CMS","+++ Attempt to access non-existing algorithm option %s[%s]",name.c_str(),nam.c_str());
  throw runtime_error("DDCMS: Attempt to access non-existing algorithm option.");
}

string DDAlgoArguments::resolved_scalar_arg(const string& nam)  const   {
  cms::DDNamespace ns(context);
  xml_h  arg = rawArgument(nam);
  string val = arg.attr<string>(_U(value));
  return ns.realName(val);
}

namespace {

  vector<string> raw_vector(const DDAlgoArguments* a, xml_h arg)   {
    xml_dim_t xp(arg);
    vector<string> data;
    cms::DDNamespace ns(a->context);
    string val = xp.text();
    string nam = xp.nameStr();
    string typ = xp.typeStr();
    int    num = xp.attr<int>(DD_CMU(nEntries));
    const BasicGrammar& gr = BasicGrammar::instance<vector<string> >();

    val = '['+ns.realName(val)+']';
    val = remove_whitespace(val);
    int res = gr.fromString(&data,val);
    if ( !res )  {
      except("DD4CMS","+++ VectorParam<%s>: %s -> %s [Invalid conversion:%d]",
             typ.c_str(), nam.c_str(), val.c_str(), res);
    }
    else if ( num != (int)data.size() )  {
      except("DD4CMS","+++ VectorParam<%s>: %s -> %s [Invalid entry count: %d <> %ld]",
             typ.c_str(), nam.c_str(), val.c_str(), num, data.size());
    }
    printout(DEBUG,"DD4CMS","+++ VectorParam<%s>: ret=%d %s -> %s",
             typ.c_str(), res, nam.c_str(), gr.str(&data).c_str());
    return data;
  }


  template <typename T> T __cnv(const string&)       { return 0;}
  template <> double __cnv<double>(const string& arg)   { return _toDouble(arg); }
  template <> float  __cnv<float> (const string& arg)   { return _toFloat(arg); }
  template <> long   __cnv<long>  (const string& arg)   { return _toLong(arg); }
  template <> int    __cnv<int>   (const string& arg)   { return _toInt(arg);  }
  template <> string __cnv<string>(const string& arg)   { return arg;  }

  template <typename T> vector<T> __cnvVect(const DDAlgoArguments* a, const char* req_typ, xml_h xp)   {
    cms::DDNamespace ns(a->context);
    string piece;
    string nam = xp.attr<string>(_U(name));
    string typ = xp.attr<string>(_U(type));
    string val = xp.text();
    int    num = xp.attr<int>(DD_CMU(nEntries));
    if ( typ != req_typ )   {
      except("DD4CMS",
             "+++ VectorParam<%s | %s>: %s -> <%s> %s [Incompatible vector-type]",
             req_typ, typ.c_str(), nam.c_str(), typeName(typeid(T)).c_str(),
             val.c_str());
    }
    vector<T> data;
    val = remove_whitespace(val);
    if ( !val.empty() ) val += ',';
    for(size_t idx=0, idq=val.find(',',idx);
        idx != string::npos && idq != string::npos;
        idx=++idq, idq=val.find(',',idx))
    {
      piece = ns.realName(val.substr(idx,idq-idx));
      T d = __cnv<T>(piece);
      data.push_back(d);
    }
    printout(DEBUG,"DD4CMS","+++ VectorParam<%s>: %s[%d] -> %s",
             typ.c_str(), nam.c_str(), num, val.c_str());
    return data;
  }
}

namespace cms  {

  template<typename T> T DDAlgoArguments::value(const string& nam)  const   {
    return __cnv<T>(resolved_scalar_arg(nam));
  }

  template double DDAlgoArguments::value<double>(const string& nam)  const;
  template float  DDAlgoArguments::value<float>(const string& nam)  const;
  template long   DDAlgoArguments::value<long>(const string& nam)  const;
  template int    DDAlgoArguments::value<int>(const string& nam)  const;
  template string DDAlgoArguments::value<string>(const string& nam)  const;
  
  template<> vector<string> DDAlgoArguments::value<vector<string> >(const string& nam)  const
  {      return raw_vector(this,rawArgument(nam));                     }
  
  template<> vector<double> DDAlgoArguments::value<vector<double> >(const string& nam)  const
  {      return __cnvVect<double>(this,"numeric",rawArgument(nam));    }
  
  template<> vector<float> DDAlgoArguments::value<vector<float> >(const string& nam)  const
  {      return __cnvVect<float>(this,"numeric",rawArgument(nam));     }
  
  template<> vector<long> DDAlgoArguments::value<vector<long> >(const string& nam)  const
  {      return __cnvVect<long>(this,"numeric",rawArgument(nam));      }
  
  template<> vector<int> DDAlgoArguments::value<vector<int> >(const string& nam)  const
  {      return __cnvVect<int>(this,"numeric",rawArgument(nam));       }
}

string DDAlgoArguments::str(const string& nam)  const
{  return this->value<string>(nam);                }

double DDAlgoArguments::dble(const string& nam)  const
{  return this->value<double>(nam);                }

int DDAlgoArguments::integer(const string& nam)  const
{  return this->value<int>(nam);                   }

vector<double> DDAlgoArguments::vecDble(const string& nam)  const
{  return this->value<vector<double> >(nam);       }

vector<int> DDAlgoArguments::vecInt(const string& nam)  const
{  return this->value<vector<int> >(nam);          }

vector<string> DDAlgoArguments::vecStr(const string& nam)  const
{  return this->value<vector<string> >(nam);       }