DDRotation Class Reference

Represents a uniquely identifyable rotation matrix. More...

#include <DDTransform.h>

Inheritance diagram for DDRotation:

Public Member Functions
	DDRotation ()
	refers to the unit-rotation (no rotation at all) More...
	DDRotation (const DDName &name)
	Creates a initialized reference-object or a reference to an allready defined rotation. More...
	DDRotation (const DDName &, std::unique_ptr< DDRotationMatrix >)
DDRotationMatrix &	matrix ()
const DDRotationMatrix &	rotation () const
	Returns the read-only rotation-matrix. More...
DDRotationMatrix &	rotation ()
Public Member Functions inherited from DDBase< DDName, std::unique_ptr< DDRotationMatrix > >
void	create (const DDName &name, std::unique_ptr< DDRotationMatrix > vals)
void	create (const DDName &name)
	DDBase ()
const DDName &	ddname () const
def_type	isDefined () const
bool	isValid () const
	true, if the wrapped pointer is valid More...
const DDName &	name () const
	operator bool () const
bool	operator< (const DDBase &b) const
bool	operator== (const DDBase &b) const
bool	operator> (const DDBase &b) const
const DDI::rep_traits< DDName, std::unique_ptr< DDRotationMatrix > >::reference	rep () const
DDI::rep_traits< DDName, std::unique_ptr< DDRotationMatrix > >::reference	rep ()
std::string	toString () const
const DDI::rep_traits< DDName, std::unique_ptr< DDRotationMatrix > >::reference	val () const
const DDI::rep_traits< DDName, std::unique_ptr< DDRotationMatrix > >::reference	val ()
virtual	~DDBase ()

Private Member Functions
	DDRotation (std::unique_ptr< DDRotationMatrix >)

Friends
DDRotation	DDanonymousRot (std::unique_ptr< DDRotationMatrix >)
	Defines a anonymous rotation or rotation-reflection matrix. More...
DDRotation	DDrot (const DDName &, std::unique_ptr< DDRotationMatrix >)
	Definition of a uniquely identifiable rotation matrix named by DDName name. More...
std::unique_ptr< DDRotation >	DDrotPtr (const DDName &, std::unique_ptr< DDRotationMatrix >)
DDRotation	DDrotReflect (const DDName &, double, double, double, double, double, double)
	Defines a rotation-reflection in the Geant3 way. More...

Additional Inherited Members
Public Types inherited from DDBase< DDName, std::unique_ptr< DDRotationMatrix > >
using	def_type = std::pair< const DDName *, bool >
using	StoreT = DDI::Singleton< DDI::Store< DDName, std::unique_ptr< DDRotationMatrix > > >
Static Public Member Functions inherited from DDBase< DDName, std::unique_ptr< DDRotationMatrix > >
static auto	begin ()
static auto	end ()

Detailed Description

Represents a uniquely identifyable rotation matrix.

An object of this class is a reference-object and thus leightweighted. It is uniquely identified by its DDName. Further details concerning reference-objects can be found in the documentation of DDLogicalPart.

DDRotation encapsulates ROOT Rotation3D.

Definition at line 57 of file DDTransform.h.

Constructor & Destructor Documentation

DDRotation() [1/4]

DDRotation::DDRotation

(

)

refers to the unit-rotation (no rotation at all)

Definition at line 40 of file DDRotation.cc.

References visDQMUpload::buf, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), and DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::create().

                       : DDBase<DDName, std::unique_ptr<DDRotationMatrix>>() {
  constexpr char const* baseName = "DdBlNa";
  // In this particular case, we do not really care about multiple threads
  // using the same counter, we simply need to have a unique id for the
  // blank matrix being created, so just making this static an atomic should do
  // the trick. In order to ensure repeatibility one should also include some
  // some run specific Id, I guess. Not sure it really matters.
  static std::atomic<int> countBlank;
  char buf[64];
  snprintf(buf, 64, "%s%i", baseName, countBlank++);
  create(DDName(buf, baseName), std::make_unique<DDRotationMatrix>());
}

DDRotation() [2/4]

DDRotation::DDRotation

(

const DDName &

name

)

Creates a initialized reference-object or a reference to an allready defined rotation.

A reference-object to a defined rotation is created if a rotation was already defined usind DDrot(). Otherwise a (default) initialized reference-object named name is created. At any later stage the rotation matrix can be defined using DDrot(). All initialized-reference object referring to the same name will then immidialtely refere to the matrix created by DDrot().

DDRotation is a lightweighted reference-object. For further details concerning reference-object refere to the documentation of DDLogicalPart.

