Example #1
0
    def from_file(cls, fname, spacing=0.2, extension=5.0, rotate=True):
        """
        Initialize ``UniformGrid`` class based on the grid specifications of a file.

        Parameters
        ----------
        fname : str
            Path to molecule's file.
        spacing : float, optional
            Increment between grid points along `x`, `y` and `z` direction.
        extension : float, optional
            The extension of the cube on each side of the molecule.
        rotate : bool, optional
            When True, the molecule is rotated so the axes of the cube file are
            aligned with the principle axes of rotation of the molecule.
        """
        # Load file
        logging.basicConfig(level=logging.INFO,
                            format='%(levelname)s: %(message)s')
        try:
            mol = IOData.from_file(str(fname))
        except IOError as _:
            try:
                with path('chemtools.data.examples', str(fname)) as fname:
                    logging.info('Loading {0}'.format(str(fname)))
                    mol = IOData.from_file(str(fname))
            except IOError as error:
                logging.info(error)
        return cls.from_molecule(mol, spacing, extension, rotate)
Example #2
0
def main():
    args = parse_args()

    fn_h5, grp_name = parse_h5(args.output, 'output')
    # check if the group is already present (and not empty) in the output file
    if check_output(fn_h5, grp_name, args.overwrite):
        return

    # Load the cost function from the HDF5 file
    cost, used_volume = load_cost(args.cost)

    # Find the optimal charges
    results = {}
    results['x'] = cost.solve(args.qtot, args.ridge)
    results['charges'] = results['x'][:cost.natom]

    # Related properties
    results['cost'] = cost.value(results['x'])
    if results['cost'] < 0:
        results['rmsd'] = 0.0
    else:
        results['rmsd'] = (results['cost'] / used_volume)**0.5

    # Worst case stuff
    results['cost_worst'] = cost.worst(0.0)
    if results['cost_worst'] < 0:
        results['rmsd_worst'] = 0.0
    else:
        results['rmsd_worst'] = (results['cost_worst'] / used_volume)**0.5

    # Write some things on screen
    if log.do_medium:
        log('Important parameters:')
        log.hline()
        log('RMSD charges:                  %10.5e' % np.sqrt(
            (results['charges']**2).mean()))
        log('RMSD ESP:                      %10.5e' % results['rmsd'])
        log('Worst RMSD ESP:                %10.5e' % results['rmsd_worst'])
        log.hline()

    # Perform a symmetry analysis if requested
    if args.symmetry is not None:
        mol_pot = IOData.from_file(args.symmetry[0])
        mol_sym = IOData.from_file(args.symmetry[1])
        if not hasattr(mol_sym, 'symmetry'):
            raise ValueError('No symmetry information found in %s.' %
                             args.symmetry[1])
        aim_results = {'charges': results['charges']}
        sym_results = symmetry_analysis(mol_pot.coordinates, mol_pot.cell,
                                        mol_sym.symmetry, aim_results)
        results['symmetry'] = sym_results

    # Store the results in an HDF5 file
    write_script_output(fn_h5, grp_name, results, args)
Example #3
0
def main():
    args = parse_args()

    fn_h5, grp_name = parse_h5(args.output, 'output')
    # check if the group is already present (and not empty) in the output file
    if check_output(fn_h5, grp_name, args.overwrite):
        return

    # Load the cost function from the HDF5 file
    cost, used_volume = load_cost(args.cost)

    # Find the optimal charges
    results = {}
    results['x'] = cost.solve(args.qtot, args.ridge)
    results['charges'] = results['x'][:cost.natom]

    # Related properties
    results['cost'] = cost.value(results['x'])
    if results['cost'] < 0:
        results['rmsd'] = 0.0
    else:
        results['rmsd'] = (results['cost']/used_volume)**0.5

    # Worst case stuff
    results['cost_worst'] = cost.worst(0.0)
    if results['cost_worst'] < 0:
        results['rmsd_worst'] = 0.0
    else:
        results['rmsd_worst'] = (results['cost_worst']/used_volume)**0.5

    # Write some things on screen
    if log.do_medium:
        log('Important parameters:')
        log.hline()
        log('RMSD charges:                  %10.5e' % np.sqrt((results['charges']**2).mean()))
        log('RMSD ESP:                      %10.5e' % results['rmsd'])
        log('Worst RMSD ESP:                %10.5e' % results['rmsd_worst'])
        log.hline()

    # Perform a symmetry analysis if requested
    if args.symmetry is not None:
        mol_pot = IOData.from_file(args.symmetry[0])
        mol_sym = IOData.from_file(args.symmetry[1])
        if not hasattr(mol_sym, 'symmetry'):
            raise ValueError('No symmetry information found in %s.' % args.symmetry[1])
        aim_results = {'charges': results['charges']}
        sym_results = symmetry_analysis(mol_pot.coordinates, mol_pot.cell, mol_sym.symmetry, aim_results)
        results['symmetry'] = sym_results

    # Store the results in an HDF5 file
    write_script_output(fn_h5, grp_name, results, args)
