epr_deer¶

metrics

Bindings for core::scoring::epr_deer namespace

class pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache¶

Bases: CacheableData

append(*args, **kwargs)¶

Overloaded function.

append(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, data: core::scoring::epr_deer::metrics::DEERData) -> None

Adds DEERDataOP object to DEERDataCache at earliest spot

metrics::DEERDataOP object to insert

C++: core::scoring::epr_deer::DEERDataCache::append(const class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData> &) –> void

append(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, data: core::scoring::epr_deer::metrics::DEERData, i: int) -> None

Adds DEERDataOP object to DEERDataCache at predefined spot

Object to insert

Position to insert object

C++: core::scoring::epr_deer::DEERDataCache::append(const class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData> &, const unsigned long &) –> void

assign(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, : pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache¶: C++: core::scoring::epr_deer::DEERDataCache::operator=(const class core::scoring::epr_deer::DEERDataCache &) –> class core::scoring::epr_deer::DEERDataCache &

at(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, i: int) → core::scoring::epr_deer::metrics::DEERData¶

Returns const data for a given ID (or nullptr if empty)

Index of data object ()

Requested DEERDataOP object (or nullptr)

C++: core::scoring::epr_deer::DEERDataCache::at(const unsigned long &) const –> const class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData> &

clone(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.basic.datacache.CacheableData¶

Copy function, overrides parent class

C++: core::scoring::epr_deer::DEERDataCache::clone() const –> class std::shared_ptr<class basic::datacache::CacheableData>

delete_data(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, i: int) → None¶

Removes data at specific spot and reparameterizes

Key of data in map

C++: core::scoring::epr_deer::DEERDataCache::delete_data(const unsigned long &) –> void

edge(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, rsd1: int, rsd2: int) → pyrosetta.rosetta.std.map_unsigned_long_double¶

Returns number of edges corresponding to the pair of residues

identity of first residue (AA sequence)

identity of second residue (AA sequence)

Map with edges and weights for residue pair

C++: core::scoring::epr_deer::DEERDataCache::edge(const unsigned long &, const unsigned long &) const –> class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >

f1_force(*args, **kwargs)¶

Overloaded function.

f1_force(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, res: int, vec: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Sets F1 force stored for residue

Residue ID of interest

Vector of F1 force

C++: core::scoring::epr_deer::DEERDataCache::f1_force(const unsigned long &, const class numeric::xyzVector<double> &) –> void

f1_force(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, res: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Returns the F1 force applied to a residue

Residue ID of interest

F1 force

C++: core::scoring::epr_deer::DEERDataCache::f1_force(const unsigned long &) const –> const class numeric::xyzVector<double> &

f2_force(*args, **kwargs)¶

Overloaded function.

f2_force(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, res: int, vec: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

Sets F2 force stored for residue

Residue ID of interest

Vector of F2 force

C++: core::scoring::epr_deer::DEERDataCache::f2_force(const unsigned long &, const class numeric::xyzVector<double> &) –> void

f2_force(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, res: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

Returns the F2 force applied to a residue

Residue ID of interest

F2 force

C++: core::scoring::epr_deer::DEERDataCache::f2_force(const unsigned long &) const –> const class numeric::xyzVector<double> &

fetch_and_organize_data(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

Fetches are parses data from command line using DEERIO object

Pose object from which data will be fetched

C++: core::scoring::epr_deer::DEERDataCache::fetch_and_organize_data(const class core::pose::Pose &) –> void

get_self_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.basic.datacache.CacheableData¶: C++: basic::datacache::CacheableData::get_self_ptr() –> class std::shared_ptr<class basic::datacache::CacheableData>

get_self_weak_ptr(self: pyrosetta.rosetta.basic.datacache.CacheableData) → pyrosetta.rosetta.std.weak_ptr_basic_datacache_CacheableData_t¶: C++: basic::datacache::CacheableData::get_self_weak_ptr() –> class std::weak_ptr<class basic::datacache::CacheableData>

has_data(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, i: int) → bool¶

Check and return if data in spot is occupied

Key to check

Whether key is being used

C++: core::scoring::epr_deer::DEERDataCache::has_data(const unsigned long &) –> bool

has_f1_force(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, res: int) → bool¶

Returns if F1 force is stored for residue

Residue ID of interest

True or false if residue is stored in F1 force map

C++: core::scoring::epr_deer::DEERDataCache::has_f1_force(const unsigned long &) const –> bool

has_f2_force(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, res: int) → bool¶

Checks if residues has an F1 force, used for gradient minimzation

C++: core::scoring::epr_deer::DEERDataCache::has_f2_force(const unsigned long &) const –> bool

indices(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.std.set_unsigned_long_t¶

Returns set of keys in the data map

Set object containing all keys in map

C++: core::scoring::epr_deer::DEERDataCache::indices() const –> class std::set<unsigned long, struct std::less<unsigned long>, class std::allocator<unsigned long> >

label_types(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.std.set_std_string_t¶

Returns list of residues spin labels to compute

Labels required by data

C++: core::scoring::epr_deer::DEERDataCache::label_types() const –> class std::set<std::string, struct std::less<std::string >, class std::allocator<std::string > >

labeled_residues(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t¶

Returns vector of residues and appropriate spin labels to compute

Residues in data

C++: core::scoring::epr_deer::DEERDataCache::labeled_residues() const –> class utility::vector1<struct std::pair<unsigned long, std::string >, class std::allocator<struct std::pair<unsigned long, std::string > > >

labels(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.utility.vector1_core_scoring_epr_deer_EPRSpinLabel¶

Stores the coordinates for residues with CUSTOM spin labels

utility::vector1< EPRSpinLabel > of custom SL rotamers in data

C++: core::scoring::epr_deer::DEERDataCache::labels() const –> class utility::vector1<class core::scoring::epr_deer::EPRSpinLabel, class std::allocator<class core::scoring::epr_deer::EPRSpinLabel> >

push_back(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, data: core::scoring::epr_deer::metrics::DEERData) → None¶

Adds DEERDataOP object to DEERDataCache at last spot

metrics::DEERDataOP object to insert

C++: core::scoring::epr_deer::DEERDataCache::push_back(const class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData> &) –> void

set_labels(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, labels: pyrosetta.rosetta.utility.vector1_core_scoring_epr_deer_EPRSpinLabel) → None¶

Stores the normalized coordinates for residues with CUSTOM spin labels

Custom rotamers across model

C++: core::scoring::epr_deer::DEERDataCache::set_labels(const class utility::vector1<class core::scoring::epr_deer::EPRSpinLabel, class std::allocator<class core::scoring::epr_deer::EPRSpinLabel> > &) –> void

set_sl_weights(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache, weights: pyrosetta.rosetta.utility.vector1_double) → None¶

Stores the weights assigned to CUSTOM spin label coordinates

Vector of weights for custom SLs

C++: core::scoring::epr_deer::DEERDataCache::set_sl_weights(const class utility::vector1<double, class std::allocator<double> > &) –> void

set_up_residues(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → None¶

Initializer function following reading of data

C++: core::scoring::epr_deer::DEERDataCache::set_up_residues() –> void

size(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → int¶

Returns number of DEERDataOPs stored here

Size object ofnumber of DEERDataOPs in map

Note: output could be less than data_.rbegin()->first)

C++: core::scoring::epr_deer::DEERDataCache::size() const –> unsigned long

sl_weights(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERDataCache) → pyrosetta.rosetta.utility.vector1_double¶

Returns the weights assigned to CUSTOM spin label coordinates

Vector of weights

C++: core::scoring::epr_deer::DEERDataCache::sl_weights() const –> const class utility::vector1<double, class std::allocator<double> > &

class pyrosetta.rosetta.core.scoring.epr_deer.DEERIO¶

Bases: pybind11_object

generate_data(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, pose: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.std.map_unsigned_long_std_shared_ptr_core_scoring_epr_deer_metrics_DEERData_t_std_allocator_std_pair_const_unsigned_long_std_shared_ptr_core_scoring_epr_deer_metrics_DEERData_t¶

Generates the data for use. Core function

Input pose (used for residue numbering)

Map of input data

Will only compute this once! Otherwise, the data is saved

in a static/global object (epr_deer_input_data_) defined in

header file

C++: core::scoring::epr_deer::DEERIO::generate_data(const class core::pose::Pose &) const –> class std::map<unsigned long, class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData> > > >

parse_bounds_lines(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, bounds_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t, bounds_data: core::scoring::epr_deer::metrics::DEERData) → None¶

Parses data for DEERDistanceBounds object

Lines labeled “BOUNDS” in input file

Proper data container that can be used by Rosetta

Note that only the last BOUNDS line will be used

C++: core::scoring::epr_deer::DEERIO::parse_bounds_lines(const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &, class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>) const –> void

parse_data(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, pose: pyrosetta.rosetta.core.pose.Pose, lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t) → core::scoring::epr_deer::metrics::DEERData¶

Parse the input lines into actual data containers

Pose (used for residue numbering)

Index of datum (used for error messages)

Lines associated with this dataset

Proper data container that can be used by Rosetta

C++: core::scoring::epr_deer::DEERIO::parse_data(const class core::pose::Pose &, const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &) const –> class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>

parse_decay_info_lines(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, info_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t, data: core::scoring::epr_deer::metrics::DEERData) → None¶

Parses information data for DEERDecayData object

Lines labeled “INFO” in input file

Proper data container that can be used by Rosetta

C++: core::scoring::epr_deer::DEERIO::parse_decay_info_lines(const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &, class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>) const –> void

parse_decay_lines(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, decay_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t, data: core::scoring::epr_deer::metrics::DEERData) → None¶

Parses decay data for DEERDecayData object

Lines labeled “DECAY” in input file

Proper data container that can be used by Rosetta

C++: core::scoring::epr_deer::DEERIO::parse_decay_lines(const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &, class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData> &) const –> void

parse_desc_lines(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, pose: pyrosetta.rosetta.core.pose.Pose, desc_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t) → pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t¶

Parse input lines for information on residues involved in data

Pose (used for residue renumbering)

Input lines containing this information

List of residues describing both the ID# and spin label type

C++: core::scoring::epr_deer::DEERIO::parse_desc_lines(const class core::pose::Pose &, const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &) const –> class utility::vector1<struct std::pair<unsigned long, std::string >, class std::allocator<struct std::pair<unsigned long, std::string > > >

parse_dist_datatype(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, info_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t) → core::scoring::epr_deer::metrics::DEERData¶

Determines function used by DEERDistanceDistribution

Lines labeled “INFO” in input file

Proper data container that can be used by Rosetta

Note that this container, upon output, is incomplete!

C++: core::scoring::epr_deer::DEERIO::parse_dist_datatype(const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &) const –> class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>

parse_dist_info_lines(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, info_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t) → core::scoring::epr_deer::metrics::DEERData¶

Parses lines labeled “INFO” into information usable by Rosetta

Lines with the information (as strings)

Proper data container that can be used by Rosetta

Note that this container, upon output, is incomplete!

C++: core::scoring::epr_deer::DEERIO::parse_dist_info_lines(const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &) const –> class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>

parse_dist_lines(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, dist_lines: pyrosetta.rosetta.utility.vector1_utility_vector1_std_string_std_allocator_std_string_t, data: core::scoring::epr_deer::metrics::DEERData) → None¶

Parses lines labeled “DIST” into information usable by Rosetta

Lines with the distance distributions

DEERData object (passed by reference and modified here)

C++: core::scoring::epr_deer::DEERIO::parse_dist_lines(const class utility::vector1<class utility::vector1<std::string, class std::allocator<std::string > >, class std::allocator<class utility::vector1<std::string, class std::allocator<std::string > > > > &, class std::shared_ptr<class core::scoring::epr_deer::metrics::DEERData>) const –> void

split_line(self: pyrosetta.rosetta.core.scoring.epr_deer.DEERIO, line: str) → pyrosetta.rosetta.utility.vector1_std_string¶

Split an input line into vector of strings

Line of interest

Vector of strings

Ignores lines starting with “#”

C++: core::scoring::epr_deer::DEERIO::split_line(const std::string &) const –> class utility::vector1<std::string, class std::allocator<std::string > >

class pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, : pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel) → pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel¶: C++: core::scoring::epr_deer::EPRSpinLabel::operator=(const class core::scoring::epr_deer::EPRSpinLabel &) –> class core::scoring::epr_deer::EPRSpinLabel &

at(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res: Tuple[int, str]) → pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t¶

Return const PseudoSL from specific residue

Residue info (number and spin label type)

Coords corresponding to residue

C++: core::scoring::epr_deer::EPRSpinLabel::at(const struct std::pair<unsigned long, std::string > &) const –> const class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > > &

calc_sl_for_res(*args, **kwargs)¶

Overloaded function.

calc_sl_for_res(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res: int, pose: pyrosetta.rosetta.core.pose.Pose, sl_vec: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t) -> pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t
calc_sl_for_res(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res: int, pose: pyrosetta.rosetta.core.pose.Pose, sl_vec: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, skip_clash_eval: bool) -> pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t
calc_sl_for_res(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res: int, pose: pyrosetta.rosetta.core.pose.Pose, sl_vec: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, skip_clash_eval: bool, min_rad: float) -> pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t

Get positions of unpaired electrons at a residue

Residue number

Pose for clash eval

Vector of PseudoSLs, which have positions of unpaired e

Exactly what it suggested by the title

Lowest radius for clash eval to check

Vector of PseudoSLs in local coordinate frame of residue

C++: core::scoring::epr_deer::EPRSpinLabel::calc_sl_for_res(const unsigned long &, const class core::pose::Pose &, const class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > > &, const bool &, const double &) –> class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > >

cutoff(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel) → float¶

Getter for cutoff for weights

Weight cutoff

C++: core::scoring::epr_deer::EPRSpinLabel::cutoff() const –> double

histogram(*args, **kwargs)¶

Overloaded function.

histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, residues: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t, bins_per_a: int) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, residues: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t, bins_per_a: int, mod: int) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, residues: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t, bins_per_a: int, mod: int, stdev: float) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, residues: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t, bins_per_a: int, mod: int, stdev: float, dist_ids: pyrosetta.rosetta.std.map_unsigned_long_double) -> pyrosetta.rosetta.std.map_unsigned_long_double

Returns histogram between coordinate sets for residues

Residues contributing to histogram

Granularity of histogram (bins per angstrom)

What to add to the X-axis

If a custom X-axis is used (default: empty)

Histogram with X- and Y-values being keys and values

Note: the X-axis = bins_per_a * distance, rounded to an int

Note: Equal labeling assumed for all sites

This matters if residues.size() > 2

C++: core::scoring::epr_deer::EPRSpinLabel::histogram(const class utility::vector1<struct std::pair<unsigned long, std::string >, class std::allocator<struct std::pair<unsigned long, std::string > > > &, const unsigned long &, const int &, const double &, const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) –> class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >

histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, res2_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, bins_per_a: int) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, res2_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, bins_per_a: int, mod: int) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, res2_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, bins_per_a: int, mod: int, stdev: float) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, res2_coords: pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t, bins_per_a: int, mod: int, stdev: float, dist_ids: pyrosetta.rosetta.std.map_unsigned_long_double) -> pyrosetta.rosetta.std.map_unsigned_long_double

Return histogram for pair of coordinate sets

Pair of PseudoSL coords for res1

Pair of PseudoSL coords for res2

Bins per angstrom for distribution

How much to shift X-axis

St deviation of gauss used to convolute pairwise dists

If a custom X-axis is used (default: empty)

Histogram with X- and Y-values being keys and values

Note: the X-axis = bins_per_a * distance, rounded to an int

C++: core::scoring::epr_deer::EPRSpinLabel::histogram(const class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > > &, const class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > > &, const unsigned long &, const int &, const double &, const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) –> class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >

histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1: Tuple[int, str], res2: Tuple[int, str], bins_per_a: int) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1: Tuple[int, str], res2: Tuple[int, str], bins_per_a: int, mod: int) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1: Tuple[int, str], res2: Tuple[int, str], bins_per_a: int, mod: int, stdev: float) -> pyrosetta.rosetta.std.map_unsigned_long_double
histogram(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1: Tuple[int, str], res2: Tuple[int, str], bins_per_a: int, mod: int, stdev: float, dist_ids: pyrosetta.rosetta.std.map_unsigned_long_double) -> pyrosetta.rosetta.std.map_unsigned_long_double

Returns histogram between coordinate sets for residues

Residue 1

Residue 2

Granularity of histogram (bins per angstrom)

What to add to the X-axis

If a custom X-axis is used (default: empty)

Histogram with X- and Y-values being keys and values

Note: the X-axis = bins_per_a * distance, rounded to an int

C++: core::scoring::epr_deer::EPRSpinLabel::histogram(const struct std::pair<unsigned long, std::string > &, const struct std::pair<unsigned long, std::string > &, const unsigned long &, const int &, const double &, const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) –> class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >

init_vdw(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel) → None¶

Initialize object used to calculate centroid clashes

C++: core::scoring::epr_deer::EPRSpinLabel::init_vdw() const –> void

label(*args, **kwargs)¶

Overloaded function.

label(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res_label: Tuple[int, str], pose: pyrosetta.rosetta.core.pose.Pose) -> None
label(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res_label: Tuple[int, str], pose: pyrosetta.rosetta.core.pose.Pose, skip_clash_eval: bool) -> None

Label a residue with a certain spin label

Residue index

SL type

Pose used for superimposition

Whether clash evaluation is skipped

Clashes are skipped for custom coordinates for reasons

relating to the way they have been calculated

C++: core::scoring::epr_deer::EPRSpinLabel::label(const struct std::pair<unsigned long, std::string > &, const class core::pose::Pose &, const bool &) –> void

label_everything(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, pose: pyrosetta.rosetta.core.pose.Pose, residues: pyrosetta.rosetta.utility.vector1_std_pair_unsigned_long_std_string_t, skip_clash_eval: bool) → None¶

Goes through every residue in provided list and calculates

Pose to label

Residues that need to be labeled

Whether clash evaluation should be skipped

C++: core::scoring::epr_deer::EPRSpinLabel::label_everything(class core::pose::Pose &, const class utility::vector1<struct std::pair<unsigned long, std::string >, class std::allocator<struct std::pair<unsigned long, std::string > > > &, const bool &) –> void

load_custom_electrons(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, all_coords: pyrosetta.rosetta.std.map_unsigned_long_utility_vector1_std_pair_numeric_xyzVector_double_double_std_allocator_std_pair_numeric_xyzVector_double_double_t_std_allocator_std_pair_const_unsigned_long_utility_vector1_std_pair_numeric_xyzVector_double_double_std_allocator_std_pair_numeric_xyzVector_double_double_t) → None¶

Allows a custom set of electrons to be read without superimposition

Custom residue-specific PseudoSLs

C++: core::scoring::epr_deer::EPRSpinLabel::load_custom_electrons(const class std::map<unsigned long, class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > >, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > > > > > &) –> void

normalize(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, sim_map: pyrosetta.rosetta.std.map_unsigned_long_double) → pyrosetta.rosetta.std.map_unsigned_long_double¶

Normalize distribution so that the sum is equal to 1.0

Simulated DEER distribution

Identical std::map except values add up to 1.0

C++: core::scoring::epr_deer::EPRSpinLabel::normalize(class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >) const –> class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > >

read_db_file(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, name: str) → pyrosetta.rosetta.utility.vector1_std_pair_numeric_xyzVector_double_double_t¶

Read DB file for a given type of spin label

of file/SL type

PseudoSLs used for simulation of DEER distributions

C++: core::scoring::epr_deer::EPRSpinLabel::read_db_file(const std::string &) –> class utility::vector1<struct std::pair<class numeric::xyzVector<double>, double>, class std::allocator<struct std::pair<class numeric::xyzVector<double>, double> > >

weight(self: pyrosetta.rosetta.core.scoring.epr_deer.EPRSpinLabel, res1: int, clash_xyz: pyrosetta.rosetta.numeric.xyzVector_double_t, w: float, pose: pyrosetta.rosetta.core.pose.Pose, rad: float) → float¶

retrieve weight for given coordinate

Residue over which the coordinate is being superimposed

Coordinate used for clash calculation

Weight, passed by value since we need a new obj to modify

Pose with all the residues we check for clash evaluation

Radius of the clash_xyz atom to consider

Weight of PseudoSL at position given local environment of pose

C++: core::scoring::epr_deer::EPRSpinLabel::weight(const unsigned long &, const class numeric::xyzVector<double> &, double, const class core::pose::Pose &, const double &) –> double

class pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, rhs: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) → pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace¶

