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 68 of file DDTransform.h.

Constructor & Destructor Documentation

DDRotation::DDRotation

(

)

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

Definition at line 43 of file DDRotation.cc.

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

Referenced by DDanonymousRot(), DDrot(), DDrotReflect(), and matrix().

  : 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::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 58 of file DDRotation.cc.

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

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

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

Definition at line 64 of file DDRotation.cc.

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

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

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

private

Definition at line 70 of file DDRotation.cc.

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

  : 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

DDRotationMatrix& DDRotation::matrix ( void  )

inline

Definition at line 97 of file DDTransform.h.

References DDRotation(), and rotation().

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

{ return rotation(); }

const DDRotationMatrix& DDRotation::rotation ( void  ) const

inline

Returns the read-only rotation-matrix.

Definition at line 93 of file DDTransform.h.

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

Referenced by DDCompareDDRot(), DDPixFwdBlades::execute(), DDG4SolidConverter::intersection(), matrix(), operator<<(), DDCoreToDDXMLOutput::position(), DDPosData::rot(), DDPosData::rotation(), DDCoreToDDXMLOutput::rotation(), DDG4SolidConverter::subtraction(), and DDG4SolidConverter::unionsolid().

{ return rep(); }   

DDRotationMatrix& DDRotation::rotation ( void  )

inline

Definition at line 95 of file DDTransform.h.

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

{ return rep(); }

Friends And Related Function Documentation

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 177 of file DDRotation.cc.

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

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 80 of file DDRotation.cc.

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

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

friend

Definition at line 87 of file DDRotation.cc.

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

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 124 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()));  
}