G4CrystalUnitCell Class Reference

#include <G4CrystalUnitCell.hh>

Public Member Functions
	G4CrystalUnitCell (G4double sizeA, G4double sizeB, G4double sizeC, G4double alpha, G4double beta, G4double gamma, G4int spacegroup)
virtual	~G4CrystalUnitCell ()=default
G4int	GetSpaceGroup () const
void	SetSpaceGroup (G4int aInt)
theLatticeSystemType	GetLatticeSystem ()
theBravaisLatticeType	GetBravaisLattice ()
const G4ThreeVector &	GetBasis (G4int idx) const
const G4ThreeVector &	GetUnitBasis (G4int idx) const
G4ThreeVector	GetSize () const
G4ThreeVector	GetAngle () const
G4ThreeVector	GetUnitBasisTrigonal ()
const G4ThreeVector &	GetRecBasis (G4int idx) const
const G4ThreeVector &	GetRecUnitBasis (G4int idx) const
G4ThreeVector	GetRecSize () const
G4ThreeVector	GetRecAngle () const
G4bool	FillAtomicUnitPos (G4ThreeVector &pos, std::vector< G4ThreeVector > &vecout)
G4bool	FillAtomicPos (G4ThreeVector &pos, std::vector< G4ThreeVector > &vecout)
G4bool	FillElReduced (G4double Cij[6][6])
G4double	ComputeCellVolume ()
G4double	GetVolume () const
G4double	GetRecVolume () const
G4double	GetIntSp2 (G4int h, G4int k, G4int l)
G4double	GetRecIntSp2 (G4int h, G4int k, G4int l)
G4double	GetIntCosAng (G4int h1, G4int k1, G4int l1, G4int h2, G4int k2, G4int l2)

Protected Attributes
G4ThreeVector	nullVec
G4ThreeVector	theSize
G4ThreeVector	theAngle
G4ThreeVector	theUnitBasis [3]
G4ThreeVector	theBasis [3]
G4ThreeVector	theRecSize
G4ThreeVector	theRecAngle
G4ThreeVector	theRecUnitBasis [3]
G4ThreeVector	theRecBasis [3]

Detailed Description

Definition at line 44 of file G4CrystalUnitCell.hh.

Constructor & Destructor Documentation

G4CrystalUnitCell()

G4CrystalUnitCell::G4CrystalUnitCell	(	G4double	sizeA,
		G4double	sizeB,
		G4double	sizeC,
		G4double	alpha,
		G4double	beta,
		G4double	gamma,
		G4int	spacegroup )