Copy assignment operator

Trace object to copy

Copy

C++: core::scoring::epr_deer::Simulated4PDEERTrace::operator=(const class core::scoring::epr_deer::Simulated4PDEERTrace &) –> class core::scoring::epr_deer::Simulated4PDEERTrace &

deer_trace(*args, **kwargs)¶

Overloaded function.

deer_trace(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) -> pyrosetta.rosetta.utility.vector1_double

DEER trace getter

The final DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::deer_trace() const –> class utility::vector1<double, class std::allocator<double> >

deer_trace(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, val: pyrosetta.rosetta.utility.vector1_double) -> None

Final DEER trace setter

The final DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::deer_trace(const class utility::vector1<double, class std::allocator<double> > &) –> void

deer_trace_intra(*args, **kwargs)¶

Overloaded function.

deer_trace_intra(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) -> pyrosetta.rosetta.utility.vector1_double

Intramolecular DEER trace getter

The intramolecular DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::deer_trace_intra() const –> class utility::vector1<double, class std::allocator<double> >

deer_trace_intra(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, val: pyrosetta.rosetta.utility.vector1_double) -> None

Intramolecular DEER trace setter

The intramolecular DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::deer_trace_intra(const class utility::vector1<double, class std::allocator<double> > &) –> void

depth(*args, **kwargs)¶

