def _main():
parser = argparse.ArgumentParser("Calculation of gaps",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--subdir", type=str, default=None,
help="Subdirectory under work_base where calculation was run")
parser.add_argument("--threshold_K", type=float, default=0.9,
help="Threshold for deciding if a state is dominated by one layer")
parser.add_argument("--threshold_Gamma", type=float, default=0.6,
help="Threshold for deciding if a state is dominated by one layer")
parser.add_argument("--spin_valence", type=str, default=None,
help="Set 'up' or 'down' to choose valence band spin type; closest to E_F is used if not set")
parser.add_argument("--spin_conduction", type=str, default=None,
help="Set 'up' or 'down' to choose conduction band spin type; closest to E_F is used if not set")
parser.add_argument("--D", type=float, default=None,
help="Perpendicular electric field value [V/nm]")
parser.add_argument('global_prefix', type=str,
help="Calculation name")
args = parser.parse_args()
gconf = _global_config()
work = os.path.expandvars(gconf["work_base"])
if args.subdir is not None:
work = os.path.join(work, args.subdir)
prefixes = get_prefixes(work, args.global_prefix)
if args.D is not None:
prefixes = filter_to_D(prefixes, args.D)
ds = ds_from_prefixes(prefixes)
ds, prefixes = wrap_cell(ds, prefixes)
dps = sorted_d_group(ds, prefixes)
K = (1/3, 1/3, 0.0)
layer_labels = ["bot.", "top"]
relax_data = get_relax_data(work, dps)
plot_relax_data(relax_data, dps)
gap_data_K = get_gap_data(work, dps, args.threshold_K, args.spin_valence, args.spin_conduction,
K, "K")
plot_gap_data(gap_data_K, dps, "K", "$K$", layer_labels)
Gamma = (0.0, 0.0, 0.0)
gap_data_Gamma = get_gap_data(work, dps, args.threshold_Gamma, args.spin_valence, args.spin_conduction,
Gamma, "Gamma", use_curvature=False)
plot_gap_data(gap_data_Gamma, dps, "Gamma", r"$\Gamma$", layer_labels, use_curvature=False)
def _main():
parser = argparse.ArgumentParser(
"Run postprocessing to set up Wannier90 calculation",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--subdir",
type=str,
default=None,
help="Subdirectory under work_base to run calculation")
parser.add_argument("--global_prefix",
type=str,
default="WSe2_WSe2_WSe2",
help="Prefix for calculation")
args = parser.parse_args()
gconf = _global_config()
base_path = os.path.expandvars(gconf["work_base"])
if args.subdir is not None:
base_path = os.path.join(base_path, args.subdir)
if "qe_bands" in gconf:
qe_bands_dir = os.path.expandvars(gconf["qe_bands"])
qe_bands_path = os.path.join(qe_bands_dir, "bands.x")
else:
qe_bands_path = "bands.x"
calc = "pw_post"
prefix_groups = get_prefix_groups(base_path, args.global_prefix)
machine = "stampede2"
cores_per_node = mpi_procs_per_node(machine)
config = {
"machine": machine,
"cores": cores_per_node,
"nodes": 1,
"queue": "normal",
"hours": 48,
"minutes": 0,
"wannier": True,
"project": "A-ph9",
"global_prefix": args.global_prefix,
"max_jobs": 24,
"qe_bands": qe_bands_path
}
submit_pw_post(base_path, config, prefix_groups)
def _main():
parser = argparse.ArgumentParser(
"Find calculations with missing files.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
"--subdir",
type=str,
default=None,
help="Subdirectory under work_base where calculation has been run")
parser.add_argument("--global_prefix",
type=str,
default="WSe2_WSe2_WSe2",
help="Prefix for calculation")
parser.add_argument(
"--depth",
type=int,
default=1,
help="How many subdirectories to search inside each calculation.")
parser.add_argument(
"missing_pattern",
type=str,
help=
"Regular expression pattern identifying files to search for. Report calculations where no file matches the pattern."
)
args = parser.parse_args()
gconf = _global_config()
base_path = os.path.expandvars(gconf["work_base"])
if args.subdir is not None:
base_path = os.path.join(base_path, args.subdir)
prefixes = get_prefixes(base_path, args.global_prefix)
missing_pattern_re = re.compile(args.missing_pattern)
missing = []
for prefix in prefixes:
in_dir = os.path.join(base_path, prefix)
if find_pattern(in_dir, missing_pattern_re, args.depth) is None:
missing.append(prefix)
for missing_prefix in missing:
print(missing_prefix)
def _main():
parser = argparse.ArgumentParser(description="Plot various quantities as function of displacement")
parser.add_argument("--subdir", type=str, default=None,
help="Subdirectory under work_base where calculation was run")
parser.add_argument('--global_prefix', type=str, default="MoS2_WS2",
help="Calculation global prefix")
args = parser.parse_args()
gconf = _global_config()
work = os.path.expandvars(gconf["work_base"])
if args.subdir is not None:
work = os.path.join(work, args.subdir)
prefixes = get_prefixes(work, args.global_prefix)
ds = ds_from_prefixes(prefixes)
ds, prefixes = wrap_cell(ds, prefixes)
dps = sorted_d_group(ds, prefixes)
write_out_data = {"_ds": []}
for d, prefix in dps:
write_out_data["_ds"].append(d)
energies = get_energies(work, dps)
energies_rel_meV = energies_relative_to(energies, dps, (0.0, 0.0))
E_title = "$\\Delta E$ [meV]"
E_plot_name = "{}_energies".format(args.global_prefix)
plot_d_vals(E_plot_name, E_title, dps, energies_rel_meV)
write_out_data["meV_relative_total_energy"] = energies_rel_meV
soc = True
Hk_vals = extract_Hk_vals(work, dps, soc)
for label, this_vals in Hk_vals.items():
title = label
plot_name = "{}_{}".format(args.global_prefix, label)
plot_d_vals(plot_name, title, dps, this_vals)
write_out_data["eV_{}".format(label)] = this_vals
def _main():
parser = argparse.ArgumentParser(
"Calculate optical matrix elements",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
"--subdir",
type=str,
default=None,
help="Subdirectory under work_base where calculation was run")
parser.add_argument('global_prefix', type=str, help="Calculation name")
args = parser.parse_args()
gconf = _global_config()
work = os.path.expandvars(gconf["work_base"])
if args.subdir is not None:
work = os.path.join(work, args.subdir)
prefixes = get_prefixes(work, args.global_prefix)
ds = ds_from_prefixes(prefixes)
ds, prefixes = wrap_cell(ds, prefixes)
dps = sorted_d_group(ds, prefixes)
write_optical_data(work, dps)
def _main():
parser = argparse.ArgumentParser(
"Report band extrema and their layer / spin weights",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument(
"--subdir",
type=str,
default=None,
help="Subdirectory under work_base where calculation was run")
parser.add_argument(
"--num_layers",
type=int,
default=2,
help=
"Number of layers in system (determines number of band extrema to consider)"
)
parser.add_argument("--D",
type=float,
default=None,
help="Perpendicular electric field value [V/nm]")
parser.add_argument('global_prefix', type=str, help="Calculation name")
args = parser.parse_args()
gconf = _global_config()
work = os.path.expandvars(gconf["work_base"])
if args.subdir is not None:
work = os.path.join(work, args.subdir)
prefixes = get_prefixes(work, args.global_prefix)
if args.D is not None:
prefixes = filter_to_D(prefixes, args.D)
ds = ds_from_prefixes(prefixes)
ds, prefixes = wrap_cell(ds, prefixes)
dps = sorted_d_group(ds, prefixes)
K = (1 / 3, 1 / 3, 0.0)
layer_labels = ["bot.", "top"]
relax_data = get_relax_data(work, dps)
plot_relax_data(relax_data, dps)
K_num_valence_bands = args.num_layers
K_num_conduction_bands = 2 * args.num_layers
Gamma_num_valence_bands = 2
Gamma_num_conduction_bands = 4
extrema_data_K = get_extrema_data(work, dps, K, "K", args.num_layers,
K_num_valence_bands,
K_num_conduction_bands)
plot_extrema_data(extrema_data_K, dps, "K", "$K$", layer_labels)
Gamma = (0.0, 0.0, 0.0)
extrema_data_Gamma = get_extrema_data(work, dps, Gamma, "Gamma",
args.num_layers,
Gamma_num_valence_bands,
Gamma_num_conduction_bands)
plot_extrema_data(extrema_data_Gamma, dps, "Gamma", r"$\Gamma$",
layer_labels)
def _main():
parser = argparse.ArgumentParser(
"Build and run calculation over various TMD stacks",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--run",
action="store_true",
help="Run calculation after making inputs")
parser.add_argument("--subdir",
type=str,
default=None,
help="Subdirectory under work_base to run calculation")
parser.add_argument("--stacking",
type=str,
default="AB",
help="Stacking mode: 'AB' (2H) or 'AA' (1H)")
parser.add_argument("--D",
type=float,
default=None,
help="Displacement field (default: no field)")
parser.add_argument("--xc",
type=str,
default="lda",
help="Exchange-correlation functional (lda or pbe)")
parser.add_argument("--pp",
type=str,
default="nc",
help="Pseudopotential type ('nc' or 'paw')")
args = parser.parse_args()
soc = True
all_syms = get_all_syms()
AB_stacking = get_stacking(args.stacking)
vacuum_dist = 20.0 # Angstrom
db_path = os.path.join(_base_dir(), "c2dm.db")
db = ase.db.connect(db_path)
prefixes = []
for syms in all_syms:
p = set_up_calculation(db, args.subdir, syms, AB_stacking, soc,
vacuum_dist, args.D, args.xc, args.pp)
prefixes.append(p)
global_prefix = "alignment"
machine = "stampede2"
num_nodes = 2
num_cores = num_nodes * mpi_procs_per_node(machine)
queue_config = {
"machine": machine,
"nodes": num_nodes,
"cores": num_cores,
"queue": "normal",
"hours": 12,
"minutes": 0,
"wannier": True,
"project": "A-ph9",
"global_prefix": global_prefix,
"max_jobs": 6,
"outer_min": -10.0,
"outer_max": 5.0,
"inner_min": -8.0,
"inner_max": 3.0,
"subdir": args.subdir,
"qe_bands": _global_config()['qe_bands']
}
_write_queuefiles(_get_base_path(args.subdir), prefixes, queue_config)
def _main():
parser = argparse.ArgumentParser(
"Build and run calculation over displacement field values",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("--run",
action="store_true",
help="Run calculation after making inputs")
parser.add_argument("--subdir",
type=str,
default=None,
help="Subdirectory under work_base to run calculation")
parser.add_argument(
"--syms",
type=str,
default="WSe2;WSe2;WSe2",
help=
"Semicolon-separated list of atomic composition of layers. Format example: WSe2;MoSe2;MoS2"
)
parser.add_argument("--stacking",
type=str,
default="AB",
help="Stacking mode: 'AB' (2H) or 'AA' (1H)")
parser.add_argument("--minD",
type=float,
default=0.01,
help="Minimum displacement field in V/nm")
parser.add_argument("--maxD",
type=float,
default=0.5,
help="Maximum displacement field in V/nm")
parser.add_argument(
"--numD",
type=int,
default=10,
help=
"Number of displacement field steps. Set to 0 to not use displacement field."
)
parser.add_argument(
"--shifts_l2",
type=int,
default=None,
help=
"Number of interlayer shifts to include for second layer: if specified, include\
calculations with second layer shifts tiling the unit cell.")
parser.add_argument(
"--interlayer_relax",
action="store_true",
help="Relax in the out-of-plane direction before performing scf")
parser.add_argument("--no_soc",
action="store_true",
help="Turn off spin-orbit coupling")
parser.add_argument("--xc",
type=str,
default="lda",
help="Exchange-correlation functional (lda or pbe)")
parser.add_argument("--pp",
type=str,
default="nc",
help="Pseudopotential type ('nc' or 'paw')")
args = parser.parse_args()
syms = _extract_syms(args.syms)
global_prefix = "_".join(syms)
print("Generating inputs for {} system {}.".format(num_layers_label(syms),
syms))
soc = not args.no_soc
db_path = os.path.join(_base_dir(), "c2dm.db")
db = ase.db.connect(db_path)
# Choose separation between layers as if the system was a bulk system
# where all layers are the same as the first layer here.
# TODO -- is there a better strategy for this?
c_sep = get_c_sep(db, syms[0])
vacuum_dist = 20.0 # Angstrom
if args.stacking == 'AB':
AB_stacking = True
elif args.stacking == 'AA':
AB_stacking = False
else:
raise ValueError("unrecognized value for argument 'stacking'")
if args.numD == 0:
Ds = [None]
else:
Ds = np.linspace(args.minD, args.maxD, args.numD)
if args.shifts_l2 is None:
all_layer_shifts = [None]
else:
num_layers = len(syms)
all_layer_shifts = make_layer_shifts(num_layers, args.shifts_l2)
prefixes = []
for layer_shifts in all_layer_shifts:
prefixes.extend(
make_system_at_shift(global_prefix, args.subdir, db, syms, c_sep,
vacuum_dist, AB_stacking, soc,
args.interlayer_relax, args.xc, args.pp, Ds,
layer_shifts))
machine = "stampede2"
num_nodes = 1
num_cores = num_nodes * mpi_procs_per_node(machine)
queue_config = {
"machine": machine,
"cores": num_cores,
"nodes": num_nodes,
"queue": "normal",
"hours": 12,
"minutes": 0,
"wannier": True,
"project": "A-ph9",
"global_prefix": global_prefix,
"max_jobs": 1,
"relax": args.interlayer_relax,
"outer_min": -10.0,
"outer_max": 6.0,
"inner_min": -8.0,
"inner_max": 3.0,
"subdir": args.subdir,
"qe_bands": _global_config()['qe_bands']
}
print(
"Generating queuefiles for machine {} on {} nodes and {} jobs with max runtime {} hours."
.format(machine, num_nodes, queue_config["max_jobs"],
queue_config["hours"]))
base_path = _get_base_path(args.subdir)
prefix_groups = _write_queuefiles(base_path, prefixes, queue_config)
if args.run:
calc_name = "wan_setup"
submit_pw(base_path, queue_config, prefix_groups, calc_name)
def _get_base_path(subdir):
work = os.path.expandvars(_global_config()['work_base'])
if subdir is not None:
work = os.path.join(work, subdir)
return work