Definition at line 33 of file G4CrystalUnitCell.cc.

  : theSize(G4ThreeVector(sizeA, sizeB, sizeC)),
    theAngle(G4ThreeVector(alpha, beta, gamma)),
    theSpaceGroup(spacegroup)
{
  nullVec = G4ThreeVector(0., 0., 0.);
  theUnitBasis[0] = CLHEP::HepXHat;
  theUnitBasis[1] = CLHEP::HepYHat;
  theUnitBasis[2] = CLHEP::HepZHat;
 
  theRecUnitBasis[0] = CLHEP::HepXHat;
  theRecUnitBasis[1] = CLHEP::HepYHat;
  theRecUnitBasis[2] = CLHEP::HepZHat;
 
  cosa = std::cos(alpha), cosb = std::cos(beta), cosg = std::cos(gamma);
  sina = std::sin(alpha), sinb = std::sin(beta), sing = std::sin(gamma);
 
  cosar = (cosb * cosg - cosa) / (sinb * sing);
  cosbr = (cosa * cosg - cosb) / (sina * sing);
  cosgr = (cosa * cosb - cosg) / (sina * sinb);
 
  theVolume = ComputeCellVolume();
  theRecVolume = 1. / theVolume;
 
  theRecSize[0] = sizeB * sizeC * sina / theVolume;
  theRecSize[1] = sizeC * sizeA * sinb / theVolume;
  theRecSize[2] = sizeA * sizeB * sing / theVolume;
 
  theRecAngle[0] = std::acos(cosar);
  theRecAngle[1] = std::acos(cosbr);
  theRecAngle[2] = std::acos(cosgr);
 
  G4double x3, y3, z3;
 
  switch (GetLatticeSystem(theSpaceGroup)) {
    case Amorphous:
      break;
    case Cubic:  // Cubic, C44 set
      break;
    case Tetragonal:
      break;
    case Orthorhombic:
      break;
    case Rhombohedral:
      theUnitBasis[1].rotateZ(gamma - CLHEP::halfpi);  // X-Y opening angle
      // Z' axis computed by hand to get both opening angles right
      // X'.Z' = cos(alpha), Y'.Z' = cos(beta), solve for Z' components
      x3 = cosa, y3 = (cosb - cosa * cosg) / sing, z3 = std::sqrt(1. - x3 * x3 - y3 * y3);
      theUnitBasis[2] = G4ThreeVector(x3, y3, z3).unit();
      break;
    case Monoclinic:
      theUnitBasis[2].rotateX(beta - CLHEP::halfpi);  // Z-Y opening angle
      break;
    case Triclinic:
      theUnitBasis[1].rotateZ(gamma - CLHEP::halfpi);  // X-Y opening angle
      // Z' axis computed by hand to get both opening angles right
      // X'.Z' = cos(alpha), Y'.Z' = cos(beta), solve for Z' components
      x3 = cosa, y3 = (cosb - cosa * cosg) / sing, z3 = std::sqrt(1. - x3 * x3 - y3 * y3);
      theUnitBasis[2] = G4ThreeVector(x3, y3, z3).unit();
      break;
    case Hexagonal:  // Tetragonal, C16=0
      theUnitBasis[1].rotateZ(30. * CLHEP::deg);  // X-Y opening angle
      break;
    default:
      break;
  }
 
  for (auto i : {0, 1, 2}) {
    theBasis[i] = theUnitBasis[i] * theSize[i];
    theRecBasis[i] = theRecUnitBasis[i] * theRecSize[i];
  }
}

~G4CrystalUnitCell()

virtual G4CrystalUnitCell::~G4CrystalUnitCell ( )

virtualdefault

Member Function Documentation

ComputeCellVolume()

G4double G4CrystalUnitCell::ComputeCellVolume

(

)

Definition at line 378 of file G4CrystalUnitCell.cc.

{
  G4double a = theSize[0], b = theSize[1], c = theSize[2];
 
  switch (GetLatticeSystem()) {
    case Amorphous:
      return 0.;
      break;
    case Cubic:
      return a * a * a;
      break;
    case Tetragonal:
      return a * a * c;
      break;
    case Orthorhombic:
      return a * b * c;
      break;
    case Rhombohedral:
      return a * a * a * std::sqrt(1. - 3. * cosa * cosa + 2. * cosa * cosa * cosa);
      break;
    case Monoclinic:
      return a * b * c * sinb;
      break;
    case Triclinic:
      return a * b * c *
             std::sqrt(1. - cosa * cosa - cosb * cosb - cosg * cosg * 2. * cosa * cosb * cosg);
      break;
    case Hexagonal:
      return std::sqrt(3.0) / 2. * a * a * c;
      break;
    default:
      break;
  }
 
  return 0.;
}

Referenced by G4CrystalUnitCell().

FillAtomicPos()

G4bool G4CrystalUnitCell::FillAtomicPos	(	G4ThreeVector &	pos,
		std::vector< G4ThreeVector > &	vecout )

Definition at line 192 of file G4CrystalUnitCell.cc.

{
  FillAtomicUnitPos(posin, vecout);
  for (auto& vec : vecout) {
    vec.setX(vec.x() * theSize[0]);
    vec.setY(vec.y() * theSize[1]);
    vec.setZ(vec.z() * theSize[2]);
  }
  return true;
}

Referenced by G4CrystalExtension::GetAtomPos().