Overloaded function.

depth(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) -> float

Modulation depth getter

Modulation depth

C++: core::scoring::epr_deer::Simulated4PDEERTrace::depth() const –> double

depth(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, val: float) -> None

Modulation depth setter

Modulation depth

C++: core::scoring::epr_deer::Simulated4PDEERTrace::depth(const double &) –> void

dim(*args, **kwargs)¶

Overloaded function.

dim(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) -> float

Background dimensionality getter

Background dimensionality

C++: core::scoring::epr_deer::Simulated4PDEERTrace::dim() const –> double

dim(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, val: float) -> None

Dimensionality setter

Background dimensionality

C++: core::scoring::epr_deer::Simulated4PDEERTrace::dim(const double &) –> void

size(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) → int¶

Return size of DEER trace

Size of DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::size() const –> unsigned long

slope(*args, **kwargs)¶

Overloaded function.

slope(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) -> float

Background slope getter

Background slope

C++: core::scoring::epr_deer::Simulated4PDEERTrace::slope() const –> double

slope(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, val: float) -> None

Background slope setter

Background slope

C++: core::scoring::epr_deer::Simulated4PDEERTrace::slope(const double &) –> void

time_pts(*args, **kwargs)¶

Overloaded function.

time_pts(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace) -> pyrosetta.rosetta.utility.vector1_double

