G4CrystalUnitCell Class Reference

#include <G4CrystalUnitCell.hh>

Collaboration diagram for G4CrystalUnitCell:

Public Member Functions
	G4CrystalUnitCell (G4double sizeA, G4double sizeB, G4double sizeC, G4double alpha, G4double beta, G4double gamma, G4int spacegroup)
virtual	~G4CrystalUnitCell ()
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 47 of file G4CrystalUnitCell.hh.

Constructor & Destructor Documentation

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

Definition at line 38 of file G4CrystalUnitCell.cc.

                                                      :
theSpaceGroup(spacegroup),
theSize(G4ThreeVector(sizeA,sizeB,sizeC)),
theAngle(G4ThreeVector(alpha,beta,gamma))
{
    
    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];
    }
    
    // Initialize sgInfo
    /* at first some initialization for SgInfo */
    /*
    const T_TabSgName *tsgn = NULL;
    
    SgInfo.MaxList = 192;
    SgInfo.ListSeitzMx = malloc( SgInfo.MaxList * sizeof(*SgInfo.ListSeitzMx) );

    // no list info needed here
    SgInfo.ListRotMxInfo = NULL;
    tsgn = FindTabSgNameEntry(SchoenfliesSymbols[theSpaceGroup], 'A');

    // initialize SgInfo struct
    InitSgInfo( &SgInfo );
    SgInfo.TabSgName = tsgn;
    if ( tsgn ){
        SgInfo.GenOption = 1;
    }
    
    ParseHallSymbol( SchoenfliesSymbols[theSpaceGroup], &SgInfo );
    CompleteSgInfo( &SgInfo );
    Set_si( &SgInfo );
    */
    
}

Here is the call graph for this function:

G4CrystalUnitCell::~G4CrystalUnitCell ( )

virtual

Definition at line 145 of file G4CrystalUnitCell.cc.

{;}

Member Function Documentation

G4double G4CrystalUnitCell::ComputeCellVolume

(

)

Definition at line 386 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.;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 217 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 207 of file G4CrystalUnitCell.cc.

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

Here is the caller graph for this function:

G4bool G4CrystalUnitCell::FillElReduced

(

G4double

Cij[6][6]

)

Definition at line 229 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;
}

Here is the call graph for this function:

G4ThreeVector G4CrystalUnitCell::GetAngle ( ) const

inline

Definition at line 102 of file G4CrystalUnitCell.hh.

{return theAngle;}

const G4ThreeVector & G4CrystalUnitCell::GetBasis

(

G4int

idx

)

const

Definition at line 180 of file G4CrystalUnitCell.cc.

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

Here is the caller graph for this function:

theBravaisLatticeType G4CrystalUnitCell::GetBravaisLattice ( )

inline

Definition at line 74 of file G4CrystalUnitCell.hh.

                                             {
        return GetBravaisLattice(theSpaceGroup);
    }

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

Definition at line 550 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.;
}

Here is the call graph for this function:

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

Definition at line 424 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.;
}

Here is the call graph for this function:

Here is the caller graph for this function:

theLatticeSystemType G4CrystalUnitCell::GetLatticeSystem ( )

inline

Definition at line 71 of file G4CrystalUnitCell.hh.

                                           {
        return GetLatticeSystem(theSpaceGroup);
    }

Here is the caller graph for this function:

G4ThreeVector G4CrystalUnitCell::GetRecAngle ( ) const

inline

Definition at line 118 of file G4CrystalUnitCell.hh.

{return theRecAngle;}

const G4ThreeVector & G4CrystalUnitCell::GetRecBasis

(

G4int

idx

)

const

Definition at line 192 of file G4CrystalUnitCell.cc.

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

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

Definition at line 491 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.;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4ThreeVector G4CrystalUnitCell::GetRecSize ( ) const

inline

Definition at line 117 of file G4CrystalUnitCell.hh.

{return theRecSize;}

const G4ThreeVector & G4CrystalUnitCell::GetRecUnitBasis

(

G4int

idx

)

const

Definition at line 186 of file G4CrystalUnitCell.cc.

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

G4double G4CrystalUnitCell::GetRecVolume ( ) const

inline

Definition at line 152 of file G4CrystalUnitCell.hh.

{return theRecVolume;} //get the stored volume

G4ThreeVector G4CrystalUnitCell::GetSize ( ) const

inline

Definition at line 101 of file G4CrystalUnitCell.hh.

{return theSize;}

G4int G4CrystalUnitCell::GetSpaceGroup ( ) const

inline

Definition at line 63 of file G4CrystalUnitCell.hh.

{return theSpaceGroup;};

const G4ThreeVector & G4CrystalUnitCell::GetUnitBasis

(

G4int

idx

)

const

Definition at line 174 of file G4CrystalUnitCell.cc.

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

G4ThreeVector G4CrystalUnitCell::GetUnitBasisTrigonal

(

)

Definition at line 198 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();
}

Here is the call graph for this function:

G4double G4CrystalUnitCell::GetVolume ( ) const

inline

Definition at line 151 of file G4CrystalUnitCell.hh.

{return theVolume;} //get the stored volume

void G4CrystalUnitCell::SetSpaceGroup ( G4int  aInt )

inline

Definition at line 64 of file G4CrystalUnitCell.hh.

{theSpaceGroup=aInt;};

Member Data Documentation

G4ThreeVector G4CrystalUnitCell::nullVec

protected

Definition at line 91 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theAngle

protected

Definition at line 94 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theBasis[3]

protected

Definition at line 96 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theRecAngle

protected

Definition at line 110 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theRecBasis[3]

protected

Definition at line 112 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theRecSize

protected

Definition at line 109 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theRecUnitBasis[3]

protected

Definition at line 111 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theSize

protected

Definition at line 93 of file G4CrystalUnitCell.hh.

G4ThreeVector G4CrystalUnitCell::theUnitBasis[3]

protected

Definition at line 95 of file G4CrystalUnitCell.hh.

---

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

• source/geant4.10.03.p03/source/materials/include/G4CrystalUnitCell.hh
• source/geant4.10.03.p03/source/materials/src/G4CrystalUnitCell.cc