#include <G4tgbRotationMatrix.hh>

Public Member Functions
	G4tgbRotationMatrix ()

	~G4tgbRotationMatrix ()

	G4tgbRotationMatrix (G4tgrRotationMatrix *tgr)

G4RotationMatrix *	BuildG4RotMatrix ()

G4RotationMatrix *	BuildG4RotMatrixFrom3 (std::vector< G4double > &values)

G4RotationMatrix *	BuildG4RotMatrixFrom6 (std::vector< G4double > &values)

G4RotationMatrix *	BuildG4RotMatrixFrom9 (std::vector< G4double > &values)

const G4String &	GetName ()

Detailed Description

Definition at line 46 of file G4tgbRotationMatrix.hh.

Constructor & Destructor Documentation

◆ G4tgbRotationMatrix() [1/2]

G4tgbRotationMatrix::G4tgbRotationMatrix ( )

Definition at line 38 of file G4tgbRotationMatrix.cc.

39{

40}

◆ ~G4tgbRotationMatrix()

G4tgbRotationMatrix::~G4tgbRotationMatrix ( )

Definition at line 43 of file G4tgbRotationMatrix.cc.

44{

45}

◆ G4tgbRotationMatrix() [2/2]

G4tgbRotationMatrix::G4tgbRotationMatrix ( G4tgrRotationMatrix * tgr )

Definition at line 48 of file G4tgbRotationMatrix.cc.

  : theTgrRM(tgr)
{
}

Member Function Documentation

◆ BuildG4RotMatrix()

G4RotationMatrix * G4tgbRotationMatrix::BuildG4RotMatrix ( )

Definition at line 54 of file G4tgbRotationMatrix.cc.

{
  std::vector<G4double> values = theTgrRM->GetValues();
 
  if(values.size() == 3)
  {
    return BuildG4RotMatrixFrom3(values);
  }
  else if(values.size() == 6)
  {
    return BuildG4RotMatrixFrom6(values);
  }
  else if(values.size() == 9)
  {
    return BuildG4RotMatrixFrom9(values);
  }
  else
  {
    G4String ErrMessage = "Number of values is: " +
                          G4UIcommand::ConvertToString(G4int(values.size())) +
                          G4String(". It should be 3, 6, or 9 !");
    G4Exception("G4tgbRotationMatrix::BuildG4RotMatrix()", "InvalidData",
                FatalException, ErrMessage);
  }
  return nullptr;
}

Referenced by G4tgbRotationMatrixMgr::FindOrBuildG4RotMatrix().

◆ BuildG4RotMatrixFrom3()

G4RotationMatrix * G4tgbRotationMatrix::BuildG4RotMatrixFrom3 ( std::vector< G4double > & values )

Definition at line 83 of file G4tgbRotationMatrix.cc.

{
  G4RotationMatrix* rotMat = new G4RotationMatrix();
 
  rotMat->rotateX(values[0]);
  rotMat->rotateY(values[1]);
  rotMat->rotateZ(values[2]);
 
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 1)
  {
    G4cout << " Constructing new G4RotationMatrix from 3 numbers " << GetName()
           << " : " << *rotMat << G4endl;
  }
#endif
 
  return rotMat;
}

Referenced by BuildG4RotMatrix().

◆ BuildG4RotMatrixFrom6()

G4RotationMatrix * G4tgbRotationMatrix::BuildG4RotMatrixFrom6 ( std::vector< G4double > & values )

Definition at line 104 of file G4tgbRotationMatrix.cc.

{
  G4double thetaX = values[0];
  G4double phiX   = values[1];
  G4double thetaY = values[2];
  G4double phiY   = values[3];
  G4double thetaZ = values[4];
  G4double phiZ   = values[5];
 
  // build the 3 axis from the values
  G4ThreeVector colx(std::sin(thetaX) * std::cos(phiX),
                     std::sin(thetaX) * std::sin(phiX), std::cos(thetaX));
  G4ThreeVector coly(std::sin(thetaY) * std::cos(phiY),
                     std::sin(thetaY) * std::sin(phiY), std::cos(thetaY));
  G4ThreeVector colz(std::sin(thetaZ) * std::cos(phiZ),
                     std::sin(thetaZ) * std::sin(phiZ), std::cos(thetaZ));
 
  // Now create a G4RotationMatrix (HepRotation), which can be left handed.
  // This is not foreseen in CLHEP, but can be achieved using the
  // constructor which does not check its input arguments!
 
  G4Rep3x3 rottemp(colx.x(), coly.x(), colz.x(),  // matrix representation
                   colx.y(), coly.y(), colz.y(),  // (inverted)
                   colx.z(), coly.z(), colz.z());
 
  G4RotationMatrix* rotMat = new G4RotationMatrix(rottemp);
 
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 1)
  {
    G4cout << " Constructing new G4RotationMatrix from 6 numbers " << GetName()
           << " : " << *rotMat << G4endl;
  }
#endif
 
  return rotMat;
}

Referenced by BuildG4RotMatrix().

◆ BuildG4RotMatrixFrom9()

G4RotationMatrix * G4tgbRotationMatrix::BuildG4RotMatrixFrom9 ( std::vector< G4double > & values )

Definition at line 144 of file G4tgbRotationMatrix.cc.

{
  // build the 3 axis from the values
  G4ThreeVector colx(values[0], values[1], values[2]);
  G4ThreeVector coly(values[3], values[4], values[5]);
  G4ThreeVector colz(values[6], values[7], values[8]);
 
  // Now create a G4RotationMatrix (HepRotation), which can be left handed.
  // This is not foreseen in CLHEP, but can be achieved using the
  // constructor which does not check its input arguments!
 
  G4Rep3x3 rottemp(colx.x(), coly.x(), colz.x(),  // matrix representation
                   colx.y(), coly.y(), colz.y(),  // (inverted)
                   colx.z(), coly.z(), colz.z());
 
  G4RotationMatrix* rotMat = new G4RotationMatrix(rottemp);
 
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 1)
  {
    G4cout << " Constructing new G4RotationMatrix from 9 numbers " << GetName()
           << " : " << *rotMat << G4endl;
  }
#endif
 
  return rotMat;
}