def __init__(self,
model,
leap_template=F_leap_in,
leaprc=None,
leap_out=None,
leap_in=None,
leap_pdb=None,
log=None,
debug=0,
verbose=0,
**kw):
"""
@param model: model
@type model: PDBModel or str
@param leap_template: path to template file for leap input
@type leap_template: str
@param leaprc: forcefield parameter file or code (e.g. ff99)
@type leaprc: str
@param leap_out: target file for leap.log (default: discard)
@type leap_out: str
@param leap_in: target file for leap.in script (default: discard)
@type leap_in: str
@param kw: kw=value pairs for additional options in the leap_template
@type kw: key=value
"""
self.m = PDBModel(model)
self.leap_template = leap_template
self.leaprc = leaprc
self.leap_pdb = leap_pdb or tempfile.mktemp('_leap_pdb')
self.keep_leap_pdb = leap_pdb is not None
self.leap_in = leap_in
self.leap_out = leap_out
self.log = log or StdLog()
self.output = None # last output of leap
self.debug = debug
self.verbose = verbose
self.__dict__.update(kw)
def __init__(self,
name,
args='',
template=None,
f_in=None,
f_out=None,
f_err=None,
strict=1,
catch_out=1,
push_inp=1,
catch_err=0,
node=None,
nice=0,
cwd=None,
tempdir=None,
log=None,
debug=0,
verbose=None,
validate=1,
**kw):
"""
Create Executor. *name* must point to an existing program configuration
unless *strict*=0. Executor will create a program input from
the template and its own fields and put it into f_in. If f_in but
no template is given, the unchanged f_in is used as input. If neither
is given, the program is called without input. If a node is given,
the process is wrapped in a ssh call. If *nice* != 0, the process
is preceeded by nice. *cwd* specifies the working directory. By
default, this setting is taken from the configuration file which
defaults to the current working directory.
@param name: program name (configured in .biskit/exe_name.dat)
@type name: str
@param args: command line arguments
@type args: str
@param template: template for input file -- this can be the template
itself or the path to a file containing it
(default: None)
@type template: str
@param f_in: target for completed input file (default: None, discard)
@type f_in: str
@param f_out: target file for program output (default: None, discard)
@type f_out: str
@param f_err: target file for error messages (default: None, discard)
@type f_err: str
@param strict: strict check of environment and configuration file
(default: 1)
@type strict: 1|0
@param catch_out: catch output in file (f_out or temporary)
(default: 1)
@type catch_out: 1|0
@param catch_err: catch errors in file (f_out or temporary)
(default: 1)
@type catch_err: 1|0
@param push_inp: push input file to process via stdin ('< f_in') [1]
@type push_inp: 1|0
@param node: host for calculation (None->no ssh) (default: None)
@type node: str
@param nice: nice level (default: 0)
@type nice: int
@param cwd: working directory, overwrites ExeConfig.cwd (default: None)
@type cwd: str
@param tempdir: folder for temporary files, will be created if not
existing (default: None ... use system default)
if set to True: create a new tempdir within default
@type tempdir: str | True
@param log: execution log (None->STOUT) (default: None)
@type log: Biskit.LogFile
@param debug: keep all temporary files (default: 0)
@type debug: 0|1
@param verbose: print progress messages to log (default: log != STDOUT)
@type verbose: 0|1
@param validate: validate binary and environment immedeatly (1=default)
or only before execution (0)
@type validate: 1|0
@param kw: key=value pairs with values for template file or string
@type kw: key=value
@raise ExeConfigError: if environment is not fit for running
the program
"""
self.exe = ExeConfigCache.get(name, strict=strict)
if validate:
self.exe.validate()
## see prepare()
self.keep_tempdir = True ## set to False if tempdir created new
self.tempdir = self.newtempfolder(tempdir) ## repeat in child classes
self.f_out = t.absfile(f_out)
if not f_out and catch_out:
self.f_out = tempfile.mktemp('.out', name + '_', self.tempdir)
self.f_err = t.absfile(f_err)
if not f_err and catch_err:
self.f_err = tempfile.mktemp('.err', name + '_', self.tempdir)
self.keep_out = f_out is not None
self.keep_inp = f_in is not None #: do not clean up the input file
self.catch_out = catch_out #: capture STDOUT into file
self.catch_err = catch_err #: capture STDERR into file
self.f_in = t.absfile(f_in)
## pre-define name of input file that will be generated later
if template and not f_in:
self.f_in = tempfile.mktemp('.inp', name + '_', self.tempdir)
self.push_inp = push_inp
self.args = args
self.template = template
self.node = node ## or os.uname()[1]
self.nice = nice
self.debug = debug
self.cwd = cwd or self.exe.cwd
#: Log object for own messages; undocumented: capture string as well
self.log = log or StdLog()
if type(self.log) is str:
self.log = B.LogFile(self.log)
self.verbose = verbose
if self.verbose is None:
self.verbose = (log is not None)
## these are set by self.run():
self.runTime = 0 #: time needed for last run
self.output = None #: STDOUT returned by process
self.error = None #: STDERR returned by process
self.returncode = None #: int status returned by process
self.pid = None #: process ID
self.result = None #: set by self.finish()
self.initVersion = self.version()
self.__dict__.update(kw)