Time point getter

Time points for the DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::time_pts() const –> class utility::vector1<double, class std::allocator<double> >

time_pts(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace, val: pyrosetta.rosetta.utility.vector1_double) -> None

Time point vector setter

Time points for the DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTrace::time_pts(const class utility::vector1<double, class std::allocator<double> > &) –> void

class pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory¶

Bases: pybind11_object

append_data_and_recalculate(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, trace_datum: float, time_point: float) → None¶

Adds a time point to the saved experimental DEER data

The datapoint (Y-axis)

The datapoint’s time (X-axis)

NOT RECOMMENDED. The entire kernel matrix is reinitialized!

This is insanely time-consuming!

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::append_data_and_recalculate(const double &, const double &) –> void

assign(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, : pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) → pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory¶: C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::operator=(const class core::scoring::epr_deer::Simulated4PDEERTraceFactory &) –> class core::scoring::epr_deer::Simulated4PDEERTraceFactory &

bckg_type(*args, **kwargs)¶

Overloaded function.

bckg_type(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) -> str

Returns background type

Background type

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::bckg_type() const –> std::string

bckg_type(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, val: str) -> None

Sets background coupling type

New background coupling

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::bckg_type(const std::string &) –> void

bins_per_a(*args, **kwargs)¶

Overloaded function.