FillAtomicUnitPos()

G4bool G4CrystalUnitCell::FillAtomicUnitPos	(	G4ThreeVector &	pos,
		std::vector< G4ThreeVector > &	vecout )

Definition at line 181 of file G4CrystalUnitCell.cc.

{
  // Just for testing the infrastructure
  G4ThreeVector aaa = pos;
  vecout.push_back(aaa);
  vecout.emplace_back(2., 5., 3.);
  return true;
}

Referenced by FillAtomicPos().

FillElReduced()

G4bool G4CrystalUnitCell::FillElReduced

(

G4double

Cij[6][6]

)

Definition at line 205 of file G4CrystalUnitCell.cc.

{
  switch (GetLatticeSystem()) {
    case Amorphous:
      return FillAmorphous(Cij);
      break;
    case Cubic:  // Cubic, C44 set
      return FillCubic(Cij);
      break;
    case Tetragonal:
      return FillTetragonal(Cij);
      break;
    case Orthorhombic:
      return FillOrthorhombic(Cij);
      break;
    case Rhombohedral:
      return FillRhombohedral(Cij);
      break;
    case Monoclinic:
      return FillMonoclinic(Cij);
      break;
    case Triclinic:
      return FillTriclinic(Cij);
      break;
    case Hexagonal:  // Tetragonal, C16=0
      return FillHexagonal(Cij);
      break;
    default:
      break;
  }
 
  return false;
}

GetAngle()

G4ThreeVector G4CrystalUnitCell::GetAngle ( ) const

inline

Definition at line 61 of file G4CrystalUnitCell.hh.

{ return theAngle; }

GetBasis()

const G4ThreeVector & G4CrystalUnitCell::GetBasis

(

G4int

idx

)

const

Definition at line 150 of file G4CrystalUnitCell.cc.

{
  return (idx >= 0 && idx < 3 ? theBasis[idx] : nullVec);
}

Referenced by G4LogicalCrystalVolume::GetBasis().

GetBravaisLattice()

theBravaisLatticeType G4CrystalUnitCell::GetBravaisLattice ( )

inline

Definition at line 56 of file G4CrystalUnitCell.hh.

{ return GetBravaisLattice(theSpaceGroup); }

Referenced by GetBravaisLattice().

GetIntCosAng()

G4double G4CrystalUnitCell::GetIntCosAng	(	G4int	h1,
		G4int	k1,
		G4int	l1,
		G4int	h2,
		G4int	k2,
		G4int	l2 )

Definition at line 540 of file G4CrystalUnitCell.cc.

