Chimie Théorique » scripts_chimie4psmn » DockOnSurf

args = get_args()

logger = config_log('DockOnSurf')

inp_vars = read_input(args.input)

if inp_vars['refinement']:

    run_refinement(inp_vars)

        logger.warning("'COORD_FILE_NAME' not specified on CP2K input. Using\n"

                       "default name 'coord.xyz'. A new CP2K input file with "

                       "the 'COORD_FILE_NAME' variable is created. If there\n"

        force_eval.SUBSYS.TOPOLOGY.Coord_file_name = 'coord.xyz'

        print(inp_file.split('/')[-1])

        check_bak(inp_file.split('/')[-1])

        subm_jobs.append(qsub(sub_script, name=job_name))

        os.chdir(init_dir)

    while not all([stat == 'f' for stat in get_jobs_status_sge(subm_jobs)]):

        sleep(30)

def sub_lsf(run_type, sub_script, max_qw, name):

    if inp_vars['batch_q_sys']:

        logger.info(f"Running {run_type} calculation with {inp_vars['code']} on"

    else:

    check_bak(run_type)

    os.mkdir(run_type)

    if inp_vars['code'] == 'cp2k':

    if data.shape[0] == data.shape[1] \

            and (np.tril(data).T == np.triu(data)).all():

        labels = get_labels_affty(data)

        if max(labels) == -1:

            logger.warning('Clustering of conformers did not converge. Try '

            exemplars = list(range(data.shape[0]))

        else:

            clusters = get_clusters(labels)

def get_subm_script():

    subm_script = dos_inp.get('Global', 'subm_script', fallback=False)

    if subm_script and not os.path.isfile(subm_script):

        raise FileNotFoundError(f'File {subm_script} not found')

    return subm_script

def get_isol_inp_file():

    isol_inp_file = dos_inp.get('Isolated', 'isol_inp_file')

    if not os.path.isfile(isol_inp_file):

        raise FileNotFoundError(f'File {isol_inp_file} not found')

    return isol_inp_file

def get_molec_file():

    molec_file = dos_inp.get('Isolated', 'molec_file')

    if not os.path.isfile(molec_file):

        raise FileNotFoundError(f'File {molec_file} not found')

    return molec_file

def get_screen_inp_file():

    screen_inp_file = dos_inp.get('Screening', 'screen_inp_file')

    if not os.path.isfile(screen_inp_file):

        raise FileNotFoundError(f'File {screen_inp_file} not found')

    return screen_inp_file

def get_surf_file():

    surf_file = dos_inp.get('Screening', 'surf_file')

    if not os.path.isfile(surf_file):

        raise FileNotFoundError(f'File {surf_file} not found')

    return surf_file

def get_refine_inp_file():  # TODO if not specified try isol_inp_file.

    refine_inp_file = dos_inp.get('Refinement', 'refine_inp_file')

    if not os.path.isfile(refine_inp_file):

        raise FileNotFoundError(f'File {refine_inp_file} not found')

    return refine_inp_file

        dos_inp.read(in_file)

    except MissingSectionHeaderError as e:

        logger.error('There are options in the input file without a Section '

        err = e

    except DuplicateOptionError as e:

        logger.error('There is an option in the input file that has been '

                     'specified more than once, possibly due to the lack of a '

        err = e

    except Exception as e:

        err = e

        if return_vars['min_coll_height'] is not False and \

                return_vars['surf_norm_vect'].tolist() not in cart_axes:

            logger.warning("'min_coll_height' option is only implemented for "

    # Refinement

    if refinement:

    return_vars_str = "\n\t".join([str(key) + ": " + str(value)

                                   for key, value in return_vars.items()])

    logger.info(

    return return_vars

    from ase import Atoms

    if mol.GetNumConformers() > 1:

        logger.warning('A mol object with multiple conformers is parsed, '

    symbols = [atm.GetSymbol() for atm in mol.GetAtoms()]

    positions = mol.GetConformer(0).GetPositions()

    return Atoms(symbols=symbols, positions=positions)

    are required to be local minima, ie. setting the 'local_min' value to 

    True, a geometry optimisation using UFF is performed.

    """

    mol = Chem.AddHs(mol)

    Chem.EmbedMultipleConfs(mol, numConfs=num_confs, numThreads=0)

    Chem.AlignMolConformers(mol)

    return mol

        if mol.GetNumConformers() < init_num_confs:

            logger.warning(f'MMFF Geometry optimization did not comverge for at'

                           f'least one conformer. Continuing with '

        logger.info(f'Pre-optimized conformers with MMFF.')

        return mol, np.array([res[1] for res in results if res[0] == 0])

    else:

    from modules.clustering import clustering, get_rmsd

    from modules.calculation import run_calc

    rd_mol = adapt_format('rdkit', inp_vars['molec_file'])

    confs = gen_confs(rd_mol, inp_vars['num_conformers'])

    if inp_vars['min_confs']:

    if num_sel >= len(conf_list):

        logger.warning('Number of conformers per magnitude is equal or larger '

                       'than the total number of conformers. Using all '

        return conf_list

    # Read properties

                if sorted_list[i].info['idx'] not in selected_ids:

                    selected_ids.append(sorted_list[i].info['idx'])

    return [conf_list[idx] for idx in selected_ids]

        raise ValueError(err)

    conf_list = read_coords(inp_vars['code'], 'isolated', 'ase')

    selected_confs = select_confs(conf_list, inp_vars['select_magns'],

                                  inp_vars['confs_per_magn'],

                                  inp_vars['code'])

                                 inp_vars['min_coll_height'],

                                 inp_vars['collision_threshold'])

    logger.info(f'Generated {len(surf_ads_list)} adsorbate-surface atomic '

    run_calc('screening', inp_vars, surf_ads_list)

    if bak_num > 0:

        os.rename(file_name, new_name)

        logger.warning(f"'{file_name}' already present. Backed it up to "

def try_command(command, expct_error_types: list, *args, **kwargs):

        self.assertEqual(get_molec_file(), 'acetic.xyz')

    def test_cluster_magns(self):

    def test_num_conformers(self):

        self.assertEqual(get_num_conformers(), 100)

        self.assertRaises(FileNotFoundError, get_isol_inp_file)

    def test_cluster_magns(self):

    def test_num_conformers(self):

        self.assertRaises(ValueError, get_num_conformers)