Difference between revisions of "Talk:Unit cell"

From GISAXS
Jump to: navigation, search
Line 20: Line 20:
 
</math>
 
</math>
  
===Vectors (Wrong?)===
+
====Vectors (Wrong?)====
 
:<math>\begin{array}{l}
 
:<math>\begin{array}{l}
 
\mathbf{a} = \begin{bmatrix}
 
\mathbf{a} = \begin{bmatrix}

Revision as of 09:30, 14 November 2022

Extra math expressions

A given real-space cubic lattice will have dimensions:

Such that the position of any particular cell within the infinite lattice is:

Where h, k, and l are indices. The corresponding inverse-space lattice would be:

In the case where :

Vectors (Wrong?)


TBD: Reciprocal vector components

Calculate q_hkl generally

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def q_hkl(self, h, k, l):
    """Determines the position in reciprocal space for the given reflection."""
     
    # The 'unitcell' coordinate system assumes:
    #  a-axis lies along x-axis
    #  b-axis is in x-y plane
    #  c-axis is vertical (or at a tilt, depending on beta)
     
    # Convert from (unitcell) Cartesian to (unitcell) fractional coordinates
    reduced_volume = sqrt( 1 - (cos(self.alpha))**2 - (cos(self.beta))**2 - (cos(self.gamma))**2 + 2*cos(self.alpha)*cos(self.beta)*cos(self.gamma) )
    #volume = reduced_volume*self.lattice_spacing_a*self.lattice_spacing_b*self.lattice_spacing_c
    a = ( self.lattice_spacing_a , \
            0.0 , \
            0.0  )
    b = ( self.lattice_spacing_b*cos(self.gamma) , \
            self.lattice_spacing_b*sin(self.gamma) , \
            0.0 )
    c = ( self.lattice_spacing_c*cos(self.beta) , \
            self.lattice_spacing_c*( cos(self.alpha) - cos(self.beta)*cos(self.gamma) )/( sin(self.gamma) ) , \
            self.lattice_spacing_c*reduced_volume/( sin(self.gamma) ) )
     
    # Compute (unitcell) reciprocal-space lattice vectors
    volume = np.dot( a, np.cross(b,c) )
    u = np.cross( b, c ) / volume # Along qx
    v = np.cross( c, a ) / volume # Along qy
    w = np.cross( a, b ) / volume # Along qz
     
    qhkl_vector = 2*pi*( h*u + k*v + l*w )
    qhkl = sqrt( qhkl_vector[0]**2 + qhkl_vector[1]**2 + qhkl_vector[2]**2 )
     
    return (qhkl, qhkl_vector)
 
             
     
def q_hkl_length(self, h, k, l):
     
    qhkl, qhkl_vector = self.q_hkl(h,k,l)
    #qhkl = sqrt( qhkl_vector[0]**2 + qhkl_vector[1]**2 + qhkl_vector[2]**2 )
     
    return qhkl