def molec_properties(geom, charge, mult, method, basis, prog,
# molecule options
mol_options=(),
# machine options
memory=1, comment='', machine_options=(),
# theory options
orb_type=None,
scf_options=(), casscf_options=(), corr_options=(),
# generic options
gen_lines=None,
# job options
job_options=()):
""" Molecular Properties input string
:param geom: cartesian or z-matrix geometry
:type geom: tuple
:param charge: molecular charge
:type charge: int
:param mult: spin multiplicity
:type mult: int
:param method: electronic structure method
:type method: str
:param basis: basis set
:type basis: str
:param prog: electronic structure program to use as a backend
:type prog: str
:param mol_options: options for the molecule block
:type mol_options: tuple[str]
;param memory: memory in GB
:type memory: int
:param comment: a comment string to be placed at the top of the file
:type comment: str
:param machine_options: machine directives (num procs, num threads, etc.)
:type machine_options: tuple[str]
:param orb_type: 'R' indicates restricted orbitals, 'U' indicates
unrestricted orbitals; can also be 'RR', 'RU', or 'UU' where the first
character sets R/U for singlets and the second sets R/U for multiplets
:type orb_type: str
:param scf_options: scf method directives
:type scf_options: tuple[str]
:param casscf_options: casscf method directives
:type casscf_options: tuple[str]
:param corr_options: correlation method directives
:type corr_options: tuple[str]
:param gen_lines: generic lines for the input file
:type gen_lines: tuple[str]
:type gen_lines: dct[idx]=[str]
"""
prog, method, basis, orb_restricted = _process_theory_specifications(
prog, method, basis, mult, orb_type)
return pm.call_module_function(
prog, MODULE_NAME, module_template.molec_properties,
# *args
geom, charge, mult, method, basis,
# **kwargs
mol_options=mol_options, memory=memory, comment=comment,
machine_options=machine_options, orb_restricted=orb_restricted,
scf_options=scf_options, casscf_options=casscf_options,
corr_options=corr_options,
gen_lines=gen_lines, job_options=job_options)
def error_list(prog):
""" list of errors that be identified from the output file
:param prog: the electronic structure program to use as a backend
:type prog: str
"""
return pm.call_module_function(prog, MODULE_NAME,
module_template.error_list)
def gradient(prog, output_string):
""" read gradient from the output string
:param prog: electronic structure program to use as a backend
:type prog: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.gradient,
# *args
output_string)
def has_normal_exit_message(prog, output_string):
""" does this output string have a normal exit message?
:param prog: electronic structure program to use as a backend
:type prog: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.has_normal_exit_message,
# *args
output_string)
def opt_zmatrix(prog, output_string):
""" read optimized zmatrix from the output string
:param prog: electronic structure program to use as a backend
:type prog: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.opt_zmatrix,
# *args
output_string)
def polarizability(prog, output_string):
""" read polarizability from the output string
:param prog: electronic structure program to use as a backend
:type prog: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.polarizability,
# *args
output_string)
def normal_coords(prog, output_string):
""" read normal modes from the output string
:param prog: electronic structure program to use as a backend
:type prog: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.normal_coords,
# *args
output_string)
def harmonic_frequencies(prog, output_string):
""" read harmonic_frequencies from the output string
:param prog: electronic structure program to use as a backend
:type prog: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.harmonic_frequencies,
# *args
output_string)
def has_error_message(prog, error, output_string):
""" does this output string have an error message?
:param prog: electronic structure program to use as a backend
:type prog: str
:param error: a key indicating the type of error message
:type error: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.has_error_message,
# *args
error,
output_string)
def energy(prog, method, output_string):
""" read energy from the output string
:param prog: electronic structure program to use as a backend
:type prog: str
:param method: electronic structure method
:type method: str
:param output_string: the program output string
:type output_string: str
"""
prog = prog.lower()
method = method.lower()
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.energy,
# *args
method,
output_string)
def check_convergence_messages(prog, error, success, output_string):
""" does this output string have an error message?
:param prog: electronic structure program to use as a backend
:type prog: str
:param error: a key indicating the type of error message
:type error: str
:param success: a key indicating the type of success message
:type success: str
:param output_string: the program output string
:type output_string: str
"""
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.check_convergence_messages,
# *args
error,
success,
output_string)
def energy(
geom,
charge,
mult,
method,
basis,
prog,
# molecule options
mol_options=(),
# machine options
memory=1,
comment='',
machine_options=(),
# theory options
orb_restricted=None,
scf_options=(),
casscf_options=(),
corr_options=(),
# generic options
gen_lines=None):
""" energy input string
:param geom: cartesian or z-matrix geometry
:type geom: tuple
:param charge: molecular charge
:type charge: int
:param mult: spin multiplicity
:type mult: int
:param method: electronic structure method
:type method: str
:param basis: basis set
:type basis: str
:param prog: electronic structure program to use as a backend
:type prog: str
:param mol_options: options for the molecule block
:type mol_options: tuple[str]
;param memory: memory in GB
:type memory: int
:param comment: a comment string to be placed at the top of the file
:type comment: str
:param machine_options: machine directives (num procs, num threads, etc.)
:type machine_options: tuple[str]
:param orb_restricted: whether the SCF orbitals are spin-restricted
:type orb_restricted: bool
:param scf_options: scf method directives
:type scf_options: tuple[str]
:param casscf_options: casscf method directives
:type casscf_options: tuple[str]
:param corr_options: correlation method directives
:type corr_options: tuple[str]
:param gen_lines: generic lines for the input file
:type gen_lines: dct[idx]=[str]
"""
prog, method, basis, orb_restricted = _process_theory_specifications(
prog, method, basis, mult, orb_restricted)
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.energy,
# *args
geom,
charge,
mult,
method,
basis,
# **kwargs
mol_options=mol_options,
memory=memory,
comment=comment,
machine_options=machine_options,
orb_restricted=orb_restricted,
scf_options=scf_options,
casscf_options=casscf_options,
corr_options=corr_options,
gen_lines=gen_lines)
def irc(
geom,
charge,
mult,
method,
basis,
prog,
# molecule options
mol_options=(),
# machine options
memory=1,
comment='',
machine_options=(),
# theory options
orb_restricted=None,
scf_options=(),
casscf_options=(),
corr_options=(),
# generic options
gen_lines=None,
# job options
job_options=(),
frozen_coordinates=(),
irc_direction=None):
""" irc input string
:param geom: cartesian or z-matrix geometry
:type geom: tuple
:param charge: molecular charge
:type charge: int
:param mult: spin multiplicity
:type mult: int
:param method: electronic structure method
:type method: str
:param basis: basis set
:type basis: str
:param prog: electronic structure program to use as a backend
:type prog: str
:param mol_options: options for the molecule block
:type mol_options: tuple[str]
;param memory: memory in GB
:type memory: int
:param comment: a comment string to be placed at the top of the file
:type comment: str
:param machine_options: machine directives (num procs, num threads, etc.)
:type machine_options: tuple[str]
:param orb_restricted: whether the SCF orbitals are spin-restricted
:type orb_restricted: bool
:param scf_options: scf method directives
:type scf_options: tuple[str]
:param casscf_options: casscf method directives
:type casscf_options: tuple[str]
:param corr_options: correlation method directives
:type corr_options: tuple[str]
:param job_options: geometry optimization routine directives
:type job_options: tuple[str]
:param frozen_coordinates: only with z-matrix geometries; list of
coordinate names to freeze
:type fozen_coordinates: tuple[str]
:param irc_direction: direction along imaginary mode eigenvector to move
:type irc_direction: string
:param gen_lines: generic lines for the input file
:type gen_lines: dct[idx]=[str]
"""
prog, method, basis, orb_restricted = _process_theory_specifications(
prog, method, basis, mult, orb_restricted)
return pm.call_module_function(
prog,
MODULE_NAME,
module_template.irc,
# *args
geom,
charge,
mult,
method,
basis,
# **kwargs
mol_options=mol_options,
memory=memory,
comment=comment,
machine_options=machine_options,
orb_restricted=orb_restricted,
scf_options=scf_options,
casscf_options=casscf_options,
corr_options=corr_options,
gen_lines=gen_lines,
job_options=job_options,
frozen_coordinates=frozen_coordinates,
irc_direction=irc_direction)
def program_version(prog, output_string):
""" get the name of the electronic structure code from the output
"""
return pm.call_module_function(prog, MODULE_NAME,
module_template.program_version,
output_string)
