SYMBOL INDEX (455 symbols across 73 files)

FILE: devtools/scripts/create_conda_env.py
  function temp_cd (line 38) | def temp_cd():

FILE: espaloma/_version.py
  function get_keywords (line 23) | def get_keywords() -> Dict[str, str]:
  class VersioneerConfig (line 36) | class VersioneerConfig:
  function get_config (line 47) | def get_config() -> VersioneerConfig:
  class NotThisMethod (line 61) | class NotThisMethod(Exception):
  function register_vcs_handler (line 69) | def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
  function run_command (line 80) | def run_command(
  function versions_from_parentdir (line 128) | def versions_from_parentdir(
  function git_get_keywords (line 157) | def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
  function git_versions_from_keywords (line 185) | def git_versions_from_keywords(
  function git_pieces_from_vcs (line 253) | def git_pieces_from_vcs(
  function plus_or_dot (line 390) | def plus_or_dot(pieces: Dict[str, Any]) -> str:
  function render_pep440 (line 397) | def render_pep440(pieces: Dict[str, Any]) -> str:
  function render_pep440_branch (line 422) | def render_pep440_branch(pieces: Dict[str, Any]) -> str:
  function pep440_split_post (line 452) | def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
  function render_pep440_pre (line 462) | def render_pep440_pre(pieces: Dict[str, Any]) -> str:
  function render_pep440_post (line 486) | def render_pep440_post(pieces: Dict[str, Any]) -> str:
  function render_pep440_post_branch (line 513) | def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
  function render_pep440_old (line 542) | def render_pep440_old(pieces: Dict[str, Any]) -> str:
  function render_git_describe (line 564) | def render_git_describe(pieces: Dict[str, Any]) -> str:
  function render_git_describe_long (line 584) | def render_git_describe_long(pieces: Dict[str, Any]) -> str:
  function render (line 604) | def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
  function get_versions (line 640) | def get_versions() -> Dict[str, Any]:

FILE: espaloma/app/experiment.py
  class Experiment (line 14) | class Experiment(abc.ABC):
    method __init__ (line 17) | def __init__(self):
  class Train (line 21) | class Train(Experiment):
    method __init__ (line 55) | def __init__(
    method train_once (line 101) | def train_once(self):
    method train (line 133) | def train(self):
  class Test (line 153) | class Test(Experiment):
    method __init__ (line 172) | def __init__(
    method test (line 191) | def test(self):
  class TrainAndTest (line 251) | class TrainAndTest(Experiment):
    method __init__ (line 254) | def __init__(
    method __str__ (line 284) | def __str__(self):
    method run (line 305) | def run(self):

FILE: espaloma/app/report.py
  function dataframe (line 11) | def dataframe(results_dict):
  function curve (line 26) | def curve(results_dict):
  function markdown (line 54) | def markdown(results_dict):
  function visual (line 59) | def visual(results_dict):
  function visual_multiple (line 105) | def visual_multiple(results_dicts):
  function visual_base64 (line 169) | def visual_base64(results_dict):
  function html (line 182) | def html(results_dict):
  function html_multiple_train_and_test (line 210) | def html_multiple_train_and_test(results):
  function html_multiple_train_and_test_2d_grid (line 220) | def html_multiple_train_and_test_2d_grid(results):

FILE: espaloma/app/tests/test_experiment.py
  function test_import (line 5) | def test_import():
  function data (line 12) | def data():
  function net (line 25) | def net():
  function test_data_and_net (line 46) | def test_data_and_net(data, net):
  function train (line 52) | def train(data, net):
  function test_train (line 70) | def test_train(train):
  function test_test (line 74) | def test_test(train, net, data):
  function test_train_and_test (line 81) | def test_train_and_test(net, data):

FILE: espaloma/app/train.py
  function run (line 13) | def run(args):

FILE: espaloma/app/train_all_params.py
  function run (line 11) | def run(args):

FILE: espaloma/app/train_bonded_energy.py
  function run (line 13) | def run(args):

FILE: espaloma/app/train_multi_typing.py
  function run (line 10) | def run(args):

FILE: espaloma/data/collection.py
  function esol (line 10) | def esol(*args, **kwargs):
  function alkethoh (line 29) | def alkethoh(*args, **kwargs):
  function zinc (line 66) | def zinc(first=-1, *args, **kwargs):
  function md17_old (line 114) | def md17_old(*args, **kwargs):
  function md17_new (line 132) | def md17_new(*args, **kwargs):
  class qca (line 144) | class qca(object):
  function _get_ds (line 159) | def _get_ds(cls, df_name):

FILE: espaloma/data/dataset.py
  class Dataset (line 14) | class Dataset(abc.ABC, torch.utils.data.Dataset):
    method __init__ (line 59) | def __init__(self, graphs=None):
    method __len__ (line 64) | def __len__(self):
    method __getitem__ (line 72) | def __getitem__(self, idx):
    method __iter__ (line 123) | def __iter__(self):
    method shuffle (line 136) | def shuffle(self, seed=None):
    method apply (line 146) | def apply(self, fn, in_place=False):
    method split (line 180) | def split(self, partition):
    method subsample (line 202) | def subsample(self, ratio, seed=None):
    method save (line 220) | def save(self, path):
    method regenerate_impropers (line 232) | def regenerate_impropers(self, improper_def="smirnoff"):
    method load (line 249) | def load(cls, path):
    method __add__ (line 262) | def __add__(self, x):
  class GraphDataset (line 266) | class GraphDataset(Dataset):
    method __init__ (line 278) | def __init__(self, graphs=[], first=None):
    method batch (line 296) | def batch(graphs):
    method view (line 314) | def view(self, collate_fn="graph", *args, **kwargs):
    method save (line 355) | def save(self, path):
    method load (line 363) | def load(cls, path):

FILE: espaloma/data/md.py
  function add_nonbonded_force (line 28) | def add_nonbonded_force(
  function get_coulomb_force (line 181) | def get_coulomb_force(
  function subtract_coulomb_force (line 320) | def subtract_coulomb_force(
  function subtract_nonbonded_force (line 346) | def subtract_nonbonded_force(
  function subtract_nonbonded_force_except_14 (line 508) | def subtract_nonbonded_force_except_14(
  class MoleculeVacuumSimulation (line 663) | class MoleculeVacuumSimulation(object):
    method __init__ (line 694) | def __init__(
    method simulation_from_graph (line 715) | def simulation_from_graph(self, g):
    method run (line 762) | def run(self, g, in_place=True):

FILE: espaloma/data/md17_utils.py
  function sum_offsets (line 36) | def sum_offsets(elements):
  function realize_molecule (line 40) | def realize_molecule(
  function get_molecule (line 84) | def get_molecule(name, *args, **kwargs):

FILE: espaloma/data/normalize.py
  class BaseNormalize (line 14) | class BaseNormalize(abc.ABC):
    method __init__ (line 17) | def __init__(self):
    method _prepare (line 21) | def _prepare(self):
  class DatasetNormalNormalize (line 30) | class DatasetNormalNormalize(BaseNormalize):
    method __init__ (line 48) | def __init__(self, dataset):
    method _prepare (line 53) | def _prepare(self):
  class DatasetLogNormalNormalize (line 122) | class DatasetLogNormalNormalize(BaseNormalize):
    method __init__ (line 140) | def __init__(self, dataset):
    method _prepare (line 145) | def _prepare(self):
  class ESOL100NormalNormalize (line 222) | class ESOL100NormalNormalize(DatasetNormalNormalize):
    method __init__ (line 223) | def __init__(self):
  class ESOL100LogNormalNormalize (line 234) | class ESOL100LogNormalNormalize(DatasetLogNormalNormalize):
    method __init__ (line 235) | def __init__(self):
  class NotNormalize (line 246) | class NotNormalize(BaseNormalize):
    method __init__ (line 247) | def __init__(self):
    method _prepare (line 251) | def _prepare(self):
  class PositiveNotNormalize (line 256) | class PositiveNotNormalize(BaseNormalize):
    method __init__ (line 257) | def __init__(self):
    method _prepare (line 261) | def _prepare(self):

FILE: espaloma/data/qcarchive_utils.py
  function get_client (line 24) | def get_client(url: str = "api.qcarchive.molssi.org") -> qcportal.client...
  function get_collection (line 42) | def get_collection(
  function process_record (line 76) | def process_record(record, entry):
  function get_graph (line 149) | def get_graph(collection, record_name, spec_name="default"):
  function get_graphs (line 176) | def get_graphs(collection, record_names, spec_name="default"):
  function fetch_td_record (line 211) | def fetch_td_record(record: qcportal.torsiondrive.record_models.Torsiond...
  function h5_to_dataset (line 283) | def h5_to_dataset(df):
  function breakdown_along_time_axis (line 338) | def breakdown_along_time_axis(g, batch_size=32):
  function make_batch_size_consistent (line 369) | def make_batch_size_consistent(ds, batch_size=32):
  function weight_by_snapshots (line 381) | def weight_by_snapshots(g, key="weight"):

FILE: espaloma/data/tests/test_collection.py
  function esol (line 5) | def esol():
  function test_view (line 11) | def test_view(esol):
  function test_typing (line 20) | def test_typing(esol):

FILE: espaloma/data/tests/test_dataset.py
  function test_tiny_dataset (line 4) | def test_tiny_dataset():
  function ds (line 12) | def ds():
  function test_get (line 19) | def test_get(ds):
  function test_len (line 23) | def test_len(ds):
  function test_iter (line 27) | def test_iter(ds):
  function test_slice (line 31) | def test_slice(ds):
  function test_split (line 39) | def test_split(ds):
  function ds_new (line 46) | def ds_new(ds):
  function test_no_change (line 51) | def test_no_change(ds_new):
  function test_get_new (line 55) | def test_get_new(ds_new):
  function test_len_new (line 59) | def test_len_new(ds_new):
  function test_iter_new (line 63) | def test_iter_new(ds_new):
  function ds_newer (line 68) | def ds_newer(ds):
  function test_iter_newer (line 73) | def test_iter_newer(ds_newer):
  function test_no_return (line 77) | def test_no_return(ds):
  function test_subsample (line 83) | def test_subsample(ds):

FILE: espaloma/data/tests/test_md.py
  function test_init (line 5) | def test_init():
  function graph (line 10) | def graph():
  function ds (line 18) | def ds():
  function test_system (line 25) | def test_system(graph):
  function test_run (line 31) | def test_run(graph):
  function test_run_in_place (line 41) | def test_run_in_place(graph):
  function test_apply (line 51) | def test_apply(ds):

FILE: espaloma/data/tests/test_normalize.py
  function test_import (line 5) | def test_import():
  function test_normalize_esol (line 9) | def test_normalize_esol():
  function test_log_normalize_esol (line 22) | def test_log_normalize_esol():
  function test_normal_normalize_reproduce (line 35) | def test_normal_normalize_reproduce():
  function test_log_normal_normalize_reproduce (line 79) | def test_log_normal_normalize_reproduce():

FILE: espaloma/data/tests/test_qcarchive.py
  function test_import (line 4) | def test_import():
  function test_get_graph (line 8) | def test_get_graph():
  function test_notsupported_dataset (line 30) | def test_notsupported_dataset():
  function test_get_torsiondrive (line 44) | def test_get_torsiondrive():

FILE: espaloma/data/tests/test_save_and_load.py
  function test_save_and_load (line 4) | def test_save_and_load():

FILE: espaloma/data/utils.py
  function make_temp_directory (line 26) | def make_temp_directory():
  function sum_offsets (line 36) | def sum_offsets(elements):
  function from_csv (line 40) | def from_csv(path, toolkit="rdkit", smiles_col=-1, y_cols=[-2], seed=2666):
  function normalize (line 73) | def normalize(ds):
  function split (line 89) | def split(ds, partition):
  function batch (line 105) | def batch(ds, batch_size, seed=2666):
  function collate_fn (line 130) | def collate_fn(graphs):
  function infer_mol_from_coordinates (line 136) | def infer_mol_from_coordinates(

FILE: espaloma/graphs/deploy.py
  function load_forcefield (line 32) | def load_forcefield(forcefield="openff_unconstrained-2.2.1"):
  function openmm_system_from_graph (line 42) | def openmm_system_from_graph(

FILE: espaloma/graphs/graph.py
  class BaseGraph (line 14) | class BaseGraph(abc.ABC):
    method __init__ (line 17) | def __init__(self):
  class Graph (line 21) | class Graph(BaseGraph):
    method __init__ (line 48) | def __init__(self, mol=None, homograph=None, heterograph=None):
    method save (line 70) | def save(self, path):
    method load (line 82) | def load(cls, path):
    method get_homograph_from_mol (line 110) | def get_homograph_from_mol(mol):
    method get_heterograph_from_graph_and_mol (line 129) | def get_heterograph_from_graph_and_mol(graph, mol):
    method ndata (line 156) | def ndata(self):
    method edata (line 160) | def edata(self):
    method nodes (line 164) | def nodes(self):

FILE: espaloma/graphs/legacy_force_field.py
  class LegacyForceField (line 36) | class LegacyForceField:
    method __init__ (line 54) | def __init__(self, forcefield="gaff-1.81"):
    method _convert_to_off (line 59) | def _convert_to_off(mol):
    method _prepare_forcefield (line 72) | def _prepare_forcefield(self):
    method _prepare_openff (line 87) | def _prepare_openff(self):
    method _prepare_smirnoff (line 93) | def _prepare_smirnoff(self):
    method _prepare_gaff (line 99) | def _prepare_gaff(self):
    method _type_gaff (line 137) | def _type_gaff(self, g):
    method _parametrize_gaff (line 188) | def _parametrize_gaff(self, g, n_max_phases=6):
    method _parametrize_smirnoff (line 430) | def _parametrize_smirnoff(self, g):
    method baseline_energy (line 613) | def baseline_energy(self, g, suffix=None):
    method _multi_typing_smirnoff (line 667) | def _multi_typing_smirnoff(self, g):
    method parametrize (line 718) | def parametrize(self, g):
    method typing (line 729) | def typing(self, g):
    method multi_typing (line 737) | def multi_typing(self, g):
    method __call__ (line 745) | def __call__(self, *args, **kwargs):

FILE: espaloma/graphs/tests/test_deploy.py
  function test_butane_charge_am1bcc (line 12) | def test_butane_charge_am1bcc():
  function test_butane_charge_nn (line 20) | def test_butane_charge_nn():
  function test_caffeine (line 38) | def test_caffeine():
  function test_parameter_consistent_caffeine (line 48) | def test_parameter_consistent_caffeine():
  function test_energy_consistent_caffeine (line 71) | def test_energy_consistent_caffeine():

FILE: espaloma/graphs/tests/test_gaff_parametrize.py
  function test_gaff_parametrize (line 5) | def test_gaff_parametrize():

FILE: espaloma/graphs/tests/test_graph.py
  function test_graph (line 9) | def test_graph():
  function graph (line 18) | def graph():
  function test_ndata_consistency (line 24) | def test_ndata_consistency(graph):
  function test_formal_charge (line 38) | def test_formal_charge(molecule, charge):
  function test_save_and_load (line 45) | def test_save_and_load(graph):
  function test_load_from_older_openff (line 56) | def test_load_from_older_openff(tmp_path_factory):

FILE: espaloma/graphs/tests/test_smirnoff.py
  function test_smirnoff_esol_first (line 6) | def test_smirnoff_esol_first():

FILE: espaloma/graphs/utils/offmol_indices.py
  function atom_indices (line 5) | def atom_indices(offmol: Molecule) -> np.ndarray:
  function bond_indices (line 9) | def bond_indices(offmol: Molecule) -> np.ndarray:
  function angle_indices (line 13) | def angle_indices(offmol: Molecule) -> np.ndarray:
  function proper_torsion_indices (line 24) | def proper_torsion_indices(offmol: Molecule) -> np.ndarray:
  function _all_improper_torsion_indices (line 35) | def _all_improper_torsion_indices(offmol: Molecule) -> np.ndarray:
  function improper_torsion_indices (line 48) | def improper_torsion_indices(

FILE: espaloma/graphs/utils/read_heterogeneous_graph.py
  function duplicate_index_ordering (line 18) | def duplicate_index_ordering(indices: np.ndarray) -> np.ndarray:
  function relationship_indices_from_offmol (line 33) | def relationship_indices_from_offmol(
  function from_homogeneous_and_mol (line 70) | def from_homogeneous_and_mol(g, offmol):

FILE: espaloma/graphs/utils/read_homogeneous_graph.py
  function fp_oe (line 14) | def fp_oe(atom):
  function fp_rdkit (line 64) | def fp_rdkit(atom):
  function from_openff_toolkit_mol (line 123) | def from_openff_toolkit_mol(mol, use_fp=True):
  function from_oemol (line 172) | def from_oemol(mol, use_fp=True):
  function from_rdkit_mol (line 216) | def from_rdkit_mol(mol, use_fp=True):

FILE: espaloma/graphs/utils/regenerate_impropers.py
  function regenerate_impropers (line 9) | def regenerate_impropers(g: Graph, improper_def="smirnoff"):

FILE: espaloma/metrics.py
  function center (line 16) | def center(metric, dim=1, reduction="none"):
  function boltzmann_weighted (line 32) | def boltzmann_weighted(metric, reduction="mean", temperature=300.0):
  function std (line 51) | def std(metric, weight=1.0, dim=1):
  function weighted (line 58) | def weighted(metric, weight, reduction="mean"):
  function weighted_with_key (line 70) | def weighted_with_key(metric, key="weight", reduction="mean"):
  function bootstrap (line 81) | def bootstrap(metric, n_samples=100, ci=0.95):
  function latex_format_ci (line 116) | def latex_format_ci(original, low, high):
  function mse (line 123) | def mse(input, target):
  function mape (line 127) | def mape(input, target):
  function rmse (line 131) | def rmse(input, target):
  function mae_of_log (line 135) | def mae_of_log(input, target):
  function cross_entropy (line 139) | def cross_entropy(input, target, reduction="mean"):
  function r2 (line 144) | def r2(input, target):
  function accuracy (line 152) | def accuracy(input, target):
  class Metric (line 163) | class Metric(torch.nn.modules.loss._Loss):
    method __init__ (line 166) | def __init__(self, size_average=None, reduce=None, reduction="mean"):
    method forward (line 170) | def forward(self, *args, **kwargs):
  class GraphMetric (line 174) | class GraphMetric(Metric):
    method __init__ (line 193) | def __init__(self, base_metric, between, level="n1", *args, **kwargs):
    method _translation (line 220) | def _translation(string, level):
    method forward (line 223) | def forward(self, g_input, g_target=None):
  class GraphDerivativeMetric (line 240) | class GraphDerivativeMetric(Metric):
    method __init__ (line 243) | def __init__(
    method _translation (line 284) | def _translation(string, level):
    method forward (line 287) | def forward(self, g_input, g_target=None):
  class GraphHalfDerivativeMetric (line 322) | class GraphHalfDerivativeMetric(Metric):
    method __init__ (line 325) | def __init__(
    method _translation (line 365) | def _translation(string, level):
    method forward (line 368) | def forward(self, g_input, g_target=None):
  class TypingCrossEntropy (line 398) | class TypingCrossEntropy(GraphMetric):
    method __init__ (line 399) | def __init__(self):
  class TypingAccuracy (line 408) | class TypingAccuracy(GraphMetric):
    method __init__ (line 409) | def __init__(self):
  class BondKMSE (line 417) | class BondKMSE(GraphMetric):
    method __init__ (line 418) | def __init__(self):
  class BondKRMSE (line 426) | class BondKRMSE(GraphMetric):
    method __init__ (line 427) | def __init__(self):

FILE: espaloma/mm/angle.py
  function harmonic_angle (line 10) | def harmonic_angle(x, k, eq):
  function linear_mixture_angle (line 36) | def linear_mixture_angle(x, coefficients, phases):
  function urey_bradley (line 54) | def urey_bradley(x_between, coefficients, phases):
  function bond_bond (line 62) | def bond_bond(u_left, u_right, k_bond_bond):
  function bond_angle (line 68) | def bond_angle(
  function angle_high (line 83) | def angle_high(

FILE: espaloma/mm/bond.py
  function harmonic_bond (line 10) | def harmonic_bond(x, k, eq):
  function gaussian_bond (line 36) | def gaussian_bond(x, coefficients):
  function linear_mixture_bond (line 44) | def linear_mixture_bond(x, coefficients, phases):
  function bond_high (line 61) | def bond_high(u_bond, k3, k4):

FILE: espaloma/mm/energy.py
  function apply_bond (line 12) | def apply_bond(nodes, suffix=""):
  function apply_angle (line 34) | def apply_angle(nodes, suffix=""):
  function apply_angle_ii (line 46) | def apply_angle_ii(nodes, suffix=""):
  function apply_bond_ii (line 76) | def apply_bond_ii(nodes, suffix=""):
  function apply_torsion_ii (line 87) | def apply_torsion_ii(nodes, suffix=""):
  function apply_torsion (line 122) | def apply_torsion(nodes, suffix=""):
  function apply_improper_torsion (line 148) | def apply_improper_torsion(nodes, suffix=""):
  function apply_bond_gaussian (line 179) | def apply_bond_gaussian(nodes, suffix=""):
  function apply_bond_linear_mixture (line 191) | def apply_bond_linear_mixture(nodes, suffix="", phases=[0.0, 1.0]):
  function apply_angle_linear_mixture (line 204) | def apply_angle_linear_mixture(nodes, suffix="", phases=[0.0, 1.0]):
  function apply_nonbonded (line 220) | def apply_nonbonded(nodes, scaling=1.0, suffix=""):
  function apply_coulomb (line 234) | def apply_coulomb(nodes, scaling=1.0, suffix=""):
  function energy_in_graph (line 248) | def energy_in_graph(
  function energy_in_graph_ii (line 396) | def energy_in_graph_ii(
  class EnergyInGraph (line 437) | class EnergyInGraph(torch.nn.Module):
    method __init__ (line 438) | def __init__(self, *args, **kwargs):
    method forward (line 443) | def forward(self, g):
  class EnergyInGraphII (line 447) | class EnergyInGraphII(torch.nn.Module):
    method __init__ (line 448) | def __init__(self, *args, **kwargs):
    method forward (line 453) | def forward(self, g):
  class CarryII (line 457) | class CarryII(torch.nn.Module):
    method forward (line 458) | def forward(self, g):

FILE: espaloma/mm/functional.py
  function linear_mixture_to_original (line 21) | def linear_mixture_to_original(k1, k2, b1, b2):
  function harmonic (line 37) | def harmonic(x, k, eq, order=[2]):
  function periodic_fixed_phases (line 62) | def periodic_fixed_phases(
  function periodic (line 124) | def periodic(
  function lj (line 203) | def lj(
  function gaussian (line 260) | def gaussian(x, coefficients, phases=[idx * 0.001 for idx in range(200)]):
  function linear_mixture (line 283) | def linear_mixture(x, coefficients, phases=[0.0, 1.0]):
  function harmonic_periodic_coupled (line 316) | def harmonic_periodic_coupled(
  function harmonic_harmonic_coupled (line 351) | def harmonic_harmonic_coupled(
  function harmonic_harmonic_periodic_coupled (line 362) | def harmonic_harmonic_periodic_coupled(

FILE: espaloma/mm/geometry.py
  function reduce_stack (line 9) | def reduce_stack(msg, out):
  function copy_src (line 18) | def copy_src(src, out):
  function distance (line 30) | def distance(x0, x1):
  function _angle (line 35) | def _angle(r0, r1):
  function angle (line 46) | def angle(x0, x1, x2):
  function _dihedral (line 53) | def _dihedral(r0, r1):
  function dihedral (line 58) | def dihedral(
  function apply_bond (line 95) | def apply_bond(nodes):
  function apply_angle (line 101) | def apply_angle(nodes):
  function apply_torsion (line 124) | def apply_torsion(nodes):
  function geometry_in_graph (line 165) | def geometry_in_graph(g):
  class GeometryInGraph (line 245) | class GeometryInGraph(torch.nn.Module):
    method __init__ (line 246) | def __init__(self, *args, **kwargs):
    method forward (line 251) | def forward(self, g):

FILE: espaloma/mm/nonbonded.py
  function geometric_mean (line 27) | def geometric_mean(msg="m", out="epsilon"):
  function arithmetic_mean (line 34) | def arithmetic_mean(msg="m", out="sigma"):
  function lorentz_berthelot (line 44) | def lorentz_berthelot(g, suffix=""):
  function multiply_charges (line 78) | def multiply_charges(g, suffix=""):
  function lj_12_6 (line 114) | def lj_12_6(x, sigma, epsilon):
  function lj_9_6 (line 135) | def lj_9_6(x, sigma, epsilon):
  function coulomb (line 158) | def coulomb(x, q, k_e=K_E):

FILE: espaloma/mm/tests/test_angle.py
  function test_angle_random_vectors (line 7) | def test_angle_random_vectors():
  function test_angle_random_points (line 31) | def test_angle_random_points():
  function test_zero (line 54) | def test_zero():

FILE: espaloma/mm/tests/test_angle_energy.py
  function test_energy_angle_and_bond (line 18) | def test_energy_angle_and_bond():

FILE: espaloma/mm/tests/test_bond_energy.py
  function test_multiple_conformation (line 4) | def test_multiple_conformation():

FILE: espaloma/mm/tests/test_charge_energy_consistency.py
  function test_coulomb_energy_consistency (line 14) | def test_coulomb_energy_consistency(g):

FILE: espaloma/mm/tests/test_charge_energy_consistency_hardcode.py
  function test_coulomb_energy_consistency (line 15) | def test_coulomb_energy_consistency(g):

FILE: espaloma/mm/tests/test_dihedral.py
  function test_dihedral_vectors (line 11) | def test_dihedral_vectors():
  function test_dihedral_points (line 28) | def test_dihedral_points():

FILE: espaloma/mm/tests/test_distance.py
  function test_distance (line 7) | def test_distance():

FILE: espaloma/mm/tests/test_energy.py
  function test_import (line 7) | def test_import():
  function test_energy (line 11) | def test_energy():

FILE: espaloma/mm/tests/test_energy_ii.py
  function test_energy (line 7) | def test_energy():

FILE: espaloma/mm/tests/test_geometry.py
  function test_import (line 8) | def test_import():
  function all_g (line 24) | def all_g():
  function test_geometry_can_be_computed_without_exceptions (line 41) | def test_geometry_can_be_computed_without_exceptions(all_g):
  function test_geometry_n_terms (line 46) | def test_geometry_n_terms(all_g):

FILE: espaloma/mm/tests/test_linear_combination.py
  function test_linear_combination (line 4) | def test_linear_combination():
  function test_consistency (line 25) | def test_consistency():

FILE: espaloma/mm/tests/test_openmm_consistency.py
  function _create_torsion_sim (line 20) | def _create_torsion_sim(
  function test_periodic_torsion (line 49) | def test_periodic_torsion(
  function test_energy_angle_and_bond (line 100) | def test_energy_angle_and_bond(g):

FILE: espaloma/mm/tests/test_recoverability.py
  function _create_impropers_only_system (line 14) | def _create_impropers_only_system(
  function test_improper_recover (line 75) | def test_improper_recover():

FILE: espaloma/mm/torsion.py
  function periodic_torsion (line 10) | def periodic_torsion(
  function angle_angle (line 45) | def angle_angle(
  function angle_torsion (line 58) | def angle_torsion(
  function angle_angle_torsion (line 74) | def angle_angle_torsion(
  function bond_torsion (line 92) | def bond_torsion(

FILE: espaloma/nn/baselines.py
  class FreeParameterBaseline (line 10) | class FreeParameterBaseline(torch.nn.Module):
    method __init__ (line 17) | def __init__(self, g_ref):
    method forward (line 36) | def forward(self, g):
  class FreeParameterBaselineInitMean (line 60) | class FreeParameterBaselineInitMean(torch.nn.Module):
    method __init__ (line 66) | def __init__(self, g_ref):
    method forward (line 86) | def forward(self, g):

FILE: espaloma/nn/layers/dgl_legacy.py
  class GN (line 23) | class GN(torch.nn.Module):
    method __init__ (line 24) | def __init__(
    method forward (line 46) | def forward(self, g, x):
  function gn (line 55) | def gn(model_name="GraphConv", kwargs={}):

FILE: espaloma/nn/readout/base_readout.py
  class BaseReadout (line 12) | class BaseReadout(abc.ABC, torch.nn.Module):
    method __init__ (line 15) | def __init__(self):
    method forward (line 19) | def forward(self, g, x=None, *args, **kwargs):
    method _forward (line 22) | def _forward(self, g, x, *args, **kwargs):

FILE: espaloma/nn/readout/charge_equilibrium.py
  function get_charges (line 12) | def get_charges(node):
  class ChargeEquilibrium (line 59) | class ChargeEquilibrium(torch.nn.Module):
    method __init__ (line 62) | def __init__(self):
    method forward (line 65) | def forward(self, g, total_charge=0.0):

FILE: espaloma/nn/readout/graph_level_readout.py
  class GraphLevelReadout (line 10) | class GraphLevelReadout(torch.nn.Module):
    method __init__ (line 13) | def __init__(
    method forward (line 47) | def forward(self, g):

FILE: espaloma/nn/readout/janossy.py
  class JanossyPooling (line 12) | class JanossyPooling(torch.nn.Module):
    method __init__ (line 19) | def __init__(
    method forward (line 92) | def forward(self, g):
  class JanossyPoolingImproper (line 176) | class JanossyPoolingImproper(torch.nn.Module):
    method __init__ (line 183) | def __init__(
    method forward (line 228) | def forward(self, g):
  class JanossyPoolingWithSmirnoffImproper (line 296) | class JanossyPoolingWithSmirnoffImproper(torch.nn.Module):
    method __init__ (line 301) | def __init__(
    method forward (line 346) | def forward(self, g):
  class JanossyPoolingNonbonded (line 414) | class JanossyPoolingNonbonded(torch.nn.Module):
    method __init__ (line 421) | def __init__(
    method forward (line 464) | def forward(self, g):
  class ExpCoefficients (line 533) | class ExpCoefficients(torch.nn.Module):
    method forward (line 534) | def forward(self, g):
  class LinearMixtureToOriginal (line 546) | class LinearMixtureToOriginal(torch.nn.Module):
    method forward (line 547) | def forward(self, g):

FILE: espaloma/nn/readout/node_typing.py
  class NodeTyping (line 12) | class NodeTyping(BaseReadout):
    method __init__ (line 15) | def __init__(self, in_features, n_classes=100):
    method forward (line 19) | def forward(self, g):

FILE: espaloma/nn/sequential.py
  class _Sequential (line 6) | class _Sequential(torch.nn.Module):
    method __init__ (line 9) | def __init__(
    method forward (line 59) | def forward(self, g, x):
  class Sequential (line 72) | class Sequential(torch.nn.Module):
    method __init__ (line 93) | def __init__(
    method _forward (line 112) | def _forward(self, g, x):
    method forward (line 122) | def forward(self, g, x=None):

FILE: espaloma/nn/tests/test_baseline.py
  function baseline (line 5) | def baseline():
  function test_init (line 25) | def test_init(baseline):
  function test_parameter (line 29) | def test_parameter(baseline):

FILE: espaloma/nn/tests/test_janossy.py
  function test_small_net (line 4) | def test_small_net():

FILE: espaloma/nn/tests/test_simple_net.py
  function test_small_net (line 4) | def test_small_net():

FILE: espaloma/utils/geometry.py
  function _sample_unit_circle (line 4) | def _sample_unit_circle(n_samples: int = 1) -> np.ndarray:
  function _sample_four_particle_torsion_scan (line 18) | def _sample_four_particle_torsion_scan(n_samples: int = 1) -> np.ndarray:
  function _timemachine_signed_torsion_angle (line 52) | def _timemachine_signed_torsion_angle(ci, cj, ck, cl):

FILE: espaloma/utils/model_fetch.py
  function _get_model_url (line 9) | def _get_model_url(version: str) -> str:
  function get_model_path (line 37) | def get_model_path(
  function get_model (line 96) | def get_model(version: str = "latest") -> dict[str, Any]:

FILE: espaloma/utils/tests/test_model_fetch.py
  function test_get_model_path (line 6) | def test_get_model_path(tmp_path):
  function test_get_model (line 18) | def test_get_model(tmp_path):

FILE: scripts/perses-benchmark/tyk2/espaloma-0.2.2/benchmark_analysis.py
  function get_simdir_list (line 30) | def get_simdir_list(base_dir='.', is_reversed=False):
  function get_simulations_data (line 58) | def get_simulations_data(simulation_dirs):
  function to_arsenic_csv (line 72) | def to_arsenic_csv(experimental_data: dict, simulation_data: list, out_c...

FILE: scripts/perses-benchmark/tyk2/espaloma-0.2.2/run_benchmarks.py
  function concatenate_files (line 33) | def concatenate_files(input_files, output_file):
  function run_relative_perturbation (line 44) | def run_relative_perturbation(lig_a_idx, lig_b_idx, reverse=False, tidy=...

FILE: scripts/perses-benchmark/tyk2/openff-1.2.0/benchmark_analysis.py
  function get_simdir_list (line 30) | def get_simdir_list(base_dir='.', is_reversed=False):
  function get_simulations_data (line 58) | def get_simulations_data(simulation_dirs):
  function to_arsenic_csv (line 72) | def to_arsenic_csv(experimental_data: dict, simulation_data: list, out_c...

FILE: scripts/perses-benchmark/tyk2/openff-1.2.0/run_benchmarks.py
  function concatenate_files (line 33) | def concatenate_files(input_files, output_file):
  function run_relative_perturbation (line 44) | def run_relative_perturbation(lig_a_idx, lig_b_idx, reverse=False, tidy=...

FILE: versioneer.py
  class VersioneerConfig (line 333) | class VersioneerConfig:
  function get_root (line 345) | def get_root() -> str:
  function get_config_from_root (line 394) | def get_config_from_root(root: str) -> VersioneerConfig:
  class NotThisMethod (line 442) | class NotThisMethod(Exception):
  function register_vcs_handler (line 451) | def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
  function run_command (line 460) | def run_command(
  function git_get_keywords (line 1195) | def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
  function git_versions_from_keywords (line 1223) | def git_versions_from_keywords(
  function git_pieces_from_vcs (line 1291) | def git_pieces_from_vcs(
  function do_vcs_install (line 1428) | def do_vcs_install(versionfile_source: str, ipy: Optional[str]) -> None:
  function versions_from_parentdir (line 1466) | def versions_from_parentdir(
  function versions_from_file (line 1512) | def versions_from_file(filename: str) -> Dict[str, Any]:
  function write_to_version_file (line 1529) | def write_to_version_file(filename: str, versions: Dict[str, Any]) -> None:
  function plus_or_dot (line 1539) | def plus_or_dot(pieces: Dict[str, Any]) -> str:
  function render_pep440 (line 1546) | def render_pep440(pieces: Dict[str, Any]) -> str:
  function render_pep440_branch (line 1571) | def render_pep440_branch(pieces: Dict[str, Any]) -> str:
  function pep440_split_post (line 1601) | def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
  function render_pep440_pre (line 1611) | def render_pep440_pre(pieces: Dict[str, Any]) -> str:
  function render_pep440_post (line 1635) | def render_pep440_post(pieces: Dict[str, Any]) -> str:
  function render_pep440_post_branch (line 1662) | def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
  function render_pep440_old (line 1691) | def render_pep440_old(pieces: Dict[str, Any]) -> str:
  function render_git_describe (line 1713) | def render_git_describe(pieces: Dict[str, Any]) -> str:
  function render_git_describe_long (line 1733) | def render_git_describe_long(pieces: Dict[str, Any]) -> str:
  function render (line 1753) | def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
  class VersioneerBadRootError (line 1789) | class VersioneerBadRootError(Exception):
  function get_versions (line 1793) | def get_versions(verbose: bool = False) -> Dict[str, Any]:
  function get_version (line 1869) | def get_version() -> str:
  function get_cmdclass (line 1874) | def get_cmdclass(cmdclass: Optional[Dict[str, Any]] = None):
  function do_setup (line 2173) | def do_setup() -> int:
  function scan_setup_py (line 2230) | def scan_setup_py() -> int:
  function setup_command (line 2267) | def setup_command() -> NoReturn: