def e2pz(w1,w2,th):
"""
Calculates the momentum scale and the relativistic Compton cross section
correction according to P. Holm, PRA 37, 3706 (1988).
from KH 29.05.96
input:
w1 = incident energy [keV]
w2 = scattered energy [keV]
th = scattering angle [deg]
returns:
pz = momentum scale [a.u.]
cf = cross section correction factor such that:
J(pz) = cf * d^2(sigma)/d(w2)*d(Omega) [barn/atom/keV/srad]
"""
w1 = np.array(w1) # make sure arrays are used
w2 = np.array(w2)
m = constants.value('electron mass energy equivalent in MeV')*1e3 #511.003 # Mass in natural units
th = math.radians(th) # th/180.0*np.pi # Angle to radians
alp = constants.value('fine-structure constant') #1.0/137.036 # Fine structure constant
r0 = constants.value('classical electron radius') #2.8179e-15 # Electron radius
q = np.sqrt(w1**2 + w2**2-2*w1*w2*np.cos(th)) # Momentum transfer
pz = q/2.0 - (w1-w2) * np.sqrt(1/4.0 + m**2/(2*w1*w2*(1-np.cos(th)))) # In natural units
E = np.sqrt(m**2+pz**2)
A = ((w1-w2)*E-w1*w2*(1-np.cos(th)))/q
D = (w1-w2*np.cos(th))*A/q
R = w1*(E-D)
R2 = R-w1*w2*(1-np.cos(th))
chi = R/R2 + R2/R + 2.0*m**2 * (1/R-1/R2) + m**4 * (1/R-1/R2)**2
cf = 2.0*w1*q*E/(m**2*r0**2*w2*chi)
cf = cf*(1e-28*(m*alp)) # Cross section now in barns/atom/keV/srad
pz = pz/(m*alp) # pz to atomic units (a.u.)
return pz, cf
def showPONI(self,event=None):
if self.ai is None:
print(' xxxxx NO CALIBRATION INFORMATION TO PRINT xxxxx ')
else:
print
print
print ' ====== CURRENT CALIBRATION INFORMATION ====== '
print
try:
print 'Detector name: %s' % self.ai.detector.name
#ai.detector.splineFile
except:
pass
prt_str = 'Detector distance: %.1f mm'
print prt_str % (self.ai._dist*1000.)
prt_str = 'Pixel size (x,y): %.1f um, %.1f um'
print prt_str % (self.ai.detector.pixel1*1000000.,
self.ai.detector.pixel2*1000000.)
prt_str = 'Detector center (x,y): %i pixels, %i pixels'
print prt_str % (self.ai._poni1/self.ai.detector.pixel1,
self.ai._poni2/self.ai.detector.pixel2)
prt_str = 'Detector tilts: %0.5f, %0.5f %0.5f'
print prt_str % (self.ai._rot1,self.ai._rot2,self.ai._rot3)
prt_str = 'Incident energy, wavelegth: %0.2f keV, %0.4f A'
hc = constants.value(u'Planck constant in eV s') * \
constants.value(u'speed of light in vacuum') * 1e-3 ## units: keV-m
E = hc/(self.ai._wavelength) ## units: keV
print prt_str % (E,self.ai._wavelength*1.e10)
def electrostatic_units(energy):
""" coefficient to convert to appropriate electrostatic units """
area = (1 / ((2 * sqrt(2)) ** 2)) * 2 * sqrt(3)
factor = (1j * ((2 *
constants.value("Rydberg constant times hc in eV")) ** 5) *
1e-5 * 2.08e-15 *
((constants.value("lattice parameter of silicon") / 1e-10) ** 3))\
/ (area * ((energy) ** 3))
return factor
def loadCIF(self,event):
wildcards = 'XRD cifile (*.cif)|*.cif|All files (*.*)|*.*'
dlg = wx.FileDialog(self, message='Choose CIF',
defaultDir=os.getcwd(),
wildcard=wildcards, style=wx.FD_OPEN)
path, read = None, False
if dlg.ShowModal() == wx.ID_OK:
read = True
path = dlg.GetPath().replace('\\', '/')
dlg.Destroy()
if read:
cifile = os.path.split(path)[-1]
try:
cif = xu.materials.Crystal.fromCIF(path)
except:
print('incorrect file format: %s' % os.path.split(path)[-1])
return
## generate hkl list
hkllist = []
maxhkl = 8
for i in range(-maxhkl,maxhkl+1):
for j in range(-maxhkl,maxhkl+1):
for k in range(-maxhkl,maxhkl+1):
if i+j+k > 0: # as long as h,k,l all positive, eliminates 0,0,0
hkllist.append([i,j,k])
hc = constants.value(u'Planck constant in eV s') * \
constants.value(u'speed of light in vacuum') * 1e-3 ## units: keV-m
if self.wavelength is not None:
qlist = cif.Q(hkllist)
Flist = cif.StructureFactorForQ(qlist,(hc/(self.wavelength*(1e-10))*1e3))
Fall = []
qall = []
hklall = []
for i,hkl in enumerate(hkllist):
if np.abs(Flist[i]) > 0.01:
Fadd = np.abs(Flist[i])
qadd = np.linalg.norm(qlist[i])
if qadd not in qall and qadd < 6:
Fall.extend((0,Fadd,0))
qall.extend((qadd,qadd,qadd))
if np.shape(Fall)[0] > 0:
Fall = np.array(Fall)
qall = np.array(qall)
self.add1Ddata(qall,Fall,name=os.path.split(path)[-1],cif=True)
else:
print('Could not calculate real structure factors.')
else:
print('Wavelength/energy must be specified for structure factor calculations.')
def onEorLSel(self,event):
hc = constants.value(u'Planck constant in eV s') * \
constants.value(u'speed of light in vacuum') * 1e-3 ## units: keV-m
if self.ch_EorL.GetSelection() == 1:
energy = float(self.entr_EorL.GetValue()) ## units keV
wavelength = hc/(energy)*1e10 ## units: A
self.entr_EorL.SetValue(str(wavelength))
else:
wavelength = float(self.entr_EorL.GetValue())*1e-10 ## units: m
energy = hc/(wavelength) ## units: keV
self.entr_EorL.SetValue(str(energy))
def __init__(self, frep_MHz = None, n = None):
if frep_MHz is not None:
self._frep_MHz = frep_MHz
if frep_MHz > 1.0e6:
warnings.warn("frep should be specified in MHz; large value given.")
if n is not None:
self.set_NPTS(n)
# Constants, moved here so that module runs through Sphynx autodoc when
# scipy is Mocked out.
self._c_nmps = constants.value('speed of light in vacuum')*1e9/1e12 # c in nm/ps
self._c_mks = constants.value('speed of light in vacuum') # m/s
def __init__(self):
## Constructor
dialog = wx.Dialog.__init__(self, None, title='Define wavelength/energy')#,size=(500, 440))
## remember: size=(width,height)
panel = wx.Panel(self)
main = wx.BoxSizer(wx.VERTICAL)
hmain1 = wx.BoxSizer(wx.HORIZONTAL)
#####
## Energy or Wavelength
hmain1 = wx.BoxSizer(wx.HORIZONTAL)
self.ch_EorL = wx.Choice(panel,choices=['Energy (keV)','Wavelength (A)'])
self.entr_EorL = wx.TextCtrl(panel)#, size=(110, -1))
self.ch_EorL.Bind(wx.EVT_CHOICE, self.onEorLSel)
hmain1.Add(self.ch_EorL, flag=wx.RIGHT, border=8)
hmain1.Add(self.entr_EorL, flag=wx.RIGHT, border=8)
#####
## OKAY!
hmain2 = wx.BoxSizer(wx.HORIZONTAL)
#hlpBtn = wx.Button(panel, wx.ID_HELP )
okBtn = wx.Button(panel, wx.ID_OK )
canBtn = wx.Button(panel, wx.ID_CANCEL )
#hmain2.Add(hlpBtn,flag=wx.RIGHT, border=8)
hmain2.Add(canBtn, flag=wx.RIGHT, border=8)
hmain2.Add(okBtn, flag=wx.RIGHT, border=8)
main.Add(hmain1, flag=wx.ALL, border=10)
main.Add(hmain2, flag=wx.ALL|wx.ALIGN_RIGHT, border=10)
panel.SetSizer(main)
self.Show()
ix,iy = panel.GetBestSize()
self.SetSize((ix+20, iy+20))
## set default
self.hc = constants.value(u'Planck constant in eV s') * \
constants.value(u'speed of light in vacuum') * 1e-3 ## units: keV-m
self.energy = 19.0
self.wavelength = self.hc/(self.energy)*1e10 ## units: A
self.ch_EorL.SetSelection(0)
self.entr_EorL.SetValue(str(self.energy))
def convert():
""" converts xyz file from angstroms to bohrs """
conversion_factor = constants.angstrom / constants.value("Bohr radius")
xx_coord, yy_coord, zz_coord = genfromtxt(XYZ_CONVERT, unpack="True")
xyz = column_stack((xx_coord, yy_coord, zz_coord))
new_xyz = xyz * 1/conversion_factor
savetxt(XYZ_CONVERT_OUT, new_xyz, fmt=('%3.15f'), delimiter=' ')
def get_electron_density(self):
r"""
Return electron density :math:`\rho_e` in unit inverse cubic meter
.. math::
\rho_e = \frac{\rho_m \cdot \sum_i}{\left( \sum_i c_i m_i \right) \left( \sum_i c_i Z_i \right)}
:math:`\rho_m`: Mass denisty of material
:math:`c_i`: Normalised fraction of atom species :math:`i`
:math:`m_i`: Standard atomic mass of atom species :math:`i`
:math:`Z_i`: Atomic number of atom species :math:`i`
"""
u = constants.value("atomic mass constant")
atomic_composition = self.get_atomic_composition(normed=True)
M = 0
Q = 0
for element in atomic_composition.keys():
# sum up electrons
M += atomic_composition[element]*get_atomic_mass(element)*u
Q += atomic_composition[element]*get_atomic_number(element)
electron_density = Q*self.massdensity/M
return electron_density
def get_scatterer_density(self):
r"""
Return total atom density :math:`\rho` in unit inverse cubic meter
.. math::
\rho = \frac{\rho_m}{\sum_i c_i m_i}
:math:`\rho_m`: Mass denisty of material
:math:`c_i`: Normalised fraction of atom species :math:`i`
:math:`m_i`: Standard atomic mass of atom species :math:`i`
"""
u = constants.value("atomic mass constant")
atomic_composition = self.get_atomic_composition(normed=True)
M = 0
for element in atomic_composition.keys():
# sum up average mass
M += atomic_composition[element]*get_atomic_mass(element)*u
number_density = self.massdensity/M
return number_density
def get_n(self,photon_wavelength):
r"""
Return complex refractive index at a given wavelength (Henke, 1994)
.. math::
n = 1 - \frac{ r_0 }{ 2\pi } \lambda^2 \sum_i \rho_i f_i(0)
:math:`r_0`: classical electron radius
:math:`\rho_q`: atomic number density of atom species :math:`i`
:math:`f_q(0)`: atomic scattering factor (forward scattering) of atom species :math:`i`
Args:
:photon_wavelength (float): Photon wavelength in unit meter
"""
f = self.get_f(photon_wavelength)
scatterer_density = self.get_scatterer_density()
r_0 = constants.value("classical electron radius")
n = 1 - r_0/2/numpy.pi * photon_wavelength**2 * f * scatterer_density
return n
def __init__(self,Ts,qE0T,phis,lamb,length=22.e-3):
self.Ts = Ts
self.Tsf = Ts # final kin. energy
self.qE0T = qE0T
self.phis = phis # rad
self.lamb = lamb
self.length = length
self.nbslices = 10 # nbof slices
dl = length/self.nbslices
m0c2 = C.value('proton mass energy equivalent in MeV') # MeV
g = 1.+Ts/m0c2 # Lorentz gamma
bg = sqrt(g**2-1.)
beta = bg/g # Lorentz beta
# phases,energies & maps of slices
phases = []
dtks = []
self.maps = []
for i in range(self.nbslices+1):
phase = self.phis+2*pi/(beta*lamb)*(i*dl-self.length/2.)
phases.append(phase)
dtk = qE0T*dl*cos(phase)
dtks.append(dtk)
for i in range(self.nbslices):
dgdp,f,pot,ham = Hamiltonian(self.Tsf,qE0T,phases[i],lamb)
self.maps.append(Order3Map(+dl,dgdp,f))
self.Tsf += dtks[i]
self.Tsf -= dtks[i] # one too much
def Hamiltonian(Ts,qE0T,phis,lamb):
"""
kanonische Koordinaten: p (aka w), x (aka phi)
unabhaegige Variable: t (aka s)
Hamiltonian H(p,x,t) = g(p) + V(x,t)
g = A*p**2/2
V = B*(sin(x)-x*cos(phis))
f = -dV/dx = -B*(cos(x)-cos(phis))
dgdp = dH/dp = A*p
"""
# closure
m0c2 = C.value('proton mass energy equivalent in MeV') # MeV
g = 1+Ts/m0c2
bgs = sqrt(g**2-1.)
A = 2.*pi/bgs**3/lamb
B = qE0T/m0c2
# potential
def V(x,B=B,phis=phis):
return B*(sin(x)-x*cos(phis))
# hamiltonian
def H(p,x,B=B,phis=phis):
return A*p**2+V(x)
# dH/dp
def dgdp(p,A=A):
return A*p
# -dV/dx
def f(x,t,B=B,phis=phis):
return -B*(cos(x)-cos(phis))
return dgdp,f,V,H
def freq_units(units):
"""
Returns conversion factor from THz to the requred units and the label in the form of a namedtuple
Accepted values: thz, ev, mev, ha, cm-1, cm^-1
"""
d = {"thz": FreqUnits(1, "THz"),
"ev": FreqUnits(const.value("hertz-electron volt relationship") * const.tera, "eV"),
"mev": FreqUnits(const.value("hertz-electron volt relationship") * const.tera / const.milli, "meV"),
"ha": FreqUnits(const.value("hertz-hartree relationship") * const.tera, "Ha"),
"cm-1": FreqUnits(const.value("hertz-inverse meter relationship") * const.tera * const.centi, "cm^{-1}"),
'cm^-1': FreqUnits(const.value("hertz-inverse meter relationship") * const.tera * const.centi, "cm^{-1}")
}
try:
return d[units.lower().strip()]
except KeyError:
raise KeyError('Value for units `{}` unknown\nPossible values are:\n {}'.format(units, list(d.keys())))
def water_term_pol(B0, T):
gamma = constants.value('proton gyromag. ratio')
hbar = constants.hbar
k = constants.k
larmor_w = gamma * B0
pol = hbar * larmor_w
pol /= (2 * k * T)
return pol
def _read_funcfl_file(self):
rphi = np.sqrt(27.2*0.529)
eV2J = spc.value('electron volt')
print('Reading EAM potential in single-element (funcfl) format')
f = open(self.filename, 'r')
line = f.readline() # comment line
self.atomic_number = int(f.readline().split()[0])
line = f.readline().split()
self.nrho = int(line[0])
self.drho = float(line[1])
self.nr = int(line[2])
self.dr = float(line[3])
self.cutoff = float(line[4])
self.fembed = np.zeros((self.nrho,2))
self.effchg = np.zeros((self.nr,2))
self.fdens = np.zeros((self.nr,2))
# read embedding functional
line = f.readline().split()
n_col = len(line)
n_lines = int(self.nrho/self.ncol)-1
i_rows = 0
while i_rows < self.nrho:
for val in line:
self.fembed[i_rows,0] = i_rows*self.drho
self.fembed[i_rows,1] = float(val)
i_rows += 1
if i_rows >= self.nrho:
break
line=f.readline().split()
# read charge function
i_rows = 0
while i_rows < self.nr:
for val in line:
self.effchg[i_rows,0]=i_rows*self.dr
self.effchg[i_rows,1]=float(val)*rphi/(1.e-30+self.effchg[self.i_rows,0])
i_rows += 1
if i_rows >= self.nr:
break
line=f.readline().split()
# read density function
i_rows = 0
while i_rows < self.nr:
for val in line:
self.fdens[i_rows,0]=i_rows*self.dr
self.fdens[i_rows,1]=float(val)
i_rows += 1
if i_rows >= self.nr:
break
line=f.readline().split()
def rotational_constants(self, units='ghz'):
"""Compute the rotational constants in 1/cm or GHz."""
choices = ('invcm', 'ghz')
units = units.lower()
if units not in choices:
raise ValueError("Invalid units, pick one of {}".format(choices))
principal_moments = self.principal_moments_of_inertia()[0]
_check_scipy(_found_scipy)
bohr2ang = spc.value('atomic unit of length') / spc.angstrom
xfamu = 1 / spc.value('electron mass in u')
xthz = spc.value('hartree-hertz relationship')
rotghz = xthz * (bohr2ang ** 2) / (2 * xfamu * spc.giga)
if units == 'ghz':
conv = rotghz
if units == 'invcm':
ghz2invcm = spc.giga * spc.centi / spc.c
conv = rotghz * ghz2invcm
return conv / principal_moments
def __init__(self, N=DEFAULT_N):
"""
Parameters
----------
N : int
the number of grid points, it should be a power of 2
Examples
--------
>>> from generic_potential import GenericPotential
>>> device = GenericPotential(1024)
"""
# default grid size
self.N = N
self.hN = int(self.N/2) # half grid
self.points_before = int(self.N/2)
self.points_after = int(self.N/2)
# useful atomic unities
self.au_l = cte.value('atomic unit of length')
self.au_t = cte.value('atomic unit of time')
self.au_e = cte.value('atomic unit of energy')
self.au_v = cte.value('atomic unit of electric potential')
self.hbar_au = 1.0
self.me_au = 1.0
# other useful constants
self.ev = cte.value('electron volt')
self.c = cte.value('speed of light in vacuum') # m/s
self.me = cte.value('electron mass')
self.q = cte.value('elementary charge')
# relations of interest
self.au2ev = self.au_e / self.ev
self.au2ang = self.au_l / 1e-10
# specific for default quantum harmonic oscillator
self.l = 0.0000081 # m
self.f = self.c / self.l # Hz
self.w = 2.0 * np.pi * self.f
self.z_m = np.linspace(-5e-9,5e-9, self.N)
self.v_j = 0.5 * self.me * self.z_m**2 * self.w**2
self.z_nm = self.z_m / 1e-9
self.v_ev = self.v_j / self.ev
self.m_eff = np.ones(self.z_nm.size)
# set default time increment
self._set_dt()
# adjust grid
self.normalize_device()
def principal_moments_of_inertia(self, units='amu_bohr_2'):
"""Return the principal moments of inertia in 3 kinds of units:
1. [amu][bohr]^2
2. [amu][angstrom]^2
3. [g][cm]^2
and the principal axes.
"""
choices = ('amu_bohr_2', 'amu_angstrom_2', 'g_cm_2')
units = units.lower()
if units not in choices:
raise ValueError("Invalid units, pick one of {}".format(choices))
moi_tensor = self.moment_of_inertia_tensor()
principal_moments, principal_axes = np.linalg.eigh(moi_tensor)
if units == 'amu_bohr_2':
conv = 1
if units == 'amu_angstrom_2':
_check_scipy(_found_scipy)
bohr2ang = spc.value('atomic unit of length') / spc.angstrom
conv = bohr2ang ** 2
if units == 'g_cm_2':
_check_scipy(_found_scipy)
amu2g = spc.value('unified atomic mass unit') * spc.kilo
conv = amu2g * (spc.value('atomic unit of length') * spc.centi) ** 2
return conv * principal_moments, principal_axes
def onLoadCIF(self, event=None):
wildcards = 'CIF file (*.cif)|*.cif|All files (*.*)|*.*'
dlg = wx.FileDialog(self, message='Choose CIF file',
defaultDir=os.getcwd(),
wildcard=wildcards, style=wx.FD_OPEN)
path, read = None, False
if dlg.ShowModal() == wx.ID_OK:
read = True
path = dlg.GetPath().replace('\\', '/')
dlg.Destroy()
if read:
cry_strc = struc_from_cif(path)
if cry_strc:
hc = constants.value(u'Planck constant in eV s') * \
constants.value(u'speed of light in vacuum') * 1e-3 ## units: keV-m
energy = hc/(self.xrd.wavelength) ## units: keV
q,F = calc_all_F(cry_strc,energy,maxhkl=10,qmax=5)
#self.plot1Dxrd(xrddata, show_xrd2=True)
print('Values are calculated; plotting not yet implemented.')
def test1(Ts,qE0T,phis,lamb):
print("----------------------Test 1--------------")
# prep plot
m0c2 = C.value('proton mass energy equivalent in MeV') # MeV
phimin = radians(-60.)
phimax = -phimin
# dphi = (phimax-phimin)/20.
wmin = -0.05/m0c2
wmax = +0.05/m0c2
# dw = (wmax-wmin)/20.
pou = []
pin = []
nbprtcls = 5000
nbgaps = 40
# loop particles
for j in range(nbprtcls):
# x0 = phi0 = rn.uniform(phimin,phimax)
# p0 = w0 = rn.uniform(wmin,wmax)
x0 = phi0 = rn.gauss(phis,2*phis)
p0 = w0 = rn.gauss(0,2*wmax)
t0 = 0
v = (p0,x0,t0)
pin.append(v)
gap = Gap(Ts,qE0T,phis,lamb)
# loop gaps
for i in range(nbgaps):
v = gap.map(v)
# increase particle impulse for next gap
gap(gap.Tsf)
pou.append(v)
print("Ts {}".format(gap.Tsf))
# plot results
win = [x[0]*m0c2 for x in pin]
phin = [degrees(x[1]) for x in pin]
wf = [x[0]*m0c2 for x in pou]
phif = [degrees(x[1]) for x in pou]
ax1 = plt.subplot(121)
plt.xlim([-100,200])
plt.ylim([-0.4,1.2])
ax1.autoscale(enable=False)
ax1.scatter(phin,win,s=1,c='r')
ax2 = plt.subplot(122,sharex=ax1,sharey=ax1)
ax2.autoscale(enable=False)
ax2.scatter(phif,wf,s=1,c='r')
plt.show()
def axis_conversion(self, data, unit, name):
# Converts the x-axis units to a format Mantid accepts,
# frequency to wavenumber, time to time of flight
logger.debug('Axis for conversion: name={0}, unit={1}'.format(name, unit))
if name == 'frequency' and unit == 'THz':
logger.information('Axis {0} will be converted to wave number in cm^-1'.format(name))
unit = 'Energy_inWavenumber'
data *= sc.tera
data *= sc.value('Planck constant in eV s')
data *= 8065.54
elif name == 'time' and unit == 'ps':
logger.information('Axis {0} will be converted to time in microsecond'.format(name))
unit = 'TOF'
data *= sc.micro
else:
unit = 'Empty'
return (data, unit, name)
def test0(Ts,qE0T,phis,lamb):
print("----------------------Test 0--------------")
m0c2 = C.value('proton mass energy equivalent in MeV') # MeV
dgdp,dfdx,pot,ham = Hamiltonian(Ts,qE0T,phis,lamb)
dt = 1.e-2
map3p = Order3Map(+dt,dgdp,dfdx)
map3m = Order3Map(-dt,dgdp,dfdx)
ax = plt.subplot()
phimin = 1.5*phis
phimax = -phis
dphi = (phimax-phimin)/20.
phi0 = phimin
wmin = -0.05/m0c2
wmax = +0.05/m0c2
dw = (wmax-wmin)/20.
w0 = wmin
# while phi0 <= phimax:
for i in range(50):
# phi0 = rn.gauss(degrees(phis),1.*degrees(abs(phis)))
phi0 = rn.uniform(phimin,phimax)
w0 = rn.uniform(wmin,wmax)
t0 = 0.
p0 = w0
x0 = phi0
vp = (p0,x0,t0)
vm = (p0,x0,t0)
pou = [vp]
for step in range(300):
vp = map3p.map(vp)
vm = map3m.map(vm)
pou.append(vp)
pou.append(vm)
# phi0 += dphi
w = [x[0]*m0c2 for x in pou]
phi = [degrees(x[1]) for x in pou]
plt.xlim([-60,60])
plt.ylim([-0.1,0.1])
plt.autoscale(enable=False,axis='both')
ax.scatter(phi,w,s=1,c='r')
plt.show()
def _axis_conversion(self, data, unit, name):
"""
Converts an axis to a Mantid axis type (possibly performing a unit
conversion).
@param data The axis data as Numpy array
@param unit The axis unit as read from the file
@param name The axis name as read from the file
@return Tuple containing updated axis details
"""
logger.debug('Axis for conversion: name={0}, unit={1}'.format(name, unit))
# Q (nm**-1) to Q (Angstrom**-1)
if name.lower() == 'q' and unit.lower() == 'inv_nm':
logger.information('Axis {0} will be converted to Q in Angstrom**-1'.format(name))
unit = 'MomentumTransfer'
data /= sc.nano # nm to m
data *= sc.angstrom # m to Angstrom
# Frequency (THz) to Energy (meV)
elif name.lower() == 'frequency' and unit.lower() == 'thz':
logger.information('Axis {0} will be converted to energy in meV'.format(name))
unit = 'Energy'
data *= sc.tera # THz to Hz
data *= sc.value('Planck constant in eV s') # Hz to eV
data /= sc.milli # eV to meV
# Time (ps) to TOF (s)
elif name.lower() == 'time' and unit.lower() == 'ps':
logger.information('Axis {0} will be converted to time in microsecond'.format(name))
unit = 'TOF'
data *= sc.micro # ps to us
# No conversion
else:
unit = 'Empty'
return (data, unit, name)
def disorder():
""" extracts selected rows from input, converts to matrix,
disorders, and returns matrix which is written to file """
count = 1
chosen = [x - 1 for x in ATOMS_DISORDERED]
blbohr = BOND_LENGTH * constants.angstrom / constants.value("Bohr radius")
xyz = loadtxt(XYZ_DISORDER)
data = xyz[chosen]
new_xyz = xyz.copy()
final = zip(data, DISORDER_AMOUNT)
while count <= REPEAT:
for atom in range(0, len(final)):
polar = random() * constants.pi
azimuthal = 2 * polar
new_xyz[chosen[atom], 0] = final[atom][0][0] + (final[atom][1] *
(blbohr / 2) * sin(polar) * cos(azimuthal))
new_xyz[chosen[atom], 1] = final[atom][0][1] + (final[atom][1] *
(blbohr / 2) * sin(polar) * sin(azimuthal))
new_xyz[chosen[atom], 2] = final[atom][0][2] + (final[atom][1] *
(blbohr / 2) * cos(polar))
out = "data/disorder/si_h_14_" + str(count).zfill(3) + ".xyz"
savetxt(out, new_xyz, fmt=('%5.14e'), delimiter='\t')
count += 1
def get_f(self, photon_wavelength):
r"""
Get effective average complex scattering factor for forward scattering at a given photon wavlength from Henke tables
Args:
:photon_wavlength (float): Photon wavelength in unit meter
"""
atomic_composition = self.get_atomic_composition(normed=True)
r_0 = constants.value("classical electron radius")
h = constants.h
c = constants.c
qe = constants.e
photon_energy_eV = h*c/photon_wavelength/qe
f_sum = complex(0.,0.)
for element in atomic_composition.keys():
# sum up average atom factor
f = get_f_element(element,photon_energy_eV)
f_sum += atomic_composition[element] * f
return f_sum
def get_photoabsorption_cross_section(self, photon_wavelength):
r"""
Return the photoabsorption cross section :math:`\mu_a` at a given wavelength :math:`\lambda`
.. math::
\mu_a = 2 r_0 \lambda f_2
:math:`r_0`: classical electron radius
:math:`f_2`: imaginary part of the atomic scattering factor
Args:
:photon_wavelength (float): Photon wavelength in unit meter
"""
r_0 = constants.value("classical electron radius")
h = constants.h
c = constants.c
qe = constants.e
mu = 2*r_0*photon_wavelength*self.get_f(photon_wavelength).imag
return mu
def parallel_band_conductivity(frequency, plane, a, m0, k_fermi, U, tau):
"""
Return the contribution to the optical conductivity resulting from
parallel-band absorption in a certain plane.
@frequency: frequency in Hz
@plane: a CrystalPlane instance
@a: lattice constant in m
@m0: mass ratio
@k_fermi: fermi wave vector in 1/m
@U: crystal plane pseudopotential in J
@tau: parallel-band relaxation time in s
"""
K = plane.magnitude_factor / a
energy_low, energy_high = pb_absorption_energy_range(plane, a, m0, k_fermi, U)
energy = Const.hbar * frequency
damping_energy = Const.hbar / tau
z = energy / energy_low
z0 = energy_high / energy_low
t0 = N.sqrt(z0 ** 2 - 1.0)
# "To obtain the total absorption corresponding to the entire first zone
# we simply weight these results by the appropriate number of planes
# bounding the zone."
factor = plane.multiplicity * sigma_a * Const.value('Bohr radius') * K
b = damping_energy / energy_low
rho = ((1 + b ** 2 - z ** 2) ** 2 + (2 * b * z) ** 2) ** 0.25
phi1 = 0.5 * (0.5 * N.pi + N.arctan2(1 + b ** 2 - z ** 2, 2 * b * z))
phi2 = 0.5 * (0.5 * N.pi - N.arctan2(1 + b ** 2 - z ** 2, 2 * b * z))
realpart = (((z / rho) / (z ** 2 + b ** 2))
* horrible_function(z, b, t0, rho, phi2))
imagpart = imaginary_horrible_function(z, b, t0, rho, phi1, phi2)
return factor * (realpart - 1j * imagpart)
class CherenkovYield(gc):
'''A class for calculating the Cherenkov yield of an upward going air shower
'''
c = value('speed of light in vacuum')
hc = value('Planck constant in eV s') * c
gga = CherenkovPhotonArray('gg_t_delta_theta_2020_normalized.npz')
def __init__(self, X_max, N_max, h0, theta, direction, tel_vectors, min_l,
max_l):
super().__init__(X_max, N_max, h0, theta, direction, tel_vectors)
self.tel_dE = self.hc / (min_l * nano) - self.hc / (max_l * nano)
self.ng, self.ng_sum, self.gg = self.calculate_ng(
self.shower_t, self.shower_delta, self.tel_q, self.shower_nch,
self.shower_dr, self.tel_omega, self.tel_dE)
self.axis_time = self.shower_r / self.c / nano
self.delay_prime = self.calculate_delay()
self.delay = self.calculate_vertical_delay(
self.axis_delta, self.axis_dh)[self.i_ch] / self.cQ
self.counter_time = self.axis_time + self.travel_length / self.c / nano + self.delay
self.counter_time_prime = self.axis_time + self.travel_length / self.c / nano + self.delay_prime
def interpolate_gg(self, t, delta, theta):
'''This funtion returns the interpolated values of gg at a given delta
and theta
parameters:
t: single value of the stage
delta: single value of the delta
theta: array of theta values at which we want to return the angular
distribution
returns:
the angular distribution values at the desired thetas
'''
gg_td = self.gga.angular_distribution(t, delta)
return np.interp(theta, self.gga.theta, gg_td)
def calculate_gg(self, t, delta, theta):
'''This funtion returns the interpolated values of gg at a given deltas
and thetas
parameters:
t: array of stages
delta: array of corresponding deltas
theta: array of theta values at each stage
returns:
the angular distribution values at the desired thetas
'''
gg = np.empty_like(theta)
for i in range(theta.shape[1]):
gg_td = self.gga.angular_distribution(t[i], delta[i])
gg[:, i] = np.interp(theta[:, i], self.gga.theta, gg_td)
return gg
def calculate_yield(self, delta, shower_nch, shower_dr, tel_dE):
''' This function returns the total number of Cherenkov photons emitted
at a given stage of a shower per all solid angle.
Parameters:
delta: single value or array of the differences from unity of the index of
refraction (n-1)
shower_nch: single value or array of the number of charged particles.
shower_dr: single value or array, the spatial distance represented by
the given stage
lw: the wavelength of the lower bound of the Cherenkov energy interval
hw: the wavelength of the higher bound of the Cherenkov energy interval
returns: the total number of photons per all solid angle
'''
alpha_over_hbarc = 370.e2 # per eV per m, from PDG
c = value('speed of light in vacuum')
hc = value('Planck constant in eV s') * c
chq = CherenkovPhoton.cherenkov_angle(1.e12, delta)
cy = alpha_over_hbarc * np.sin(chq)**2 * tel_dE
return shower_nch * shower_dr * cy
def calculate_ng(self, t, delta, theta, shower_nch, shower_dr, omega,
tel_dE):
gg = self.calculate_gg(t, delta, theta)
ng = gg * omega * self.calculate_yield(delta, shower_nch, shower_dr,
tel_dE)
return ng, ng.sum(axis=1), gg
def calculate_vertical_delay(self, axis_delta, axis_dh):
return np.cumsum((axis_delta * axis_dh)[::-1])[::-1] / self.c / nano
def calculate_delay(self):
delay = np.empty_like(self.cQ)
i_min = np.min(self.i_ch)
Q = np.arccos(self.cQ)
for i in range(delay.shape[0]):
for j in range(delay.shape[1]):
cos = self.theta_normal(self.axis_h[i_min + j:-1], Q[i, j])
delay[i, j] = np.sum((self.axis_delta[i_min + j:-1] *
self.axis_dh[i_min + j:-1]) / cos)
return delay / self.c / nano
def t_K(t):
eV_per_K = value('Boltzmann constant in eV/K')
return t / eV_per_K
file.close()
if __name__ == '__main__':
# lattice
lattice = factory('yml/simuIN.yml')
sections = lattice.get_sections()
waccept(lattice.first_gap)
# Parameters
# The following parameters are hardcoded to a specific value.
particles = 3000
tof_time_adjustment = 0
attenuation_factor = 1.0
c = C.c
pi = C.pi
m0c2 = C.value('proton mass energy equivalent in MeV')
t1 = 0.83
tp1 = 4.9e-2
tpp1 = 4.9e-3
# Parameter import
# Import all the parameters and convert them to the correct units apart from the accelerating
# and transport elements which are imported later on as thier parameters are not global.
alphax = PARAMS['alfax_i']
betax = PARAMS['betax_i'] # mm/mrad - DYNAC units
emitx = PARAMS['emitx_i']*1E06 # mm*mrad - DYNAC units
alphay = PARAMS['alfay_i']
betay = PARAMS['betay_i']
emity = PARAMS['emity_i']*1E06 # mm*mrad - DYNAC units
emitw = PARAMS['emitw'] # mm/mrad - DYNAC units
rfphdeg = PARAMS['phisoll']
class ExcitingInput(MSONable):
"""
Object for representing the data stored in the structure part of the
exciting input.
.. attribute:: structure
Associated Structure.
.. attribute:: title
Optional title string.
.. attribute:: lockxyz
Lockxyz attribute for each site if available. A Nx3 array of
booleans.
"""
def __init__(self, structure, title=None, lockxyz=None):
"""
Args:
structure (Structure): Structure object.
title (str): Optional title for exciting input. Defaults to unit
cell formula of structure. Defaults to None.
lockxyz (Nx3 array): bool values for selective dynamics,
where N is number of sites. Defaults to None.
"""
if structure.is_ordered:
site_properties = {}
if lockxyz:
site_properties["selective_dynamics"] = lockxyz
self.structure = structure.copy(site_properties=site_properties)
self.title = structure.formula if title is None else title
else:
raise ValueError("Structure with partial occupancies cannot be "
"converted into exciting input!")
# define conversion factor between Bohr radius and Angstrom
bohr2ang = const.value("Bohr radius") / const.value("Angstrom star")
@property
def lockxyz(self):
"""
:return: Selective dynamics site properties.
"""
return self.structure.site_properties.get("selective_dynamics")
@lockxyz.setter
def lockxyz(self, lockxyz):
self.structure.add_site_property("selective_dynamics", lockxyz)
@staticmethod
def from_string(data):
"""
Reads the exciting input from a string
"""
root = ET.fromstring(data)
speciesnode = root.find("structure").iter("species")
elements = []
positions = []
vectors = []
lockxyz = []
# get title
title_in = str(root.find("title").text)
# Read elements and coordinates
for nodes in speciesnode:
symbol = nodes.get("speciesfile").split(".")[0]
if len(symbol.split("_")) == 2:
symbol = symbol.split("_")[0]
if Element.is_valid_symbol(symbol):
# Try to recognize the element symbol
element = symbol
else:
raise ValueError("Unknown element!")
for atom in nodes.iter("atom"):
x, y, z = atom.get("coord").split()
positions.append([float(x), float(y), float(z)])
elements.append(element)
# Obtain lockxyz for each atom
if atom.get("lockxyz") is not None:
lxyz = []
for l in atom.get("lockxyz").split():
if l in ("True", "true"):
lxyz.append(True)
else:
lxyz.append(False)
lockxyz.append(lxyz)
else:
lockxyz.append([False, False, False])
# check the atomic positions type
if "cartesian" in root.find("structure").attrib.keys():
if root.find("structure").attrib["cartesian"]:
cartesian = True
for i, p in enumerate(positions):
for j in range(3):
p[j] = p[j] * ExcitingInput.bohr2ang
print(positions)
else:
cartesian = False
# get the scale attribute
scale_in = root.find("structure").find("crystal").get("scale")
if scale_in:
scale = float(scale_in) * ExcitingInput.bohr2ang
else:
scale = ExcitingInput.bohr2ang
# get the stretch attribute
stretch_in = root.find("structure").find("crystal").get("stretch")
if stretch_in:
stretch = np.array([float(a) for a in stretch_in])
else:
stretch = np.array([1.0, 1.0, 1.0])
# get basis vectors and scale them accordingly
basisnode = root.find("structure").find("crystal").iter("basevect")
for vect in basisnode:
x, y, z = vect.text.split()
vectors.append([
float(x) * stretch[0] * scale,
float(y) * stretch[1] * scale,
float(z) * stretch[2] * scale,
])
# create lattice and structure object
lattice_in = Lattice(vectors)
structure_in = Structure(lattice_in,
elements,
positions,
coords_are_cartesian=cartesian)
return ExcitingInput(structure_in, title_in, lockxyz)
@staticmethod
def from_file(filename):
"""
:param filename: Filename
:return: ExcitingInput
"""
with zopen(filename, "rt") as f:
data = f.read().replace("\n", "")
return ExcitingInput.from_string(data)
def write_etree(self,
celltype,
cartesian=False,
bandstr=False,
symprec=0.4,
angle_tolerance=5,
**kwargs):
"""
Writes the exciting input parameters to an xml object.
Args:
celltype (str): Choice of unit cell. Can be either the unit cell
from self.structure ("unchanged"), the conventional cell
("conventional"), or the primitive unit cell ("primitive").
cartesian (bool): Whether the atomic positions are provided in
Cartesian or unit-cell coordinates. Default is False.
bandstr (bool): Whether the bandstructure path along the
HighSymmKpath is included in the input file. Only supported if the
celltype is set to "primitive". Default is False.
symprec (float): Tolerance for the symmetry finding. Default is 0.4.
angle_tolerance (float): Angle tolerance for the symmetry finding.
Default is 5.
**kwargs: Additional parameters for the input file.
Returns:
ET.Element containing the input XML structure
"""
root = ET.Element("input")
root.set(
"{http://www.w3.org/2001/XMLSchema-instance}noNamespaceSchemaLocation",
"http://xml.exciting-code.org/excitinginput.xsd",
)
title = ET.SubElement(root, "title")
title.text = self.title
if cartesian:
structure = ET.SubElement(root,
"structure",
cartesian="true",
speciespath="./")
else:
structure = ET.SubElement(root, "structure", speciespath="./")
crystal = ET.SubElement(structure, "crystal")
# set scale such that lattice vector can be given in Angstrom
ang2bohr = const.value("Angstrom star") / const.value("Bohr radius")
crystal.set("scale", str(ang2bohr))
# determine which structure to use
finder = SpacegroupAnalyzer(self.structure,
symprec=symprec,
angle_tolerance=angle_tolerance)
if celltype == "primitive":
new_struct = finder.get_primitive_standard_structure(
international_monoclinic=False)
elif celltype == "conventional":
new_struct = finder.get_conventional_standard_structure(
international_monoclinic=False)
elif celltype == "unchanged":
new_struct = self.structure
else:
raise ValueError("Type of unit cell not recognized!")
# write lattice
basis = new_struct.lattice.matrix
for i in range(3):
basevect = ET.SubElement(crystal, "basevect")
basevect.text = "%16.8f %16.8f %16.8f" % (
basis[i][0],
basis[i][1],
basis[i][2],
)
# write atomic positions for each species
index = 0
for i in sorted(new_struct.types_of_species, key=lambda el: el.X):
species = ET.SubElement(structure,
"species",
speciesfile=i.symbol + ".xml")
sites = new_struct.indices_from_symbol(i.symbol)
for j in sites:
coord = "%16.8f %16.8f %16.8f" % (
new_struct[j].frac_coords[0],
new_struct[j].frac_coords[1],
new_struct[j].frac_coords[2],
)
# obtain cartesian coords from fractional ones if needed
if cartesian:
coord2 = []
for k in range(3):
inter = (new_struct[j].frac_coords[k] * basis[0][k] +
new_struct[j].frac_coords[k] * basis[1][k] +
new_struct[j].frac_coords[k] *
basis[2][k]) * ang2bohr
coord2.append(inter)
coord = "%16.8f %16.8f %16.8f" % (coord2[0], coord2[1],
coord2[2])
# write atomic positions
index = index + 1
_ = ET.SubElement(species, "atom", coord=coord)
# write bandstructure if needed
if bandstr and celltype == "primitive":
kpath = HighSymmKpath(new_struct,
symprec=symprec,
angle_tolerance=angle_tolerance)
prop = ET.SubElement(root, "properties")
bandstrct = ET.SubElement(prop, "bandstructure")
for i in range(len(kpath.kpath["path"])):
plot = ET.SubElement(bandstrct, "plot1d")
path = ET.SubElement(plot, "path", steps="100")
for j in range(len(kpath.kpath["path"][i])):
symbol = kpath.kpath["path"][i][j]
coords = kpath.kpath["kpoints"][symbol]
coord = "%16.8f %16.8f %16.8f" % (coords[0], coords[1],
coords[2])
if symbol == "\\Gamma":
symbol = "GAMMA"
_ = ET.SubElement(path, "point", coord=coord, label=symbol)
elif bandstr and celltype != "primitive":
raise ValueError("Bandstructure is only implemented for the \
standard primitive unit cell!")
# write extra parameters from kwargs if provided
self._dicttoxml(kwargs, root)
return root
def write_string(self,
celltype,
cartesian=False,
bandstr=False,
symprec=0.4,
angle_tolerance=5,
**kwargs):
"""
Writes exciting input.xml as a string.
Args:
celltype (str): Choice of unit cell. Can be either the unit cell
from self.structure ("unchanged"), the conventional cell
("conventional"), or the primitive unit cell ("primitive").
cartesian (bool): Whether the atomic positions are provided in
Cartesian or unit-cell coordinates. Default is False.
bandstr (bool): Whether the bandstructure path along the
HighSymmKpath is included in the input file. Only supported if the
celltype is set to "primitive". Default is False.
symprec (float): Tolerance for the symmetry finding. Default is 0.4.
angle_tolerance (float): Angle tolerance for the symmetry finding.
Default is 5.
**kwargs: Additional parameters for the input file.
Returns:
String
"""
try:
root = self.write_etree(celltype, cartesian, bandstr, symprec,
angle_tolerance, **kwargs)
self._indent(root)
# output should be a string not a bytes object
string = ET.tostring(root).decode("UTF-8")
except Exception:
raise ValueError("Incorrect celltype!")
return string
def write_file(self,
celltype,
filename,
cartesian=False,
bandstr=False,
symprec=0.4,
angle_tolerance=5,
**kwargs):
"""
Writes exciting input file.
Args:
celltype (str): Choice of unit cell. Can be either the unit cell
from self.structure ("unchanged"), the conventional cell
("conventional"), or the primitive unit cell ("primitive").
filename (str): Filename for exciting input.
cartesian (bool): Whether the atomic positions are provided in
Cartesian or unit-cell coordinates. Default is False.
bandstr (bool): Whether the bandstructure path along the
HighSymmKpath is included in the input file. Only supported if the
celltype is set to "primitive". Default is False.
symprec (float): Tolerance for the symmetry finding. Default is 0.4.
angle_tolerance (float): Angle tolerance for the symmetry finding.
Default is 5.
**kwargs: Additional parameters for the input file.
"""
try:
root = self.write_etree(celltype, cartesian, bandstr, symprec,
angle_tolerance, **kwargs)
self._indent(root)
tree = ET.ElementTree(root)
tree.write(filename)
except Exception:
raise ValueError("Incorrect celltype!")
# Missing PrettyPrint option in the current version of xml.etree.cElementTree
@staticmethod
def _indent(elem, level=0):
"""
Helper method to indent elements.
:param elem:
:param level:
:return:
"""
i = "\n" + level * " "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for el in elem:
ExcitingInput._indent(el, level + 1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
def _dicttoxml(self, paramdict_, element):
for key, value in paramdict_.items():
if isinstance(value, str) and key == "text()":
element.text = value
elif isinstance(value, str):
element.attrib[key] = value
elif isinstance(value, list):
for item in value:
self._dicttoxml(item, ET.SubElement(element, key))
elif isinstance(value, dict):
if element.findall(key) == []:
self._dicttoxml(value, ET.SubElement(element, key))
else:
self._dicttoxml(value, element.findall(key)[0])
else:
print("cannot deal with", key, "=", value)
def pressure_pPa(n, t):
k = value('Boltzmann constant')
assert unit('Boltzmann constant') == 'J K^-1'
return k * n * t * (100**3) * (1e12)
def test_exact_values():
# Check that updating stored values with exact ones worked.
for key in codata.exact_values:
assert_((codata.exact_values[key][0] - value(key)) / value(key) == 0)
def C(s):
return Q(constants.value(s), constants.unit(s))
import numpy as np
import numpy.linalg as la
import matplotlib.pyplot as plt
import cmath
import scipy.constants as const
from scipy import fftpack
import time as tti
import skfuzzy.membership as fuzzy
t0=tti.time()
pi=np.pi
aSi=0.6101*10**(-9)
a=aSi/const.value('Bohr radius') #Lattice constant in a.u.
a=1 #Lattice constant in a.u.
p1=a/8 #dimensioni della buca
p2=7*a/8 #Boundary
V0=-0.15 #potenziale normalizzato
N=12 #numero vettori base
p=p2-p1 #ampiezza della buca
kpoints=100 #numero punti nello spazio k
#ESW=((const.hbar**2)*(const.pi**2))/(2*const.m_e*(a**2)) #Infinite square well energy
lamb=3200*10**(-9) #Laser Wavelenght
w=2*np.pi*const.c/lamb #Laser pulsation
freqau=const.value('atomic unit of velocity')/const.value('Bohr radius')
wau=w/freqau
timeau=const.value('Bohr radius')/const.value('atomic unit of velocity')
T=16*np.pi/w
Td=16*np.pi/wau #Pulse Duration in a.u.
"""Derivation of variable `toz`."""
import cf_units
import iris
from scipy import constants
from ._baseclass import DerivedVariableBase
from ._shared import pressure_level_widths
# Constants
AVOGADRO_CONST = constants.value('Avogadro constant')
AVOGADRO_CONST_UNIT = constants.unit('Avogadro constant')
STANDARD_GRAVITY = constants.value('standard acceleration of gravity')
STANDARD_GRAVITY_UNIT = constants.unit('standard acceleration of gravity')
MW_AIR = 29
MW_AIR_UNIT = cf_units.Unit('g mol^-1')
MW_O3 = 48
MW_O3_UNIT = cf_units.Unit('g mol^-1')
DOBSON_UNIT = cf_units.Unit('2.69e20 m^-2')
class DerivedVariable(DerivedVariableBase):
"""Derivation of variable `toz`."""
@staticmethod
def required(project):
"""Declare the variables needed for derivation."""
if project == 'CMIP6':
required = [{'short_name': 'o3'}, {'short_name': 'ps'}]
else:
required = [{'short_name': 'tro3'}, {'short_name': 'ps'}]
return required
def mg(dl, B, lam):
return const.h * const.c / (lam**2 * B * const.value("Bohr magneton")) * dl
def main():
# Input parser
parser = argparse.ArgumentParser(
description="Reorganize abICS RXMC results by temperature")
parser.add_argument("inputfi", help="toml input file used for abICS run")
parser.add_argument(
"skipsteps",
nargs="?",
type=int,
default=0,
help="number of thermalization steps to skip in energy averaging." +
" Default: 0",
)
args = parser.parse_args()
inputfi = args.inputfi
nskip = args.skipsteps
rxparams = RXParams.from_toml(inputfi)
nreplicas = rxparams.nreplicas
comm = RX_MPI_init(rxparams)
myreplica = comm.Get_rank()
if myreplica == 0:
if os.path.exists("Tseparate"):
shutil.move("Tseparate",
"Tseparate.bak.{}".format(datetime.datetime.now()))
os.mkdir("Tseparate")
comm.Barrier()
# Separate structure files
os.mkdir(os.path.join("Tseparate", str(myreplica)))
Trank_hist = np.load(os.path.join(str(myreplica), "Trank_hist.npy"))
os.chdir(str(myreplica))
for j in range(len(Trank_hist)):
shutil.copy(
"structure.{}.vasp".format(j),
os.path.join(os.pardir, "Tseparate", str(Trank_hist[j])),
)
# Separate energies
myreplica_energies = np.load("obs_save.npy")[:, 0]
for Tid in range(nreplicas):
T_energies = np.where(Trank_hist == Tid, myreplica_energies, 0)
T_energies_rcvbuf = np.zeros(T_energies.shape[0], "d")
comm.Reduce(
[T_energies, MPI.DOUBLE],
[T_energies_rcvbuf, MPI.DOUBLE],
op=MPI.SUM,
root=Tid,
)
if myreplica == Tid:
np.savetxt(
os.path.join(os.pardir, "Tseparate", str(Tid), "energies.dat"),
T_energies_rcvbuf,
)
comm.Barrier()
if myreplica == 0:
os.chdir(os.path.join(os.pardir, "Tseparate"))
with open("energies_T.dat", "w") as fi:
kTs = np.load(os.path.join(os.pardir, "kTs.npy"))
Ts = kTs / constants.value(u"Boltzmann constant in eV/K")
for Tid in range(nreplicas):
energy_mean = np.mean(
np.loadtxt(os.path.join(str(Tid), "energies.dat"))[nskip:])
fi.write("{}\t{}\n".format(Ts[Tid], energy_mean))
# coding: utf-8
# Copyright (c) Pymatgen Development Team.
# Distributed under the terms of the MIT License.
"""
This module defines classes to represent the phonon density of states, etc.
"""
import numpy as np
import scipy.constants as const
from monty.functools import lazy_property
from monty.json import MSONable
from pymatgen.core.structure import Structure
from pymatgen.util.coord import get_linear_interpolated_value
BOLTZ_THZ_PER_K = (const.value("Boltzmann constant in Hz/K") / const.tera
) # Boltzmann constant in THz/K
THZ_TO_J = const.value("hertz-joule relationship") * const.tera
def coth(x):
"""
Coth function.
Args:
x (): value
Returns:
coth(x)
"""
return 1.0 / np.tanh(x)
import numpy as np
from scipy.integrate import quad
import scipy.constants as spc
from atmosphere import *
from charged_particle import EnergyDistribution, AngularDistribution
twopi = 2. * np.pi
m_e = spc.value('electron mass energy equivalent in MeV')
class CherenkovPhoton:
inner_precision = 1.e-5
outer_precision = 1.e-4
def __init__(self, t, delta, ntheta=321, minlgtheta=-3., maxlgtheta=0.2):
"""Create a normalized Cherenkov-photon angular distribution at the
given shower stage, t, and with the index-of-refraction of the atmosphere
given by delta. By default there are 321 logarithmically spaced angular
points from 1 mR to pi/2 R.
Parameters:
t: shower stage
delta: difference of index-of-refraction from unity
ntheta: number of log-spaced theta points to create
minlgtheta: the minimum value of lgtheta
maxlgtheta: the maximum value of lgtheta
"""
self.t = t
self.delta = delta
lgtheta, dlgtheta = np.linspace(minlgtheta,
maxlgtheta,
#!/usr/bin/env python3
import pickle
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt
import numpy
from scipy import constants
from pysolidg2p import asymmetry, cross_section, sim_reader, structure_f
_alpha = constants.alpha
_m_p = constants.value('proton mass energy equivalent in MeV') * 1e-3
_inv_fm_to_gev = constants.hbar * constants.c / constants.e * 1e6
_inv_gev_to_fm = _inv_fm_to_gev
_inv_gev_to_mkb = _inv_gev_to_fm**2 * 1e4
e = 11
binning = {'bins': 20, 'range': (0.0, 1.0)}
yield_limit = 10000
def create_bins():
bins = binning['bins']
bin_low, bin_high = binning['range']
bin_centers = numpy.linspace(bin_low + (bin_high - bin_low) / bins / 2,
bin_high - (bin_high - bin_low) / bins / 2,
bins)
bin_edges = numpy.linspace(bin_low, bin_high, bins + 1)
return bin_centers, bin_edges
from hyperspy.misc.eels.base_gos import GOSBase
_logger = logging.getLogger(__name__)
XU = [
.82, .52, .52, .42, .30, .29, .22, .30, .22, .16, .12, .13, .13, .14, .16,
.18, .19, .22, .14, .11, .12, .12, .12, .10, .10, .10
]
# IE3=[73,99,135,164,200,245,294,347,402,455,513,575,641,710,
# 779,855,931,1021,1115,1217,1323,1436,1550,1675]
# IE1=[118,149,189,229,270,320,377,438,500,564,628,695,769,846,
# 926,1008,1096,1194,1142,1248,1359,1476,1596,1727]
R = constants.value("Rydberg constant times hc in eV")
class HydrogenicGOS(GOSBase):
"""Computes the K and L GOS using R. Egerton's routines.
Parameters
----------
element_subshell : str
For example, 'Ti_L3' for the GOS of the titanium L3 subshell
Methods
-------
parametrize_GOS()
Parametrize the GOS to speed up the calculation.
get_qaxis_and_gos(ienergy, qmin, qmax)
# Filename of mesh (excluding .xml)
# fname = "../mesh/3D/laframboise_sphere_in_sphere_res1c"
fname = "../mesh/3D/laframboise_sphere_in_cube_res1"
# Get the mesh
mesh, bnd = load_mesh(fname)
ext_bnd_id, int_bnd_ids = get_mesh_ids(bnd)
ext_bnd = ExteriorBoundaries(bnd, ext_bnd_id)
npc = 4 # Number of particles per cell
# num = 300000 # Total number of particles in the domain
V = df.assemble(1*df.dx(mesh))
Np = npc*mesh.num_cells()
me = constants.value('electron mass')
mp = constants.value('proton mass')
e = constants.value('elementary charge')
eps0 = constants.value('electric constant')
kB = constants.value('Boltzmann constant')
ne = 1e10
# Te = 1000
# debye = np.sqrt(eps0*kB*Te/(e**2 * ne))
debye = 1.0
Te = (e*debye)**2*ne/(eps0*kB)
wpe = np.sqrt(ne*e**2/(eps0*me))
vthe = debye*wpe
vthi = vthe/np.sqrt(1836)
Rp = 1*debye
X = Rp
#!/usr/bin/env python
from scipy import constants as K # <1>
print("pi: {0}".format(K.pi)) # <2>
print("Planck: {0}".format(K.Planck)) # <2>
print("c (speed of light): {0}".format(K.c)) # <2>
print("natural unit of energy: {0}".format(K.value('natural unit of energy')))
print("natural unit of energy (Unit): {0}".format(K.unit('natural unit of energy')))
"""
This script collects the data from forward and backward switchings and computed the absolute free energy for each temperature.
Usage:
python integrate.py
"""
from numpy import *
import scipy.constants as sc
from scipy.integrate import cumtrapz
T0 = 100 # Reference temperature [K]
kB = sc.value('Boltzmann constant in eV/K')
# Load free energy reference value.
T, F0 = loadtxt('../../frenkel_ladd/data/free_energy.dat', unpack=True)
F0 = F0[T == T0]
# Load potential energy and lambda.
U_f, lamb_f = loadtxt('../data/forward.dat', unpack=True)
U_b, lamb_b = loadtxt('../data/backward.dat', unpack=True)
# Fix adapt also scales the potential energy besides the forces, so we unscale.
U_f /= lamb_f
U_b /= lamb_b
# Compute work done using cummulative integrals [Eq.(21) in the paper].
I_f = cumtrapz(U_f, lamb_f, initial=0)
I_b = cumtrapz(U_b[::-1], lamb_b[::-1], initial=0)
W = (I_f + I_b) / (2 * lamb_f)
"""Constants and helper methods for use within the schedule submodule.
"""
import numpy as np
from scipy import constants
from scipy import sparse
import scipy.special as special
BOLTZ = constants.value("Boltzmann constant in Hz/K")
E_CHARGE = constants.value("atomic unit of charge")
H_PLANCK = constants.value("Planck constant")
PHI_0 = constants.value("mag. flux quantum")
def e_j(i_c):
"""Returns the josephson energy for the given critical current
in GHZ (omega)
E_j = Phi_0/2pi * I_c
Arguments
---------
i_c : float
Junction critical current, in nA
Returns
-------
float
Josephson energy in GHz (i.e., omega = 2*pi*f)
"""
return PHI_0 * (i_c * 1e-9) / H_PLANCK / 1e9
from numpy.lib import scimath
import scipy
from scipy.optimize import curve_fit
from scipy import constants
from scipy.stats import sem
import matplotlib.pyplot as plt
from uncertainties import ufloat
import uncertainties.unumpy as unp
from uncertainties.unumpy import log10, log, exp, sqrt
import sympy
import cmath
plt.rcParams['figure.figsize'] = (10, 8)
plt.rcParams['font.size'] = 16
h = constants.value(u'Planck constant')
c = constants.value(u'speed of light in vacuum')
mb = constants.value(u'Bohr magneton')
l_blue = 480 * 10**(-9)
l_red = 643.8 * 10**(-9)
ld_red = 48.9 * 10**(-12)
ld_blue = 26.9 * 10**(-12)
data_b = np.genfromtxt('magnetfeld.txt', unpack='True')
data_deltas_red = np.genfromtxt('deltas_red.txt', unpack='True', skip_header=1)
data_deltas_blue = np.genfromtxt('deltas_blue.txt',
unpack='True',
skip_header=1)
ValenceIonicRadiusEvaluator
from pymatgen.analysis.local_env import get_okeeffe_distance_prediction, MinimumDistanceNN, \
VoronoiNN, MinimumOKeeffeNN, MinimumVIRENN
from pymatgen.analysis.structure_analyzer import OrderParameters
from pymatgen.core.periodic_table import Specie, Element
from pymatgen.analysis.structure_analyzer import VoronoiCoordFinder as VCF
from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
from matminer.featurizers.base import BaseFeaturizer
from matminer.featurizers.stats import PropertyStats
__authors__ = 'Anubhav Jain <*****@*****.**>, Saurabh Bajaj <*****@*****.**>, ' \
'Nils E.R. Zimmerman <*****@*****.**>'
# ("@article{label, title={}, volume={}, DOI={}, number={}, pages={}, journal={}, author={}, year={}}")
ANG_TO_BOHR = const.value('Angstrom star') / const.value('Bohr radius')
# To do:
# - Use local_env-based neighbor finding
# once this is part of the stable Pymatgen version.
class DensityFeatures(BaseFeaturizer):
def __init__(self, desired_features=None):
self.features = ["density", "vpa", "packing fraction"] if not desired_features else desired_features
def featurize(self, s):
features = []
if "density" in self.features:
# %%
#
#dummy = wpu.dummy_images('Shapes', shape=(110, 110), noise = 1)
#fname = 'dummy.tif'
#image = dummy[5:-5,5:-5]
#image_ref = dummy[7:-3,4:-6]
# =============================================================================
# %% parameters
# =============================================================================
rad2deg = np.rad2deg(1)
deg2rad = np.deg2rad(1)
NAN = float('Nan') # not a number alias
hc = constants.value('inverse meter-electron volt relationship') # hc
wavelength = hc / phenergy
kwave = 2 * np.pi / wavelength
# =============================================================================
# %% Crop
# =============================================================================
#image = np.rot90(image) # rotate images, good for sanity checks
#image_ref = np.rot90(image_ref)
kb_input = input('\nGraphic Crop? [N/y] : ')
if kb_input.lower() == 'y':
# Graphical Crop
def write_etree(self,
celltype,
cartesian=False,
bandstr=False,
symprec=0.4,
angle_tolerance=5,
**kwargs):
"""
Writes the exciting input parameters to an xml object.
Args:
celltype (str): Choice of unit cell. Can be either the unit cell
from self.structure ("unchanged"), the conventional cell
("conventional"), or the primitive unit cell ("primitive").
cartesian (bool): Whether the atomic positions are provided in
Cartesian or unit-cell coordinates. Default is False.
bandstr (bool): Whether the bandstructure path along the
HighSymmKpath is included in the input file. Only supported if the
celltype is set to "primitive". Default is False.
symprec (float): Tolerance for the symmetry finding. Default is 0.4.
angle_tolerance (float): Angle tolerance for the symmetry finding.
Default is 5.
**kwargs: Additional parameters for the input file.
Returns:
ET.Element containing the input XML structure
"""
root = ET.Element("input")
root.set(
"{http://www.w3.org/2001/XMLSchema-instance}noNamespaceSchemaLocation",
"http://xml.exciting-code.org/excitinginput.xsd",
)
title = ET.SubElement(root, "title")
title.text = self.title
if cartesian:
structure = ET.SubElement(root,
"structure",
cartesian="true",
speciespath="./")
else:
structure = ET.SubElement(root, "structure", speciespath="./")
crystal = ET.SubElement(structure, "crystal")
# set scale such that lattice vector can be given in Angstrom
ang2bohr = const.value("Angstrom star") / const.value("Bohr radius")
crystal.set("scale", str(ang2bohr))
# determine which structure to use
finder = SpacegroupAnalyzer(self.structure,
symprec=symprec,
angle_tolerance=angle_tolerance)
if celltype == "primitive":
new_struct = finder.get_primitive_standard_structure(
international_monoclinic=False)
elif celltype == "conventional":
new_struct = finder.get_conventional_standard_structure(
international_monoclinic=False)
elif celltype == "unchanged":
new_struct = self.structure
else:
raise ValueError("Type of unit cell not recognized!")
# write lattice
basis = new_struct.lattice.matrix
for i in range(3):
basevect = ET.SubElement(crystal, "basevect")
basevect.text = "%16.8f %16.8f %16.8f" % (
basis[i][0],
basis[i][1],
basis[i][2],
)
# write atomic positions for each species
index = 0
for i in sorted(new_struct.types_of_species, key=lambda el: el.X):
species = ET.SubElement(structure,
"species",
speciesfile=i.symbol + ".xml")
sites = new_struct.indices_from_symbol(i.symbol)
for j in sites:
coord = "%16.8f %16.8f %16.8f" % (
new_struct[j].frac_coords[0],
new_struct[j].frac_coords[1],
new_struct[j].frac_coords[2],
)
# obtain cartesian coords from fractional ones if needed
if cartesian:
coord2 = []
for k in range(3):
inter = (new_struct[j].frac_coords[k] * basis[0][k] +
new_struct[j].frac_coords[k] * basis[1][k] +
new_struct[j].frac_coords[k] *
basis[2][k]) * ang2bohr
coord2.append(inter)
coord = "%16.8f %16.8f %16.8f" % (coord2[0], coord2[1],
coord2[2])
# write atomic positions
index = index + 1
_ = ET.SubElement(species, "atom", coord=coord)
# write bandstructure if needed
if bandstr and celltype == "primitive":
kpath = HighSymmKpath(new_struct,
symprec=symprec,
angle_tolerance=angle_tolerance)
prop = ET.SubElement(root, "properties")
bandstrct = ET.SubElement(prop, "bandstructure")
for i in range(len(kpath.kpath["path"])):
plot = ET.SubElement(bandstrct, "plot1d")
path = ET.SubElement(plot, "path", steps="100")
for j in range(len(kpath.kpath["path"][i])):
symbol = kpath.kpath["path"][i][j]
coords = kpath.kpath["kpoints"][symbol]
coord = "%16.8f %16.8f %16.8f" % (coords[0], coords[1],
coords[2])
if symbol == "\\Gamma":
symbol = "GAMMA"
_ = ET.SubElement(path, "point", coord=coord, label=symbol)
elif bandstr and celltype != "primitive":
raise ValueError("Bandstructure is only implemented for the \
standard primitive unit cell!")
# write extra parameters from kwargs if provided
self._dicttoxml(kwargs, root)
return root
# Author: Chao Gu, 2018
from scipy import constants
__all__ = ['mass']
_ma = constants.value('atomic mass constant energy equivalent in MeV') / 1000
def mass(z, a):
return {
(1, 1): 1.007940,
(2, 4): 4.002602,
(6, 12): 12.0107,
(7, 14): 14.0067,
}.get((z, a), a) * _ma
num_cpu = mp.cpu_count()
# Tracking
from tqdm import tqdm
#########################
# #
# GLOBAL PARAMETERS #
# #
#########################
# Physical Constants
hbar = constants.hbar
kB = constants.Boltzmann
muB = constants.value('Bohr magneton')
Da = constants.value('atomic mass constant')
# Strontium 88 parameters
m = 88 * Da
Gamma = 2 * np.pi * 32 * 10**6 # linewidth of 32MHz (angular frequency)
k = (2 * np.pi) / (0.461 * 10**-6)
IO = 42.5 # Saturation intensity, mW/cm^2
gJ = 1.
# Fixed parameters
MOT3dXoffset = 0.
MOT3dYoffset = -0.003
MOT3dZoffset = 0.43
offset = np.array([MOT3dXoffset, MOT3dYoffset, MOT3dZoffset])
g = 9.8
def get_number_of_effective_electrons(self, nat, cumulative=False):
"""Compute the number of effective electrons using the Bethe f-sum
rule.
The Bethe f-sum rule gives rise to two definitions of the effective
number (see [Egerton2011]_):
$n_{\mathrm{eff}}\left(-\Im\left(\epsilon^{-1}\right)\right)$ that
we'll call neff1 and
$n_{\mathrm{eff}}\left(\epsilon_{2}\right)$ that we'll call neff2. This
method computes both.
Parameters
----------
nat: float
Number of atoms (or molecules) per unit volume of the
sample.
cumulative : bool
If False calculate the number of effective electrons up to the
higher energy-loss of the spectrum. If True, calculate the
number of effective electrons as a function of the energy-loss up
to the higher energy-loss of the spectrum. *True is only supported
by SciPy newer than 0.13.2*.
Returns
-------
neff1, neff2: Signal
Signal instances containing neff1 and neff2. The signal and
navigation dimensions are the same as the current signal if
`cumulative` is True, otherwise the signal dimension is 0
and the navigation dimension is the same as the current
signal.
Notes
-----
.. [Egerton2011] Ray Egerton, "Electron Energy-Loss
Spectroscopy in the Electron Microscope", Springer-Verlag, 2011.
"""
m0 = constants.value("electron mass")
epsilon0 = constants.epsilon_0 # Vacuum permittivity [F/m]
hbar = constants.hbar # Reduced Plank constant [J·s]
k = 2 * epsilon0 * m0 / (np.pi * nat * hbar ** 2)
axis = self.axes_manager.signal_axes[0]
if cumulative is False:
dneff1 = k * simps((-1. / self.data).imag * axis.axis,
x=axis.axis,
axis=axis.index_in_array)
dneff2 = k * simps(self.data.imag * axis.axis,
x=axis.axis,
axis=axis.index_in_array)
neff1 = self._get_navigation_signal()
neff2 = self._get_navigation_signal()
neff1.data = dneff1
neff2.data = dneff2
else:
neff1 = self._deepcopy_with_new_data(
k * cumtrapz((-1. / self.data).imag * axis.axis,
x=axis.axis,
axis=axis.index_in_array,
initial=0))
neff2 = self._deepcopy_with_new_data(
k * cumtrapz(self.data.imag * axis.axis,
x=axis.axis,
axis=axis.index_in_array,
initial=0))
# Prepare return
neff1.metadata.General.title = (
r"$n_{\mathrm{eff}}\left(-\Im\left(\epsilon^{-1}\right)\right)$ "
"calculated from " +
self.metadata.General.title +
" using the Bethe f-sum rule.")
neff2.metadata.General.title = (
r"$n_{\mathrm{eff}}\left(\epsilon_{2}\right)$ "
"calculated from " +
self.metadata.General.title +
" using the Bethe f-sum rule.")
return neff1, neff2
def fit_sdm_desoto(v_mp,
i_mp,
v_oc,
i_sc,
alpha_sc,
beta_voc,
cells_in_series,
EgRef=1.121,
dEgdT=-0.0002677,
temp_ref=25,
irrad_ref=1000,
root_kwargs={}):
"""
Calculates the parameters for the De Soto single diode model using the
procedure described in [1]_. This procedure has the advantage of
using common specifications given by manufacturers in the
datasheets of PV modules.
The solution is found using the scipy.optimize.root() function,
with the corresponding default solver method 'hybr'.
No restriction is put on the fit variables, i.e. series
or shunt resistance could go negative. Nevertheless, if it happens,
check carefully the inputs and their units; alpha_sc and beta_voc are
often given in %/K in manufacturers datasheets and should be given
in A/K and V/K here.
The parameters returned by this function can be used by
pvsystem.calcparams_desoto to calculate the values at different
irradiance and cell temperature.
Parameters
----------
v_mp: float
Module voltage at the maximum-power point at reference conditions [V].
i_mp: float
Module current at the maximum-power point at reference conditions [A].
v_oc: float
Open-circuit voltage at reference conditions [V].
i_sc: float
Short-circuit current at reference conditions [A].
alpha_sc: float
The short-circuit current (i_sc) temperature coefficient of the
module [A/K].
beta_voc: float
The open-circuit voltage (v_oc) temperature coefficient of the
module [V/K].
cells_in_series: integer
Number of cell in the module.
EgRef: float, default 1.121 eV - value for silicon
Energy of bandgap of semi-conductor used [eV]
dEgdT: float, default -0.0002677 - value for silicon
Variation of bandgap according to temperature [eV/K]
temp_ref: float, default 25
Reference temperature condition [C]
irrad_ref: float, default 1000
Reference irradiance condition [W/m2]
root_kwargs: dictionary, default None
Dictionary of arguments to pass onto scipy.optimize.root()
Returns
-------
Dictionary with the following elements:
* ``I_L_ref`` (float) --
Light-generated current at reference conditions [A]
* ``I_o_ref`` (float) --
Diode saturation current at reference conditions [A]
* ``R_s`` (float) --
Series resistance [ohms]
* ``R_sh_ref`` (float) --
Shunt resistance at reference conditions [ohms].
* ``a_ref`` (float) --
Modified ideality factor at reference conditions.
The product of the usual diode ideality factor (n, unitless),
number of cells in series (Ns), and cell thermal voltage at
specified effective irradiance and cell temperature.
* ``alpha_sc`` (float) --
The short-circuit current (i_sc) temperature coefficient of the
module [A/K].
* ``EgRef`` (float) --
Energy of bandgap of semi-conductor used [eV]
* ``dEgdT`` (float) --
Variation of bandgap according to temperature [eV/K]
* ``irrad_ref`` (float) --
Reference irradiance condition [W/m2]
* ``temp_ref`` (float) --
Reference temperature condition [C]
scipy.optimize.OptimizeResult
Optimization result of scipy.optimize.root().
See scipy.optimize.OptimizeResult for more details.
References
----------
.. [1] W. De Soto et al., "Improvement and validation of a model for
photovoltaic array performance", Solar Energy, vol 80, pp. 78-88,
2006.
.. [2] John A Duffie, William A Beckman, "Solar Engineering of Thermal
Processes", Wiley, 2013
"""
try:
from scipy.optimize import root
from scipy import constants
except ImportError:
raise ImportError("The fit_sdm_desoto function requires scipy.")
# Constants
k = constants.value('Boltzmann constant in eV/K')
Tref = temp_ref + 273.15 # [K]
# initial guesses of variables for computing convergence:
# Values are taken from [2], p753
Rsh_0 = 100.0
a_0 = 1.5 * k * Tref * cells_in_series
IL_0 = i_sc
Io_0 = i_sc * np.exp(-v_oc / a_0)
Rs_0 = (a_0 * np.log1p((IL_0 - i_mp) / Io_0) - v_mp) / i_mp
# params_i : initial values vector
params_i = np.array([IL_0, Io_0, a_0, Rsh_0, Rs_0])
# specs of module
specs = (i_sc, v_oc, i_mp, v_mp, beta_voc, alpha_sc, EgRef, dEgdT, Tref, k)
# computing with system of equations described in [1]
optimize_result = root(_system_of_equations_desoto,
x0=params_i,
args=(specs, ),
**root_kwargs)
if optimize_result.success:
sdm_params = optimize_result.x
else:
raise RuntimeError('Parameter estimation failed:\n' +
optimize_result.message)
# results
return ({
'I_L_ref': sdm_params[0],
'I_o_ref': sdm_params[1],
'a_ref': sdm_params[2],
'R_sh_ref': sdm_params[3],
'R_s': sdm_params[4],
'alpha_sc': alpha_sc,
'EgRef': EgRef,
'dEgdT': dEgdT,
'irrad_ref': irrad_ref,
'temp_ref': temp_ref
}, optimize_result)
import numpy as np
import pylab as pl
import matplotlib.pyplot as plt
from scipy import constants as cst
from matplotlib.ticker import FormatStrFormatter
#from scipy.signal import savgol_filter
verbose = 2 # control verbosity
if verbose == 2:
fig = plt.figure(figsize=(6.5, 5))
ax = fig.add_subplot(1, 1, 1)
tmpl = [0.8, 1., 1.2, 1.5, 2., 2.5, 3., 4., 5., 6., 7.5]
## Physical cst
c0 = cst.value('speed of light in vacuum') * 1.e6 #um/s
h0 = cst.value('Planck constant') # J.s
kb = cst.value('Boltzmann constant') # J/K
hc = c0 * h0 # um.J
Apert = 0.83 # Aperture in m
fnum = 4.5 # fnumber
R = 300 # lambda / delta lambda spectral resolution
lmax = 7.5 # maximum wavelength, microns
lmin = 0.75 # minumin wavelength, microns
Area_dp = 31 # deep survey area, sq deg
Area_sh = 311 # shallow survey area, sq deg
Tmission = 2. # mission length, years
obs_eff = 0.8 # observation efficiency (that is, fraction of time
# spent surveying)
t_dp = 104 # minutes per band per resolution element, deep survey
# ## Constantes e Definições
# In[3]:
# dataframe de pandas com valores utilizados para calculos
device = pd.DataFrame()
N = 1024 # tamanho padrao do grid
L = 500.0 # tamanho padrao do sistema em angstrom
dt = 1e-17 # incremento de tempo padrao em segundos
device['z_ang'] = np.linspace(-L/2, L/2, N) # malha espacial em angstrom
# fatores de conversao para unidades atomicas
au_l = cte.value('atomic unit of length')
au_t = cte.value('atomic unit of time')
au_e = cte.value('atomic unit of energy')
au_v = cte.value('atomic unit of electric potential')
au_ef = cte.value('atomic unit of electric field')
hbar_au = 1.0
me_au = 1.0
# constantes fisicas
ev = cte.value('electron volt')
c = cte.value('speed of light in vacuum')
me = cte.value('electron mass')
q = cte.value('elementary charge')
hbar_ev = cte.value('Planck constant over 2 pi in eV s')
hbar = cte.value('Planck constant over 2 pi')
h = cte.value('Planck constant')
# -*- coding: utf-8 -*-
"""
Contains constants and unit conversions.
"""
import scipy.constants as spc
###############################################################################
kcal_to_J = 4184
cal_to_J = 4.184
# Speed of light in m/s
C = spc.c
# ħ = h / 2π in J/s
HBAR = spc.hbar
# Conversion factor for momentum in SI to atomic units
P_AU = spc.value("atomic unit of momentum")
# Bohr radius in m
BOHR2M = spc.value("Bohr radius")
# Bohr -> Å conversion factor
BOHR2ANG = BOHR2M * 1e10
# Å -> Bohr conversion factor
ANG2BOHR = 1 / BOHR2ANG
# Hartree to J
AU2J = spc.value("Hartree energy")
# Hartree to kJ / mol
AU2KJPERMOL = AU2J / 1000 * spc.Avogadro
# Hartree to kcal / mol
AU2KCALMOL = AU2KJPERMOL / spc.calorie
# cal to j
CAL2J = AU2KJPERMOL / AU2KCALMOL
from Xpect_2 import LR as meth
else:
raise KeyError("specified method unkown")
self.spec = meth.ECD(kwargs)
def spectrum(self, **kwargs):
print("ECD!!!")
return self.spec.spectrum(kwargs)
if __name__ == '__main__':
import matplotlib.pyplot as plt
broadening = 0.1 * const.e / const.value('Hartree energy') #
print(broadening)
files = (
"/home/jmatti/projects/uracil/functionals_ts_au/functionals/uracil_pbe_rtp_x-dir-output-moments.dat",
"/home/jmatti/projects/uracil/functionals_ts_au/functionals/uracil_pbe_rtp_y-dir-output-moments.dat",
"/home/jmatti/projects/uracil/functionals_ts_au/functionals/uracil_pbe_rtp_z-dir-output-moments.dat",
)
files_lr = ("/home/jmatti/projects/uracil/tm_lrtddft/pbe/escf.out", )
files_mag = (
"/home/jmatti/projects/methyloxirane/ts_au_TZVP/r-methyloxirane_pbe_x-dir_TZVP-output-moments.dat",
"/home/jmatti/projects/methyloxirane/ts_au_TZVP/r-methyloxirane_pbe_y-dir_TZVP-output-moments.dat",
"/home/jmatti/projects/methyloxirane/ts_au_TZVP/r-methyloxirane_pbe_z-dir_TZVP-output-moments.dat"
)
files_mag_s = (
"/home/jmatti/projects/methyloxirane/ts_au_TZVP/s-methyloxirane_pbe_x-dir_TZVP-output-moments.dat",
def load_consts(self):
r""" Load constants, needed after unpickling in some cases """
self._c_nmps = constants.value(
'speed of light in vacuum') * 1e9 / 1e12 # c in nm/ps
self._c_mks = constants.value('speed of light in vacuum') # m/s