Example #4
0
def main():
    args = parse_args()
    margin = args.margin*angstrom
    spacing = args.spacing*angstrom

    mol = IOData.from_file(args.structure)
    # compute the shape tensor
    shape = np.dot(mol.coordinates.transpose(), mol.coordinates)
    # diagonalize to obtain the x, y and z directions.
    evals, evecs = np.linalg.eigh(shape)
    axes = evecs.transpose()*spacing

    # compute the origin and the number of repetitions along each axis.
    nrep = np.zeros(3, int)
    origin = np.zeros(3, float)
    for i in xrange(3):
        projc = np.dot(mol.coordinates, evecs[:,i])
        nrep[i] = np.ceil((projc.max() - projc.min() + 2*margin)/spacing)+1
        origin += 0.5*(projc.max() + projc.min() - (nrep[i]-1)*spacing)*evecs[:,i]

    with open(args.output, 'w') as f:
        # the header is written in Bohr, hence the -nrep[0]
        print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (0, origin[0], origin[1], origin[2])
        print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (-nrep[0], axes[0,0], axes[0,1], axes[0,2])
        print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (nrep[1], axes[1,0], axes[1,1], axes[1,2])
        print >> f, '% 5i % 15.10f % 15.10f % 15.10f' % (nrep[2], axes[2,0], axes[2,1], axes[2,2])
Example #5
0
    def load_atom(self, dn_mult, ext):
        fn = "%s/atom.%s" % (dn_mult, ext)
        if not os.path.isfile(fn):
            return None, None

        try:
            mol = IOData.from_file(fn)
        except:
            return None, None
        mol.energy = self._get_energy(mol, dn_mult)
        return mol, mol.energy
Example #6
0
    def load_atom(self, dn_mult, ext):
        fn = '%s/atom.%s' % (dn_mult, ext)
        if not os.path.isfile(fn):
            return None, None

        try:
            mol = IOData.from_file(fn)
        except:
            return None, None
        mol.energy = self._get_energy(mol, dn_mult)
        return mol, mol.energy
Example #7
0
def write_random_lta_cube(dn, fn_cube):
    '''Write a randomized cube file'''
    # start from an existing cube file
    mol = IOData.from_file(context.get_fn('test/lta_gulp.cif'))
    # Define a uniform grid with only 1000 points, to make the tests fast.
    ugrid = UniformGrid(np.zeros(3, float), mol.cell.rvecs*0.1, np.array([10, 10, 10]), np.array([1, 1, 1]))
    # Write to the file dn/fn_cube
    mol.cube_data = np.random.uniform(0, 1, ugrid.shape)
    mol.grid = ugrid
    mol.to_file(os.path.join(dn, fn_cube))
    return mol
Example #8
0
    def from_file(cls, fname):
        """Initialize class given a file.

        Parameters
        ----------
        fname : str
            Path to molecule"s files.

        """
        # load molecule
        logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
        try:
            iodata = IOData.from_file(str(fname))
        except IOError as _:
            try:
                with path("chemtools.data.examples", str(fname)) as fname:
                    logging.info("Loading {0}".format(str(fname)))
                    iodata = IOData.from_file(str(fname))
            except IOError as error:
                logging.info(error)
        return cls(iodata)