{
  /* Reference:
   Table 2.4, pag. 65
 
   @Inbook{Kelly2012,
   author="Anthony A. Kelly and Kevin M. Knowles",
   title="Appendix 3 Interplanar Spacings and Interplanar Angles",
   bookTitle="Crystallography and Crystal Defects, 2nd Edition",
   year="2012",
   publisher="John Wiley & Sons, Ltd.",
   isbn="978-0-470-75014-8",
   doi="10.1002/9781119961468",
   url="http://onlinelibrary.wiley.com/book/10.1002/9781119961468"
   }
   */
 
  G4double a = theRecSize[0], b = theRecSize[1], c = theRecSize[2];
  G4double a2 = a * a, b2 = b * b, c2 = c * c;
  G4double dsp1dsp2;
  switch (GetLatticeSystem()) {
    case Amorphous:
      return 0.;
      break;
    case Cubic:
      return (h1 * h2 + k1 * k2 + l1 + l2) /
             (std::sqrt(h1 * h1 + k1 * k1 + l1 * l1) * std::sqrt(h2 * h2 + k2 * k2 + l2 * l2));
      break;
    case Tetragonal:
      dsp1dsp2 = std::sqrt(GetIntSp2(h1, k1, l1) * GetIntSp2(h2, k2, l2));
      return 0.;
      break;
    case Orthorhombic:
      dsp1dsp2 = std::sqrt(GetIntSp2(h1, k1, l1) * GetIntSp2(h2, k2, l2));
      return dsp1dsp2 * (h1 * h2 * a2 + k1 * k2 * a2 + l1 * l2 * c2);
      break;
    case Rhombohedral:
      dsp1dsp2 = std::sqrt(GetIntSp2(h1, k1, l1) * GetIntSp2(h2, k2, l2));
      return dsp1dsp2 *
             (h1 * h2 * a2 + k1 * k2 * b2 + l1 * l2 * c2 + (k1 * l2 + k2 * l1) * b * c * cosar +
               (h1 * l2 + h2 * l1) * a * c * cosbr + (h1 * k2 + h2 * k1) * a * b * cosgr);
      break;
    case Monoclinic:
      dsp1dsp2 = std::sqrt(GetIntSp2(h1, k1, l1) * GetIntSp2(h2, k2, l2));
      return dsp1dsp2 *
             (h1 * h2 * a2 + k1 * k2 * b2 + l1 * l2 * c2 + (k1 * l2 + k2 * l1) * b * c * cosar +
               (h1 * l2 + h2 * l1) * a * c * cosbr + (h1 * k2 + h2 * k1) * a * b * cosgr);
      break;
    case Triclinic:
      dsp1dsp2 = std::sqrt(GetIntSp2(h1, k1, l1) * GetIntSp2(h2, k2, l2));
      return dsp1dsp2 *
             (h1 * h2 * a2 + k1 * k2 * b2 + l1 * l2 * c2 + (k1 * l2 + k2 * l1) * b * c * cosar +
               (h1 * l2 + h2 * l1) * a * c * cosbr + (h1 * k2 + h2 * k1) * a * b * cosgr);
      break;
    case Hexagonal:
      dsp1dsp2 = std::sqrt(GetIntSp2(h1, k1, l1) * GetIntSp2(h2, k2, l2));
      return dsp1dsp2 * ((h1 * h2 + k1 * k2 + 0.5 * (h1 * k2 + k1 * h2)) * a2 + l1 * l2 * c2);
      break;
    default:
      break;
  }
 
  return 0.;
}

GetIntSp2()

G4double G4CrystalUnitCell::GetIntSp2	(	G4int	h,
		G4int	k,
		G4int	l )

Definition at line 417 of file G4CrystalUnitCell.cc.

{
  /* Reference:
   Table 2.4, pag. 65
 
   @Inbook{Ladd2003,
   author="Ladd, Mark and Palmer, Rex",
   title="Lattices and Space-Group Theory",
   bookTitle="Structure Determination by X-ray Crystallography",
   year="2003",
   publisher="Springer US",
   address="Boston, MA",
   pages="51--116",
   isbn="978-1-4615-0101-5",
   doi="10.1007/978-1-4615-0101-5_2",
   url="http://dx.doi.org/10.1007/978-1-4615-0101-5_2"
   }
  */
 
  G4double a = theSize[0], b = theSize[1], c = theSize[2];
  G4double a2 = a * a, b2 = b * b, c2 = c * c;
  G4double h2 = h * h, k2 = k * k, l2 = l * l;
 
  G4double cos2a, sin2a, sin2b;
  G4double R, T;
 
  switch (GetLatticeSystem()) {
    case Amorphous:
      return 0.;
      break;
    case Cubic:
      return a2 / (h2 + k2 + l2);
      break;
    case Tetragonal:
      return 1.0 / ((h2 + k2) / a2 + l2 / c2);
      break;
    case Orthorhombic:
      return 1.0 / (h2 / a2 + k2 / b2 + l2 / c2);
      break;
    case Rhombohedral:
      cos2a = cosa * cosa;
      sin2a = sina * sina;
      T = h2 + k2 + l2 + 2. * (h * k + k * l + h * l) * ((cos2a - cosa) / sin2a);
      R = sin2a / (1. - 3 * cos2a + 2. * cos2a * cosa);
      return a * a / (T * R);
      break;
    case Monoclinic:
      sin2b = sinb * sinb;
      return 1. / (1. / sin2b * (h2 / a2 + l2 / c2 - 2 * h * l * cosb / (a * c)) + k2 / b2);
      break;
    case Triclinic:
      return 1. / GetRecIntSp2(h, k, l);
      break;
    case Hexagonal:
      return 1. / ((4. * (h2 + k2 + h * k) / (3. * a2)) + l2 / c2);
      break;
    default:
      break;
  }
 
  return 0.;
}

