Dans_Diffraction.multiple_scattering (version 1.0)
index
c:\users\grp66007\onedrive - diamond light source ltd\pythonprojects\dans_diffraction\dans_diffraction\multiple_scattering.py

Multiple Scattering code, By Dr Gareth Nisbet
For more information see:
Nisbet, A. G. A., Beutier, G., Fabrizi, F., Moser, B. & Collins, S. P. (2015). Acta Cryst. A71, 20-25.
http://dx.doi.org/10.5281/zenodo.12866
 
Example:
    xtl = dif.Crystal('Diamond.cif')
    mslist = run_calcms(xtl, [0,0,3], [0,1,0], [1,0], [2.83, 2.85], plot=True)
 
Created from python package "calcms"
Version 1.0
12/12/2019
 -------------------------------------------
 Copyright 2014 Diamond Light Source Ltd.123
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 
 Dr Gareth Nisbet, gareth.nisbet@diamond.ac.uk Tel: +44 1235 778786
 www.diamond.ac.uk
 Diamond Light Source, Chilton, Didcot, Oxon, OX11 0DE, U.K.

 
Modules
       
itertools
numpy
matplotlib.pyplot

 
Classes
       
builtins.object
Bmatrix
Bragg
Calcms
Dhkl
Hklgen
Interplanarangle
Rotxyz
Vfind

 
class Bmatrix(builtins.object)
    Bmatrix(lattice)
 
Convert to Cartesian coordinate system. Returns the Bmatrix and the metric tensors in direct and reciprocal spaces
 
  Methods defined here:
__init__(self, lattice)
Initialize self.  See help(type(self)) for accurate signature.
bm(self)
ibm(self)
mt(self)
rmt(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Bragg(builtins.object)
    Bragg(lattice, hkl, energy)
 

 
  Methods defined here:
__init__(self, lattice, hkl, energy)
returns Bragg angle of a reflection
theta = Bragg(lattice,hkl,energy)
th(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Calcms(builtins.object)
    Calcms(lattice, hkl, hklint, hkl2, energy, azir, F=[], F2=[])
 

 
  Methods defined here:
SF(self)
SF2(self)
__init__(self, lattice, hkl, hklint, hkl2, energy, azir, F=[], F2=[])
Initialize self.  See help(type(self)) for accurate signature.
angs(self)
Angles between ko and beam vectors
bragg(self)
bvects(self)
returns secondary beam vectors
bvects2(self)
returns tertiary beam vectors
ewpsi(self)
full(self)
returns hkl2,psi1,psi2,brag1,energ
geometry(self)
ko(self)
kov(self)
kv(self)
orig(self)
Returns reciprocal space origin.
ov(self)
returns original vector list.
pol(self, polv)
returns hkl2, sig, pi, pfactor
pol1only(self, polv)
pol2(self, polv)
returns hkl3, sig, pi, pfactor
pol2only(self, polv)
polfull(self, polv)
polfull2(self, polv)
returns hkl2,psi1,psi2,brag1,energy, sig, pi, pfactor, pfactor*F
ppsi(self)
prlv(self)
psi(self)
psiplaneang(self)
Angle required to rotate k1 about ko onto the secondary scattering plane
psiplaneang2(self)
Angle required to rotate k2 about k1 onto the tertiary scattering plane
pv1xsf1(self, polv)
pxf(self, polv)
rhkangle(self)
sfonly(self)
th(self)
trv(self)
returns transformed and rotated vectors.
trvt(self)
returns transformed and rotated tertiary vectors.
tv(self)
tvp(self)
tvt(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Dhkl(builtins.object)
    Dhkl(lattice, hkl)
 
calculate d-spacing for reflection from reciprocal metric tensor
d = Dhkl(lattice,HKL)
lattice = [a b c alpha beta gamma] (angles in degrees)
HKL: list of hkl. size(HKL) = n x 3 or 3 x n
!!! if size(HKL) is 3 x 3, HKL must be in the form:
HKL = [h1 k1 l1 ; h2 k2 l2 ; h3 k3 l3]
 
  Methods defined here:
__init__(self, lattice, hkl)
Initialize self.  See help(type(self)) for accurate signature.
d(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Hklgen(builtins.object)
    Hklgen(depth)
 

 
  Methods defined here:
__init__(self, depth)
Initialize self.  See help(type(self)) for accurate signature.
v(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Interplanarangle(builtins.object)
    Interplanarangle(lattice, hkl1, hkl2)
 

 
  Methods defined here:
__init__(self, lattice, hkl1, hkl2)
calculates interplanar angles in degrees for reflections using the metric tensor
Example Interplanarangle(lattice,hkl,hkl2) where hkl and hkl2 must have the same column length
Interplanarangle([3,3,3,90,90,120],[[1,2,3],[1,2,3]],[[1,1,3],[1,2,3]])
ang(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Rotxyz(builtins.object)
    Rotxyz(u, angle)
 
Example p = Rotxyz(initial_vector, vectorrotateabout, angle)
 
  Methods defined here:
__init__(self, u, angle)
Initialize self.  See help(type(self)) for accurate signature.
rmat(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class Vfind(builtins.object)
    Vfind(vlist, v)
 

 
  Methods defined here:
__init__(self, vlist, v)
Initialize self.  See help(type(self)) for accurate signature.
vindex(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
loadcif(xtl, energy_kev)
New loadcif from Dans_Diffraction
returns:
    intensity: Structure factor^2. I = sf x sf*
    reflist: array of [h,k,l] reflections
    lattice: [a,b,c,alpha,beta,gamma]
    sf: complex structure factors
run_calcms(xtl, hkl, azir=[0, 0, 1], pv=[1, 0], energy_range=[7.8, 8.2], numsteps=60, full=False, pv1=False, pv2=False, sfonly=True, pv1xsf1=False)
Run the multiple scattering code
 
mslist = run_calcms(xtl, [0,0,1])
 
:param xtl: Crystal structure from Dans_Diffraction
:param hkl: [h,k,l] principle reflection
:param azir: [h,k,l] reference of azimuthal 0 angle
:param pv: [s,p] polarisation vector
:param energy_range: [min, max] energy range in keV
:param numsteps: int: number of calculation steps from energy min to max
:param full: True/False: calculation type: full
:param pv1: True/False: calculation type: pv1
:param pv2: True/False: calculation type: pv2
:param sfonly: True/False: calculation type: sfonly *default
:param pv1xsf1: True/False: calculation type: pv1xsf1?
:return: array