Example #9
0
    def from_file(cls, fname, wavefunction=False):
        """Initialize class given a file.

        Parameters
        ----------
        fname : str
            Path to molecule's files.

        """
        # load molecule
        logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
        try:
            iodata = IOData.from_file(str(fname))
        except IOError as _:
            try:
                with path('chemtools.data.examples', str(fname)) as fname:
                    logging.info('Loading {0}'.format(str(fname)))
                    iodata = IOData.from_file(str(fname))
            except IOError as error:
                logging.info(error)
        return cls(iodata, wavefunction)
Example #10
0
def write_random_lta_cube(dn, fn_cube):
    '''Write a randomized cube file'''
    # start from an existing cube file
    mol = IOData.from_file(context.get_fn('test/lta_gulp.cif'))
    # Define a uniform grid with only 1000 points, to make the tests fast.
    ugrid = UniformGrid(np.zeros(3, float), mol.cell.rvecs * 0.1,
                        np.array([10, 10, 10]), np.array([1, 1, 1]))
    # Write to the file dn/fn_cube
    mol.cube_data = np.random.uniform(0, 1, ugrid.shape)
    mol.grid = ugrid
    mol.to_file(os.path.join(dn, fn_cube))
    return mol
Example #11
0
def load_rho(coordinates, numbers, fn_cube, ref_ugrid, stride, chop):
    '''Load densities from a file, reduce by stride, chop and check ugrid

       **Arguments:**

       coordinates
            An array with shape (N, 3) containing atomic coordinates.

       numbers
            A vector with shape (N,) containing atomic numbers.

       fn_cube
            The cube file with the electron density.

       ref_ugrid
            A reference ugrid that must match the one from the density cube
            file (after reduction).

       stride
            The reduction factor.

       chop
            The number of slices to chop of the grid in each direction.
    '''
    if fn_cube is None:
        # Load the built-in database of proatoms
        natom = len(numbers)
        numbers = np.unique(numbers)
        proatomdb = ProAtomDB.from_refatoms(numbers,
                                            max_kation=0,
                                            max_anion=0,
                                            agspec='fine')
        # Construct the pro-density
        rho = np.zeros(ref_ugrid.shape)
        for i in xrange(natom):
            spline = proatomdb.get_spline(numbers[i])
            ref_ugrid.eval_spline(spline, coordinates[i], rho)
    else:
        # Load cube
        mol_rho = IOData.from_file(fn_cube)
        rho = mol_rho.cube_data
        ugrid = mol_rho.grid
        # Reduce grid size
        if stride > 1:
            rho, ugrid = reduce_data(rho, ugrid, stride, chop)
        # Compare with ref_ugrid (only shape)
        if (ugrid.shape != ref_ugrid.shape).any():
            raise ValueError(
                'The densities file does not contain the same amount if information as the potential file.'
            )
    return rho
Example #12
0
def main():
    args = parse_args()

    fn_h5, grp_name = parse_h5(args.output, 'output')
    # check if the group is already present (and not empty) in the output file
    if check_output(fn_h5, grp_name, args.overwrite):
        return

    # Load the system
    mol = IOData.from_file(args.wfn)

    # Define a list of optional arguments for the WPartClass:
    WPartClass = wpart_schemes[args.scheme]
    kwargs = dict((key, val) for key, val in vars(args).iteritems()
                  if key in WPartClass.options)

    # Load the proatomdb
    if args.atoms is not None:
        proatomdb = ProAtomDB.from_file(args.atoms)
        proatomdb.normalize()
        kwargs['proatomdb'] = proatomdb
    else:
        proatomdb = None

    # Run the partitioning
    agspec = AtomicGridSpec(args.grid)
    grid = BeckeMolGrid(mol.coordinates,
                        mol.numbers,
                        mol.pseudo_numbers,
                        agspec,
                        mode='only')
    dm_full = mol.get_dm_full()
    moldens = mol.obasis.compute_grid_density_dm(dm_full,
                                                 grid.points,
                                                 epsilon=args.epsilon)
    dm_spin = mol.get_dm_spin()
    if dm_spin is not None:
        kwargs['spindens'] = mol.obasis.compute_grid_density_dm(
            dm_spin, grid.points, epsilon=args.epsilon)
    wpart = wpart_schemes[args.scheme](mol.coordinates, mol.numbers,
                                       mol.pseudo_numbers, grid, moldens,
                                       **kwargs)
    keys = wpart.do_all()

    if args.slow:
        # ugly hack for the slow analysis involving the AIM overlap operators.
        wpart_slow_analysis(wpart, mol)
        keys = list(wpart.cache.iterkeys(tags='o'))

    write_part_output(fn_h5, grp_name, wpart, keys, args)