bins_per_a(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) -> int

Returns bins per angstrom in the kernel matrix

Bins per angstrom in the kernel matrix

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::bins_per_a() const –> unsigned long

bins_per_a(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, val: int) -> None

Sets bins per angstrom of kernel matrix and recalculates matrix

New value for bins per angstrom

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::bins_per_a(const unsigned long &) –> void

depth(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) → float¶: C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::depth() const –> double

dim(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) → float¶: C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::dim() const –> double

initial_search(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, deer_trace: pyrosetta.rosetta.utility.vector1_double) → None¶

Performs an initial search for background parameters

Intramolecular DEER trace

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::initial_search(const class utility::vector1<double, class std::allocator<double> > &) –> void

initialize_kernel(*args, **kwargs)¶

Overloaded function.

initialize_kernel(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, time_pts: pyrosetta.rosetta.utility.vector1_double, bins_per_a: int) -> pyrosetta.rosetta.numeric.MathMatrix_double_t
initialize_kernel(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, time_pts: pyrosetta.rosetta.utility.vector1_double, bins_per_a: int, max_dist: int) -> pyrosetta.rosetta.numeric.MathMatrix_double_t
initialize_kernel(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, time_pts: pyrosetta.rosetta.utility.vector1_double, bins_per_a: int, max_dist: int, n_bins: int) -> pyrosetta.rosetta.numeric.MathMatrix_double_t