Referenced by GetIntCosAng().

GetLatticeSystem()

theLatticeSystemType G4CrystalUnitCell::GetLatticeSystem ( )

inline

Definition at line 55 of file G4CrystalUnitCell.hh.

{ return GetLatticeSystem(theSpaceGroup); }

Referenced by ComputeCellVolume(), FillElReduced(), G4CrystalUnitCell(), GetIntCosAng(), GetIntSp2(), GetLatticeSystem(), and GetRecIntSp2().

GetRecAngle()

G4ThreeVector G4CrystalUnitCell::GetRecAngle ( ) const

inline

Definition at line 69 of file G4CrystalUnitCell.hh.

{ return theRecAngle; }

GetRecBasis()

const G4ThreeVector & G4CrystalUnitCell::GetRecBasis

(

G4int

idx

)

const

Definition at line 164 of file G4CrystalUnitCell.cc.

{
  return (idx >= 0 && idx < 3 ? theRecBasis[idx] : nullVec);
}

GetRecIntSp2()

G4double G4CrystalUnitCell::GetRecIntSp2	(	G4int	h,
		G4int	k,
		G4int	l )

Definition at line 482 of file G4CrystalUnitCell.cc.

{
  /* Reference:
   Table 2.4, pag. 65
 
   @Inbook{Ladd2003,
   author="Ladd, Mark and Palmer, Rex",
   title="Lattices and Space-Group Theory",
   bookTitle="Structure Determination by X-ray Crystallography",
   year="2003",
   publisher="Springer US",
   address="Boston, MA",
   pages="51--116",
   isbn="978-1-4615-0101-5",
   doi="10.1007/978-1-4615-0101-5_2",
   url="http://dx.doi.org/10.1007/978-1-4615-0101-5_2"
   }
   */
 
  G4double a = theRecSize[0], b = theRecSize[1], c = theRecSize[2];
  G4double a2 = a * a, b2 = b * b, c2 = c * c;
  G4double h2 = h * h, k2 = k * k, l2 = l * l;
 
  switch (GetLatticeSystem()) {
    case Amorphous:
      return 0.;
      break;
    case Cubic:
      return a2 * (h2 + k2 + l2);
      break;
    case Tetragonal:
      return (h2 + k2) * a2 + l2 * c2;
      break;
    case Orthorhombic:
      return h2 * a2 + k2 + b2 + h2 * c2;
      break;
    case Rhombohedral:
      return (h2 + k2 + l2 + 2. * (h * k + k * l + h * l) * cosar) * a2;
      break;
    case Monoclinic:
      return h2 * a2 + k2 * b2 + l2 * c2 + 2. * h * l * a * c * cosbr;
      break;
    case Triclinic:
      return h2 * a2 + k2 * b2 + l2 * c2 + 2. * k * l * b * c * cosar + 2. * l * h * c * a * cosbr +
             2. * h * k * a * b * cosgr;
      break;
    case Hexagonal:
      return (h2 + k2 + h * k) * a2 + l2 * c2;
      break;
    default:
      break;
  }
 
  return 0.;
}

Referenced by GetIntSp2().

GetRecSize()

G4ThreeVector G4CrystalUnitCell::GetRecSize ( ) const

inline

Definition at line 68 of file G4CrystalUnitCell.hh.

{ return theRecSize; }

GetRecUnitBasis()

const G4ThreeVector & G4CrystalUnitCell::GetRecUnitBasis

(

G4int

idx

)

