def test_excited_state():
"""Test excited state transition energies"""
gsatoms = H2Morse()
Egs0 = gsatoms.get_potential_energy()
for i in range(1, 4):
exatoms = H2Morse()
exatoms[1].position[2] = Re[i] # set to potential minimum
Egs = exatoms.get_potential_energy()
exc = H2MorseExcitedStatesCalculator()
exl = exc.calculate(exatoms)
assert (exl[i - 1].energy == pytest.approx(Etrans[i] - Egs + Egs0,
1e-8))
def test_overlap():
"""Test equality with and without overlap"""
atoms = H2Morse()
name = 'profeta'
name = 'rrmorse'
nstates = 3
po = Profeta(atoms,
H2MorseExcitedStatesAndCalculator,
exkwargs={'nstates': nstates},
approximation='Placzek',
overlap=lambda x, y: x.overlap(y),
gsname=name,
exname=name,
txt='-')
po.run()
om = 1
poi = po.absolute_intensity(omega=om)[-1]
pr = Profeta(atoms,
H2MorseExcitedStatesAndCalculator,
exkwargs={'nstates': nstates},
approximation='Placzek',
gsname=name,
exname=name,
txt=None)
pri = pr.absolute_intensity(omega=om)[-1]
print('overlap', pri, poi, poi / pri)
assert pri == pytest.approx(poi, 1e-4)
def test_summary(testdir):
atoms = H2Morse()
rmc = ResonantRamanCalculator(atoms, H2MorseExcitedStatesCalculator)
rmc.run()
pz = Placzek(atoms, H2MorseExcitedStates)
pz.summary(1.)
def test_compare_placzek_implementation_intensities(testdir):
"""Intensities of different Placzek implementations
should be similar"""
atoms = H2Morse()
name = 'placzek'
rmc = ResonantRamanCalculator(atoms, H2MorseExcitedStatesCalculator,
overlap=lambda x, y: x.overlap(y),
name=name, txt='-')
rmc.run()
om = 1
gam = 0.1
pz = Placzek(atoms, H2MorseExcitedStates,
name=name, txt=None)
pzi = pz.get_absolute_intensities(omega=om, gamma=gam)[-1]
print(pzi, 'Placzek')
# Profeta using frozenset
pr = Profeta(atoms, H2MorseExcitedStates,
approximation='Placzek',
name=name, txt=None)
pri = pr.get_absolute_intensities(omega=om, gamma=gam)[-1]
print(pri, 'Profeta using frozenset')
assert pzi == pytest.approx(pri, 1e-3)
# Profeta using overlap
pr = Profeta(atoms, H2MorseExcitedStates,
approximation='Placzek', overlap=True,
name=name, txt=None)
pro = pr.get_absolute_intensities(omega=om, gamma=gam)[-1]
print(pro, 'Profeta using overlap')
assert pro == pytest.approx(pri, 1e-3)
def test_names(testdir):
"""Test different gs vs excited name. Tests also default names."""
# do a Vibrations calculation first
atoms = H2Morse()
vib = Vibrations(atoms)
vib.run()
assert '0x-' in vib.cache
# do a Resonant Raman calculation
rmc = ResonantRamanCalculator(atoms,
H2MorseExcitedStatesCalculator,
verbose=True)
rmc.run()
# excitation files should reside in the same directory as cache files
assert (Path(rmc.name) / ('ex.eq' + rmc.exext)).is_file()
# XXX does this still make sense?
# remove the corresponding pickle file,
# then Placzek can not anymore use it for vibrational properties
key = '0x-'
assert key in rmc.cache
del rmc.cache[key] # make sure this is not used
om = 1
gam = 0.1
pz = Placzek(atoms, H2MorseExcitedStates, name='vib', exname='raman')
pzi = pz.get_absolute_intensities(omega=om, gamma=gam)[-1]
parprint(pzi, 'Placzek')
# check that work was distributed correctly
assert len(pz.myindices) <= -(-6 // world.size)
def test_compare_placzek_implementation_intensities():
"""Intensities of different Placzek implementations
should be similar"""
atoms = H2Morse()
name = 'placzek'
pz = Placzek(atoms, H2MorseExcitedStatesAndCalculator,
gsname=name, exname=name, txt=None)
pz.run()
om = 1
pzi = pz.absolute_intensity(omega=om)[-1]
# Profeta using frozenset
pr = Profeta(atoms, H2MorseExcitedStatesAndCalculator,
approximation='Placzek',
gsname=name, exname=name, txt=None)
pri = pr.absolute_intensity(omega=om)[-1]
assert pzi == pytest.approx(pri, 1e-3)
# Profeta using overlap
name = 'profeta'
pr = Profeta(atoms, H2MorseExcitedStatesAndCalculator,
approximation='Placzek',
gsname=name, exname=name,
overlap=lambda x, y: x.overlap(y),
txt=None)
pr.run()
pro = pr.absolute_intensity(omega=om)[-1]
assert pro == pytest.approx(pri, 1e-3)
def test_overlap(testdir):
"""Test equality with and without overlap"""
atoms = H2Morse()
name = 'rrmorse'
nstates = 3
with ResonantRamanCalculator(atoms,
H2MorseExcitedStatesCalculator,
exkwargs={'nstates': nstates},
overlap=lambda x, y: x.overlap(y),
name=name,
txt='-') as rmc:
rmc.run()
om = 1
gam = 0.1
with Profeta(atoms,
H2MorseExcitedStates,
exkwargs={'nstates': nstates},
approximation='Placzek',
overlap=True,
name=name,
txt='-') as po:
poi = po.get_absolute_intensities(omega=om, gamma=gam)[-1]
with Profeta(atoms,
H2MorseExcitedStates,
exkwargs={'nstates': nstates},
approximation='Placzek',
name=name,
txt=None) as pr:
pri = pr.get_absolute_intensities(omega=om, gamma=gam)[-1]
print('overlap', pri, poi, poi / pri)
assert pri == pytest.approx(poi, 1e-4)
def test_names():
"""Test different gs vs excited name. Tests also default names."""
# do a Vibrations calculation first
atoms = H2Morse()
Vibrations(atoms).run()
assert os.path.isfile('vib.0x-.pckl')
# do a Resonant Raman calculation
rmc = ResonantRamanCalculator(atoms,
H2MorseExcitedStatesCalculator,
verbose=True)
rmc.run()
# remove the corresponding pickle file,
# then Placzek can not anymore use it for vibrational properties
assert os.path.isfile('raman.0x-.pckl')
os.remove('raman.0x-.pckl') # make sure this is not used
om = 1
gam = 0.1
pz = Placzek(atoms, H2MorseExcitedStates, name='vib', exname='raman')
pzi = pz.get_absolute_intensities(omega=om, gamma=gam)[-1]
parprint(pzi, 'Placzek')
# check that work was distributed correctly
assert len(pz.myindices) <= -(-6 // world.size)
def test_gs_io_overlap():
"""Test ground state IO and 'wave function' overlap"""
atoms0 = H2Morse()
calc0 = atoms0.calc
fname = 'calc0'
calc0.write(fname)
calc1 = H2MorseCalculator.read(fname)
for wf0, wf1 in zip(calc0.wfs, calc1.wfs):
assert wf0 == pytest.approx(wf1, 1e-5)
atoms1 = H2Morse()
ov = calc0.overlap(calc0)
# own overlap is the unity matrix
assert np.eye(4) == pytest.approx(calc0.overlap(calc0), 1e-8)
# self and other - test on unitarity
ov = calc0.overlap(atoms1.calc)
assert np.eye(4) == pytest.approx(ov.dot(ov.T), 1e-8)
def test_placzek_run():
atoms = H2Morse()
name = 'placzek'
pz = Placzek(atoms,
H2MorseExcitedStatesAndCalculator,
gsname=name,
exname=name,
txt='-')
pz.run()
def test_profeta_run():
atoms = H2Morse()
name = 'profeta'
pr = Profeta(atoms,
H2MorseExcitedStatesAndCalculator,
gsname=name,
exname=name,
txt='-')
pr.run()
def test_gs_minimum():
"""Test ground state minimum distance, energy and
vibrational frequency"""
atoms = H2Morse()
assert atoms.get_distance(0, 1) == pytest.approx(Re[0], 1.e-12)
assert atoms.get_potential_energy() == -De[0]
# check ground state vibrations
vib = Vibrations(atoms)
vib.run()
assert (vib.get_frequencies().real[-1] == pytest.approx(ome[0], 1e-2))
def test_overlap():
name = 'rrmorse'
atoms = H2Morse()
om = 1
ao = Albrecht(atoms,
H2MorseExcitedStatesAndCalculator,
gsname=name,
exname=name,
overlap=lambda x, y: x.overlap(y),
approximation='Albrecht A',
txt=None)
ao.run()
"""One state only"""
ao = Albrecht(atoms,
H2MorseExcitedStatesAndCalculator,
exkwargs={'nstates': 1},
gsname=name,
exname=name,
overlap=True,
approximation='Albrecht A',
txt=None)
aoi = ao.absolute_intensity(omega=om)[-1]
al = Albrecht(atoms,
H2MorseExcitedStatesAndCalculator,
exkwargs={'nstates': 1},
gsname=name,
exname=name,
approximation='Albrecht A',
txt=None)
ali = al.absolute_intensity(omega=om)[-1]
assert ali == pytest.approx(aoi, 1e-9)
"""Include degenerate states"""
ao = Albrecht(atoms,
H2MorseExcitedStatesAndCalculator,
gsname=name,
exname=name,
overlap=True,
approximation='Albrecht A',
txt=None)
aoi = ao.absolute_intensity(omega=om)[-1]
al = Albrecht(atoms,
H2MorseExcitedStatesAndCalculator,
gsname=name,
exname=name,
approximation='Albrecht A',
txt=None)
ali = al.absolute_intensity(omega=om)[-1]
# XXX this test sometimes fails for 1e-5 XXX
# print(ali, aoi)
assert ali == pytest.approx(aoi, 1e-2)
def test_traditional():
"""Check that traditional calling works"""
atoms = H2Morse()
fname = 'exlist.dat'
exl1 = H2MorseExcitedStatesAndCalculator(atoms.calc)
exl1.write(fname)
ex1 = exl1[0]
exl2 = H2MorseExcitedStatesAndCalculator(fname, nstates=1)
ex2 = exl2[-1]
assert ex1.energy == pytest.approx(ex2.energy, 1e-3)
assert ex1.mur == pytest.approx(ex2.mur, 1e-5)
assert ex1.muv == pytest.approx(ex2.muv, 1e-5)
def test_excited_io():
"""Check writing and reading"""
fname = 'exlist.dat'
atoms = H2Morse()
exc = H2MorseExcitedStatesCalculator()
exl1 = exc.calculate(atoms)
exl1.write(fname)
exl2 = H2MorseExcitedStates(fname)
for ex1, ex2 in zip(exl1, exl2):
assert ex1.energy == pytest.approx(ex2.energy, 1e-3)
assert ex1.mur == pytest.approx(ex2.mur, 1e-5)
assert ex1.muv == pytest.approx(ex2.muv, 1e-5)
def test_compare_placzek_albrecht_intensities(testdir):
atoms = H2Morse()
name = 'rrmorse'
rmc = ResonantRamanCalculator(atoms,
H2MorseExcitedStatesCalculator,
overlap=lambda x, y: x.overlap(y),
name=name,
txt='-')
rmc.run()
om = 1
gam = 0.1
pri, ali = 0, 0
"""Albrecht A and P-P are approximately equal"""
pr = Profeta(atoms,
H2MorseExcitedStates,
name=name,
overlap=True,
approximation='p-p',
txt=None)
pri = pr.get_absolute_intensities(omega=om, gamma=gam)[-1]
al = Albrecht(atoms,
H2MorseExcitedStates,
name=name,
overlap=True,
approximation='Albrecht A',
txt=None)
ali = al.get_absolute_intensities(omega=om, gamma=gam)[-1]
print('pri, ali', pri, ali)
assert pri == pytest.approx(ali, 1e-2)
"""Albrecht B+C and Profeta are approximately equal"""
pr.approximation = 'Profeta'
pri = pr.get_absolute_intensities(omega=om, gamma=gam)[-1]
al.approximation = 'Albrecht BC'
ali = al.get_absolute_intensities(omega=om, gamma=gam)[-1]
print('pri, ali', pri, ali)
assert pri == pytest.approx(ali, 1e-2)
"""Albrecht and Placzek are approximately equal"""
pr.approximation = 'Placzek'
pri = pr.get_absolute_intensities(omega=om, gamma=gam)[-1]
al.approximation = 'Albrecht'
ali = al.get_absolute_intensities(omega=om, gamma=gam)[-1]
print('pri, ali', pri, ali)
assert pri == pytest.approx(ali, 1e-2)
def test_shapes():
"""Test evaluation of polarizabily and resulting shapes"""
atoms = H2Morse()
exl = H2MorseExcitedStatesCalculator().calculate(atoms)
alphaf = polarizability(exl, range(2))
assert alphaf.shape == (2, )
assert alphaf.dtype == float
alphat = polarizability(exl, 5 + 2j, tensor=True)
assert alphat.shape == (3, 3)
assert alphat.dtype == complex
alphat = polarizability(exl, range(2), tensor=True)
assert alphat.shape == (2, 3, 3)
assert alphat.dtype == float
# check tensor
for af, at in zip(alphaf, alphat):
assert at.diagonal().sum() / 3 == pytest.approx(af, 1.e-8)
def test_compare_placzek_albrecht_intensities():
atoms = H2Morse()
name = 'rrmorse'
pr = Profeta(atoms,
H2MorseExcitedStatesAndCalculator,
approximation='Placzek',
gsname=name,
exname=name,
overlap=lambda x, y: x.overlap(y),
txt=None)
pr.run()
om = 1
pri, ali = 0, 0
"""Albrecht A and P-P are approximately equal"""
pr.approximation = 'p-p'
pri = pr.absolute_intensity(omega=om)[-1]
al = Albrecht(atoms,
H2MorseExcitedStatesAndCalculator,
gsname=name,
exname=name,
overlap=True,
approximation='Albrecht A',
txt=None)
ali = al.absolute_intensity(omega=om)[-1]
print('pri, ali', pri, ali)
assert pri == pytest.approx(ali, 1e-2)
"""Albrecht B+C and Profeta are approximately equal"""
pr.approximation = 'Profeta'
pri = pr.absolute_intensity(omega=om)[-1]
al.approximation = 'Albrecht BC'
ali = al.absolute_intensity(omega=om)[-1]
print('pri, ali', pri, ali)
assert pri == pytest.approx(ali, 1e-2)
"""Albrecht and Placzek are approximately equal"""
pr.approximation = 'Placzek'
pri = pr.absolute_intensity(omega=om)[-1]
al.approximation = 'Albrecht'
ali = al.absolute_intensity(omega=om)[-1]
print('pri, ali', pri, ali)
assert pri == pytest.approx(ali, 1e-2)
def atoms():
return H2Morse()
from ase.calculators.h2morse import (H2Morse, H2MorseExcitedStatesCalculator)
from ase.vibrations.resonant_raman import ResonantRamanCalculator
atoms = H2Morse()
rmc = ResonantRamanCalculator(atoms,
H2MorseExcitedStatesCalculator,
overlap=lambda x, y: x.overlap(y))
rmc.run()
