def compare_spectral_dens_to_analytical(self, fctype):
m = Manager()
i = 0
sd_data = numpy.zeros((world.sd.axis.data.shape[0], 2))
wa = world.ta.get_FrequencyAxis()
with energy_units("int"):
sd_data[:, 0] = wa.data
omega = wa.data
with energy_units(world.e_units):
lamb = m.convert_energy_2_internal_u(world.reorg)
ctime = world.ctime
if fctype == "OverdampedBrownian":
# Analytical for for the overdamped Brownian spectral density
sd_data[:, 1] = (2.0 * lamb / ctime) * omega / (omega**2 +
(1.0 / ctime)**2)
else:
raise Exception()
data = numpy.zeros((world.sd.axis.data.shape[0], 2))
for t in world.sd.axis.data:
data[i, 0] = t
data[i, 1] = numpy.real(world.sd.data[i])
#data[i,2] = numpy.imag(world.cf.data[i])
i += 1
numpy.testing.assert_allclose(sd_data, data, rtol=1.0e-7)
def compare_rates_analytical(self, rtols):
print("Comparison of redfield rates with analytical results")
m = Manager()
rtol = float(rtols)
with energy_units(world.r_units):
J = m.convert_energy_2_internal_u(world.r_coupl)
with energy_units(world.e_units):
lamb = m.convert_energy_2_internal_u(world.reorg)
tauc = world.ctime
kBT = kB_int * world.temp
#print(world.temp, lamb, tauc, J)
K12 = ((lamb * J / 2.0) * (1.0 + 1.0 / numpy.tanh(J / kBT)) /
((J**2) * tauc + 1.0 / (4.0 * tauc)))
print(K12, 1.0 / K12)
print(world.K12, 1.0 / world.K12)
print(K12 / world.K12)
numpy.testing.assert_allclose(K12, world.K12, rtol=rtol) #,atol=atol)
def compare_rates_analytical(self, rtols):
print("Comparison of redfield rates with analytical results")
m = Manager()
rtol = float(rtols)
with energy_units(world.r_units):
J = m.convert_energy_2_internal_u(world.r_coupl)
with energy_units(world.e_units):
lamb = m.convert_energy_2_internal_u(world.reorg)
tauc = world.ctime
kBT = kB_int*world.temp
#print(world.temp, lamb, tauc, J)
K12 = ((lamb*J/2.0)
*(1.0 + 1.0/numpy.tanh(J/kBT))/((J**2)*tauc + 1.0/(4.0*tauc)))
print(K12, 1.0/K12)
print(world.K12, 1.0/world.K12)
print(K12/world.K12)
numpy.testing.assert_allclose(K12, world.K12 ,rtol=rtol) #,atol=atol)
def compare_spectral_dens_to_analytical(self, fctype):
m = Manager()
i = 0
sd_data = numpy.zeros((world.sd.axis.data.shape[0],2))
wa = world.ta.get_FrequencyAxis()
with energy_units("int"):
sd_data[:,0] = wa.data
omega = wa.data
with energy_units(world.e_units):
lamb = m.convert_energy_2_internal_u(world.reorg)
ctime = world.ctime
if fctype == "OverdampedBrownian":
# Analytical for for the overdamped Brownian spectral density
sd_data[:,1] = (2.0*lamb/ctime)*omega/(omega**2 + (1.0/ctime)**2)
else:
raise Exception()
data = numpy.zeros((world.sd.axis.data.shape[0],2))
for t in world.sd.axis.data:
data[i,0] = t
data[i,1] = numpy.real(world.sd.data[i])
#data[i,2] = numpy.imag(world.cf.data[i])
i += 1
diff = numpy.amax(numpy.abs(sd_data[:,1]-data[:,1]))
maxv = numpy.amax(numpy.abs(sd_data[:,1]))
print("Difference: ", diff, " on ", maxv)
numpy.testing.assert_allclose(sd_data,data,rtol=1.0e-3,atol=1.0e-3)
def test_that_Manager_is_a_singleton(self):
"""Testing that Manager object is a singleton
"""
m = Manager()
n = Manager()
if m is not n:
raise Exception()
def test_saving_and_loading_with_loader(self):
"""Testing loading Saveable objects with load(filename) function
"""
if legacy:
from quantarhei.core.saveable import load, read_info
else:
from quantarhei.core.parcel import load_parcel, check_parcel
from quantarhei import Manager
obj3 = self.obj3
if legacy:
with h5py.File("test_file_2", driver="core",
backing_store=False) as f:
obj3.save(f, test=True)
obj = load(f, test=True)
info = read_info(f)
else:
with tempfile.TemporaryFile() as f:
obj3.save(f)
f.seek(0)
obj = load_parcel(f)
f.seek(0)
info = check_parcel(f)
liple = obj3.liple
n = len(liple)
for i in range(n):
self.assertEqual(obj3.liple[i], obj.liple[i])
if legacy:
self.assertEqual(info["version"], Manager().version)
else:
self.assertEqual(info["qrversion"], Manager().version)
def qntr_action(self, q):
if q.text() == "Version info":
def msgbtn(i):
print("Button pressed is:", i.text())
try:
from quantarhei import Manager
version = Manager().version
import quantarhei
path = os.path.dirname(quantarhei.__file__)
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Quantarhei version info")
msg.setInformativeText("Package version: " + str(version))
msg.setWindowTitle("Quantarhei version info")
msg.setDetailedText("""
Quantarhei package
version: %s
path: %s
""" % (version, path))
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msg.buttonClicked.connect(msgbtn)
msg.exec_()
except Exception as e:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Cannot import Quantarhei Package")
msg.setInformativeText(
"Problems with importing Quantarhei" +
" package.\nCheck PYTHONPATH system variable.\n" +
"See details below")
msg.setWindowTitle("Quantarhei version info")
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msg.buttonClicked.connect(msgbtn)
msg.setDetailedText(str(e))
msg.exec_()
def test_saving_and_loading_with_loader(self):
"""Testing loading Saveable objects with load(filename) function
"""
from quantarhei.core.saveable import load, read_info
from quantarhei import Manager
obj3 = self.obj3
with h5py.File("test_file_2", driver="core", backing_store=False) as f:
obj3.save(f, test=True)
obj = load(f, test=True)
info = read_info(f)
liple = obj3.liple
n = len(liple)
for i in range(n):
self.assertEqual(obj3.liple[i], obj.liple[i])
self.assertEqual(info["version"], Manager().version)
"""
print("""
***********************************************************
*
*
* Lindblad form demo
*
*
***********************************************************
""")
from quantarhei import Manager
#
# FIXME: temporary fix for version 0.0.34
#
Manager().gen_conf.legacy_relaxation = True
#
# PURELY ELECTRONIC Aggregate of two molecules
#
from quantarhei import Molecule
m1 = Molecule([0.0, 1.0])
m2 = Molecule([0.0, 1.1])
m3 = Molecule([0.0, 1.2])
from quantarhei import Aggregate
agg = Aggregate([m1, m2, m3])
agg.build()
def main():
parser = argparse.ArgumentParser(description='Quantarhei Package Driver')
parser.add_argument("script",
metavar='script',
type=str,
help='script file to be processed')
parser.add_argument("-v",
"--version",
action="store_true",
help="shows Quantarhei package version")
parser.add_argument("-i",
"--info",
action='store_true',
help="shows detailed information about Quantarhei" +
" installation")
parser.add_argument("-s",
"--silent",
action='store_true',
help="no output from qrhei script itself")
parser.add_argument("-p",
"--parallel",
action='store_true',
help="executes the code in parallel")
parser.add_argument("-n",
"--nprocesses",
type=int,
default=0,
help="number of processes to start")
args = parser.parse_args()
nprocesses = args.nprocesses
flag_parallel = args.parallel
flag_silent = args.silent
#
# show longer info
#
if args.info:
print("")
print("qrhei: Quantarhei Package Driver")
print("")
print("MPI parallelization enabled: ", flag_parallel)
if not args.version:
print("Quantarhei package version: ", Manager().version)
#
# show just Quantarhei version number
#
if args.version:
print("Quantarhei package version: ", Manager().version)
###########################################################################
#
# Running a script
#
###########################################################################
#
# Script name
#
scr = args.script
#
# Greeting
#
if not flag_silent:
print("Running Quantarhei (python) script file: ", scr)
#
# Run serial or parallel
#
if flag_parallel:
#
# get parallel configuration
#
cpu_count = 0
try:
import multiprocessing
cpu_count = multiprocessing.cpu_count()
except (ImportError, NotImplementedError):
pass
prl_exec = "mpirun"
prl_n = "-n"
if cpu_count != 0:
prl_np = cpu_count
else:
prl_np = 4
if nprocesses != 0:
prl_np = nprocesses
engine = "qrhei -s "
# running MPI with proper parallel configuration
prl_cmd = prl_exec + " " + prl_n + " " + str(prl_np) + " "
cmd = prl_cmd + engine + scr
if not flag_silent:
print("System reports", cpu_count, "processors")
print("Starting parallel execution with", prl_np,
"processes (executing command below)")
print(cmd)
print("")
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
if not flag_silent:
print(" --- output below ---")
# read and print output
for line in iter(p.stdout.readline, b''):
#for line in p.stdout.readlines():
ln = line.decode()
# line is returned with a \n character at the end
# ln = ln[0:len(ln)-2]
print(ln, end="", flush=True)
retval = p.wait()
else:
if not flag_silent:
print(" --- output below ---")
# running the script within the same interpreter
exec(open(scr).read(), globals())
retval = 0
#
# Saying good bye
#
if retval == 0:
if not flag_silent:
print(" --- output above --- ")
print("Finshed sucessfully; exit code: ", retval)
else:
print("Warning, exit code: ", retval)
from quantarhei import Molecule from quantarhei import Aggregate from quantarhei import energy_units from quantarhei import TimeAxis from quantarhei import CorrelationFunction from quantarhei.spectroscopy.twod2 import TwoDSpectrumCalculator from quantarhei.spectroscopy.twod2 import TwoDSpectrumContainer from quantarhei.spectroscopy.twod2 import TwoDSpectrum from aceto.lab_settings import lab_settings from quantarhei import Manager print(Manager().version) t_fstart = time.time() # Time axis for t1 and t3 times Nr = 1000 ta = TimeAxis(0.0, Nr, 2.0) ############################################################################### # # Define problem # ############################################################################### # # define molecules
def test_of_multiple_addition(self):
"""(CorrelationFunction) Testing multiple addition of objects """
t = TimeAxis(0.0, 1000, 1.0)
params1 = dict(ftype="OverdampedBrownian",
reorg = 30.0,
cortime = 100.0,
T = 300.0)
params2 = dict(ftype="OverdampedBrownian",
reorg = 40.0,
cortime = 100.0,
T = 300.0)
params3 = dict(ftype="OverdampedBrownian",
reorg = 15.0,
cortime = 200.0,
T = 300.0)
params4 = dict(ftype="OverdampedBrownian",
reorg = 10.0,
cortime = 50.0,
T = 300.0)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
f3 = CorrelationFunction(t, params3)
f4 = CorrelationFunction(t, params4)
f = f1 + f2 + f3 + f4
sum_data = f1.data + f2.data + f3.data + f4.data
sum_lamb = f1.lamb + f2.lamb + f3.lamb + f4.lamb
sum_cutoff = max(f1.cutoff_time, f2.cutoff_time,
f3.cutoff_time, f4.cutoff_time)
sum_temp = f1.temperature
self.assertEqual(f.lamb, sum_lamb)
numpy.testing.assert_allclose(f.data, sum_data)
self.assertEqual(f.cutoff_time, sum_cutoff)
self.assertEqual(f.temperature, sum_temp)
#self.assertFalse(f.is_analytical())
self.assertTrue(f._is_composed)
self.assertFalse(f._is_empty)
#
# Inplace
#
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params2)
f3 = CorrelationFunction(t, params3)
f4 = CorrelationFunction(t, params4)
fs = f1
sum_data = f1.data + f2.data + f3.data + f4.data
sum_lamb = f1.lamb + f2.lamb + f3.lamb + f4.lamb
sum_cutoff = max(f1.cutoff_time, f2.cutoff_time,
f3.cutoff_time, f4.cutoff_time)
sum_temp = f3.temperature
f1 += f2 + f3
f1 += f4
f = f1
self.assertEqual(f.lamb, sum_lamb)
numpy.testing.assert_allclose(f.data, sum_data)
#print(f.cutoff_time, sum_cutoff)
self.assertEqual(f.cutoff_time, sum_cutoff)
self.assertEqual(f.temperature, sum_temp)
#self.assertFalse(f.is_analytical())
self.assertTrue(f._is_composed)
self.assertFalse(f._is_empty)
# test if inplace addition really happend
self.assertEqual(fs, f1)
#
# Loops
#
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
f2 = CorrelationFunction(t, params1)
f1_data = f1.data.copy()
for i in range(5):
f1 += f1
with energy_units("1/cm"):
self.assertEqual(f1.lamb,
32.0*Manager().convert_energy_2_internal_u(params1["reorg"]))
numpy.testing.assert_allclose(f1.data, 32.0*f1_data)
self.assertEqual(f1.temperature, params1["T"])
#self.assertFalse(f1.is_analytical())
self.assertTrue(f1._is_composed)
self.assertFalse(f1._is_empty)
with energy_units("1/cm"):
f1 = CorrelationFunction(t, params1)
for i in range(5):
f1 += f2
self.assertEqual(f1.lamb,
6.0*Manager().convert_energy_2_internal_u(params1["reorg"]))
numpy.testing.assert_allclose(f1.data, 6.0*f1_data)
self.assertEqual(f1.temperature, params1["T"])
#self.assertFalse(f1.is_analytical())
self.assertTrue(f1._is_composed)
self.assertFalse(f1._is_empty)
def main():
parser = argparse.ArgumentParser(description='Quantarhei Package Driver')
parser.add_argument("script",
metavar='script',
type=str,
help='script file to be processed',
nargs='?')
parser.add_argument("-v",
"--version",
action="store_true",
help="shows Quantarhei package version")
parser.add_argument("-i",
"--info",
action='store_true',
help="shows detailed information about Quantarhei" +
" installation")
parser.add_argument("-s",
"--silent",
action='store_true',
help="no output from qrhei script itself")
parser.add_argument("-p",
"--parallel",
action='store_true',
help="executes the code in parallel")
parser.add_argument("-n",
"--nprocesses",
type=int,
default=0,
help="number of processes to start")
parser.add_argument("-b",
"--benchmark",
type=int,
default=0,
help="run one of the predefined benchmark" +
"calculations")
parser.add_argument("-y",
"--verbosity",
type=int,
default=5,
help="defines verbosity between 0 and 10")
args = parser.parse_args()
nprocesses = args.nprocesses
flag_parallel = args.parallel
flag_silent = args.silent
m = qr.Manager()
m.verbosity = args.verbosity
if args.silent:
m.verbosity = 0
#
# show longer info
#
if args.info:
qr.printlog("\n" + "qrhei: Quantarhei Package Driver\n" + "\n" +
"MPI parallelization enabled: ",
flag_parallel,
verbose=True,
loglevel=0)
if not args.version:
qr.printlog("Package version: ",
Manager().version,
"\n",
verbose=True,
loglevel=0)
return
#
# show just Quantarhei version number
#
if args.version:
qr.printlog("Quantarhei package version: ",
Manager().version,
"\n",
verbose=True,
loglevel=0)
return
#
# run benchmark
#
if args.benchmark > 0:
import time
qr.printlog("Running benchmark no. ",
args.benchmark,
verbose=True,
loglevel=1)
import quantarhei.benchmarks.bm_001 as bm
t1 = time.time()
bm.main()
t2 = time.time()
qr.printlog("... done in", t2 - t1, "sec", verbose=True, loglevel=1)
return
###########################################################################
#
# Running a script
#
###########################################################################
#
# Script name
#
scr = args.script
#
# Greeting
#
qr.printlog("Running Quantarhei (python) script file: ",
scr,
verbose=True,
loglevel=3)
#
# Setting environment to see shared libraries
#
if True:
# fix to get it work on Python 3.4 and earlier
if sys.version_info[1] > 4:
# home
home = str(Path.home())
else:
from os.path import expanduser
home = expanduser("~")
#home = str(Path.home())
slib_path = os.path.join(home, "lib")
from sys import platform as _platform
if _platform == "linux" or _platform == "linux2":
# linux
if not flag_silent:
print("Running on platform " + _platform + " (linux)")
print("Setting shared libraty path to: " + slib_path)
os.environ["LD_LIBRARY_PATH"] = slib_path
elif _platform == "darwin":
# MAC OS X
if not flag_silent:
print("Running on platform " + _platform + " (macOS)")
print("Setting shared libraty path to: " + slib_path)
os.environ["DYLD_LIBRARY_PATH"] = slib_path
elif _platform == "win32":
# Windows
print(_platform + " win32")
elif _platform == "win64":
# Windows 64-bit
print(_platform + " win64")
else:
print(_platform + " unrecognized")
raise Exception("Unrecognized platform")
#
# Run serial or parallel
#
if flag_parallel:
#
# get parallel configuration
#
cpu_count = 0
try:
import multiprocessing
cpu_count = multiprocessing.cpu_count()
except (ImportError, NotImplementedError):
pass
prl_exec = "mpirun"
prl_n = "-n"
if cpu_count != 0:
prl_np = cpu_count
else:
prl_np = 4
if nprocesses != 0:
prl_np = nprocesses
engine = "qrhei -s "
# running MPI with proper parallel configuration
prl_cmd = prl_exec + " " + prl_n + " " + str(prl_np) + " "
cmd = prl_cmd + engine + scr
if not flag_silent:
print("System reports", cpu_count, "processors")
print("Starting parallel execution with", prl_np,
"processes (executing command below)")
print(cmd)
print("")
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
if not flag_silent:
print(" --- output below ---")
# read and print output
for line in iter(p.stdout.readline, b''):
#for line in p.stdout.readlines():
ln = line.decode()
# line is returned with a \n character at the end
# ln = ln[0:len(ln)-2]
print(ln, end="", flush=True)
retval = p.wait()
else:
qr.printlog(" --- output below ---", verbose=True, loglevel=0)
# running the script within the same interpreter
exec(open(scr).read(), globals())
retval = 0
#
# Saying good bye
#
if retval == 0:
qr.printlog(" --- output above --- ", verbose=True, loglevel=0)
qr.printlog("Finshed sucessfully; exit code: ",
retval,
verbose=True,
loglevel=0)
else:
qr.printlog("Warning, exit code: ", retval, verbose=True, loglevel=0)
def test_comparison_of_rates(self):
"""Testing that Redfield tensor and rate matrix are compatible
"""
tensor = True
matrix = True
print("\n")
dim = self.H1.dim
KT = numpy.zeros((dim, dim), dtype=numpy.float64)
KM = numpy.zeros((dim, dim), dtype=numpy.float64)
KF = numpy.zeros((dim, dim), dtype=numpy.float64)
if tensor:
with energy_units("1/cm"):
m = Manager()
cutoff = m.convert_energy_2_internal_u(100.0)
print(cutoff)
# Time independent combined tensor
ham = self.H1
ham.subtract_cutoff_coupling(cutoff)
ham.protect_basis()
with eigenbasis_of(ham):
RT = \
RedfieldFoersterRelaxationTensor(ham, self.sbi1,
coupling_cutoff=cutoff)
#if secular_relaxation:
# relaxT.secularize()
ham.unprotect_basis()
#ham.recover_cutoff_coupling()
#print(self.H1)
with energy_units("1/cm"):
print(ham)
with eigenbasis_of(ham):
#if True:
for n in range(2):
for m in range(2):
#print(n,m,numpy.real(RT.data[n,n,m,m]))
KT[n, m] = numpy.real(RT.data[n, n, m, m])
if matrix:
#print(self.H2)
RR = RedfieldRateMatrix(self.H2, self.sbi2)
for n in range(2):
for m in range(2):
#print(n,m,numpy.real(RR.data[n,m]))
KM[n, m] = numpy.real(RR.data[n, m])
RR = FoersterRateMatrix(self.H2, self.sbi2)
for n in range(2):
for m in range(2):
#print(n,m,numpy.real(RR.data[n,m]))
KF[n, m] = numpy.real(RR.data[n, m])
#print(self.c_omega_p)
#print(self.c_omega_m)
#KM = KT
print("Combined rate matrix:")
print(1.0 / KT)
print("Redfield rate matrix (eigenbasis)")
print(1.0 / KM)
print("Foerster rate matrix (site basis): ")
print(1.0 / KF)
KT = KM
numpy.testing.assert_allclose(KT, KM, rtol=1.0e-2)