const

Definition at line 157 of file G4CrystalUnitCell.cc.

{
  return (idx >= 0 && idx < 3 ? theRecUnitBasis[idx] : nullVec);
}

GetRecVolume()

G4double G4CrystalUnitCell::GetRecVolume ( ) const

inline

Definition at line 83 of file G4CrystalUnitCell.hh.

{ return theRecVolume; }  // get the stored volume

GetSize()

G4ThreeVector G4CrystalUnitCell::GetSize ( ) const

inline

Definition at line 60 of file G4CrystalUnitCell.hh.

{ return theSize; }

GetSpaceGroup()

G4int G4CrystalUnitCell::GetSpaceGroup ( ) const

inline

Definition at line 52 of file G4CrystalUnitCell.hh.

{ return theSpaceGroup; };

GetUnitBasis()

const G4ThreeVector & G4CrystalUnitCell::GetUnitBasis

(

G4int

idx

)

const

Definition at line 143 of file G4CrystalUnitCell.cc.

{
  return (idx >= 0 && idx < 3 ? theUnitBasis[idx] : nullVec);
}

GetUnitBasisTrigonal()

G4ThreeVector G4CrystalUnitCell::GetUnitBasisTrigonal

(

)

Definition at line 171 of file G4CrystalUnitCell.cc.

{
  // Z' axis computed by hand to get both opening angles right
  // X'.Z' = cos(alpha), Y'.Z' = cos(beta), solve for Z' components
  G4double x3 = cosa, y3 = (cosb - cosa * cosg) / sing, z3 = std::sqrt(1. - x3 * x3 - y3 * y3);
  return G4ThreeVector(x3, y3, z3).unit();
}

GetVolume()

G4double G4CrystalUnitCell::GetVolume ( ) const

inline

Definition at line 82 of file G4CrystalUnitCell.hh.

{ return theVolume; }  // get the stored volume

SetSpaceGroup()

void G4CrystalUnitCell::SetSpaceGroup ( G4int aInt )

inline

Definition at line 53 of file G4CrystalUnitCell.hh.

{ theSpaceGroup = aInt; };

Member Data Documentation

nullVec

G4ThreeVector G4CrystalUnitCell::nullVec

protected

Definition at line 96 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), GetBasis(), GetRecBasis(), GetRecUnitBasis(), and GetUnitBasis().

theAngle

G4ThreeVector G4CrystalUnitCell::theAngle

protected

Definition at line 99 of file G4CrystalUnitCell.hh.

Referenced by GetAngle().

theBasis

G4ThreeVector G4CrystalUnitCell::theBasis[3]

protected

Definition at line 101 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), and GetBasis().

theRecAngle

G4ThreeVector G4CrystalUnitCell::theRecAngle

protected

Definition at line 106 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), and GetRecAngle().

theRecBasis

G4ThreeVector G4CrystalUnitCell::theRecBasis[3]

protected

Definition at line 108 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), and GetRecBasis().

theRecSize

G4ThreeVector G4CrystalUnitCell::theRecSize

protected

Definition at line 105 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), GetIntCosAng(), GetRecIntSp2(), and GetRecSize().

theRecUnitBasis

G4ThreeVector G4CrystalUnitCell::theRecUnitBasis[3]

protected

Definition at line 107 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), and GetRecUnitBasis().

theSize

G4ThreeVector G4CrystalUnitCell::theSize

protected

Definition at line 98 of file G4CrystalUnitCell.hh.

Referenced by ComputeCellVolume(), FillAtomicPos(), G4CrystalUnitCell(), GetIntSp2(), and GetSize().

theUnitBasis

G4ThreeVector G4CrystalUnitCell::theUnitBasis[3]

protected

Definition at line 100 of file G4CrystalUnitCell.hh.

Referenced by G4CrystalUnitCell(), and GetUnitBasis().

---

The documentation for this class was generated from the following files:

• G4CrystalUnitCell.hh
• G4CrystalUnitCell.cc