Python custodian.Custodian类代码示例

 def run(self, job_cmd=None):
     """
     run the vasp jobs through custodian
     if the job list is empty,
     run a single job with the initial input set
     """
     for j in self.jobs:
         if job_cmd is not None:            
             j.job_cmd = job_cmd
         else:
             j.job_cmd = self.job_cmd
     c_params = {'jobs': [j.as_dict() for j in self.jobs],
             'handlers': [h.as_dict() for h in self.handlers],
             'max_errors': 5}
     c = Custodian(self.handlers, self.jobs, max_errors=5)
     c.run()
     for j in self.jobs:
         self.cal_log.append({"job": j.as_dict(), 
                              'job_id': j.job_id, 
                              "corrections": [], 
                              'final_energy': None})
         self.job_ids.append(j.job_id)
     if self.checkpoint_file:
         dumpfn(self.cal_log, self.checkpoint_file,
                cls=MontyEncoder, indent=4)
     else:
         dumpfn(self.cal_log, Calibrate.LOG_FILE, cls=MontyEncoder,
                indent=4)

def run_vasp(override=[], suffix=''):
    '''
    execute vasp with given override and suffix

    :param override:
    :param suffix:
    :return:
    '''
    from Classes_Pymatgen import Incar
    from Classes_Custodian import StandardJob
    from custodian.custodian import Custodian
    import os

    # Determine wheter to use Gamma optimized vasp
    incar = Incar.from_file('INCAR')
    if 'AUTO_GAMMA' in incar and incar['AUTO_GAMMA']:
        vasp = os.environ['VASP_GAMMA']
    else:
        vasp = os.environ['VASP_KPTS']

    handlers = []
    vaspjob = [StandardJob(['mpirun', '-np', os.environ['VASP_PROCS'], vasp], 'vasp.log', auto_npar=False, backup=False,
                           settings_override=override, suffix=suffix, final=False)]
    c = Custodian(handlers, vaspjob, max_errors=10)
    c.run()

 def run(self, fw_spec):
     # class VaspJob(Job):
     #     """
     #     A basic vasp job. Just runs whatever is in the directory. But conceivably
     #     can be a complex processing of inputs etc. with initialization.
     #     """
     #
     #     def __init__(self, vasp_cmd, output_file="vasp.out", stderr_file="std_err.txt",
     #                  suffix="", final=True, backup=True, auto_npar=True,
     #                  auto_gamma=True, settings_override=None,
     #                  gamma_vasp_cmd=None, copy_magmom=False, auto_continue=False):
     try:
         vasp_cmd = os.environ['VASP_CMD'].split()
     except:
         raise ValueError('Unable to find vasp command')
     if 'custodian_jobs' in fw_spec:
         jobs = fw_spec['custodian_jobs']
     else:
         jobs = [VaspJob(vasp_cmd=vasp_cmd, auto_npar=False,
                         output_file=os.path.join(self.run_dir, 'vasp.out'),
                         stderr_file=os.path.join(self.run_dir, 'std_err.txt'),
                         backup=False,
                         auto_gamma=False)]
     custodian = Custodian(handlers=self.custodian_handlers, jobs=jobs,
                           validators=None, max_errors=10,
                           polling_time_step=10, monitor_freq=30)
     custodian.run()

def do_run(args):
    handlers = [VaspErrorHandler(), MeshSymmetryErrorHandler(),
                UnconvergedErrorHandler(), NonConvergingErrorHandler(),
                PotimErrorHandler()]
    c = Custodian(handlers, get_runs(args), max_errors=10, gzipped_output=args.gzip)
    c.run()
    logging.info("Geometry optimization complete")

    def run_task(self, fw_spec):
        # write a file containing the formula and task_type for somewhat easier file system browsing
        self._write_formula_file(fw_spec)

        # TODO: make this better - is there a way to load an environment variable as the VASP_EXE?
        if 'nid' in socket.gethostname():  # hopper compute nodes
            v_exe = shlex.split('aprun -n 48 vasp')  # TODO: make ncores dynamic!
        elif 'c' in socket.gethostname():  # carver / mendel compute nodes
            v_exe = shlex.split('mpirun -n 32 vasp')  # TODO: make ncores dynamic!
        else:
            raise ValueError('Unrecognized host!')

        for job in self.jobs:
            job.vasp_command = v_exe

        c = Custodian(self.handlers, self.jobs, self.max_errors)
        custodian_out = c.run()

        all_errors = set()
        for run in custodian_out:
            for correction in run['corrections']:
                all_errors.update(correction['errors'])

        stored_data = {'error_list': list(all_errors)}
        update_spec = {'prev_vasp_dir': os.getcwd(), 'prev_task_type': fw_spec['task_type']}

        update_spec.update({'mpsnl': fw_spec['mpsnl'], 'snlgroup_id': fw_spec['snlgroup_id']})

        return FWAction(stored_data=stored_data, update_spec=update_spec)