Definition at line 53 of file DDRotation.cc.

References DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::create(), and DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::name().

: DDBase<DDName, std::unique_ptr<DDRotationMatrix>>() { create(name); }

DDRotation() [3/4]

DDRotation::DDRotation	(	const DDName &	name,
		std::unique_ptr< DDRotationMatrix >	rot
	)

Definition at line 55 of file DDRotation.cc.

References DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::create(), eostools::move(), DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::name(), and makeMuonMisalignmentScenario::rot.

    : DDBase<DDName, std::unique_ptr<DDRotationMatrix>>() {
  create(name, std::move(rot));
}

DDRotation() [4/4]

DDRotation::DDRotation ( std::unique_ptr< DDRotationMatrix >  rot )

private

Definition at line 60 of file DDRotation.cc.

References visDQMUpload::buf, DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::create(), eostools::move(), and makeMuonMisalignmentScenario::rot.

                                                          : DDBase<DDName, std::unique_ptr<DDRotationMatrix>>() {
  static std::atomic<int> countNN;
  char buf[64];
  snprintf(buf, 64, "DdNoNa%i", countNN++);
  create(DDName(buf, "DdNoNa"), std::move(rot));
}

Member Function Documentation

matrix()

DDRotationMatrix& DDRotation::matrix ( void  )

inline

Definition at line 85 of file DDTransform.h.

References rotation().

Referenced by TGeoMgrFromDdd::createShape(), DDHtmlRoDetails::details(), DDTrackerIrregularRingAlgo::execute(), and DDTrackerRingAlgo::execute().

{ return rotation(); }

rotation() [1/2]

const DDRotationMatrix& DDRotation::rotation ( void  ) const

inline

Returns the read-only rotation-matrix.

Definition at line 81 of file DDTransform.h.

References DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::rep().

Referenced by DDCompareDDRot(), DDPixFwdBladesNew::execute(), DDPixFwdBlades::execute(), matrix(), DDCoreToDDXMLOutput::position(), DDPosData::rot(), and DDPosData::rotation().

{ return rep(); }

rotation() [2/2]

DDRotationMatrix& DDRotation::rotation ( void  )

inline

Definition at line 83 of file DDTransform.h.

References DDBase< DDName, std::unique_ptr< DDRotationMatrix > >::rep().

{ return rep(); }

Friends And Related Function Documentation

DDanonymousRot

DDRotation DDanonymousRot ( std::unique_ptr< DDRotationMatrix >  rot )

friend

Defines a anonymous rotation or rotation-reflection matrix.

It can't be addressed by a unique DDName. Once created, it's the users responsibility to keep the reference object DDRotation! Will be mostly used by algorithmic positioning.

Definition at line 143 of file DDRotation.cc.

{ return DDRotation(std::move(rot)); }

DDrot

DDRotation DDrot ( const DDName &  name, std::unique_ptr< DDRotationMatrix >  rot  )

friend

Definition of a uniquely identifiable rotation matrix named by DDName name.

DDrot() returns a reference-object DDRotation representing the rotation matrix rot.

The user must not free memory allocated for rot!

Definition at line 67 of file DDRotation.cc.

                                                                            {
  // memory of rot goes sto DDRotationImpl!!
  return DDRotation(ddname, std::move(rot));
}

DDrotPtr

std::unique_ptr<DDRotation> DDrotPtr ( const DDName &  name, std::unique_ptr< DDRotationMatrix >  rot  )

friend

Definition at line 72 of file DDRotation.cc.

                                                                                              {
  // memory of rot goes sto DDRotationImpl!!
  return std::make_unique<DDRotation>(ddname, std::move(rot));
}

DDrotReflect

DDRotation DDrotReflect ( const DDName &  name, double  thetaX, double  phiX, double  thetaY, double  phiY, double  thetaZ, double  phiZ  )

friend

Defines a rotation-reflection in the Geant3 way.

The resulting matrix MUST be a LEFThanded orthonormal system, otherwise a DDException will be thrown!

Definition at line 101 of file DDRotation.cc.

                                                                                                              {
  // 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));

  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 (fabs(1. + check) > tol) {
    edm::LogError("DDRotation") << ddname << " is not a LEFT-handed orthonormal matrix!" << std::endl;
    throw cms::Exception("DDException") << ddname.name() << " is not LEFT-handed!";
  }

  return DDRotation(ddname,
                    std::make_unique<DDRotationMatrix>(x.x(), y.x(), z.x(), x.y(), y.y(), z.y(), x.z(), y.z(), z.z()));
}