def do_command_list(args):
"""Lists files for Quantarhei
"""
global parser_list
if args.examples:
qr.printlog("Listing available examples ...", loglevel=0)
import quantarhei.wizard.examples as exmpl
filenames = exmpl._available_examples
if args.glob:
pattern = args.glob
matching = _match_filenames(filenames, pattern, add_stars=True)
else:
matching = filenames
for ex in matching:
qr.printlog(" "+ex, loglevel=0)
else:
parser_list.print_help()
def do_command_list(args):
"""Lists files for Quantarhei
"""
global parser_list
if args.examples:
qr.printlog("Listing available examples ...", loglevel=1)
import quantarhei.wizard.examples as exmpl
filenames = exmpl._available_examples
if args.glob:
pattern = args.glob
matching = _match_filenames(filenames, pattern, add_stars=True)
else:
matching = filenames
for ex in matching:
qr.printlog(" " + ex, loglevel=1)
else:
parser_list.print_help()
def do_command_test(args):
"""Runs Quantarhei tests
"""
qr.printlog("Running tests", loglevel=0)
def _propagate_SExp_RTOp_ReSymK_Re_numpy(self, rhoi, Ham, RT, dt, L=4):
"""Integration by short exponentional expansion
Integration by expanding exponential (_SExp_) to Lth order.
This is a numpy (_numpy) implementation with real (_Re_) matrices
for a system part of the system-bath interaction operator ``K``
in a form of real symmetric operator (ReSymK). The relaxation tensor
is assumed in form of a set of operators (_RTOp_)
"""
Nref = self.Nref
Nt = self.Nt
verbose = self.verbose
timea = self.TimeAxis
prop_name = self.propagation_name
# no self beyond this point
qr.log_detail("PROPAGATION (short exponential with "+
"relaxation in operator form): order ", L,
verbose=verbose)
qr.log_detail("Using real valued numpy implementation")
pr = ReducedDensityMatrixEvolution(timea, rhoi,
name=prop_name)
rho1_r = numpy.real(rhoi.data)
rho2_r = numpy.real(rhoi.data)
rho1_i = numpy.imag(rhoi.data)
rho2_i = numpy.imag(rhoi.data)
HH = Ham.data
try:
Km = RT.Km #self.RelaxationTensor.Km # real
Lm_r = numpy.real(RT.Lm) #self.RelaxationTensor.Lm) # complex
Lm_i = numpy.imag(RT.Lm) #self.RelaxationTensor.Lm)
Nm = Km.shape[0]
except:
raise Exception("Tensor is not in operator form")
indx = 1
# verbosity inside loops
levs = [qr.LOG_QUICK]
verb = qr.loglevels2bool(levs, verbose=self.verbose)
# after each step we apply pure dephasing (if present)
if self.has_PDeph:
# loop over time
for ii in range(1, Nt):
qr.printlog("time step ", ii, "of", Nt,
verbose=verb[0], loglevel=levs[0], end="\r")
# steps in between saving the results
for jj in range(Nref):
# L interations to get short exponential expansion
for ll in range(1, L+1):
A = numpy.dot(HH,rho1_i)
B = numpy.dot(HH,rho1_r)
rhoY_r = (dt/ll)*(A + numpy.transpose(A))
rhoY_i = -(dt/ll)*(B - numpy.transpose(B))
for mm in range(Nm):
a = numpy.dot(Lm_r[mm,:,:], rho1_r)
A = a - numpy.transpose(a)
b = numpy.dot(Lm_i[mm,:,:], rho1_i)
B = b - numpy.transpose(b)
c = numpy.dot(Lm_r[mm,:,:], rho1_i)
C = -(c + numpy.transpose(c))
d = numpy.dot(Lm_i[mm,:,:], rho1_r)
D = d + numpy.transpose(d)
E = B - A
F = C - D
A = numpy.dot(Km[mm,:,:], E)
B = numpy.dot(Km[mm,:,:], F)
rhoY_r += (dt/ll)*(A + numpy.transpose(A))
rhoY_i += (dt/ll)*(B - numpy.transpose(B))
rho1_r = rhoY_r
rho1_i = rhoY_i
rho2_r += rho1_r
rho2_i += rho1_i
rho2_r = rho2_r*numpy.exp(-self.PDeph.data*dt)
rho2_i = rho2_i*numpy.exp(-self.PDeph.data*dt)
rho1_r = rho2_r
rho1_i = rho2_i
pr.data[indx,:,:] = rho2_r + 1j*rho2_i
indx += 1
# propagatiomn with no extra dephasing
else:
# loop over time
for ii in range(1, Nt):
qr.printlog("time step ", ii, "of", Nt,
verbose=verb[0], loglevel=levs[0], end="\r")
# steps in between saving the results
for jj in range(Nref):
# L interations to get short exponential expansion
for ll in range(1, L+1):
A = numpy.dot(HH,rho1_i)
B = numpy.dot(HH,rho1_r)
rhoY_r = (dt/ll)*(A + numpy.transpose(A))
rhoY_i = -(dt/ll)*(B - numpy.transpose(B))
for mm in range(Nm):
a = numpy.dot(Lm_r[mm,:,:], rho1_r)
A = a - numpy.transpose(a)
b = numpy.dot(Lm_i[mm,:,:], rho1_i)
B = b - numpy.transpose(b)
c = numpy.dot(Lm_r[mm,:,:], rho1_i)
C = -(c + numpy.transpose(c))
d = numpy.dot(Lm_i[mm,:,:], rho1_r)
D = d + numpy.transpose(d)
E = B - A
F = C - D
A = numpy.dot(Km[mm,:,:], E)
B = numpy.dot(Km[mm,:,:], F)
rhoY_r += (dt/ll)*(A + numpy.transpose(A))
rhoY_i += (dt/ll)*(B - numpy.transpose(B))
rho1_r = rhoY_r
rho1_i = rhoY_i
rho2_r += rho1_r
rho2_i += rho1_i
rho1_r = rho2_r
rho1_i = rho2_i
pr.data[indx,:,:] = rho2_r + 1j*rho2_i
indx += 1
qr.log_detail()
qr.log_detail("...DONE")
return pr
def do_command_file(args):
"""Report on the content of a file
"""
qr.printlog("Checking file info", loglevel=1)
#
# File name
#
if args.fname:
fname = args.fname[0]
qr.printlog("File name: " + fname, loglevel=1)
try:
check = qr.check_parcel(fname)
qr.printlog("Object type: " + check["class_name"], loglevel=1)
if check["class_name"] == "builtins.list":
prcl = qr.load_parcel(fname)
qr.printlog("List length: " + str(len(prcl)), loglevel=1)
types = []
for el in prcl:
tp = type(prcl[0])
if tp not in types:
types.append(tp)
qr.printlog("Element types: " + str(types), loglevel=1)
qr.printlog("Saved with Quantarhei version: " + check["qrversion"],
loglevel=1)
qr.printlog("Description: " + check["comment"])
except:
qr.printlog("The file is not a Quantarhei parcel", loglevel=1)
def do_command_config(args):
"""Configures Quantarhei
"""
qr.printlog("Setting configuration", loglevel=1)
def do_command_run(args):
"""Runs a script
"""
m = qr.Manager().log_conf
dc = qr.Manager().get_DistributedConfiguration()
#
# analyzing --verbosity option
#
verb = args.verbosity
try:
vrbint = int(verb)
m.verbosity = vrbint
m.fverbosity = vrbint + 2
except:
try:
vrbint = verb.split(",")
m.verbosity = int(vrbint[0])
m.fverbosity = int(vrbint[1])
except:
raise Exception(
"Integer or two comma separated integers required" +
" for -y/--verbosity option")
# we set the verbosity lower for other than the leading process
if dc.rank != 0:
m.verbosity -= 2
m.fverbosity -= 2
#
# log into file
#
m.log_to_file = args.logtofile
if m.log_to_file:
m.log_file_name = args.filename
#
# parallel options
#
nprocesses = args.nprocesses
flag_parallel = args.parallel
hostfile = ""
if len(args.hostfile) > 0:
hostfile = args.hostfile
#
# some other logging option
#
flag_silent = args.silent
flag_quiet = args.quiet
if args.silent:
m.verbosity = 0
#
# 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
#
# Script name
#
if args.script:
scr = args.script[0]
#
# if the file is yaml, look into it to find the script file name
#
# get the file extension
extsplt = os.path.splitext(scr)
ext = extsplt[1]
#
# Reading configuration file
#
# yaml
if ext in [".yaml", ".yml"]:
INP = qr.Input(scr)
# see if the script name is specified, if not use the conf name + .py
try:
script = INP.script
except:
script = extsplt[0] + ".py"
# see if path is defined, if not use local directory
try:
spath = INP.path
except:
spath = "."
scr = os.path.join(spath, script)
#
# Greeting
#
if not flag_quiet:
qr.printlog("", verbose=True, loglevel=qr.LOG_URGENT)
qr.printlog("Running Quantarhei (python) script file: ",
scr,
verbose=True,
loglevel=qr.LOG_URGENT)
#
# Run serial or parallel
#
if flag_parallel:
#
# If this is set to True, we use one more processes than processor
# number to steer other processes
#
# Also set the corresponding flag in the parallel module
#
use_steerer = False
if use_steerer:
nsteerer = 1
else:
nsteerer = 0
#
# get parallel configuration
#
cpu_count = 0
try:
import multiprocessing
cpu_count = multiprocessing.cpu_count()
except (ImportError, NotImplementedError):
pass
prl_exec = "mpirun"
prl_n = "-n"
prl_h = ""
if len(hostfile) > 0:
prl_h += " --hostfile " + hostfile + " "
if cpu_count != 0:
prl_np = cpu_count + nsteerer
else:
prl_np = 4
if nprocesses != 0:
prl_np = nprocesses + nsteerer
#
engine = "qrhei"
if m.log_to_file:
engine += " -lf " + m.log_file_name
engine += " -y " + str(m.verbosity) + "," + str(
m.fverbosity) + " run -q "
# running MPI with proper parallel configuration
prl_cmd = prl_exec + " " + prl_n + " " + str(prl_np) + " " + prl_h
cmd = prl_cmd + engine + scr
if not flag_silent:
qr.printlog("System reports", cpu_count, "processors")
qr.printlog("Starting parallel execution with", prl_np,
"processes (executing command below)")
qr.printlog(">>>", cmd)
qr.printlog("")
try:
p = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
if not flag_silent and (not flag_quiet):
qr.printlog(" --- output below ---\n",
verbose=True,
loglevel=1)
# 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()
except SystemExit:
qr.printlog("", verbose=True, loglevel=qr.LOG_DETAIL)
qr.printlog(" --- Exited by SystemExit --- ",
verbose=True,
loglevel=qr.LOG_DETAIL)
pass
else:
if not flag_silent and (not flag_quiet):
qr.printlog(" --- output below ---\n",
verbose=True,
loglevel=qr.LOG_URGENT)
# running the script within the same interpreter
try:
# launch this properly, so that it gives information
# on the origin of exceptions
with open(scr, 'U') as fp:
code = fp.read()
exec(compile(code, scr, "exec"), globals())
except SystemExit:
qr.printlog("", verbose=True, loglevel=qr.LOG_DETAIL)
qr.printlog(" --- Exited by SystemExit --- ",
verbose=True,
loglevel=qr.LOG_DETAIL)
except:
print(traceback.format_exc())
retval = 0
#
# Saying good bye
#
if retval == 0:
if not flag_silent and (not flag_quiet):
qr.printlog("", verbose=True, loglevel=1)
qr.printlog(" --- output above --- \n",
verbose=True,
loglevel=qr.LOG_URGENT)
qr.printlog("Finished sucessfully; exit code: ",
retval,
verbose=True,
loglevel=1)
else:
qr.printlog("Warning, exit code: ",
retval,
verbose=True,
loglevel=qr.LOG_URGENT)
def _propagate_SExp_RTOp_ReSymK_Re_numpy(self, rhoi, Ham, RT, dt, L=4):
"""Integration by short exponentional expansion
Integration by expanding exponential (_SExp_) to Lth order.
This is a numpy (_numpy) implementation with real (_Re_) matrices
for a system part of the system-bath interaction operator ``K``
in a form of real symmetric operator (ReSymK). The relaxation tensor
is assumed in form of a set of operators (_RTOp_)
"""
Nref = self.Nref
Nt = self.Nt
verbose = self.verbose
timea = self.TimeAxis
prop_name = self.propagation_name
# no self beyond this point
qr.log_detail("PROPAGATION (short exponential with " +
"relaxation in operator form): order ",
L,
verbose=verbose)
qr.log_detail("Using real valued numpy implementation")
pr = ReducedDensityMatrixEvolution(timea, rhoi, name=prop_name)
rho1_r = numpy.real(rhoi.data)
rho2_r = numpy.real(rhoi.data)
rho1_i = numpy.imag(rhoi.data)
rho2_i = numpy.imag(rhoi.data)
HH = Ham.data
try:
Km = RT.Km #self.RelaxationTensor.Km # real
Lm_r = numpy.real(RT.Lm) #self.RelaxationTensor.Lm) # complex
Lm_i = numpy.imag(RT.Lm) #self.RelaxationTensor.Lm)
Nm = Km.shape[0]
except:
raise Exception("Tensor is not in operator form")
indx = 1
# verbosity inside loops
levs = [qr.LOG_QUICK]
verb = qr.loglevels2bool(levs, verbose=self.verbose)
# after each step we apply pure dephasing (if present)
if self.has_PDeph:
# loop over time
for ii in range(1, Nt):
qr.printlog("time step ",
ii,
"of",
Nt,
verbose=verb[0],
loglevel=levs[0],
end="\r")
# steps in between saving the results
for jj in range(Nref):
# L interations to get short exponential expansion
for ll in range(1, L + 1):
A = numpy.dot(HH, rho1_i)
B = numpy.dot(HH, rho1_r)
rhoY_r = (dt / ll) * (A + numpy.transpose(A))
rhoY_i = -(dt / ll) * (B - numpy.transpose(B))
for mm in range(Nm):
a = numpy.dot(Lm_r[mm, :, :], rho1_r)
A = a - numpy.transpose(a)
b = numpy.dot(Lm_i[mm, :, :], rho1_i)
B = b - numpy.transpose(b)
c = numpy.dot(Lm_r[mm, :, :], rho1_i)
C = -(c + numpy.transpose(c))
d = numpy.dot(Lm_i[mm, :, :], rho1_r)
D = d + numpy.transpose(d)
E = B - A
F = C - D
A = numpy.dot(Km[mm, :, :], E)
B = numpy.dot(Km[mm, :, :], F)
rhoY_r += (dt / ll) * (A + numpy.transpose(A))
rhoY_i += (dt / ll) * (B - numpy.transpose(B))
rho1_r = rhoY_r
rho1_i = rhoY_i
rho2_r += rho1_r
rho2_i += rho1_i
rho2_r = rho2_r * numpy.exp(-self.PDeph.data * dt)
rho2_i = rho2_i * numpy.exp(-self.PDeph.data * dt)
rho1_r = rho2_r
rho1_i = rho2_i
pr.data[indx, :, :] = rho2_r + 1j * rho2_i
indx += 1
# propagatiomn with no extra dephasing
else:
# loop over time
for ii in range(1, Nt):
qr.printlog("time step ",
ii,
"of",
Nt,
verbose=verb[0],
loglevel=levs[0],
end="\r")
# steps in between saving the results
for jj in range(Nref):
# L interations to get short exponential expansion
for ll in range(1, L + 1):
A = numpy.dot(HH, rho1_i)
B = numpy.dot(HH, rho1_r)
rhoY_r = (dt / ll) * (A + numpy.transpose(A))
rhoY_i = -(dt / ll) * (B - numpy.transpose(B))
for mm in range(Nm):
a = numpy.dot(Lm_r[mm, :, :], rho1_r)
A = a - numpy.transpose(a)
b = numpy.dot(Lm_i[mm, :, :], rho1_i)
B = b - numpy.transpose(b)
c = numpy.dot(Lm_r[mm, :, :], rho1_i)
C = -(c + numpy.transpose(c))
d = numpy.dot(Lm_i[mm, :, :], rho1_r)
D = d + numpy.transpose(d)
E = B - A
F = C - D
A = numpy.dot(Km[mm, :, :], E)
B = numpy.dot(Km[mm, :, :], F)
rhoY_r += (dt / ll) * (A + numpy.transpose(A))
rhoY_i += (dt / ll) * (B - numpy.transpose(B))
rho1_r = rhoY_r
rho1_i = rhoY_i
rho2_r += rho1_r
rho2_i += rho1_i
rho1_r = rho2_r
rho1_i = rho2_i
pr.data[indx, :, :] = rho2_r + 1j * rho2_i
indx += 1
qr.log_detail()
qr.log_detail("...DONE")
return pr
def main():
parser = argparse.ArgumentParser(description='Quantarhei Remote Launcher')
parser.add_argument("directory",
metavar='directory',
type=str,
help='job directory to launch',
nargs='?')
#
# Driver options
#
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.set_defaults(func=do_launch)
#
# Parsing all arguments
#
args = parser.parse_args()
if len(sys.argv) < 2:
parser.print_usage()
qr.exit()
#
# show longer info
#
if args.info:
qr.printlog("\n" + "qrhei: Quantarhei Package Driver\n",
verbose=True,
loglevel=1)
# +"\n"
# +"MPI parallelization enabled: ", flag_parallel,
# verbose=True, loglevel=0)
if not args.version:
qr.printlog("Package version: ",
qr.Manager().version,
"\n",
verbose=True,
loglevel=1)
return
#
# show just Quantarhei version number
#
if args.version:
qr.printlog("Quantarhei package version: ",
qr.Manager().version,
"\n",
verbose=True,
loglevel=1)
return
def do_command_test(args):
"""Runs Quantarhei tests
"""
qr.printlog("Running tests", loglevel=0)
def parsing():
"""This function handles parsing command line arguments
"""
descr = 'Ghenerate, the Gherkin Python Step Generator from Quantarhei'
parser = argparse.ArgumentParser(description=descr + ' ...')
parser.add_argument("file",
metavar='file',
type=str,
help='feature file to be processed',
nargs='?')
#
# Generator options
#
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("-d",
"--destination",
type=str,
help="specifies destination directory for the" +
" generated step file")
parser.add_argument("-n",
"--no-pass",
action="store_true",
help="empty tests should not pass (default is" +
" passing empty tests)")
parser.add_argument("-f",
"--start-from",
type=int,
help="step functions will be numberred starting" +
" from this value")
#
# Parsing all arguments
#
args = parser.parse_args()
#
# show longer info
#
if args.info:
qr.printlog("\n" +
"ghenerate: Quantarhei Gherkin Python Step Generator\n",
verbose=True,
loglevel=0)
if not args.version:
qr.printlog("Package version: ",
qr.Manager().version,
"\n",
verbose=True,
loglevel=0)
return 0
#
# show just Quantarhei version number
#
if args.version:
qr.printlog("Quantarhei package version: ",
qr.Manager().version,
"\n",
verbose=True,
loglevel=0)
return 0
if args.destination:
ddir = args.destination
else:
ddir = "ghen"
if args.file:
print("")
print(descr + " ...")
filename = args.file
else:
print("No file specified: quiting")
parser.print_help()
return 0
steps_pass = True
if args.no_pass:
steps_pass = False
k_from = 0
if args.start_from:
k_from = args.start_from
try:
with open(filename, 'r') as myfile:
data = myfile.read()
except:
raise Exception("Problems reading file: " + filename)
parser = Parser()
try:
feature_file = parser.parse(TokenScanner(data))
except:
raise Exception("Problem parsing file: " + filename +
" - is it a feature file?")
try:
children = feature_file["feature"]["children"]
except:
raise Exception("No scenarii or scenario outlines")
return dict(children=children,
ddir=ddir,
steps_pass=steps_pass,
filename=filename,
k_from=k_from)
def parsing():
"""This function handles parsing command line arguments
"""
descr = 'Ghenerate, the Gherkin Python Step Generator from Quantarhei'
parser = argparse.ArgumentParser(description=descr+' ...')
parser.add_argument("file", metavar='file', type=str,
help='feature file to be processed', nargs='?')
#
# Generator options
#
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("-d", "--destination", type=str,
help="specifies destination directory for the"+
" generated step file")
parser.add_argument("-n", "--no-pass", action="store_true",
help="empty tests should not pass (default is"
+" passing empty tests)")
parser.add_argument("-f", "--start-from", type=int,
help="step functions will be numberred starting"
+" from this value")
#
# Parsing all arguments
#
args = parser.parse_args()
#
# show longer info
#
if args.info:
qr.printlog("\n"
+"ghenerate: Quantarhei Gherkin Python Step Generator\n",
verbose=True, loglevel=0)
if not args.version:
qr.printlog("Package version: ", qr.Manager().version, "\n",
verbose=True, loglevel=0)
return 0
#
# show just Quantarhei version number
#
if args.version:
qr.printlog("Quantarhei package version: ", qr.Manager().version, "\n",
verbose=True, loglevel=0)
return 0
if args.destination:
ddir = args.destination
else:
ddir = "ghen"
if args.file:
print("")
print(descr+" ...")
filename = args.file
else:
print("No file specified: quiting")
parser.print_help()
return 0
steps_pass = True
if args.no_pass:
steps_pass = False
k_from = 0
if args.start_from:
k_from = args.start_from
try:
with open(filename, 'r') as myfile:
data = myfile.read()
except:
raise Exception("Problems reading file: "+filename)
parser = Parser()
try:
feature_file = parser.parse(TokenScanner(data))
except:
raise Exception("Problem parsing file: "+filename+
" - is it a feature file?")
try:
children = feature_file["feature"]["children"]
except:
raise Exception("No scenarii or scenario outlines")
return dict(children=children, ddir=ddir,
steps_pass=steps_pass, filename=filename, k_from=k_from)
def _propagate_SExp_RTOp_ReSymK_Re_pytorch(self, rhoi, Ham, RT, dt,
use_gpu=False, L=4):
"""Integration by short exponentional expansion
Integration by expanding exponential (_SExp_) to Lth order.
This is a PyTorch (_pytorch) implementation with real (_Re_) matrices
for a system part of the system-bath interaction operator ``K``
in a form of real symmetric operator (ReSymK). The relaxation tensor
is assumed in form of a set of operators (_RTOp_)
"""
Nref = self.Nref
Nt = self.Nt
verbose = self.verbose
timea = self.TimeAxis
prop_name = self.propagation_name
try:
import torch
except:
raise Exception("PyTorch not installed")
# no self beyond this point
qr.log_detail("PROPAGATION (short exponential with "+
"relaxation in operator form): order ", L,
verbose=verbose)
qr.log_detail("Using pytorch implementation")
qr.log_detail("Using GPU: ", use_gpu & torch.cuda.is_available())
pr = ReducedDensityMatrixEvolution(timea, rhoi,
name=prop_name)
rho1_r = torch.from_numpy(numpy.real(rhoi.data))
rho2_r = torch.from_numpy(numpy.real(rhoi.data))
rho1_i = torch.from_numpy(numpy.imag(rhoi.data))
rho2_i = torch.from_numpy(numpy.imag(rhoi.data))
HH = torch.from_numpy(Ham.data)
try:
Km = torch.from_numpy(RT.Km) #self.RelaxationTensor.Km # real
Lm_r = torch.from_numpy(numpy.real(RT.Lm)) #self.RelaxationTensor.Lm) # complex
Lm_i = torch.from_numpy(numpy.imag(RT.Lm)) #self.RelaxationTensor.Lm)
Nm = RT.Km.shape[0]
except:
raise Exception("Tensor is not in operator form")
if use_gpu & torch.cuda.is_available():
rho1_r = rho1_r.cuda()
rho2_r = rho1_r
rho1_i = rho1_i.cuda()
rho2_i = rho1_i
HH = HH.cuda()
Km = Km.cuda()
Lm_r = Lm_r.cuda()
Lm_i = Lm_i.cuda()
indx = 1
# verbosity inside loops
levs = [qr.LOG_QUICK]
verb = qr.loglevels2bool(levs)
# loop over time
for ii in range(1, Nt):
qr.printlog(" time step ", ii, "of", Nt,
verbose=verb[0], loglevel=levs[0])
# steps in between saving the results
for jj in range(Nref):
# L interations to get short exponential expansion
for ll in range(1, L+1):
A = torch.matmul(HH,rho1_i)
B = torch.matmul(HH,rho1_r)
rhoY_r = torch.mul(A + torch.transpose(A, 0, 1), dt/ll)
rhoY_i = torch.mul(B - torch.transpose(B, 0, 1), -dt/ll)
for mm in range(Nm):
a = torch.matmul(Lm_r[mm,:,:], rho1_r)
A = a - torch.transpose(a, 0, 1)
b = torch.matmul(Lm_i[mm,:,:], rho1_i)
B = b - torch.transpose(b, 0, 1)
c = torch.matmul(Lm_r[mm,:,:], rho1_i)
C = -(c + torch.transpose(c, 0, 1))
d = torch.matmul(Lm_i[mm,:,:], rho1_r)
D = d + torch.transpose(d, 0, 1)
E = B - A
F = C - D
A = torch.matmul(Km[mm,:,:], E)
B = torch.matmul(Km[mm,:,:], F)
rhoY_r += torch.mul(A + torch.transpose(A, 0, 1),dt/ll)
rhoY_i += torch.mul(B - torch.transpose(B, 0, 1),dt/ll)
rho1_r = rhoY_r
rho1_i = rhoY_i
rho2_r += rho1_r
rho2_i += rho1_i
rho1_r = rho2_r
rho1_i = rho2_i
if use_gpu & torch.cuda.is_available():
rho2_sr = rho2_r.cpu()
rho2_si = rho2_i.cpu()
else:
rho2_sr = rho2_r
rho2_si = rho2_i
pr.data[indx,:,:] = rho2_sr.numpy() + 1j*rho2_si.numpy()
indx += 1
qr.log_detail("...DONE")
return pr
def do_command_run(args):
"""Runs a script
"""
m = qr.Manager().log_conf
m.verbosity = args.verbosity
nprocesses = args.nprocesses
flag_parallel = args.parallel
flag_silent = args.silent
if args.silent:
m.verbosity = 0
#
# 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
#
# Script name
#
if args.script:
scr = args.script[0]
#
# Greeting
#
qr.printlog("Running Quantarhei (python) script file: ",
scr,
verbose=True,
loglevel=3)
#
# 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("", verbose=True, loglevel=0)
qr.printlog(" --- output above --- ", verbose=True, loglevel=0)
qr.printlog("Finished sucessfully; exit code: ",
retval,
verbose=True,
loglevel=0)
else:
qr.printlog("Warning, exit code: ", retval, verbose=True, loglevel=0)
def do_command_fetch(args):
"""Fetches files for Quantarhei
"""
global parser_fetch
def get_number(file):
"""Returns the number part of the file name
"""
parts = file.split(sep="_")
return parts[1]
if args.examples:
qr.printlog("Fetching example(s) ...", loglevel=0)
import quantarhei.wizard.examples as exmpl
filenames = exmpl._available_examples
data_files = exmpl._available_data
if args.glob:
pattern = args.glob
matching = _match_filenames(filenames, pattern, add_stars=True)
else:
matching = []
if len(matching) > 0:
newmatch = matching.copy()
for match in matching:
data_pattern = get_number(match)
newmatch += _match_filenames(data_files, data_pattern,
add_stars=True)
matching = newmatch
if len(matching) > 0:
for filename in matching:
resource_package = "quantarhei"
resource_path = '/'.join(('wizard', 'examples', filename))
content = pkg_resources.resource_string(resource_package,
resource_path)
over = True
if os.path.isfile(filename):
qr.printlog("File", filename, "already exists!")
answr = input(" Overwrite? (y/n) [n]")
if answr == "y":
over = True
else:
over = False
elif os.path.isdir(filename):
qr.printlog("Directory with the name", filename,
"already exists!")
qr.printlog("Aborting fetching")
over = False
if over:
with open(filename, "w") as file:
file.write(content.decode("utf-8"))
qr.printlog(" "+filename, loglevel=0)
else:
qr.printlog("No matching examples found", loglevel=0)
else:
parser_fetch.print_help()
def __propagate_short_exp_with_rel_operators(self, rhoi, L=4):
"""Integration by short exponentional expansion
Integration by expanding exponential to Lth order.
"""
mana = Manager()
save_pytorch = None
legacy = mana.gen_conf.legacy_relaxation
if mana.num_conf.gpu_acceleration:
save_pytorch = mana.num_conf.enable_pytorch
mana.num_conf.enable_pytorch = True
if mana.num_conf.enable_pytorch and (not legacy):
ret = self._propagate_SExp_RTOp_ReSymK_Re_pytorch(
rhoi,
self.Hamiltonian,
self.RelaxationTensor,
self.dt,
use_gpu=mana.num_conf.gpu_acceleration,
L=L)
if save_pytorch is not None:
mana.num_conf.enable_pytorch = save_pytorch
return ret
elif not legacy:
return self._propagate_SExp_RTOp_ReSymK_Re_numpy(
rhoi, self.Hamiltonian, self.RelaxationTensor, self.dt, L=L)
#
# legacy version
#
pr = ReducedDensityMatrixEvolution(self.TimeAxis,
rhoi,
name=self.propagation_name)
rho1 = rhoi.data
rho2 = rhoi.data
#
# RWA is applied here
#
if self.Hamiltonian.has_rwa:
HH = self.Hamiltonian.get_RWA_data() #data - self.HOmega
else:
HH = self.Hamiltonian.data
qr.log_detail("PROPAGATION (short exponential with " +
"relaxation in operator form): order ",
L,
verbose=self.verbose)
qr.log_detail("Using complex numpy implementation")
try:
Km = self.RelaxationTensor.Km # real
Lm = self.RelaxationTensor.Lm # complex
Ld = self.RelaxationTensor.Ld # complex - get by transposition
Kd = numpy.zeros(Km.shape, dtype=numpy.float64)
Nm = Km.shape[0]
for m in range(Nm):
Kd[m, :, :] = numpy.transpose(Km[m, :, :])
except:
raise Exception("Tensor is not in operator form")
indx = 1
levs = [qr.LOG_QUICK] #, 8]
verb = qr.loglevels2bool(levs)
# after each step we apply pure dephasing (if present)
if self.has_PDeph:
if self.PDeph.dtype == "Lorentzian":
expo = numpy.exp(-self.PDeph.data * self.dt)
t0 = 0.0
elif self.PDeph.dtype == "Gaussian":
expo = numpy.exp(-self.PDeph.data * (self.dt**2) / 2.0)
t0 = self.PDeph.data * self.dt
# loop over time
for ii in range(1, self.Nt):
qr.printlog(" time step ",
ii,
"of",
self.Nt,
verbose=verb[0],
loglevel=levs[0])
# time at the beginning of the step
tNt = self.TimeAxis.data[indx - 1]
#print("tNt = ", tNt)
# steps in between saving the results
for jj in range(0, self.Nref):
tt = tNt + jj * self.dt # time right now
# L interations to get short exponential expansion
for ll in range(1, L + 1):
rhoY = -(1j * self.dt / ll) * (numpy.dot(HH, rho1) -
numpy.dot(rho1, HH))
#rhoX = numpy.zeros(rho1.shape, dtype=numpy.complex128)
for mm in range(Nm):
rhoY += (self.dt / ll) * (
numpy.dot(Km[mm, :, :],
numpy.dot(rho1, Ld[mm, :, :])) +
numpy.dot(Lm[mm, :, :],
numpy.dot(rho1, Kd[mm, :, :])) -
numpy.dot(
numpy.dot(Kd[mm, :, :], Lm[mm, :, :]),
rho1) - numpy.dot(
rho1,
numpy.dot(Ld[mm, :, :], Km[mm, :, :])))
rho1 = rhoY #+ rhoX
rho2 = rho2 + rho1
# pure dephasing is added here
rho2 = rho2 * expo * numpy.exp(-t0 * tt)
rho1 = rho2
pr.data[indx, :, :] = rho2
indx += 1
# no extra dephasing
else:
# loop over time
for ii in range(1, self.Nt):
qr.printlog(" time step ",
ii,
"of",
self.Nt,
verbose=verb[0],
loglevel=levs[0])
# steps in between saving the results
for jj in range(0, self.Nref):
# L interations to get short exponential expansion
for ll in range(1, L + 1):
rhoY = -(1j * self.dt / ll) * (numpy.dot(HH, rho1) -
numpy.dot(rho1, HH))
#rhoX = numpy.zeros(rho1.shape, dtype=numpy.complex128)
for mm in range(Nm):
rhoY += (self.dt / ll) * (
numpy.dot(Km[mm, :, :],
numpy.dot(rho1, Ld[mm, :, :])) +
numpy.dot(Lm[mm, :, :],
numpy.dot(rho1, Kd[mm, :, :])) -
numpy.dot(
numpy.dot(Kd[mm, :, :], Lm[mm, :, :]),
rho1) - numpy.dot(
rho1,
numpy.dot(Ld[mm, :, :], Km[mm, :, :])))
rho1 = rhoY #+ rhoX
rho2 = rho2 + rho1
rho1 = rho2
pr.data[indx, :, :] = rho2
indx += 1
qr.log_detail("...DONE")
if self.Hamiltonian.has_rwa:
pr.is_in_rwa = True
return pr
def do_command_run(args):
"""Runs a script
"""
m = qr.Manager().log_conf
m.verbosity = args.verbosity
nprocesses = args.nprocesses
flag_parallel = args.parallel
flag_silent = args.silent
if args.silent:
m.verbosity = 0
#
# 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
#
# Script name
#
if args.script:
scr = args.script[0]
#
# Greeting
#
qr.printlog("Running Quantarhei (python) script file: ", scr,
verbose=True, loglevel=3)
#
# 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("", verbose=True, loglevel=0)
qr.printlog(" --- output above --- ", verbose=True, loglevel=0)
qr.printlog("Finished sucessfully; exit code: ", retval,
verbose=True, loglevel=0)
else:
qr.printlog("Warning, exit code: ", retval, verbose=True, loglevel=0)
def _propagate_SExp_RTOp_ReSymK_Re_pytorch(self,
rhoi,
Ham,
RT,
dt,
use_gpu=False,
L=4):
"""Integration by short exponentional expansion
Integration by expanding exponential (_SExp_) to Lth order.
This is a PyTorch (_pytorch) implementation with real (_Re_) matrices
for a system part of the system-bath interaction operator ``K``
in a form of real symmetric operator (ReSymK). The relaxation tensor
is assumed in form of a set of operators (_RTOp_)
"""
Nref = self.Nref
Nt = self.Nt
verbose = self.verbose
timea = self.TimeAxis
prop_name = self.propagation_name
try:
import torch
except:
raise Exception("PyTorch not installed")
# no self beyond this point
qr.log_detail("PROPAGATION (short exponential with " +
"relaxation in operator form): order ",
L,
verbose=verbose)
qr.log_detail("Using pytorch implementation")
qr.log_detail("Using GPU: ", use_gpu & torch.cuda.is_available())
pr = ReducedDensityMatrixEvolution(timea, rhoi, name=prop_name)
rho1_r = torch.from_numpy(numpy.real(rhoi.data))
rho2_r = torch.from_numpy(numpy.real(rhoi.data))
rho1_i = torch.from_numpy(numpy.imag(rhoi.data))
rho2_i = torch.from_numpy(numpy.imag(rhoi.data))
HH = torch.from_numpy(Ham.data)
try:
Km = torch.from_numpy(RT.Km) #self.RelaxationTensor.Km # real
Lm_r = torch.from_numpy(numpy.real(
RT.Lm)) #self.RelaxationTensor.Lm) # complex
Lm_i = torch.from_numpy(numpy.imag(
RT.Lm)) #self.RelaxationTensor.Lm)
Nm = RT.Km.shape[0]
except:
raise Exception("Tensor is not in operator form")
if use_gpu & torch.cuda.is_available():
rho1_r = rho1_r.cuda()
rho2_r = rho1_r
rho1_i = rho1_i.cuda()
rho2_i = rho1_i
HH = HH.cuda()
Km = Km.cuda()
Lm_r = Lm_r.cuda()
Lm_i = Lm_i.cuda()
indx = 1
# verbosity inside loops
levs = [qr.LOG_QUICK]
verb = qr.loglevels2bool(levs)
# loop over time
for ii in range(1, Nt):
qr.printlog(" time step ",
ii,
"of",
Nt,
verbose=verb[0],
loglevel=levs[0])
# steps in between saving the results
for jj in range(Nref):
# L interations to get short exponential expansion
for ll in range(1, L + 1):
A = torch.matmul(HH, rho1_i)
B = torch.matmul(HH, rho1_r)
rhoY_r = torch.mul(A + torch.transpose(A, 0, 1), dt / ll)
rhoY_i = torch.mul(B - torch.transpose(B, 0, 1), -dt / ll)
for mm in range(Nm):
a = torch.matmul(Lm_r[mm, :, :], rho1_r)
A = a - torch.transpose(a, 0, 1)
b = torch.matmul(Lm_i[mm, :, :], rho1_i)
B = b - torch.transpose(b, 0, 1)
c = torch.matmul(Lm_r[mm, :, :], rho1_i)
C = -(c + torch.transpose(c, 0, 1))
d = torch.matmul(Lm_i[mm, :, :], rho1_r)
D = d + torch.transpose(d, 0, 1)
E = B - A
F = C - D
A = torch.matmul(Km[mm, :, :], E)
B = torch.matmul(Km[mm, :, :], F)
rhoY_r += torch.mul(A + torch.transpose(A, 0, 1),
dt / ll)
rhoY_i += torch.mul(B - torch.transpose(B, 0, 1),
dt / ll)
rho1_r = rhoY_r
rho1_i = rhoY_i
rho2_r += rho1_r
rho2_i += rho1_i
rho1_r = rho2_r
rho1_i = rho2_i
if use_gpu & torch.cuda.is_available():
rho2_sr = rho2_r.cpu()
rho2_si = rho2_i.cpu()
else:
rho2_sr = rho2_r
rho2_si = rho2_i
pr.data[indx, :, :] = rho2_sr.numpy() + 1j * rho2_si.numpy()
indx += 1
qr.log_detail("...DONE")
return pr
def do_command_config(args):
"""Configures Quantarhei
"""
qr.printlog("Setting configuration", loglevel=0)
def do_command_test(args):
"""Runs Quantarhei tests
"""
qr.printlog("--- Running tests ---", loglevel=qr.LOG_URGENT)
qr.printlog("")
qr.printlog("Testing parallel capabilities:", loglevel=qr.LOG_URGENT)
#
# number of processors
#
cpu_count = 0
try:
import multiprocessing
cpu_count = multiprocessing.cpu_count()
except (ImportError, NotImplementedError):
pass
qr.printlog("Processor count:", cpu_count)
#
# mpi4py
#
have_mpi = False
try:
from mpi4py import MPI
have_mpi = True
except:
pass
qr.printlog("mpi4py installed:", have_mpi)
#
# MPI implementation
#
cmd = "mpirun -h"
mpirun = _try_cmd(cmd)
qr.printlog("mpirun available:", mpirun)
#
# MPI implementation
#
cmd = "mpiexec -h"
mpiexec = _try_cmd(cmd)
qr.printlog("mpiexec available:", mpiexec)
def do_command_report(args):
"""Reports on Quantarhei and the system
"""
qr.printlog("Probing system configuration", loglevel=0)
def do_command_fetch(args):
"""Fetches files for Quantarhei
"""
global parser_fetch
def get_number(file):
"""Returns the number part of the file name
"""
parts = file.split(sep="_")
return parts[1]
if args.examples:
qr.printlog("Fetching example(s) ...", loglevel=1)
import quantarhei.wizard.examples as exmpl
filenames = exmpl._available_examples
data_files = exmpl._available_data
if args.glob:
pattern = args.glob
matching = _match_filenames(filenames, pattern, add_stars=True)
else:
matching = []
if len(matching) > 0:
newmatch = matching.copy()
for match in matching:
data_pattern = get_number(match)
newmatch += _match_filenames(data_files,
data_pattern,
add_stars=True)
matching = newmatch
if len(matching) > 0:
for filename in matching:
resource_package = "quantarhei"
resource_path = '/'.join(('wizard', 'examples', filename))
content = pkg_resources.resource_string(
resource_package, resource_path)
over = True
if os.path.isfile(filename):
qr.printlog("File", filename, "already exists!")
answr = input(" Overwrite? (y/n) [n]")
if answr == "y":
over = True
else:
over = False
elif os.path.isdir(filename):
qr.printlog("Directory with the name", filename,
"already exists!")
qr.printlog("Aborting fetching")
over = False
if over:
with open(filename, "w") as file:
file.write(content.decode("utf-8"))
qr.printlog(" " + filename, loglevel=1)
else:
qr.printlog("No matching examples found", loglevel=1)
else:
parser_fetch.print_help()
def main():
global parser_list
global parser_fetch
parser = argparse.ArgumentParser(
description='Quantarhei Package Driver')
subparsers = parser.add_subparsers(help="Subcommands")
#
# Driver options
#
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("-y", "--verbosity", type=int, default=5,
help="defines verbosity between 0 and 10")
#
# Subparser for command `run`
#
parser_run = subparsers.add_parser("run", help="Script runner")
parser_run.add_argument("script", metavar='script', type=str,
help='script file to be processed', nargs=1)
parser_run.add_argument("-s", "--silent", action='store_true',
help="no output from qrhei script itself")
parser_run.add_argument("-p", "--parallel", action='store_true',
help="executes the code in parallel")
parser_run.add_argument("-n", "--nprocesses", type=int, default=0,
help="number of processes to start")
parser_run.add_argument("-b", "--benchmark", type=int, default=0,
help="run one of the predefined benchmark"
+"calculations")
parser_run.set_defaults(func=do_command_run)
#
# Subparser for command `test`
#
parser_test = subparsers.add_parser("test", help="Test runner")
parser_test.set_defaults(func=do_command_test)
#
# Subparser for command `fetch`
#
parser_fetch = subparsers.add_parser("fetch", help="Fetches examples,"
+" benchmarks, tutorials, templates"
+" and configuration files")
parser_fetch.add_argument("glob", metavar='glob', type=str,
help='file name', nargs="?")
parser_fetch.add_argument("-e", "--examples", action='store_true',
help="fetches a specified example file")
parser_fetch.set_defaults(func=do_command_fetch)
#
# Subparser for command `list`
#
parser_list = subparsers.add_parser("list", help="Lists examples,"
+" benchmarks, tutorials and templates")
parser_list.add_argument("glob", metavar='glob', type=str,
help='file name', nargs="?")
parser_list.add_argument("-e", "--examples", action='store_true',
help="list all available example files")
parser_list.set_defaults(func=do_command_list)
#
# Subparser for command `config`
#
parser_conf = subparsers.add_parser("config", help="Configures Quantarhei")
parser_conf.set_defaults(func=do_command_config)
#
# Subparser for command `report`
#
parser_report = subparsers.add_parser("report", help=
"Probes Quantarhei as system configurations")
parser_report.set_defaults(func=do_command_report)
#
# Parsing all arguments
#
args = parser.parse_args()
#
# show longer info
#
if args.info:
qr.printlog("\n"
+"qrhei: Quantarhei Package Driver\n",
verbose=True, loglevel=0)
# +"\n"
# +"MPI parallelization enabled: ", flag_parallel,
# verbose=True, loglevel=0)
if not args.version:
qr.printlog("Package version: ", qr.Manager().version, "\n",
verbose=True, loglevel=0)
return
#
# show just Quantarhei version number
#
if args.version:
qr.printlog("Quantarhei package version: ", qr.Manager().version, "\n",
verbose=True, loglevel=0)
return
try:
if args.func:
args.func(args)
except:
parser.error("No arguments provided")
def do_command_report(args):
"""Reports on Quantarhei and the system
"""
qr.printlog("Probing system configuration", loglevel=1)
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 main():
global parser_list
global parser_fetch
parser = argparse.ArgumentParser(description='Quantarhei Package Driver')
subparsers = parser.add_subparsers(help="Subcommands")
#
# Driver options
#
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("-y",
"--verbosity",
type=str,
default="5",
help="defines verbosity between 0 and 10")
parser.add_argument("-f",
"--filename",
metavar="FILENAME",
default="qrhei.log",
help="defines verbosity for logging into file")
parser.add_argument("-l",
"--logtofile",
action='store_true',
help="copy logging into a file")
#
# Subparser for command `run`
#
parser_run = subparsers.add_parser("run", help="Script runner")
parser_run.add_argument("script",
metavar='script',
type=str,
help='script file to be processed',
nargs=1)
parser_run.add_argument("-s",
"--silent",
action='store_true',
help="logging level set to zero")
parser_run.add_argument("-q",
"--quiet",
action='store_true',
help="no output from qrhei script itself")
parser_run.add_argument("-p",
"--parallel",
action='store_true',
help="executes the code in parallel")
parser_run.add_argument("-n",
"--nprocesses",
type=int,
default=0,
help="number of processes to start")
parser_run.add_argument("-f",
"--hostfile",
metavar="HOSTFILE",
default="",
help="list of available" +
" host for parallel calculation")
parser_run.add_argument("-b",
"--benchmark",
type=int,
default=0,
help="run one of the predefined benchmark" +
" calculations")
parser_run.set_defaults(func=do_command_run)
#
# Subparser for command `test`
#
parser_test = subparsers.add_parser("test", help="Test runner")
parser_test.set_defaults(func=do_command_test)
#
# Subparser for command `fetch`
#
parser_fetch = subparsers.add_parser("fetch",
help="Fetches examples," +
" benchmarks, tutorials, templates" +
" and configuration files")
parser_fetch.add_argument("glob",
metavar='glob',
type=str,
help='file name',
nargs="?")
parser_fetch.add_argument("-e",
"--examples",
action='store_true',
help="fetches a specified example file")
parser_fetch.set_defaults(func=do_command_fetch)
#
# Subparser for command `list`
#
parser_list = subparsers.add_parser("list",
help="Lists examples," +
" benchmarks, tutorials and templates")
parser_list.add_argument("glob",
metavar='glob',
type=str,
help='file name',
nargs="?")
parser_list.add_argument("-e",
"--examples",
action='store_true',
help="list all available example files")
parser_list.set_defaults(func=do_command_list)
#
# Subparser for command `config`
#
parser_conf = subparsers.add_parser("config", help="Configures Quantarhei")
parser_conf.set_defaults(func=do_command_config)
#
# Subparser for command `report`
#
parser_report = subparsers.add_parser(
"report", help="Probes Quantarhei as system configurations")
parser_report.set_defaults(func=do_command_report)
#
# Subparser for command `file`
#
parser_file = subparsers.add_parser("file",
help="Shows information about files" +
" created by Quantarhei")
parser_file.add_argument("fname",
metavar='fname',
type=str,
help='file to be checked',
nargs=1)
parser_file.set_defaults(func=do_command_file)
#
# Parsing all arguments
#
args = parser.parse_args()
#
# show longer info
#
if args.info:
qr.printlog("\n" + "qrhei: Quantarhei Package Driver\n",
verbose=True,
loglevel=1)
# +"\n"
# +"MPI parallelization enabled: ", flag_parallel,
# verbose=True, loglevel=0)
if not args.version:
qr.printlog("Package version: ",
qr.Manager().version,
"\n",
verbose=True,
loglevel=1)
return
#
# show just Quantarhei version number
#
if args.version:
qr.printlog("Quantarhei package version: ",
qr.Manager().version,
"\n",
verbose=True,
loglevel=1)
return
try:
if args.func:
args.func(args)
except:
parser.error("No arguments provided")
def __propagate_short_exp_with_rel_operators(self, rhoi, L=4):
"""Integration by short exponentional expansion
Integration by expanding exponential to Lth order.
"""
mana = Manager()
save_pytorch = None
legacy = mana.gen_conf.legacy_relaxation
if mana.num_conf.gpu_acceleration:
save_pytorch = mana.num_conf.enable_pytorch
mana.num_conf.enable_pytorch = True
if mana.num_conf.enable_pytorch and (not legacy):
ret = self._propagate_SExp_RTOp_ReSymK_Re_pytorch(rhoi,
self.Hamiltonian,
self.RelaxationTensor,
self.dt,
use_gpu=mana.num_conf.gpu_acceleration,
L=L)
if save_pytorch is not None:
mana.num_conf.enable_pytorch = save_pytorch
return ret
elif not legacy:
return self._propagate_SExp_RTOp_ReSymK_Re_numpy(rhoi,
self.Hamiltonian,
self.RelaxationTensor,
self.dt, L=L)
#
# legacy version
#
pr = ReducedDensityMatrixEvolution(self.TimeAxis, rhoi,
name=self.propagation_name)
rho1 = rhoi.data
rho2 = rhoi.data
#
# RWA is applied here
#
if self.Hamiltonian.has_rwa:
HH = self.Hamiltonian.data - self.HOmega
else:
HH = self.Hamiltonian.data
qr.log_detail("PROPAGATION (short exponential with "+
"relaxation in operator form): order ", L,
verbose=self.verbose)
qr.log_detail("Using complex numpy implementation")
try:
Km = self.RelaxationTensor.Km # real
Lm = self.RelaxationTensor.Lm # complex
Ld = self.RelaxationTensor.Ld # complex - get by transposition
Kd = numpy.zeros(Km.shape, dtype=numpy.float64)
Nm = Km.shape[0]
for m in range(Nm):
Kd[m, :, :] = numpy.transpose(Km[m, :, :])
except:
raise Exception("Tensor is not in operator form")
indx = 1
levs = [qr.LOG_QUICK] #, 8]
verb = qr.loglevels2bool(levs)
# after each step we apply pure dephasing (if present)
if self.has_PDeph:
if self.PDeph.dtype == "Lorentzian":
expo = numpy.exp(-self.PDeph.data*self.dt)
t0 = 0.0
elif self.PDeph.dtype == "Gaussian":
expo = numpy.exp(-self.PDeph.data*(self.dt**2)/2.0)
t0 = self.PDeph.data*self.dt
# loop over time
for ii in range(1, self.Nt):
qr.printlog(" time step ", ii, "of", self.Nt,
verbose=verb[0], loglevel=levs[0])
# time at the beginning of the step
tNt = self.TimeAxis.data[indx-1]
#print("tNt = ", tNt)
# steps in between saving the results
for jj in range(0, self.Nref):
tt = tNt + jj*self.dt # time right now
# L interations to get short exponential expansion
for ll in range(1, L+1):
rhoY = - (1j*self.dt/ll)*(numpy.dot(HH,rho1)
- numpy.dot(rho1,HH))
#rhoX = numpy.zeros(rho1.shape, dtype=numpy.complex128)
for mm in range(Nm):
rhoY += (self.dt/ll)*(
numpy.dot(Km[mm,:,:],numpy.dot(rho1, Ld[mm,:,:]))
+numpy.dot(Lm[mm,:,:],numpy.dot(rho1, Kd[mm,:,:]))
-numpy.dot(numpy.dot(Kd[mm,:,:],Lm[mm,:,:]), rho1)
-numpy.dot(rho1, numpy.dot(Ld[mm,:,:],Km[mm,:,:]))
)
rho1 = rhoY #+ rhoX
rho2 = rho2 + rho1
# pure dephasing is added here
rho2 = rho2*expo*numpy.exp(-t0*tt)
rho1 = rho2
pr.data[indx,:,:] = rho2
indx += 1
# no extra dephasing
else:
# loop over time
for ii in range(1, self.Nt):
qr.printlog(" time step ", ii, "of", self.Nt,
verbose=verb[0], loglevel=levs[0])
# steps in between saving the results
for jj in range(0, self.Nref):
# L interations to get short exponential expansion
for ll in range(1, L+1):
rhoY = - (1j*self.dt/ll)*(numpy.dot(HH,rho1)
- numpy.dot(rho1,HH))
#rhoX = numpy.zeros(rho1.shape, dtype=numpy.complex128)
for mm in range(Nm):
rhoY += (self.dt/ll)*(
numpy.dot(Km[mm,:,:],numpy.dot(rho1, Ld[mm,:,:]))
+numpy.dot(Lm[mm,:,:],numpy.dot(rho1, Kd[mm,:,:]))
-numpy.dot(numpy.dot(Kd[mm,:,:],Lm[mm,:,:]), rho1)
-numpy.dot(rho1, numpy.dot(Ld[mm,:,:],Km[mm,:,:]))
)
rho1 = rhoY #+ rhoX
rho2 = rho2 + rho1
rho1 = rho2
pr.data[indx,:,:] = rho2
indx += 1
qr.log_detail("...DONE")
return pr