Kernel matrix initialization method

Time points to be used in the kernel

Bins per angstrom

Maximum distance in Angstroms to be stored here

For discretization of angle-dependent dipolar coupling

Kernel matrix

Mathematical details can be found in Ibanez and Jeschke, 2019

JMR (doi: 10.1016/j.jmr.2019.01.008)

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::initialize_kernel(const class utility::vector1<double, class std::allocator<double> > &, const unsigned long &, const unsigned long &, const unsigned long &) const –> class numeric::MathMatrix<double>

kernel_mult(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, distr: pyrosetta.rosetta.std.map_unsigned_long_double) → pyrosetta.rosetta.utility.vector1_double¶

Actual nitty-gritty code for applying the kernel matrix

DEER distribution stored as a map

Vector with intramolecular component

Note that throughout this calculation, the bins per angstrom

and time points are assumed to be correct! This is not

checked (maybe a debug assert can be used?)

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::kernel_mult(const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) const –> class utility::vector1<double, class std::allocator<double> >

opt_bckg(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, deer_trace: pyrosetta.rosetta.utility.vector1_double) → pyrosetta.rosetta.utility.vector1_double¶

Optimize the intermolecular background by least squares

The intramolecular deer trace

vector with final DEER trace

The function can be run with and without dimensionality

