def main():
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root")
sys.exit(1)
logger = logging.getLogger(__name__)
try:
sdj = setupPHDjob()
except FileNotFoundError:
sys.exit(1)
except OSError:
logger.exception(
"OSError encountered, likely an issue with moving files around")
logger.critical("If the issue persists, contact the developers")
sys.exit(1)
except ParameterError:
logger.error("Please make sure your parameters are correct")
sys.exit(1)
except:
logger.exception("Unknown exception encountered, quitting")
sys.exit(1)
def main():
# Begin the logger (__main__)
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root.")
sys.exit(1)
logger = logging.getLogger(__name__)
logger.debug("Parsing Arguments")
parser = argparse.ArgumentParser(description="Setups a turbomole job")
parser.add_argument("-t",
dest="timeout",
action='store_false',
default=True,
required=False,
help="Turns off timeout")
args = parser.parse_args()
timeout_time = 0
if args.timeout:
logger.debug("Timeout is turned on")
timeout_time = 15
# Start to do the dew
try:
tm = setupTMjob(timeout=timeout_time)
except FileExistsError as e:
if str(e) == 'control':
logger.info(
"Either delete control file, or perform define by hand!")
else:
logger.exception("Unknown FileExistsError encountered!")
except FileNotFoundError as e:
if str(e) == "definput.json":
logger.error(
"Please resubmit once you are done editing the parameters")
elif str(e) == "coord":
logger.info("Please provide a structure file for this job!")
else:
logger.exception("Unknown FileNotFoundError encountered!")
except exceptions.DefineError:
logger.info("Check define.out for the exact issue!")
except exceptions.ParameterError as e:
logger.info(e)
except:
logger.exception("Exception encountered in running setupjob.py")
def main():
# Load the logger
utilities.load_logger_config()
logger = logging.getLogger(__name__)
# Sets up the argument parser for the necessary vars
logger.debug("Parsing arguments")
parser = argparse.ArgumentParser(description="Runs a TURBOMOLE job")
parser.add_argument('-n',
nargs=1,
dest="cores",
type=int,
required=True,
help='number of cores available to TURBOMOLE')
parser.add_argument('-t',
nargs=1,
dest="time",
type=int,
default=[-1],
required=False,
help='time available to run job (hours)')
parser.add_argument('-s',
nargs=1,
dest="scratch_directory",
default='./',
type=str,
required=False,
help='scratch directory to run the job in')
args = parser.parse_args()
logger.debug("Proper arguments passed")
try:
job = TMcalculation(cores=args.cores[0],
time=args.time[0],
run_dir=args.scratch_directory[0])
except FileNotFoundError as e:
if str(e) == "definput.json":
logger.error("There were no parameters for this job!")
elif str(e) == "coord":
logger.error("You do not have a structure file!")
else:
logger.exception("Unknown FileNotFoundError encountered!")
raise
except exceptions.ParameterError:
logger.error(
"Parameters passed where invalid! Check to ensure that the value in definput are valid!"
)
except:
logger.exception(
"Unknown exception encountered while trying to run job")
raise
def main():
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root")
sys.exit(1)
logger = logging.getLogger(__name__)
logger.debug("Parsing Arguments")
parser = argparse.ArgumentParser(
description="Converts a piDMD movie file to a pdb")
parser.add_argument("pdbfile",
type=str,
nargs=1,
help="initial pdb file (typically initial.pdb)")
parser.add_argument("moviefile",
type=str,
nargs=1,
help="Movie file from piDMD")
parser.add_argument("-o",
dest="outputFile",
default=["movie.pdb"],
type=str,
nargs=1,
required=False,
help="Output for movie file")
# parser.add_argument("--p", dest="protonate", nargs='*', default=[], required=False, help="Protonates the movie file")
args = parser.parse_args()
if not os.path.isfile(args.pdbfile[0]):
logger.error(f"pdb file provided does not exist: {args.pdbfile[0]}")
sys.exit(1)
if not os.path.isfile(args.moviefile[0]):
logger.error(
f"movie file provided does not exist: {args.moviefile[0]}")
sys.exit(1)
logger.debug("Passing parameters...")
try:
logger.debug("Passing args to the function in utilities")
utilities.make_movie(args.pdbfile[0], args.moviefile[0],
args.outputFile[0])
#utilities.make_movie(args.pdbfile[0], args.moviefile[0], args.outputFile[0], protonate=args.protonate)
except OSError:
logger.error("Error creating movie file")
sys.exit(1)
#TODO check for the output file actually...
logger.info("Successfully converted movie file!")
logger.debug("Finished")
def main():
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root.")
sys.exit(1)
logger = logging.getLogger(__name__)
# This is the logger for the free_energy script. We now need to remove all of the handlers and append the typical sys.std to it as this is a command line script
# Now we have switched out the logger for the sys.stoud so that everything at info or above is output to the console
logger.debug("Logger is setup!")
logger.debug("Creating argparser")
parser = argparse.ArgumentParser(
description=
"Calculates the free energy correction following a Vibrational Frequency calculation"
)
parser.add_argument(
"-T",
dest="temp",
type=float,
required=False,
default=298.15,
help="The temperature at which to calculate the free energy correction"
)
args = parser.parse_args()
if args.temp < 0:
logger.error("Cannot have a negative temperature!")
sys.exit(1)
try:
gcorr = free_energy.free_energy_correction(args.temp)
except:
#TODO Make this except clause better...not as general
logger.exception("Error while calculating free energy")
sys.exit(1)
logger.info(f"[Free energy correction] ==>> {gcorr} (Hart)")
logger.debug("Finished with Calculation")
def main():
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root")
sys.exit(1)
logger = logging.getLogger(__name__)
proteins = utilities.load_movie("movie.pdb")
rmsd = []
for protein in proteins:
rmsd.append(proteins[0].aa_rmsd(protein))
print(rmsd)
logger.info("[Finished]")
def main():
# Load the logger
utilities.load_logger_config()
logger = logging.getLogger(__name__)
# Sets up the argument parser for the necessary vars
logger.debug("Parsing arguments")
parser = argparse.ArgumentParser(description="Runs a QM/DMD job")
parser.add_argument('-n',
nargs=1,
dest="cores",
type=int,
required=True,
help='number of cores available')
parser.add_argument('-t',
nargs=1,
dest="time",
type=int,
default=[-1],
required=False,
help='time available to run job (hours)')
parser.add_argument('-s',
nargs=1,
dest="scratch_directory",
default='./',
type=str,
required=False,
help='scratch directory to run the job in')
args = parser.parse_args()
logger.debug("Proper arguments passed")
try:
utilities.print_header()
job = controller(cores=args.cores[0],
time=args.time[0],
scratch=args.scratch_directory[0])
except:
logger.exception(
"Unknown exception encountered while trying to run job")
raise
def main():
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root")
sys.exit(1)
logger = logging.getLogger(__name__)
parser = argparse.ArgumentParser(
description="Converts pdb -> coord, or reinstalls coord in pdb")
parser.add_argument("--reinstall",
dest="install",
required=False,
action="store_true",
help="Reinstall coord into pdb")
args = parser.parse_args()
if not os.path.isfile("phdinput.json"):
logger.error("No phdinput.json file")
sys.exit(1)
with open("phdinput.json", 'r') as optionFile:
parameters = json.load(optionFile)
protein = utilities.load_pdb(parameters["pdb file"])
if not args.install:
logger.info("[Cutting]...")
dmd_to_qm.protein_to_coord(protein, parameters["QM Chop"])
else:
logger.info("Reinstalling...")
protein = dmd_to_qm.coord_to_protein(protein, parameters["QM Chop"])
protein.write_pdb("reinstalled.pdb")
logger.info("[Finished]")
def main():
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .dmdpy in the root")
sys.exit(1)
logger = logging.getLogger(__name__)
logger.debug("Logger initialized")
logger.debug("Parsing arguments")
parser = argparse.ArgumentParser(description="Runs a DMD simulation")
parser.add_argument('-n', nargs=1, dest="cores", type=int, required=True,
help='number of cores available')
parser.add_argument('-t', nargs=1, dest="time", type=int, default=[-1], required=False,
help='time available to run job (hours)')
parser.add_argument('-s', nargs=1, dest="scratch_directory", default='./', type=str, required=False,
help='scratch directory to run the job in')
args = parser.parse_args()
logger.debug("Proper arguments passed")
# TODO have it receive argument for the number of cores, time to run, and a scratch directory
try:
logger.debug("Attempting to begin the calculation")
c = phd3.dmd_simulation(cores=args.cores[0], time=args.time[0], run_dir=args.scratch_directory[0])
except:
logger.exception("Check the error")
logger.error("Error on the calculation")
sys.exit(1)
def main(_cores: int = None,
_time: int = None,
_nodes: int = 1,
_sub: bool = True):
# Load in the logger
utilities.load_logger_config()
logger = logging.getLogger(__name__)
# Load in the configuration for this user
logger.debug("Calling load_phd_config")
config = utilities.load_phd_config()
# Parse the configuration!
logger.debug("Assigning variables for users queueing")
max_nodes = config['QUEUING']['max_nodes']
node_types = config['QUEUING']['node_types']
max_time = config['QUEUING']['max_time']
high_priority_nodes = config['QUEUING']['high_priority_nodes']
# Creates a list of (num_cores, max_time)
avail_nodes = list(zip(node_types, max_time))
# Assign the vars passed
logger.debug("Checking for any passed args")
cores = _cores
time = _time
nodes = _nodes
sub = _sub
# If no args passed, check for command line args
if cores is None or time is None:
# Arg Parser Here
logger.debug("Parsing args")
parser = argparse.ArgumentParser(
description="Submits a DMD simulation to a queuing system")
parser.add_argument(
"-N",
dest="nodes",
type=int,
required=False,
default=1,
help=f"The number of nodes to run the DMD simulation on.")
parser.add_argument(
"-n",
dest="cores",
type=int,
required=True,
help=f"The number of cores per node to run the DMD simulation with."
)
parser.add_argument(
"-t",
dest="time",
type=int,
required=True,
help="The amount of time to submit the job for (hours).")
parser.add_argument("-sub",
dest="sub",
action='store_true',
help="Submit the job to the queueing system.")
args = parser.parse_args()
if args.nodes > max_nodes or args.cores > max(
node_types) or args.time > max(max_time):
logger.error(
"Invalid args parsed based off of what user has specified in config file"
)
parser.print_help()
sys.exit(1)
cores = args.cores
time = args.time
nodes = args.nodes
sub = args.sub
# Finds the appropriate node to use
logger.debug("Checking to ensure user has enough resources")
big_enough_nodes = list(filter(lambda i: i[0] >= cores, avail_nodes))
enough_time_nodes = list(filter(lambda i: i[1] >= time, big_enough_nodes))
possible_nodes = sorted(enough_time_nodes, key=lambda x: x[0])
if not possible_nodes:
logger.error("User does not have access to resources")
raise ValueError
# Grab the minimum processing node
node_type = min(possible_nodes)[0]
logger.debug(f"Using node type: {node_type}")
high_priority = True if node_type in high_priority_nodes else False
# Create the jinja2 dictionary
job_params = {
"date": datetime.datetime.now(),
"submit_dir": os.path.realpath(os.getcwd()),
"node_type": node_type,
"cores": cores,
"nodes": nodes,
"high_priority": ",highp" if high_priority else "",
"user": os.environ["USER"],
"job_name": os.path.basename(os.getcwd()),
"run_script": os.path.join(os.path.dirname(__file__), "rundmd.py"),
"time": time
}
# Make the submit script for the queuing system
home = os.path.expanduser("~")
path_to_template = os.path.join(home, ".config/phd3")
if not os.path.isdir(path_to_template):
path_to_template = os.path.join(home, ".phd3")
logger.debug(f"Finding file in: {path_to_template} ")
templateLoader = jinja2.FileSystemLoader(searchpath=path_to_template)
templateEnv = jinja2.Environment(loader=templateLoader)
TEMPLATE_FILE = "submit.j2"
try:
template = templateEnv.get_template(TEMPLATE_FILE)
except jinja2.exceptions.TemplateNotFound:
logger.error(f"Template file not found in {path_to_template}")
raise
logger.debug("Found template file!")
# Now we dump text to a file
outputText = template.render(job_params)
try:
logger.debug(f"Writing out submit file: {constants.SUBMIT_FILE_NAME}")
with open(constants.SUBMIT_FILE_NAME, "w+") as submit_file:
submit_file.write(outputText)
except IOError:
logger.exception("Could not write out submit file!")
sys.exit(1)
if not os.path.isfile("dmdinput.json"):
logger.warn("[WARNING] ==>> No dmdinput.json file found")
# Submit the Job!!
if sub:
logger.info("Submitting job to queue")
with Popen(
f"{config['QUEUING']['submit']} {constants.SUBMIT_FILE_NAME}",
shell=True,
universal_newlines=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
bufsize=1,
env=os.environ) as shell:
while shell.poll() is None:
logger.info(shell.stdout.readline().strip())
logger.info(shell.stderr.readline().strip())
def main():
# Load in the logger
try:
utilities.load_logger_config()
except ValueError:
print("CRITICAL: Created .phd3 in the root")
sys.exit(1)
logger = logging.getLogger(__name__)
logger.debug("Parsing Arguments")
parser = argparse.ArgumentParser(
description="Relabels a pdb to a new atom labeling scheme")
parser.add_argument("pdbfile", type=str, nargs=1, help="PDB file to edit")
parser.add_argument("scheme",
type=str,
nargs=1,
help="Scheme to convert to")
parser.add_argument("-o",
dest="outputFile",
default="",
type=str,
nargs=1,
required=False,
help="PDB file to write to")
args = parser.parse_args()
if not os.path.isfile(args.pdbfile[0]):
logger.error(f"Could not find pdb: {args.pdbfile[0]}")
sys.exit(1)
logger.debug("Proper Arguments Passed")
try:
protein = utilities.load_pdb(args.pdbfile[0])
except IOError:
logger.error("Error in loading in the PDB file provided")
sys.exit(1)
protein.reformat_protein(relabel_protein=False)
logger.debug("Relabeling")
try:
protein.relabel(args.scheme[0])
except ValueError:
logger.error("Error in relabeling the protein")
raise
if args.outputFile != "":
logger.debug(f"Changing protein name to {args.outputFile[0]}")
protein.name = args.outputFile[0]
try:
protein.write_pdb()
except IOError:
logger.error("Error writing the protein to pdb file")
sys.exit(1)
logger.debug("Finished")