def do_run(args):
    handlers = [VaspErrorHandler(), UnconvergedErrorHandler()]
    c = Custodian(handlers, get_runs(vasp_command=args.command.split(),
                                     target=args.target, mode=args.mode,
                                     max_steps=args.max_steps),
                  max_errors=10)
    c.run()

 def test_run(self):
     njobs = 100
     params = {"initial": 0, "total": 0}
     c = Custodian([ExampleHandler(params)],
                   [ExampleJob(i, params) for i in xrange(njobs)],
                   max_errors=njobs, log_file=None)
     output = c.run()
     self.assertEqual(len(output), njobs)

 def _test_simplejob(self):
     os.chdir(self.path)
     njobs = 100
     params = {"initial": 0, "total": 0}
     c = Custodian([ExampleHandler(params), ExampleHandler2(params)],
                   [ExampleJob(i, params) for i in range(njobs)],
                   max_errors=njobs*2)
     c.run()

 def test_max_errors_per_handler_warning(self):
     njobs = 100
     params = {"initial": 0, "total": 0}
     c = Custodian([ExampleHandler1c(params)],
                   [ExampleJob(i, params) for i in range(njobs)],
                   max_errors=njobs*10, max_errors_per_job=1000)
     c.run()
     self.assertTrue(all(len(r["corrections"]) <= 2 for r in c.run_log))

    def run_task(self, fw_spec):

        # write a file containing the formula and task_type for somewhat
        # easier file system browsing
        self._write_formula_file(fw_spec)

        fw_env = fw_spec.get("_fw_env", {})

        if "mpi_cmd" in fw_env:
            mpi_cmd = fw_spec["_fw_env"]["mpi_cmd"]
        elif which("mpirun"):
            mpi_cmd = "mpirun"
        elif which("aprun"):
            mpi_cmd = "aprun"
        else:
            raise ValueError("No MPI command found!")

        nproc = os.environ['PBS_NP']

        v_exe = shlex.split('{} -n {} {}'.format(mpi_cmd, nproc, fw_env.get("vasp_cmd", "vasp")))
        gv_exe = shlex.split('{} -n {} {}'.format(mpi_cmd, nproc, fw_env.get("gvasp_cmd", "gvasp")))

        print 'host:', os.environ['HOSTNAME']

        for job in self.jobs:
            job.vasp_cmd = v_exe
            job.gamma_vasp_cmd = gv_exe

        incar_errors = check_incar(fw_spec['task_type'])
        if incar_errors:
            raise ValueError("Critical error: INCAR does not pass checks: {}".format(incar_errors))

        logging.basicConfig(level=logging.DEBUG)
        c = Custodian(self.handlers, self.jobs, max_errors=self.max_errors, gzipped_output=False, validators=[VasprunXMLValidator()])  # manual gzip
        custodian_out = c.run()

        if self.gzip_output:
            for f in os.listdir(os.getcwd()):
                if not f.lower().endswith("gz") and not f.endswith(".OU") and not f.endswith(".ER"):
                    with open(f, 'rb') as f_in, \
                            GzipFile('{}.gz'.format(f), 'wb') as f_out:
                        f_out.writelines(f_in)
                    os.remove(f)

        all_errors = set()
        for run in custodian_out:
            for correction in run['corrections']:
                all_errors.update(correction['errors'])

        stored_data = {'error_list': list(all_errors)}
        update_spec = {'prev_vasp_dir': os.getcwd(),
                       'prev_task_type': fw_spec['task_type'],
                       'mpsnl': fw_spec['mpsnl'],
                       'snlgroup_id': fw_spec['snlgroup_id'],
                       'run_tags': fw_spec['run_tags'],
                       'parameters': fw_spec.get('parameters')}

        return FWAction(stored_data=stored_data, update_spec=update_spec)

 def test_run(self):
     njobs = 100
     params = {"initial": 0, "total": 0}
     c = Custodian([ExampleHandler(params)],
                   [ExampleJob(i, params) for i in range(njobs)],
                   max_errors=njobs)
     output = c.run()
     self.assertEqual(len(output), njobs)
     print(ExampleHandler(params).as_dict())

 def test_checkpoint_loading(self):
     njobs = 5
     params = {"initial": 0, "total": 0}
     c = Custodian([ExampleHandler(params)],
                   [ExampleJob(i, params) for i in range(njobs)],
                   [ExampleValidator1()],
                   max_errors=100, checkpoint=True)
     self.assertEqual(len(c.run_log), 3)
     self.assertEqual(len(c.run()), 5)

 def test_unrecoverable(self):
     njobs = 100
     params = {"initial": 0, "total": 0}
     c = Custodian([ExampleHandler2(params)],
                   [ExampleJob(i, params) for i in xrange(njobs)],
                   max_errors=njobs, log_file=None)
     output = c.run()
     #Because this is unrecoverable, there should only be one output.
     self.assertEqual(len(output), 1)

def do_run(args):
    logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO,
                        filename="run.log")
    job = NwchemJob(nwchem_cmd=args.command.split(),
                    input_file=args.infile,
                    output_file=args.outfile)
    c = Custodian([NwchemErrorHandler(output_filename=args.outfile)], [job],
                  max_errors=5, scratch_dir=args.scratch,
                  gzipped_output=args.gzipped, checkpoint=True)
    c.run()

def do_run(args):
    FORMAT = '%(asctime)s %(message)s'
    logging.basicConfig(format=FORMAT, level=logging.INFO, filename="run.log")
    logging.info("Handlers used are %s" % args.handlers)
    handlers = [load_class("custodian.vasp.handlers", n) for n in
                args.handlers]
    validators = [load_class("custodian.vasp.validators", n) for n in
                  args.validators]

    c = Custodian(handlers, get_jobs(args), validators,
                  max_errors=args.max_errors, scratch_dir=args.scratch,
                  gzipped_output=args.gzip,
                  checkpoint=True)
    c.run()