Example #13
0
def load_rho(coordinates, numbers, fn_cube, ref_ugrid, stride, chop):
    '''Load densities from a file, reduce by stride, chop and check ugrid

       **Arguments:**

       coordinates
            An array with shape (N, 3) containing atomic coordinates.

       numbers
            A vector with shape (N,) containing atomic numbers.

       fn_cube
            The cube file with the electron density.

       ref_ugrid
            A reference ugrid that must match the one from the density cube
            file (after reduction).

       stride
            The reduction factor.

       chop
            The number of slices to chop of the grid in each direction.
    '''
    if fn_cube is None:
        # Load the built-in database of proatoms
        natom = len(numbers)
        numbers = np.unique(numbers)
        proatomdb = ProAtomDB.from_refatoms(numbers, max_kation=0, max_anion=0, agspec='fine')
        # Construct the pro-density
        rho = np.zeros(ref_ugrid.shape)
        for i in xrange(natom):
            spline = proatomdb.get_spline(numbers[i])
            ref_ugrid.eval_spline(spline, coordinates[i], rho)
    else:
        # Load cube
        mol_rho = IOData.from_file(fn_cube)
        rho = mol_rho.cube_data
        ugrid = mol_rho.grid
        # Reduce grid size
        if stride > 1:
            rho, ugrid = reduce_data(rho, ugrid, stride, chop)
        # Compare with ref_ugrid (only shape)
        if (ugrid.shape != ref_ugrid.shape).any():
            raise ValueError('The densities file does not contain the same amount if information as the potential file.')
    return rho
Example #14
0
def main():
    args = parse_args()

    fn_h5, grp_name = parse_h5(args.output, 'output')
    # check if the group is already present (and not empty) in the output file
    if check_output(fn_h5, grp_name, args.overwrite):
        return

    # Load the system
    mol = IOData.from_file(args.wfn)

    # Define a list of optional arguments for the WPartClass:
    WPartClass = wpart_schemes[args.scheme]
    kwargs = dict((key, val) for key, val in vars(args).iteritems() if key in WPartClass.options)

    # Load the proatomdb
    if args.atoms is not None:
        proatomdb = ProAtomDB.from_file(args.atoms)
        proatomdb.normalize()
        kwargs['proatomdb'] = proatomdb
    else:
        proatomdb = None

    # Run the partitioning
    agspec = AtomicGridSpec(args.grid)
    grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, agspec, mode='only')
    dm_full = mol.get_dm_full()
    moldens = mol.obasis.compute_grid_density_dm(dm_full, grid.points, epsilon=args.epsilon)
    dm_spin = mol.get_dm_spin()
    if dm_spin is not None:
        kwargs['spindens'] = mol.obasis.compute_grid_density_dm(dm_spin, grid.points, epsilon=args.epsilon)
    wpart = wpart_schemes[args.scheme](mol.coordinates, mol.numbers, mol.pseudo_numbers,grid, moldens, **kwargs)
    keys = wpart.do_all()

    if args.slow:
        # ugly hack for the slow analysis involving the AIM overlap operators.
        wpart_slow_analysis(wpart, mol)
        keys = list(wpart.cache.iterkeys(tags='o'))

    write_part_output(fn_h5, grp_name, wpart, keys, args)
