def hessian(output_str): """ Reads the molecular Hessian (in Cartesian coordinates) from the output file string. Returns the Hessian in atomic units. :param output_str: string of the program's output file :type output_str: str :rtype: tuple(tuple(float)) """ comp_ptt = app.one_of_these(['X', 'Y', 'Z']) + app.UNSIGNED_INTEGER mat = ar.matrix.read( output_str, start_ptt=(app.escape('The second derivative matrix:') + app.lpadded(app.NEWLINE)), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=True) if mat is None: comp_ptt = app.UNSIGNED_INTEGER mat = ar.matrix.read( output_str, val_ptt=app.EXPONENTIAL_FLOAT_D, start_ptt=( app.escape('Force constants in Cartesian coordinates:') + app.lpadded(app.NEWLINE)), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=True) if mat is not None: mat = [[_cast(apf.replace('d', 'e', dst, case=False)) for dst in row] for row in mat]
def opt_geometry(output_str): """ Reads the optimized molecular geometry (in Cartesian coordinates) from the output file string. Returns the geometry in Bohr. :param output_str: string of the program's output file :type output_str: str :rtype: automol molecular geometry data structure """ nums, xyzs = ar.geom.read( output_str, start_ptt=app.padded(app.NEWLINE).join([ app.escape('Standard orientation:'), app.LINE, app.LINE, app.LINE, app.LINE, '']), symb_ptt=app.UNSIGNED_INTEGER, line_start_ptt=app.UNSIGNED_INTEGER, line_sep_ptt=app.UNSIGNED_INTEGER,) if all(x is None for x in (nums, xyzs)): nums, xyzs = ar.geom.read( output_str, start_ptt=app.padded(app.NEWLINE).join([ app.escape('Z-Matrix orientation:'), app.LINE, app.LINE, app.LINE, app.LINE, '']), symb_ptt=app.UNSIGNED_INTEGER, line_start_ptt=app.UNSIGNED_INTEGER, line_sep_ptt=app.UNSIGNED_INTEGER,) if all(x is not None for x in (nums, xyzs)): symbs = tuple(map(ptab.to_symbol, nums)) geo = automol.geom.from_data(symbs, xyzs, angstrom=True) else: geo = None return geo
def block_pattern(sym_ptt=par.Pattern.ATOM_SYMBOL, key_ptt=KEY_PATTERN, name_ptt=NAME_PATTERN, entry_start_ptt=None, entry_sep_ptt=ENTRY_SEP_PATTERN, entry_end_ptt=None, line_start_ptt=None, line_end_ptt=None): """ matrix pattern (assumes more than one atom) """ line_ptts = [ line_pattern( num, sym_ptt=sym_ptt, key_ptt=key_ptt, name_ptt=name_ptt, entry_start_ptt=entry_start_ptt, entry_sep_ptt=entry_sep_ptt, entry_end_ptt=entry_end_ptt, start_ptt=line_start_ptt, end_ptt=line_end_ptt, ) for num in range(4) ] block_end_ptt = app.series(line_ptts[3], app.padded(app.NEWLINE)) block_ptt = app.one_of_these([ app.padded(app.NEWLINE).join(line_ptts[:3] + [block_end_ptt]), app.padded(app.NEWLINE).join(line_ptts[:3]), app.padded(app.NEWLINE).join(line_ptts[:2]), app.padded(app.NEWLINE).join(line_ptts[:1]), ]) return block_ptt
def hessian(output_string): """ read hessian from the output string """ try: comp_ptt = app.one_of_these(['X', 'Y', 'Z']) + app.UNSIGNED_INTEGER mat = ar.matrix.read( output_string, start_ptt=(app.escape('The second derivative matrix:') + app.lpadded(app.NEWLINE)), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=True) except TypeError: comp_ptt = app.UNSIGNED_INTEGER mat = ar.matrix.read( output_string, val_ptt=app.EXPONENTIAL_FLOAT_D, start_ptt=( app.escape('Force constants in Cartesian coordinates:') + app.lpadded(app.NEWLINE)), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=True) mat = [[_cast(apf.replace('d', 'e', dst, case=False)) for dst in row] for row in mat] mat = tuple(map(tuple, mat)) return mat
def irc_geometry(output_str): """ Reads the molecular geometry at a point on the Intrinsic Reaction Coordinate. Returns the geometry in Bohr. :param output_str: string of the program's output file :type output_str: str :rtype: tuple(automol geom data structure) """ nums, xyzs = ar.geom.read(output_str, start_ptt=app.padded(app.NEWLINE).join([ app.escape('CURRENT STRUCTURE'), app.LINE, app.LINE, app.LINE, app.LINE, app.LINE, '' ]), symb_ptt=app.UNSIGNED_INTEGER, line_start_ptt=app.UNSIGNED_INTEGER) if any(val is None for val in (nums, xyzs)): nums, xyzs = ar.geom.read( output_str, start_ptt=app.padded(app.NEWLINE).join([ app.escape('Input orientation:'), app.LINE, app.LINE, app.LINE, app.LINE, '' ]), symb_ptt=app.UNSIGNED_INTEGER, line_start_ptt=app.UNSIGNED_INTEGER, line_sep_ptt=app.UNSIGNED_INTEGER, ) if all(val is not None for val in (nums, xyzs)): syms = tuple(map(ptab.to_symbol, nums)) geo = automol.geom.from_data(syms, xyzs, angstrom=True) else: geo = None return geo
def block_pattern(val_ptt=VALUE_PATTERN, start_ptt=None, line_start_ptt=None, capture_block=False): """ Build a pattern that matches a block with a single matrix. :param val_ptt: matches numeric matrix entry :type val_ptt: str :param start_ptt: pattern before start of the matrix block :type start_ptt: str :param line_start_ptt: matches at start of each line of each block :type line_start_ptt: str :param capture_blocks: add capturing pattern for the matrix block :type capture_blocks: bool :rtype: list(float) """ line_ptt = line_pattern(val_ptt=val_ptt, start_ptt=line_start_ptt) block_ptt_ = app.series(line_ptt, app.padded(app.NEWLINE)) if capture_block: block_ptt_ = app.capturing(block_ptt_) block_ptt_ = block_ptt_ if start_ptt is None else start_ptt + block_ptt_ return app.padded(block_ptt_)
def anharmonicity_matrix(output_str): """ Reads the VPT2-computed anharmonicity matrix from the output file string. Returns the matrix in _. :param output_str: string of the program's output file :type output_str: str :rtype: tuple(tuple(float)) """ start_string = 'Total Anharmonic X Matrix (in cm^-1)' comp_ptt = app.UNSIGNED_INTEGER mat = ar.matrix.read( output_str, val_ptt=app.EXPONENTIAL_FLOAT_D, start_ptt=app.padded(app.NEWLINE).join([ app.padded(app.escape(start_string), app.NONNEWLINE), app.LINE, '' ]), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=True) mat = tuple( tuple(float(val.replace('D', 'E')) for val in row) for row in mat) return mat
def opt_zmatrix(output_str): """ Reads the optimized Z-Matrix from the output file string. Returns the Z-Matrix in Bohr and Radians. :param output_str: string of the program's output file :type output_str: str :rtype: automol molecular geometry data structure """ # Read the matrix and the values from the output symbs, key_mat, name_mat, val_mat = ar.zmat.read( output_str, start_ptt=( app.padded(app.escape('Geometry (in Angstrom),'), app.NONNEWLINE) + 2 * app.padded(app.NEWLINE))) # Call the automol constructor if all(x is not None for x in (symbs, key_mat, name_mat, val_mat)): zma = automol.zmat.from_data(symbs, key_mat, val_mat, name_mat, one_indexed=True, angstrom=True, degree=True) else: zma = None return zma
def gradient(output_str): """ Reads the molecular gradient (in Cartesian coordinates) from the output file string. Returns the gradient in atomic units. :param output_str: string of the program's output file :type output_str: str :rtype: tuple(tuple(float)) """ comp_ptt = app.UNSIGNED_INTEGER start_ptts = ((app.padded(app.NEWLINE).join([ app.escape('## Gradient (Symmetry 0) ##'), app.LINE, '', app.LINE, '', '' ])), (app.padded(app.NEWLINE).join( [app.escape('-Total gradient:'), app.LINE, app.LINE, ''])), (app.padded(app.NEWLINE).join( [app.escape('-Total Gradient:'), app.LINE, app.LINE, '']))) for ptt in start_ptts: grad = ar.matrix.read(output_str, start_ptt=ptt, line_start_ptt=comp_ptt) if grad is not None: break return grad
def inp_zmatrix(inp_str): """ Reads the input z-matrix from the input file string Returns the Z-Matrix in Bohr and Radians. :param output_str: string of the program's output file :type output_str: str :rtype: automol molecular geometry data structure """ # Reads the matrix from the beginning of the input symbs, key_mat, name_mat = ar.vmat.read( inp_str, start_ptt=app.padded(app.NEWLINE).join([ app.escape('comment:'), app.LINE, app.LINE, '']), symb_ptt=(ar.par.Pattern.ATOM_SYMBOL + app.not_followed_by(app.SPACES + app.FLOAT) + app.maybe(app.UNSIGNED_INTEGER)), key_ptt=app.one_of_these([app.UNSIGNED_INTEGER, app.VARIABLE_NAME]), line_end_ptt=app.maybe(app.UNSIGNED_INTEGER), last=False) # Reads the values from the input if all(x is not None for x in (symbs, key_mat, name_mat)): if len(symbs) == 1: # val_dct = {} val_mat = ((None, None, None),) else: val_dct = ar.setval.read( inp_str, start_ptt=app.padded(app.NEWLINE).join([ app.padded('Variables:', app.NONNEWLINE), '']), entry_sep_ptt='', entry_start_ptt='', sep_ptt=app.maybe(app.LINESPACES).join([ app.NEWLINE]), last=True) val_mat = ar.setval.convert_dct_to_matrix(val_dct, name_mat) # Check for the pattern # For the case when variable names are used instead of integer keys: # (otherwise, does nothing) key_dct = dict(map(reversed, enumerate(symbs))) key_dct[None] = 0 key_mat = [ [key_dct[val]+1 if not isinstance(val, numbers.Real) else val for val in row] for row in key_mat] symb_ptt = app.STRING_START + app.capturing(ar.par.Pattern.ATOM_SYMBOL) symbs = [apf.first_capture(symb_ptt, symb) for symb in symbs] # Call the automol constructor zma = automol.zmat.from_data( symbs, key_mat, val_mat, name_mat, one_indexed=True, angstrom=True, degree=True) else: zma = None return zma
def dipole_moment(output_string): """ Reads the dipole moment """ pattern = (app.escape('Dipole moment (field-independent basis, Debye):') + app.NEWLINE + app.padded('X=') + app.capturing(app.FLOAT) + app.padded('Y=') + app.capturing(app.FLOAT) + app.padded('Z=') + app.capturing(app.FLOAT)) vals = [float(val) for val in apf.last_capture(pattern, output_string)] return vals
def test__geom(): """ test autoread.geom """ start_ptt = (app.padded(app.NEWLINE).join([ app.escape('Standard orientation:'), app.LINE, app.LINE, app.LINE, app.LINE, '' ])) nums, xyzs = autoread.geom.read( GEO1_STR, start_ptt=start_ptt, symb_ptt=app.UNSIGNED_INTEGER, line_start_ptt=app.UNSIGNED_INTEGER, line_sep_ptt=app.UNSIGNED_INTEGER, ) assert nums == (8, 8, 1, 1) assert xyzs == ((-0.0, 0.723527, -0.046053), (0.0, -0.723527, -0.046053), (0.876174, 0.838634, 0.368421), (-0.876174, -0.838634, 0.368421)) start_ptt = (app.padded(app.NEWLINE).join( [app.escape('Final (previous) structure:'), app.LINE, ''])) symbs, xyzs = autoread.geom.read(GEO2_STR, start_ptt=start_ptt) assert symbs == ('O', 'O', 'H', 'H') assert xyzs == ((0.0, 0.7028389815, 0.0245676525), (0.0, -0.7028389815, 0.0245676525), (-0.8761735478, 0.8179459165, -0.389906474), (0.8761735478, -0.8179459165, -0.389906474)) start_ptt = (app.padded(app.NEWLINE).join( [app.escape('ATOMIC COORDINATES'), app.LINE, app.LINE, app.LINE, ''])) symbs, xyzs = autoread.geom.read( GEO3_STR, start_ptt=start_ptt, line_start_ptt=app.UNSIGNED_INTEGER, line_sep_ptt=app.FLOAT, ) assert symbs == ('O', 'H', 'H') assert xyzs == ((0.0, 0.0, -0.109999068), (0.0, -1.635000492, 0.875999553), (0.0, 1.635000492, 0.875999553)) symbs, xyzs = autoread.geom.read_xyz(XYZ_STR) assert symbs == ('O', 'O', 'H', 'H') assert xyzs == ((0.0, 0.7028389815, 0.0245676525), (0.0, -0.7028389815, 0.0245676525), (-0.8761735478, 0.8179459165, -0.389906474), (0.8761735478, -0.8179459165, -0.389906474)) with pytest.raises(ValueError): symbs, xyzs = autoread.geom.read_xyz(BAD_XYZ_STR)
def block_pattern(symb_ptt=par.Pattern.ATOM_SYMBOL, key_ptt=KEY_PATTERN, name_ptt=NAME_PATTERN, entry_start_ptt=None, entry_sep_ptt=ENTRY_SEP_PATTERN, entry_end_ptt=None, line_start_ptt=None, line_end_ptt=None): """ Builds a pattern that can match a Z-matrix pattern from a block of lines (function currently assumes more than one atom). :param symb_ptt: matches atom symbol in first column of block :type symb_ptt: str :param key_ptt: matches key/index in columns 2, 4, 6 of block :type key_ptt: str :param name_ptt: matches z-matrix variable names in block in columns 3, 5, 7; can also match numbers at these positions :type name_ptt: str :param entry_start_ptt: matches before key_ptt :type entry_start_ptt: str :param entry_sep_ptt: matches between key_ptt and name_ptt :type entry_sep_ptt: str :param entry_end_ptt: matches after name_ptt :type entry_end_ptt: str :param line_start_ptt: matches at the start of a z-matrix block line :type line_start_ptt: str :param line_end_ptt: matches at the end of a z-matrix block line :type line_end_ptt: str :rtype: tuple """ line_ptts = [ line_pattern( num, symb_ptt=symb_ptt, key_ptt=key_ptt, name_ptt=name_ptt, entry_start_ptt=entry_start_ptt, entry_sep_ptt=entry_sep_ptt, entry_end_ptt=entry_end_ptt, start_ptt=line_start_ptt, end_ptt=line_end_ptt, ) for num in range(4)] block_end_ptt = app.series(line_ptts[3], app.padded(app.NEWLINE)) block_ptt = app.one_of_these([ app.padded(app.NEWLINE).join(line_ptts[:3] + [block_end_ptt]), app.padded(app.NEWLINE).join(line_ptts[:3]), app.padded(app.NEWLINE).join(line_ptts[:2]), app.padded(app.NEWLINE).join(line_ptts[:1]), ]) return block_ptt
def opt_geometry(output_string): """ get optimized geometry from output """ syms, xyzs = ar.geom.read( output_string, start_ptt=app.padded(app.NEWLINE).join([ app.padded(app.escape('CARTESIAN COORDINATES (ANGSTROEM)'), app.NONNEWLINE), app.LINE, '' ])) geo = automol.geom.from_data(syms, xyzs, angstrom=True) return geo
def dipole_moment(output_string): """ Reads the dipole moment """ pattern = app.padded((app.LINESPACES.join( [app.escape('Dipole moment [Debye]:'), app.FLOAT])) + app.NEWLINE + app.padded('x=') + app.capturing(app.FLOAT) + app.padded('y=') + app.capturing(app.FLOAT) + app.padded('z=') + app.capturing(app.FLOAT)) vals = [float(val) for val in apf.last_capture(pattern, output_string)] return vals
def opt_zmatrix(output_string): """ get optimized z-matrix geometry from output """ # read the matrix from the beginning of the output syms, key_mat, name_mat = ar.zmatrix.matrix.read( output_string, start_ptt=app.maybe(app.SPACES).join([ 'geometry', app.escape('='), app.escape('{'), '']), entry_start_ptt=app.maybe(','), entry_sep_ptt=',', last=False, case=False) # read the initial z-matrix values from the beginning out the output if len(syms) == 1: val_dct = {} else: val_dct = ar.zmatrix.setval.read( output_string, # name_ptt=MOLPRO_VAR_NAME_PATTERN, entry_start_ptt=MOLPRO_ENTRY_START_PATTERN, val_ptt=app.one_of_these([app.EXPONENTIAL_FLOAT_D, app.NUMBER]), last=True, case=False) print('val_dct:', val_dct) names = sorted(set(numpy.ravel(name_mat)) - {None}) caps_names = list(map(str.upper, names)) name_dct = dict(zip(caps_names, names)) assert set(caps_names) <= set(val_dct) val_dct = {name_dct[caps_name]: val_dct[caps_name] for caps_name in caps_names} # read optimized z-matrix values from the end of the output VAR_STRING = app.one_of_these([ app.padded('Optimized variables'), app.padded('Current variables') ]) opt_val_dct = ar.zmatrix.setval.read( output_string, start_ptt=VAR_STRING + app.NEWLINE, entry_end_ptt=app.one_of_these(['ANGSTROM', 'DEGREE']), last=True, case=False) opt_val_dct = {name_dct[caps_name]: opt_val_dct[caps_name] for caps_name in opt_val_dct.keys()} assert set(opt_val_dct) <= set(val_dct) val_dct.update(opt_val_dct) # call the automol constructor zma = automol.zmatrix.from_data( syms, key_mat, name_mat, val_dct, one_indexed=True, angstrom=True, degree=True) return zma
def gradient(output_string): """ read gradient from the output string """ grad = ar.matrix.read( output_string, start_ptt=app.padded(app.NEWLINE).join([ app.padded(app.escape('Forces (Hartrees/Bohr)'), app.NONNEWLINE), app.LINE, app.LINE, '']), line_start_ptt=app.LINESPACES.join([app.UNSIGNED_INTEGER] * 2)) grad = numpy.multiply(grad, -1.0) assert numpy.shape(grad)[1] == 3 return grad
def hessian(output_string): """ get hessian from output """ comp_ptt = app.UNSIGNED_INTEGER hess = ar.matrix.read( output_string, start_ptt=app.padded(app.NEWLINE).join([ app.escape('## Hessian (Symmetry 0) ##'), app.LINE, '']), block_start_ptt=app.padded(app.NEWLINE).join([ '', app.series(comp_ptt, app.LINESPACES), '', '']), line_start_ptt=comp_ptt) assert numpy.allclose(hess, numpy.transpose(hess)) return hess
def gradient(output_string): """ read gradient from the output string """ head_ptt = ('Atom' + app.SPACES + app.escape('dE/dx') + app.SPACES + app.escape('dE/dy') + app.SPACES + app.escape('dE/dz')) grad = ar.matrix.read(output_string, start_ptt=app.padded(app.NEWLINE).join([ app.padded(head_ptt, app.NONNEWLINE), app.LINE, '' ]), line_start_ptt=app.UNSIGNED_INTEGER) assert numpy.shape(grad)[1] == 3 return grad
def opt_zmatrix(output_string): """ get optimized z-matrix geometry from output """ # read the matrix from the beginning of the output syms, key_mat, name_mat = ar.zmatrix.matrix.read( output_string, start_ptt=app.padded(app.NEWLINE).join( [app.escape('Symbolic Z-matrix:'), app.LINE, '']), sym_ptt=ar.par.Pattern.ATOM_SYMBOL + app.maybe(app.UNSIGNED_INTEGER), key_ptt=app.one_of_these([app.UNSIGNED_INTEGER, app.VARIABLE_NAME]), line_end_ptt=app.maybe(app.UNSIGNED_INTEGER), last=False) # read the values from the end of the output if len(syms) == 1: val_dct = {} else: val_dct = ar.zmatrix.setval.read( output_string, start_ptt=app.padded(app.NEWLINE).join([ app.padded('Optimized Parameters', app.NONNEWLINE), app.LINE, app.LINE, app.LINE, app.LINE, '' ]), entry_sep_ptt='', entry_start_ptt=app.escape('!'), sep_ptt=app.maybe(app.LINESPACES).join([ app.escape('-DE/DX ='), app.FLOAT, app.escape('!'), app.NEWLINE ]), last=True) # for the case when variable names are used instead of integer keys: # (otherwise, does nothing) key_dct = dict(map(reversed, enumerate(syms))) key_dct[None] = 0 key_mat = [[ key_dct[val] + 1 if not isinstance(val, numbers.Real) else val for val in row ] for row in key_mat] sym_ptt = app.STRING_START + app.capturing(ar.par.Pattern.ATOM_SYMBOL) syms = [apf.first_capture(sym_ptt, sym) for sym in syms] # call the automol constructor zma = automol.zmatrix.from_data(syms, key_mat, name_mat, val_dct, one_indexed=True, angstrom=True, degree=True) return zma
def test__setval(): """ test autoread.zmat.setval """ val_dct = autoread.setval.read(ZMA_VAL1_STR) assert val_dct == { 'A2': 96.772572, 'D3': 129.366995, 'R1': 1.4470582953, 'R2': 0.976073} start_ptt = app.padded(app.NEWLINE).join([ app.escape('! Optimized Parameters !'), app.LINE, app.LINE, app.LINE, app.LINE, '']) val_dct = autoread.setval.read( ZMA_VAL2_STR, start_ptt=start_ptt, entry_sep_ptt='', entry_start_ptt=app.escape('!'), sep_ptt=app.maybe(app.LINESPACES).join([ app.escape('-DE/DX ='), app.FLOAT, app.escape('!'), app.NEWLINE])) assert val_dct == { 'R1': 1.4057, 'R2': 0.9761, 'A2': 96.7726, 'D3': 129.367} val_dct = autoread.setval.read( ZMA_VAL3_STR, sep_ptt=app.one_of_these(['', app.NEWLINE])) assert val_dct == { 'R1': 2.73454, 'R2': 1.84451, 'A2': 96.7726, 'R3': 1.84451, 'A3': 96.7726, 'D3': 129.367} val_dct = autoread.setval.read( ZMA_VAL4_STR, entry_start_ptt='SETTING', val_ptt=app.one_of_these([app.EXPONENTIAL_FLOAT_D, app.NUMBER]), last=False, case=False) assert val_dct == { 'R1': 1.375861, 'R2': 1.058354, 'A2': 108.861981, 'R3': 1.058354, 'A3': 108.861981, 'D3': 120.321137, 'R4': 1.058354, 'A4': 108.861981, 'D4': 234.912696, 'R5': 0.952519, 'A5': 103.132403, 'D5': 297.938053, 'SPIN': '0.00000000D+00', 'CHARGE': '0.00000000D+00'} val_dct = autoread.setval.read( ZMA_VAL5_STR, start_ptt=app.padded('Optimized variables') + app.NEWLINE, entry_end_ptt=app.one_of_these(['ANGSTROM', 'DEGREE']), last=True, case=False) assert val_dct == { 'R1': 1.43218364, 'R2': 1.09538054, 'A2': 112.03775543, 'R3': 1.09538307, 'A3': 112.04463832, 'R4': 1.09084803, 'A4': 108.31761858, 'D4': 240.16203078, 'D5': 299.84441753}
def gradient(output_string): """ read gradient from the output string """ grad = ar.matrix.read(output_string, start_ptt=app.padded(app.NEWLINE).join([ app.padded(app.escape('CARTESIAN GRADIENT'), app.NONNEWLINE), app.LINE, app.LINE, '' ]), line_start_ptt=app.LINESPACES.join([ app.UNSIGNED_INTEGER, app.one_or_more(app.LETTER), ':' ])) assert numpy.shape(grad)[1] == 3 return grad
def block_pattern(val_ptt=VALUE_PATTERN, start_ptt=None, line_start_ptt=None, capture_block=False): """ matrix block pattern """ line_ptt = line_pattern(val_ptt=val_ptt, start_ptt=line_start_ptt) block_ptt_ = app.series(line_ptt, app.padded(app.NEWLINE)) if capture_block: block_ptt_ = app.capturing(block_ptt_) block_ptt_ = block_ptt_ if start_ptt is None else start_ptt + block_ptt_ return app.padded(block_ptt_)
def vibro_rot_alpha_matrix_reader(output_string): """ Get the Vibration-Rotation Alpha Matrix """ begin_string = 'Vibro-Rot alpha Matrix (in cm^-1)' end_string = app.escape('Q( ') + app.UNSIGNED_INTEGER + app.escape(')') vib_rot_mat = ar.matrix.read(output_string, start_ptt=app.padded(app.NEWLINE).join([ app.padded(app.escape(begin_string), app.NONNEWLINE), app.LINE, app.LINE, '' ]), line_start_ptt=end_string) return vib_rot_mat
def hessian(output_str): """ Reads the molecular Hessian (in Cartesian coordinates) from the output file string. Returns the Hessian in atomic units. :param output_str: string of the program's output file :type output_str: str :rtype: tuple(tuple(float)) """ comp_ptt = (app.one_or_more(app.LETTER) + app.one_of_these(['X', 'Y', 'Z']) + app.UNSIGNED_INTEGER) mat = ar.matrix.read( output_str, start_ptt=( app.escape('Force Constants (Second Derivatives of the Energy) ') + app.escape('in [a.u.]') + app.lpadded(app.NEWLINE)), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=True) if mat is not None: mat = tuple(map(tuple, mat)) return mat
def dipole_moment(output_string): """ Reads the dipole moment """ pattern = (app.escape('Dipole moment (field-independent basis, Debye):') + app.LINE_FILL + app.NEWLINE + app.padded('X=') + app.capturing(app.FLOAT) + app.padded('Y=') + app.capturing(app.FLOAT) + app.padded('Z=') + app.capturing(app.FLOAT)) captures = apf.last_capture(pattern, output_string) vals = captures if captures is not None else [] if vals: vals = [float(val) for val in vals] else: vals = None return vals
def hessian(output_string): """ read hessian from the output string """ comp_ptt = app.UNSIGNED_INTEGER mat = ar.matrix.read( output_string, val_ptt=app.EXPONENTIAL_FLOAT, start_ptt=app.padded(app.NEWLINE).join( [app.escape('$hessian'), app.LINE, '']), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=False) mat = tuple(map(tuple, mat)) return mat
def entry_pattern(name_ptt=NAME_PATTERN, val_ptt=VALUE_PATTERN, sep_ptt=ENTRY_SEP_PATTERN, start_ptt=None, end_ptt=None): """ Builds pattern that match a line of a setvalue block where the value of a single coordinate of a Z-matrix is assigned. :param name_ptt: matches the variable name in the setval block :type name_ptt: str :param val_ptt: matches the numeric value in the setval block :type name_ptt: str :param sep_ptt: matches the separator between a variable name and its value, such as the equals sign in 'R1 = 5.00' :type sep_ptt: str :param start_ptt: matches at the start of a setval entry :type start_ptt: str :param end_ptt: matches at the end of a setval entry :rtype: str """ parts = (([] if start_ptt is None else [start_ptt]) + [name_ptt] + [sep_ptt] + [val_ptt] + ([] if end_ptt is None else [end_ptt])) ptt = app.padded(app.maybe(app.LINESPACES).join(parts)) return ptt
def block_pattern(name_ptt=NAME_PATTERN, val_ptt=VALUE_PATTERN, entry_sep_ptt=ENTRY_SEP_PATTERN, entry_start_ptt=None, entry_end_ptt=None, sep_ptt=SEP_PATTERN): """ Builds pattern that match a single setvalue block where the values of a set of coordinates for a single Z-matrix are assigned. :param name_ptt: matches the variable name in the setval block :type name_ptt: str :param val_ptt: matches the numeric value in the setval block :type name_ptt: str :param entry_sep_ptt: matches the separator between a variable name and its value, such as the equals sign in 'R1 = 5.00' :type entry_sep_ptt: str :param entry_start_ptt: matches at the start of a setval entry :type entry_start_ptt: str :param entry_end_ptt: matches at the end of a setval entry :param sep_ptt: matches the separator between setval entries, such as a newline or comma :rtype: str """ entry_ptt = entry_pattern( name_ptt=name_ptt, val_ptt=val_ptt, sep_ptt=entry_sep_ptt, start_ptt=entry_start_ptt, end_ptt=entry_end_ptt, ) block_ptt = app.series(entry_ptt, app.padded(sep_ptt)) return block_ptt
def block_pattern(symb_ptt=par.Pattern.ATOM_SYMBOL, val_ptt=par.Pattern.NUMERIC_VALUE, line_sep_ptt=None, line_start_ptt=None): """ Builds a pattern that can match a Cartesian molecular geometry from block of lines. :param symb_ptt: matches atom symbol in the first column of xyz lines :type symb_ptt: str :param val_ptt: matches coordinate values in columns 2-4 of xyz lines :type val_ptt: str :param line_sep_ptt: pattern that delimits columns of xyz line :type line_sep_ptt: str :param line_start_ptt: pattern preceding atom symbols of geometry block :type line_start_ptt: str :rtype: str """ line_ptt = line_pattern(symb_ptt=symb_ptt, val_ptt=val_ptt, sep_ptt=line_sep_ptt, start_ptt=line_start_ptt) block_ptt = app.series(line_ptt, app.padded(app.NEWLINE)) return block_ptt