calculation. This is reserved for cases where membrane

proteins are studied and are not uniformly distributed

in three-dimensional space.

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::opt_bckg(const class utility::vector1<double, class std::allocator<double> > &) –> class utility::vector1<double, class std::allocator<double> >

reset(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) → None¶

Reset background calculation to force initial search

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::reset() –> void

slope(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) → float¶: C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::slope() const –> double

time_pts(*args, **kwargs)¶

Overloaded function.

time_pts(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) -> pyrosetta.rosetta.utility.vector1_double

Returns time points for experimental data

Time points for experimental data

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::time_pts() const –> class utility::vector1<double, class std::allocator<double> >

time_pts(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, val: pyrosetta.rosetta.utility.vector1_double) -> None

Sets time points to new data

New data to set

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::time_pts(const class utility::vector1<double, class std::allocator<double> > &) –> void

trace(*args, **kwargs)¶

Overloaded function.

trace(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory) -> pyrosetta.rosetta.utility.vector1_double

Returns experimental data

DEER data

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::trace() const –> class utility::vector1<double, class std::allocator<double> >

trace(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, val: pyrosetta.rosetta.utility.vector1_double) -> None

Sets experimental data to new DEER trace

New data to set

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::trace(const class utility::vector1<double, class std::allocator<double> > &) –> void

trace_from_distr(self: pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTraceFactory, distr: pyrosetta.rosetta.std.map_unsigned_long_double) → pyrosetta.rosetta.core.scoring.epr_deer.Simulated4PDEERTrace¶

Process for converting distance distribution to DEER trace

DEER distribution stored as a map

DEER trace with all the bells and whistles attached

C++: core::scoring::epr_deer::Simulated4PDEERTraceFactory::trace_from_distr(const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) –> class core::scoring::epr_deer::Simulated4PDEERTrace

pyrosetta.rosetta.core.scoring.epr_deer.add_bckg(*args, **kwargs)¶

Overloaded function.

add_bckg(sim_trace: pyrosetta.rosetta.utility.vector1_double, time_pts: pyrosetta.rosetta.utility.vector1_double, depth: float, slope: float, dim: float) -> pyrosetta.rosetta.utility.vector1_double
add_bckg(sim_trace: pyrosetta.rosetta.utility.vector1_double, time_pts: pyrosetta.rosetta.utility.vector1_double, depth: float, slope: float, dim: float, thru_sigmoid: bool) -> pyrosetta.rosetta.utility.vector1_double