Example #15
0
def main():
    args = parse_args()

    fn_h5, grp_name = parse_h5(args.output, 'output')
    # check if the group is already present (and not empty) in the output file
    if check_output(fn_h5, grp_name, args.overwrite):
        return

    # Load the IOData
    mol = IOData.from_file(args.cube)
    ugrid = mol.grid
    if not isinstance(ugrid, UniformGrid):
        raise TypeError('The density cube file does not contain data on a rectangular grid.')
    ugrid.pbc[:] = parse_pbc(args.pbc)
    moldens = mol.cube_data

    # Reduce the grid if required
    if args.stride > 1 or args.chop > 0:
        moldens, ugrid = reduce_data(moldens, ugrid, args.stride, args.chop)

    # Load the spin density (optional)
    if args.spindens is not None:
        molspin = IOData.from_file(args.spindens)
        if not isinstance(molspin.grid, UniformGrid):
            raise TypeError('The spin cube file does not contain data on a rectangular grid.')
        spindens = molspin.cube_data
        if args.stride > 1 or args.chop > 0:
            spindens = reduce_data(spindens, molspin.grid, args.stride, args.chop)[0]
        if spindens.shape != moldens.shape:
            raise TypeError('The shape of the spin cube does not match the shape of the density cube.')
    else:
        spindens = None

    # Load the proatomdb and make pro-atoms more compact if that is requested
    proatomdb = ProAtomDB.from_file(args.atoms)
    if args.compact is not None:
        proatomdb.compact(args.compact)
    proatomdb.normalize()

    # Select the partitioning scheme
    CPartClass = cpart_schemes[args.scheme]

    # List of element numbers for which weight corrections are needed:
    if args.wcor == '0':
        wcor_numbers = []
    else:
        wcor_numbers = list(iter_elements(args.wcor))

    # Run the partitioning
    kwargs = dict((key, val) for key, val in vars(args).iteritems() if key in CPartClass.options)
    cpart = cpart_schemes[args.scheme](
        mol.coordinates, mol.numbers, mol.pseudo_numbers, ugrid, moldens,
        proatomdb, spindens=spindens, local=True, wcor_numbers=wcor_numbers,
        wcor_rcut_max=args.wcor_rcut_max, wcor_rcond=args.wcor_rcond, **kwargs)
    keys = cpart.do_all()

    # Do a symmetry analysis if requested.
    if args.symmetry is not None:
        mol_sym = IOData.from_file(args.symmetry)
        if not hasattr(mol_sym, 'symmetry'):
            raise ValueError('No symmetry information found in %s.' % args.symmetry)
        aim_results = dict((key, cpart[key]) for key in keys)
        sym_results = symmetry_analysis(mol.coordinates, ugrid.get_cell(), mol_sym.symmetry, aim_results)
        cpart.cache.dump('symmetry', sym_results)
        keys.append('symmetry')

    write_part_output(fn_h5, grp_name, cpart, keys, args)
Example #16
0
def load_ugrid_coordinates(arg_grid):
    mol = IOData.from_file(arg_grid)
    return mol.grid, mol.coordinates
Example #17
0
import numpy as np
import sympy as sp

from horton import (context, IOData, get_gobasis, CholeskyLinalgFactory,
                    guess_core_hamiltonian, compute_nucnuc, RTwoIndexTerm,
                    RDirectTerm, RExchangeTerm, REffHam, AufbauOccModel)

from polar.data_generate import model_finitefield_ham

# Hartree-Fock calculation
# ------------------------

# Load the coordinates from file.
# Use the XYZ file from HORTON's test data directory.
fn_xyz = context.get_fn('test/water.xyz')
mol = IOData.from_file(fn_xyz)
# Create a Gaussian basis set
obasis = get_gobasis(mol.coordinates, mol.numbers, 'sto-3g')
lf = CholeskyLinalgFactory(obasis.nbasis)
# Create a linalg factory
# Compute Gaussian integrals
olp = obasis.compute_overlap(lf)
kin = obasis.compute_kinetic(lf)
na = obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, lf)
er = obasis.compute_electron_repulsion(lf)

# Create alpha orbitals
orb = lf.create_expansion()

# Initial guess
guess_core_hamiltonian(olp, kin, na, orb)
Example #18
0
 def read(self, path):
     mol = IOData.from_file(path)
     end = self.begin + mol.natom
     result = [[self.begin, end], mol.numbers, mol.coordinates]
     self.begin = end
     return result
