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 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)) """ # Try to read the gradient from several differnt methods ptt1 = ('Gradient of SCF Energy' + app.NEWLINE + app.SPACES + app.series(app.INTEGER, app.SPACES) + app.NEWLINE) ptt2 = ('Full Analytical Gradient' + app.LINE_FILL + app.NEWLINE + app.SPACES + app.series(app.INTEGER, app.SPACES) + app.NEWLINE) start_ptt = app.one_of_these([ptt1, ptt2]) grad = ar.matrix.read(output_str, val_ptt=app.FLOAT, start_ptt=start_ptt, line_start_ptt=app.UNSIGNED_INTEGER) # Try and read a general tensor from a numerical gradient if grad is None: grad = _general_xyz_tensor(output_str) return grad
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 line_pattern(val_ptt=VALUE_PATTERN, start_ptt=None, capture_values=False): """ Build a pattern that matches a line from a block with a single matrix. :param val_ptt: matches numeric matrix entry :type val_ptt: str :param start_ptt: matches at start of the line of the block :type start_ptt: str :param capture_values: add capturing pattern for the values in the line :type capture_values: bool :rtype: list(float) """ vals_ptt = app.series(val_ptt, app.LINESPACES) if capture_values: vals_ptt = app.capturing(vals_ptt) parts = ( ([] if start_ptt is None else [start_ptt]) + [vals_ptt]) ptt = app.LINE_START + app.padded(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(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 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 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
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 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 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.UNSIGNED_INTEGER mat = ar.matrix.read( output_str, val_ptt=app.FLOAT, start_ptt=( app.escape('Final Hessian.') + app.lpadded(app.NEWLINE)), block_start_ptt=(app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)), line_start_ptt=comp_ptt, tril=False) if mat is not None: mat = tuple(map(tuple, mat)) return mat
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 block_pattern(sym_ptt=par.Pattern.ATOM_SYMBOL, val_ptt=par.Pattern.NUMERIC_VALUE, line_sep_ptt=None, line_start_ptt=None): """ geometry block pattern """ line_ptt = line_pattern( sym_ptt=sym_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
def line_pattern(val_ptt=VALUE_PATTERN, start_ptt=None, capture_values=False): """ matrix line pattern """ vals_ptt = app.series(val_ptt, app.LINESPACES) if capture_values: vals_ptt = app.capturing(vals_ptt) parts = (([] if start_ptt is None else [start_ptt]) + [vals_ptt]) ptt = app.LINE_START + app.padded(app.LINESPACES.join(parts)) return ptt
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 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 chebyshev_parameters(rxn_dstr): """ Parses the data string for a reaction in the reactions block for the lines containing the Chebyshevs fitting parameters, then reads the parameters from these lines. :param rxn_dstr: data string for species in reaction block :type rxn_dstr: str :return params: Chebyshev fitting parameters :rtype: dict[param: value] """ temp_pattern = ('TCHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.SPACES + app.capturing(app.FLOAT) + app.SPACES + app.capturing(app.FLOAT) + app.zero_or_more(app.SPACE) + app.escape('/')) pressure_pattern = ('PCHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.SPACES + app.capturing(app.FLOAT) + app.SPACES + app.capturing(app.FLOAT) + app.zero_or_more(app.SPACE) + app.escape('/')) alpha_dimension_pattern = ('CHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.SPACES + app.capturing(app.INTEGER) + app.SPACES + app.capturing(app.INTEGER) + app.zero_or_more(app.SPACE) + app.escape('/')) alpha_elements_pattern = ( 'CHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.series( app.capturing(app.SPACES + app.capturing(app.EXPONENTIAL_FLOAT)), app.SPACES) + app.zero_or_more(app.SPACE) + app.escape('/')) cheb_temps = apf.first_capture(temp_pattern, rxn_dstr) cheb_pressures = apf.first_capture(pressure_pattern, rxn_dstr) alpha_dims = apf.first_capture(alpha_dimension_pattern, rxn_dstr) alpha_elm = apf.all_captures(alpha_elements_pattern, rxn_dstr) if not alpha_elm: alpha_elm = None params_dct = {} if all(vals is not None for vals in (cheb_temps, cheb_pressures, alpha_dims, alpha_elm)): params_dct['t_limits'] = [float(val) for val in cheb_temps] params_dct['p_limits'] = [float(val) for val in cheb_pressures] params_dct['alpha_dim'] = [int(val) for val in alpha_dims] params_dct['alpha_elm'] = [list(map(float, row)) for row in alpha_elm] else: params_dct = None return params_dct
def hessian2(output_string): """ read hessian from the output string """ 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]
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 hessian(output_string): """ read hessian from the output string """ comp_ptt = (app.one_or_more(app.LETTER) + app.one_of_these(['X', 'Y', 'Z']) + app.UNSIGNED_INTEGER) mat = ar.matrix.read( output_string, 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) mat = tuple(map(tuple, mat)) return mat
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): """ a single setvalue entry """ 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 blocks_pattern(val_ptt=VALUE_PATTERN, start_ptt=None, block_start_ptt=None, line_start_ptt=None, capture_blocks=False): """ multi-block matrix pattern """ block_ptt = block_pattern(val_ptt=val_ptt, start_ptt=block_start_ptt, line_start_ptt=line_start_ptt) blocks_ptt_ = app.series(block_ptt, app.padded(app.NEWLINE)) if capture_blocks: blocks_ptt_ = app.capturing(blocks_ptt_) blocks_ptt_ = blocks_ptt_ if start_ptt is None else start_ptt + blocks_ptt_ return blocks_ptt_
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.UNSIGNED_INTEGER hess = ar.matrix.read( output_str, 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) return hess
def anharmonicity_matrix_reader(output_string): """ Get the Anharmonicity Matrix """ # Set strings to find anharm matrix start_string = 'Total Anharmonic X Matrix (in cm^-1)' comp_ptt = app.UNSIGNED_INTEGER # Obtain the matrix mat = ar.matrix.read( output_string, 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) return mat
def chebyshev_parameters(rxn_dstr): """ chebyshev parameters """ temp_pattern = ('TCHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.SPACES + app.capturing(app.FLOAT) + app.SPACES + app.capturing(app.FLOAT) + app.zero_or_more(app.SPACE) + app.escape('/')) pressure_pattern = ('PCHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.SPACES + app.capturing(app.FLOAT) + app.SPACES + app.capturing(app.FLOAT) + app.zero_or_more(app.SPACE) + app.escape('/')) alpha_dimension_pattern = ('CHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.SPACES + app.capturing(app.INTEGER) + app.SPACES + app.capturing(app.INTEGER) + app.zero_or_more(app.SPACE) + app.escape('/')) alpha_elements_pattern = ( 'CHEB' + app.zero_or_more(app.SPACE) + app.escape('/') + app.series( app.capturing(app.SPACES + app.capturing(app.EXPONENTIAL_FLOAT)), app.SPACES) + app.zero_or_more(app.SPACE) + app.escape('/')) cheb_temps = apf.first_capture(temp_pattern, rxn_dstr) cheb_pressures = apf.first_capture(pressure_pattern, rxn_dstr) alpha_dims = apf.first_capture(alpha_dimension_pattern, rxn_dstr) alpha_elms = apf.all_captures(alpha_elements_pattern, rxn_dstr) if not alpha_elms: alpha_elms = None if all(vals is not None for vals in (cheb_temps, cheb_pressures, alpha_dims, alpha_elms)): cheb_temps = [float(val) for val in cheb_temps] cheb_pressures = [float(val) for val in cheb_pressures] alpha_dims = [int(val) for val in alpha_dims] alpha_elms = [list(map(float, row)) for row in alpha_elms] cheb_params = cheb_temps, cheb_pressures, alpha_dims, alpha_elms else: cheb_params = None return cheb_params
def test__matrix(): """ test autoread.matrix """ # gaussian gradient string = (' ***** Axes restored to original set *****\n' ' ------------------------------------------------------------\n' ' Center Atomic Forces (Hartrees/Bohr)\n' ' Number Number X Y Z\n' ' ------------------------------------------------------------\n' ' 1 8 0.000000000 -0.000000000 -0.061240635\n' ' 2 1 0.000000000 -0.021691602 0.030622057\n' ' 3 1 -0.000000000 0.021691602 0.030622057\n' ' ------------------------------------------------------------\n' ' Cartesian Forces: Max 0.061240635 RMS 0.027012111\n') mat = autoread.matrix.read( 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)) assert numpy.allclose(mat, ((0.0, -0.0, -0.061240635), (0.0, -0.021691602, 0.030622057), (-0.0, 0.021691602, 0.030622057))) # gaussian hessian string = (' The second derivative matrix:\n' ' X1 Y1 Z1 X2 Y2\n' ' X1 -0.21406\n' ' Y1 -0.00000 2.05336\n' ' Z1 -0.00000 0.12105 0.19177\n' ' X2 -0.06169 -0.00000 0.00000 0.03160\n' ' Y2 0.00000 -0.09598 -0.05579 -0.00000 0.12501\n' ' Z2 0.00000 0.08316 -0.38831 -0.00000 -0.06487\n' ' X3 0.27574 0.00000 0.00000 0.03009 -0.00000\n' ' Y3 0.00000 -1.95737 -0.06525 0.00000 -0.02902\n' ' Z3 0.00000 -0.20421 0.19654 -0.00000 0.12066\n' ' Z2 X3 Y3 Z3\n' ' Z2 0.44623\n' ' X3 0.00000 -0.30583\n' ' Y3 -0.01829 -0.00000 1.98640\n' ' Z3 -0.05792 -0.00000 0.08354 -0.13862\n' ' ITU= 0\n' ' Eigenvalues --- 0.06664 0.66895 3.25121\n') comp_ptt = app.one_of_these(['X', 'Y', 'Z']) + app.UNSIGNED_INTEGER mat = autoread.matrix.read( 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) assert numpy.allclose( mat, ((-0.21406, 0., 0., -0.06169, 0., 0., 0.27574, 0., 0.), (0., 2.05336, 0.12105, 0., -0.09598, 0.08316, 0., -1.95737, -0.20421), (0., 0.12105, 0.19177, 0., -0.05579, -0.38831, 0., -0.06525, 0.19654), (-0.06169, 0., 0., 0.0316, 0., 0., 0.03009, 0., 0.), (0., -0.09598, -0.05579, 0., 0.12501, -0.06487, 0., -0.02902, 0.12066), (0., 0.08316, -0.38831, 0., -0.06487, 0.44623, 0., -0.01829, -0.05792), (0.27574, 0., 0., 0.03009, 0., 0., -0.30583, 0., 0.), (0., -1.95737, -0.06525, 0., -0.02902, -0.01829, 0., 1.9864, 0.08354), (0., -0.20421, 0.19654, 0., 0.12066, -0.05792, 0., 0.08354, -0.13862))) # psi4 gradient string = (' ## Gradient (Symmetry 0) ##\n' ' Irrep: 1 Size: 3 x 3\n' '\n' ' 1 2 3\n' '\n' ' 1 0.000 0.000 0.997\n' ' 2 0.000 -0.749 -0.488\n' ' 3 -0.000 0.749 -0.488\n') mat = autoread.matrix.read(string, start_ptt=app.padded(app.NEWLINE).join([ app.escape('## Gradient (Symmetry 0) ##'), app.LINE, '', app.LINE, '', '' ]), line_start_ptt=app.UNSIGNED_INTEGER) assert numpy.allclose(mat, ((0.0, 0.0, 0.997), (0.0, -0.749, -0.488), (-0.0, 0.749, -0.488))) # psi4 hessian string = ('-------------------------------------------\n' ' ## Hessian (Symmetry 0) ##\n' ' Irrep: 1 Size: 9 x 9\n' '\n' ' 1 2 3 4 5 \n' '\n' ' 1 0.000 0.000 0.000 0.000 0.000\n' ' 2 0.000 0.959 0.000 0.000 -0.452\n' ' 3 0.000 0.000 0.371 0.000 0.222\n' ' 4 0.000 0.000 0.000 0.000 0.000\n' ' 5 0.000 -0.479 0.279 0.000 0.455\n' ' 6 0.000 0.251 -0.185 0.000 -0.247\n' ' 7 0.000 0.000 0.000 0.000 0.000\n' ' 8 0.000 -0.479 -0.279 0.000 -0.003\n' ' 9 0.000 -0.251 -0.185 0.000 0.025\n' '\n' ' 6 7 8 9\n' '\n' ' 1 0.000 0.000 0.000 0.000\n' ' 2 0.519 0.000 -0.477 -0.230\n' ' 3 -0.555 0.000 -0.279 -0.128\n' ' 4 0.000 0.000 0.000 0.000\n' ' 5 -0.256 0.000 -0.017 0.051\n' ' 6 0.607 0.000 -0.012 0.090\n' ' 7 0.000 0.000 0.000 0.000\n' ' 8 -0.263 0.000 0.494 0.279\n' ' 9 0.947 0.000 0.292 0.137\n') mat = autoread.matrix.read(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(app.UNSIGNED_INTEGER, app.LINESPACES), '', '' ]), line_start_ptt=app.UNSIGNED_INTEGER) assert numpy.allclose( mat, ((0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), (0.0, 0.959, 0.0, 0.0, -0.452, 0.519, 0.0, -0.477, -0.23), (0.0, 0.0, 0.371, 0.0, 0.222, -0.555, 0.0, -0.279, -0.128), (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), (0.0, -0.479, 0.279, 0.0, 0.455, -0.256, 0.0, -0.017, 0.051), (0.0, 0.251, -0.185, 0.0, -0.247, 0.607, 0.0, -0.012, 0.09), (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), (0.0, -0.479, -0.279, 0.0, -0.003, -0.263, 0.0, 0.494, 0.279), (0.0, -0.251, -0.185, 0.0, 0.025, 0.947, 0.0, 0.292, 0.137)))
CHEMKIN_ARROW = (app.maybe(app.escape('<')) + app.escape('=') + app.maybe(app.escape('>'))) CHEMKIN_PLUS_EM = app.PLUS + 'M' CHEMKIN_PAREN_PLUS_EM = app.escape('(') + app.PLUS + 'M' + app.escape(')') CHEMKIN_PAREN_PLUS = app.escape('(') + app.PLUS CHEMKIN_PAREN_CLOSE = app.escape(')') SPECIES_NAME_PATTERN = (r'[^\s=+\-]' + app.zero_or_more( app.one_of_these([ app.LETTER, app.DIGIT, r'[#,()\-_]', app.escape('*'), app.escape('(+)'), app.escape('['), app.escape(']') ])) + app.zero_or_more(app.PLUS)) SPECIES_NAMES_PATTERN = app.series(app.padded(SPECIES_NAME_PATTERN), app.padded(app.PLUS)) REACTION_PATTERN = (SPECIES_NAMES_PATTERN + app.padded(CHEMKIN_ARROW) + SPECIES_NAMES_PATTERN) COEFF_PATTERN = (app.NUMBER + app.LINESPACES + app.NUMBER + app.LINESPACES + app.NUMBER) COMMENTS_PATTERN = app.escape('!') + app.capturing( app.one_or_more(app.WILDCARD2)) BAD_STRS = ['inf', 'INF', 'nan'] def get_rxn_param_dct(block_str, ea_units, a_units): """ Parses all of the chemical equations and corresponding fitting parameters in the reactions block of the mechanism input file and subsequently pulls all of the species names and fitting
def test__matrix(): """ test autoread.matrix """ # Gradients start_ptt = (app.padded(app.NEWLINE).join([ app.padded(app.escape('Forces (Hartrees/Bohr)'), app.NONNEWLINE), app.LINE, app.LINE, '' ])) mat = autoread.matrix.read(GRAD1_STR, start_ptt=start_ptt, line_start_ptt=app.LINESPACES.join( [app.UNSIGNED_INTEGER] * 2)) assert numpy.allclose(mat, ((0.0, -0.0, -0.061240635), (0.0, -0.021691602, 0.030622057), (-0.0, 0.021691602, 0.030622057))) start_ptt = (app.padded(app.NEWLINE).join([ app.escape('## Gradient (Symmetry 0) ##'), app.LINE, '', app.LINE, '', '' ])) mat = autoread.matrix.read(GRAD2_STR, start_ptt=start_ptt, line_start_ptt=app.UNSIGNED_INTEGER) assert numpy.allclose(mat, ((0.0, 0.0, 0.997), (0.0, -0.749, -0.488), (-0.0, 0.749, -0.488))) # Hessians start_ptt = (app.escape('The second derivative matrix:') + app.lpadded(app.NEWLINE)) comp_ptt = app.one_of_these(['X', 'Y', 'Z']) + app.UNSIGNED_INTEGER block_start_ptt = (app.series(comp_ptt, app.LINESPACES) + app.padded(app.NEWLINE)) mat = autoread.matrix.read(HESS1_STR, start_ptt=start_ptt, block_start_ptt=block_start_ptt, line_start_ptt=comp_ptt, tril=True) assert numpy.allclose( mat, ((-0.21406, 0., 0., -0.06169, 0., 0., 0.27574, 0., 0.), (0., 2.05336, 0.12105, 0., -0.09598, 0.08316, 0., -1.95737, -0.20421), (0., 0.12105, 0.19177, 0., -0.05579, -0.38831, 0., -0.06525, 0.19654), (-0.06169, 0., 0., 0.0316, 0., 0., 0.03009, 0., 0.), (0., -0.09598, -0.05579, 0., 0.12501, -0.06487, 0., -0.02902, 0.12066), (0., 0.08316, -0.38831, 0., -0.06487, 0.44623, 0., -0.01829, -0.05792), (0.27574, 0., 0., 0.03009, 0., 0., -0.30583, 0., 0.), (0., -1.95737, -0.06525, 0., -0.02902, -0.01829, 0., 1.9864, 0.08354), (0., -0.20421, 0.19654, 0., 0.12066, -0.05792, 0., 0.08354, -0.13862))) start_ptt = (app.padded(app.NEWLINE).join( [app.escape('## Hessian (Symmetry 0) ##'), app.LINE, ''])) block_start_ptt = (app.padded(app.NEWLINE).join( ['', app.series(app.UNSIGNED_INTEGER, app.LINESPACES), '', ''])) mat = autoread.matrix.read(HESS2_STR, start_ptt=start_ptt, block_start_ptt=block_start_ptt, line_start_ptt=app.UNSIGNED_INTEGER) assert numpy.allclose( mat, ((0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), (0.0, 0.959, 0.0, 0.0, -0.452, 0.519, 0.0, -0.477, -0.23), (0.0, 0.0, 0.371, 0.0, 0.222, -0.555, 0.0, -0.279, -0.128), (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), (0.0, -0.479, 0.279, 0.0, 0.455, -0.256, 0.0, -0.017, 0.051), (0.0, 0.251, -0.185, 0.0, -0.247, 0.607, 0.0, -0.012, 0.09), (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), (0.0, -0.479, -0.279, 0.0, -0.003, -0.263, 0.0, 0.494, 0.279), (0.0, -0.251, -0.185, 0.0, 0.025, 0.947, 0.0, 0.292, 0.137))) # Test finding nothing mat = autoread.matrix.read('', start_ptt=start_ptt, block_start_ptt=block_start_ptt, line_start_ptt=app.UNSIGNED_INTEGER) assert mat is None
def _parse_sort_order_from_aux_info(aux_info): ptt = app.escape('/N:') + app.capturing( app.series(app.UNSIGNED_INTEGER, ',')) num_str = apf.first_capture(ptt, aux_info) nums = tuple(map(int, num_str.split(','))) return nums
def _parse_sort_order_from_aux_info(aux_info): ptt = app.escape('/N:') + app.capturing( app.series(app.UNSIGNED_INTEGER, app.one_of_these(',;'))) num_strs = apf.first_capture(ptt, aux_info).split(';') nums_lst = ap_cast(tuple(s.split(',') for s in num_strs)) return nums_lst