Function for adding non-3D background coupling to DEER trace

Simulated DEER trace (intramolecular)

Time points for DEER trace

Modulation deoth

Background slope

Background dimensionality

Note that this is a “friend” function, not part of the factory

Also note that all values need to pass through sigmoid function

C++: core::scoring::epr_deer::add_bckg(const class utility::vector1<double, class std::allocator<double> > &, const class utility::vector1<double, class std::allocator<double> > &, double, double, double, const bool) –> class utility::vector1<double, class std::allocator<double> >

pyrosetta.rosetta.core.scoring.epr_deer.gauss(x: float, avg: float, stdev: float) → float¶

Compute amplitude at a given point of a normal distribution

The point of interest

Average value of distribution

Width of distribution

Amplitude

C++: core::scoring::epr_deer::gauss(const double &, const double &, const double &) –> double

pyrosetta.rosetta.core.scoring.epr_deer.ln(q: float) → float¶

Safe version of log() that doesn’t crash when zero is passed

Value to take logarithm

natural logarithm of q, or arbitrarily large number of q=0.0

C++: core::scoring::epr_deer::ln(const double &) –> double

pyrosetta.rosetta.core.scoring.epr_deer.logit(*args, **kwargs)¶

Overloaded function.

logit(x: float) -> float
logit(x: float, lo: float) -> float
logit(x: float, lo: float, hi: float) -> float

Calculate logit function given certain value

Value to calculate

Lower bound

Upper bound

: Logit value

C++: core::scoring::epr_deer::logit(const double &, const double &, const double &) –> double

pyrosetta.rosetta.core.scoring.epr_deer.min_max(histr1: pyrosetta.rosetta.std.map_unsigned_long_double, histr2: pyrosetta.rosetta.std.map_unsigned_long_double) → Tuple[int, int]¶

Return the minimum and maximum bins from two distributions

First distribution

Second distribution

Tuple of minimum and maximum, in that order

C++: core::scoring::epr_deer::min_max(const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &) –> class std::tuple<unsigned long, unsigned long>

pyrosetta.rosetta.core.scoring.epr_deer.minimize_sumsq(par: float, m_dat: int, data: capsule, fvec: float, : int) → None¶

LM function for optimizing non-3D background coupling

C-style parameter array

Number of data points

Generic data pointer object that needs to be unpacked

Vector of residuals used by lmmin()

(not used)

Note that this is a “friend” function, not part of the factory

C++: core::scoring::epr_deer::minimize_sumsq(const double *, int, const void *, double *, int *) –> void

pyrosetta.rosetta.core.scoring.epr_deer.minimize_sumsq_nodim(par: float, m_dat: int, data: capsule, fvec: float, : int) → None¶

LM function for optimizing 3D background coupling

C-style parameter array

Number of data points

Generic data pointer object that needs to be unpacked

Vector of residuals used by lmmin()

(not used)

Note that this is a “friend” function, not part of the factory

C++: core::scoring::epr_deer::minimize_sumsq_nodim(const double *, int, const void *, double *, int *) –> void

pyrosetta.rosetta.core.scoring.epr_deer.probit(x: float) → float¶

Calculate probit function given a certain value

Value to calculate

Probit function of x

C++: core::scoring::epr_deer::probit(const double &) –> double

pyrosetta.rosetta.core.scoring.epr_deer.sigmoid(x: float, min: float, max: float) → float¶

Sigmoid function implementation

Number to convert

Minimum value of output

Maximum value of output

Y output on sigmoid function

Note that neither the slope nor the y-intercept can be modified

C++: core::scoring::epr_deer::sigmoid(const double &, const double &, const double &) –> double

pyrosetta.rosetta.core.scoring.epr_deer.unpack(data: capsule, time_pts: pyrosetta.rosetta.utility.vector1_double, exp_trace: pyrosetta.rosetta.utility.vector1_double, sim_trace: pyrosetta.rosetta.utility.vector1_double) → None¶

Unpacks data passed to lmmin function

The data passed to lmmin

Time point vector to assign

Experimental DEER trace to assign

Simulated DEER trace to assign

C++: core::scoring::epr_deer::unpack(const void *, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<double, class std::allocator<double> > &) –> void