Example #19
0
def main():
    args = parse_args()

    fn_h5, grp_name = parse_h5(args.output, 'output')
    # check if the group is already present (and not empty) in the output file
    if check_output(fn_h5, grp_name, args.overwrite):
        return

    # Load the potential data
    if log.do_medium:
        log('Loading potential array')
    mol_pot = IOData.from_file(args.cube)
    if not isinstance(mol_pot.grid, UniformGrid):
        raise TypeError('The specified file does not contain data on a rectangular grid.')
    mol_pot.grid.pbc[:] = parse_pbc(args.pbc) # correct pbc
    esp = mol_pot.cube_data

    # Reduce the grid if required
    if args.stride > 1:
        esp, mol_pot.grid = reduce_data(esp, mol_pot.grid, args.stride, args.chop)

    # Fix sign
    if args.sign:
        esp *= -1

    # Some screen info
    if log.do_medium:
        log('Important parameters:')
        log.hline()
        log('Number of grid points:   %12i' % np.product(mol_pot.grid.shape))
        log('Grid shape:                 [%8i, %8i, %8i]' % tuple(mol_pot.grid.shape))
        log('PBC:                        [%8i, %8i, %8i]' % tuple(mol_pot.grid.pbc))
        log.hline()

    # Construct the weights for the ESP Cost function.
    wdens = parse_wdens(args.wdens)
    if wdens is not None:
        if log.do_medium:
            log('Loading density array')
        # either the provided density or a built-in prodensity
        rho = load_rho(mol_pot.coordinates, mol_pot.numbers, wdens[0], mol_pot.grid, args.stride, args.chop)
        wdens = (rho,) + wdens[1:]
    if log.do_medium:
        log('Constructing weight function')
    weights = setup_weights(mol_pot.coordinates, mol_pot.numbers, mol_pot.grid,
        dens=wdens,
        near=parse_wnear(args.wnear),
        far=parse_wnear(args.wfar),
    )

    # write the weights to a cube file if requested
    if args.wsave is not None:
        if log.do_medium:
            log('   Saving weights array   ')
        # construct a new data dictionary that contains all info for the cube file
        mol_weights = mol_pot.copy()
        mol_weights.cube_data = weights
        mol_weights.to_file(args.wsave)

    # rescale weights such that the cost function is the mean-square-error
    if weights.max() == 0.0:
        raise ValueError('No points with a non-zero weight were found')
    wmax = weights.min()
    wmin = weights.max()
    used_volume = mol_pot.grid.integrate(weights)

    # Some screen info
    if log.do_medium:
        log('Important parameters:')
        log.hline()
        log('Used number of grid points:   %12i' % (weights>0).sum())
        log('Used volume:                      %12.5f' % used_volume)
        log('Used volume/atom:                 %12.5f' % (used_volume/mol_pot.natom))
        log('Lowest weight:                %12.5e' % wmin)
        log('Highest weight:               %12.5e' % wmax)
        log('Max weight at edge:           %12.5f' % max_at_edge(weights, mol_pot.grid.pbc))

    # Ewald parameters
    rcut, alpha, gcut = parse_ewald_args(args)

    # Some screen info
    if log.do_medium:
        log('Ewald real cutoff:       %12.5e' % rcut)
        log('Ewald alpha:             %12.5e' % alpha)
        log('Ewald reciprocal cutoff: %12.5e' % gcut)
        log.hline()

    # Construct the cost function
    if log.do_medium:
        log('Setting up cost function (may take a while)   ')
    cost = ESPCost.from_grid_data(mol_pot.coordinates, mol_pot.grid, esp, weights, rcut, alpha, gcut)

    # Store cost function info
    results = {}
    results['cost'] = cost
    results['used_volume'] = used_volume

    # Store cost function properties
    results['evals'] = np.linalg.eigvalsh(cost._A)
    abs_evals = abs(results['evals'])
    if abs_evals.min() == 0.0:
        results['cn'] = 0.0
    else:
        results['cn'] = abs_evals.max()/abs_evals.min()

    # Report some on-screen info
    if log.do_medium:
        log('Important parameters:')
        log.hline()
        log('Lowest abs eigen value:       %12.5e' % abs_evals.min())
        log('Highest abs eigen value:      %12.5e' % abs_evals.max())
        log('Condition number:             %12.5e' % results['cn'])
        log.hline()

    # Store the results in an HDF5 file
    write_script_output(fn_h5, grp_name, results, args)
Example #20
0
 def read(self, path):
     mol = IOData.from_file(path)
     end = self.begin + mol.natom
     result = [[self.begin, end], mol.numbers, mol.coordinates]
     self.begin = end
     return result
Example #21
0
def main():
    args = parse_args()
    mol = IOData.from_file(args.input)
    mol.to_file(args.output)
Example #22
0
def load_ugrid_coordinates(arg_grid):
    mol = IOData.from_file(arg_grid)
    return mol.grid, mol.coordinates