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 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