electron_density

Bindings for core::scoring::electron_density namespace

class pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

Bases: pybind11_object

S2(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, h: int, k: int, l: int) → float

C++: core::scoring::electron_density::ElectronDensity::S2(int, int, int) const –> double

assign(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, : pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

C++: core::scoring::electron_density::ElectronDensity::operator=(const class core::scoring::electron_density::ElectronDensity &) –> class core::scoring::electron_density::ElectronDensity &

cart2idx(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, cartX: pyrosetta.rosetta.numeric.xyzVector_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::electron_density::ElectronDensity::cart2idx(const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

clearMask(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → None

reset scoring to use all residues

C++: core::scoring::electron_density::ElectronDensity::clearMask() –> void

clear_dCCdx_res_cache(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose) → None

Resets the counters used for derivative computation in

sliding-window/fast scoring

C++: core::scoring::electron_density::ElectronDensity::clear_dCCdx_res_cache(const class core::pose::Pose &) –> void

computeStats(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → None

C++: core::scoring::electron_density::ElectronDensity::computeStats() –> void

compute_symm_rotations(*args, **kwargs)

Overloaded function.

1. compute_symm_rotations(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. compute_symm_rotations(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> None

Computes the symmatric rotation matrices

C++: core::scoring::electron_density::ElectronDensity::compute_symm_rotations(const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>) –> void

dCCdB_fastRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, atmid: int, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose) → float

Gradient of CC w.r.t B factors

C++: core::scoring::electron_density::ElectronDensity::dCCdB_fastRes(int, int, const class core::conformation::Residue &, const class core::pose::Pose &) –> double

dCCdBs(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, dE_dvars: pyrosetta.rosetta.utility.vector1_double, maskC: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t) → None

calculate all gradients of CC w.r.t B factors (slow more precise version)

C++: core::scoring::electron_density::ElectronDensity::dCCdBs(const class core::pose::Pose &, class utility::vector1<double, class std::allocator<double> > &, class ObjexxFCL::FArray3D<double> &) –> void

dCCdx_PointFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, X: pyrosetta.rosetta.numeric.xyzVector_double_t, dCCdx: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

access fastdens scoring for a single point

C++: core::scoring::electron_density::ElectronDensity::dCCdx_PointFast(class numeric::xyzVector<double>, class numeric::xyzVector<double> &) –> void

dCCdx_aacen(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, atmid: int, resid: int, X: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose, gradX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Return the gradient of whole-structure-CC w.r.t. atom X’s movement

non-sliding-window analogue of dCCdx

C++: core::scoring::electron_density::ElectronDensity::dCCdx_aacen(int, int, const class numeric::xyzVector<double> &, const class core::pose::Pose &, class numeric::xyzVector<double> &) –> void

dCCdx_cen(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, X: pyrosetta.rosetta.numeric.xyzVector_double_t, pose: pyrosetta.rosetta.core.pose.Pose, gradX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Return the gradient of CC w.r.t. res X’s CA’s movement

Centroid-mode analogue of dCCdx

C++: core::scoring::electron_density::ElectronDensity::dCCdx_cen(int, const class numeric::xyzVector<double> &, const class core::pose::Pose &, class numeric::xyzVector<double> &) –> void

dCCdx_fastRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, atmid: int, resid: int, X: pyrosetta.rosetta.numeric.xyzVector_double_t, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, gradX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Return the gradient of “fast CC” w.r.t. atom X’s movement

Uses information stored from the previous call to matchRes with this resid

C++: core::scoring::electron_density::ElectronDensity::dCCdx_fastRes(int, int, const class numeric::xyzVector<double> &, const class core::conformation::Residue &, const class core::pose::Pose &, class numeric::xyzVector<double> &) –> void

dCCdx_res(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, atmid: int, resid: int, X: pyrosetta.rosetta.numeric.xyzVector_double_t, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, gradX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

Return the gradient of CC w.r.t. atom X’s movement

Uses information stored from the previous call to matchRes with this resid

C++: core::scoring::electron_density::ElectronDensity::dCCdx_res(int, int, const class numeric::xyzVector<double> &, const class core::conformation::Residue &, const class core::pose::Pose &, class numeric::xyzVector<double> &) –> void

dens_grad(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::electron_density::ElectronDensity::dens_grad(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

get(*args, **kwargs)

Overloaded function.

1. get(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, i: int, j: int, k: int) -> float

get the density at a grid point

C++: core::scoring::electron_density::ElectronDensity::get(int, int, int) –> double

2. get(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, X: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

get the interpolated density at a point _in index space_

C++: core::scoring::electron_density::ElectronDensity::get(class numeric::xyzVector<double>) –> double

getAtomMask(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getAtomMask() const –> double

getCachedScore(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int) → float

get the precomputed CC (THIS SHOULD LIVE IN POSE DATACACHE!)

C++: core::scoring::electron_density::ElectronDensity::getCachedScore(unsigned long) –> double

getEffectiveBfactor(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

get the “effective B factor”: a global b factor based on map resolution

C++: core::scoring::electron_density::ElectronDensity::getEffectiveBfactor() const –> double

getFSC(*args, **kwargs)

Overloaded function.

1. getFSC(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, Frho1: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, Frho2: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, nbuckets: int, maxreso: float, minreso: float, FSC: pyrosetta.rosetta.utility.vector1_double) -> None

2. getFSC(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, Frho1: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, Frho2: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, nbuckets: int, maxreso: float, minreso: float, FSC: pyrosetta.rosetta.utility.vector1_double, S2_bin: bool) -> None

Compute map-map FSC

C++: core::scoring::electron_density::ElectronDensity::getFSC(const class ObjexxFCL::FArray3D<struct std::complex<double> > &, const class ObjexxFCL::FArray3D<struct std::complex<double> > &, unsigned long, double, double, class utility::vector1<double, class std::allocator<double> > &, bool) –> void

getGrid(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzVector_int_t

C++: core::scoring::electron_density::ElectronDensity::getGrid() const –> class numeric::xyzVector<int>

getIntensities(*args, **kwargs)

Overloaded function.

1. getIntensities(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, FrhoC: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, nbuckets: int, maxreso: float, minreso: float, Imap: pyrosetta.rosetta.utility.vector1_double) -> None

2. getIntensities(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, FrhoC: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, nbuckets: int, maxreso: float, minreso: float, Imap: pyrosetta.rosetta.utility.vector1_double, S2_bin: bool) -> None

Compute map intensities, masked by a pose. Also compute mask intensities

C++: core::scoring::electron_density::ElectronDensity::getIntensities(const class ObjexxFCL::FArray3D<struct std::complex<double> > &, unsigned long, double, double, class utility::vector1<double, class std::allocator<double> > &, bool) –> void

getMax(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getMax() const –> double

getMean(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getMean() const –> double

getMin(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getMin() const –> double

getOrigin(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::electron_density::ElectronDensity::getOrigin() const –> class numeric::xyzVector<double>

getPhaseError(*args, **kwargs)

Overloaded function.

1. getPhaseError(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, Frho1: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, Frho2: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, nbuckets: int, maxreso: float, minreso: float, phaseError: pyrosetta.rosetta.utility.vector1_double) -> None

2. getPhaseError(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, Frho1: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, Frho2: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, nbuckets: int, maxreso: float, minreso: float, phaseError: pyrosetta.rosetta.utility.vector1_double, S2_bin: bool) -> None

Compute map-map phase error

C++: core::scoring::electron_density::ElectronDensity::getPhaseError(const class ObjexxFCL::FArray3D<struct std::complex<double> > &, const class ObjexxFCL::FArray3D<struct std::complex<double> > &, unsigned long, double, double, class utility::vector1<double, class std::allocator<double> > &, bool) –> void

getRSCC(*args, **kwargs)

Overloaded function.

1. getRSCC(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, density2: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, mask: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t) -> float

Real-space correlation

C++: core::scoring::electron_density::ElectronDensity::getRSCC(const class ObjexxFCL::FArray3D<double> &, const class ObjexxFCL::FArray3D<double> &) –> double

2. getRSCC(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, rhoC: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t) -> float

Real-space correlation

C++: core::scoring::electron_density::ElectronDensity::getRSCC(class ObjexxFCL::FArray3D<double> &) –> double

getResolution(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getResolution() const –> double

getResolutionBins(*args, **kwargs)

Overloaded function.

1. getResolutionBins(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, nbuckets: int, maxreso: float, minreso: float, : pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

2. getResolutionBins(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, nbuckets: int, maxreso: float, minreso: float, : pyrosetta.rosetta.utility.vector1_double, : pyrosetta.rosetta.utility.vector1_unsigned_long, S2_bin: bool) -> None

get resolution bins

C++: core::scoring::electron_density::ElectronDensity::getResolutionBins(unsigned long, double, double, class utility::vector1<double, class std::allocator<double> > &, class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, bool) –> void

getSCscaling(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getSCscaling() –> double

getScoreWindowContext(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → bool

C++: core::scoring::electron_density::ElectronDensity::getScoreWindowContext() const –> bool

getStdev(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::getStdev() const –> double

getTransform(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzVector_double_t

Get the transformation from indices to Cartesian coords using ‘real’ origin

C++: core::scoring::electron_density::ElectronDensity::getTransform() –> class numeric::xyzVector<double>

getWindow(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → int

C++: core::scoring::electron_density::ElectronDensity::getWindow() –> unsigned long

get_R(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, subunit: int, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

gets rotation vactor for subunit ‘subunit’ in last-scored pose (Rosetta symmetry)

C++: core::scoring::electron_density::ElectronDensity::get_R(int, class numeric::xyzMatrix<double> &) const –> void

get_c2f(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: core::scoring::electron_density::ElectronDensity::get_c2f() const –> class numeric::xyzMatrix<double>

get_cellDimensions(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::electron_density::ElectronDensity::get_cellDimensions() const –> class numeric::xyzVector<double>

get_data(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t

access raw density data

C++: core::scoring::electron_density::ElectronDensity::get_data() const –> const class ObjexxFCL::FArray3D<float> &

get_f2c(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzMatrix_double_t

get frac<=>cartesian conversion matrices

C++: core::scoring::electron_density::ElectronDensity::get_f2c() const –> class numeric::xyzMatrix<double>

get_symmMap(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, vrtid: int, X_map: pyrosetta.rosetta.utility.vector1_int, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None

get symmetrized gradients for -score_symm_complex

C++: core::scoring::electron_density::ElectronDensity::get_symmMap(int, class utility::vector1<int, class std::allocator<int> > &, class numeric::xyzMatrix<double> &) –> void

get_voxel_spacing(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.numeric.xyzVector_double_t

set voxel spacing of the map

C++: core::scoring::electron_density::ElectronDensity::get_voxel_spacing() –> class numeric::xyzVector<double>

get_voxel_volume(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

C++: core::scoring::electron_density::ElectronDensity::get_voxel_volume() –> double

getsymmOps(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → pyrosetta.rosetta.utility.vector1_core_kinematics_RT

C++: core::scoring::electron_density::ElectronDensity::getsymmOps() const –> class utility::vector1<class core::kinematics::RT, class std::allocator<class core::kinematics::RT> >

grad(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, X: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t

get the interpolated gradient at a point _in index space_

C++: core::scoring::electron_density::ElectronDensity::grad(class numeric::xyzVector<double>) –> class numeric::xyzVector<double>

idx2cart(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t, cartX: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::electron_density::ElectronDensity::idx2cart(const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

init(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → None

initialize vars from command line options

C++: core::scoring::electron_density::ElectronDensity::init() –> void

isMapLoaded(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → bool

C++: core::scoring::electron_density::ElectronDensity::isMapLoaded() const –> bool

mapSphericalSamples(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapShellR: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, nRsteps: int, delR: float, B: int, center: pyrosetta.rosetta.numeric.xyzVector_double_t, laplacian_offset: float) → None

resample the map in spherical shells around a pose

C++: core::scoring::electron_density::ElectronDensity::mapSphericalSamples(class ObjexxFCL::FArray3D<double> &, unsigned long, double, unsigned long, class numeric::xyzVector<double>, double) –> void

maskResidues(*args, **kwargs)

Overloaded function.

1. maskResidues(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, scoring_mask: int) -> None

set scoring to use only a subset of residues

C++: core::scoring::electron_density::ElectronDensity::maskResidues(int) –> void

2. maskResidues(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, scoring_mask: pyrosetta.rosetta.utility.vector1_int) -> None

set scoring to use only a subset of residues

C++: core::scoring::electron_density::ElectronDensity::maskResidues(const class utility::vector1<int, class std::allocator<int> > &) –> void

matchAtomFast(*args, **kwargs)

Overloaded function.

1. matchAtomFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, atomid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose) -> float

2. matchAtomFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, atomid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> float

3. matchAtomFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, atomid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, ignoreBs: bool) -> float

Matches an individual atom to the density using the fast approximation

C++: core::scoring::electron_density::ElectronDensity::matchAtomFast(int, unsigned long, const class core::conformation::Residue &, const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, bool) –> double

matchCentroidPose(*args, **kwargs)

Overloaded function.

1. matchCentroidPose(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose) -> float

2. matchCentroidPose(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> float

3. matchCentroidPose(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, cacheCCs: bool) -> float

Quickly matches a centroid pose into a low-resolution density map

by placing a single Gaussian at each CA

C++: core::scoring::electron_density::ElectronDensity::matchCentroidPose(const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, bool) –> double

matchPointFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, X: pyrosetta.rosetta.numeric.xyzVector_double_t) → float

access fastdens scoring for a single point

C++: core::scoring::electron_density::ElectronDensity::matchPointFast(class numeric::xyzVector<double>) –> double

matchPose(*args, **kwargs)

Overloaded function.

1. matchPose(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose) -> float

2. matchPose(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> float

3. matchPose(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, cacheCCs: bool) -> float

Match a pose into a medium-resolution density map

by placing a single Gaussian at each atom

C++: core::scoring::electron_density::ElectronDensity::matchPose(const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, bool) –> double

matchPoseInPocket(*args, **kwargs)

Overloaded function.

1. matchPoseInPocket(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius: float) -> float

2. matchPoseInPocket(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius: float, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> float

3. matchPoseInPocket(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, center: pyrosetta.rosetta.numeric.xyzVector_double_t, radius: float, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, cacheCCs: bool) -> float

C++: core::scoring::electron_density::ElectronDensity::matchPoseInPocket(const class core::pose::Pose &, class numeric::xyzVector<double>, double, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, bool) –> double

matchRes(*args, **kwargs)

Overloaded function.

1. matchRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose) -> float

2. matchRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> float

3. matchRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, bfactors: bool) -> float

4. matchRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, bfactors: bool, cacheCCs: bool) -> float

Match a residue’s conformation to the density map.

Backbone atoms from adjacent residues are also used for scoring. Returns the correlation coefficient between map and pose Internally stores per-res CCs, per-atom dCC/dxs

C++: core::scoring::electron_density::ElectronDensity::matchRes(int, const class core::conformation::Residue &, const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, bool, bool) –> double

matchResFast(*args, **kwargs)

Overloaded function.

1. matchResFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose) -> float

2. matchResFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> float

3. matchResFast(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, resid: int, rsd: pyrosetta.rosetta.core.conformation.Residue, pose: pyrosetta.rosetta.core.pose.Pose, symmInfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, sc_scale: float) -> float

Match a residue’s conformation to the density map.

Same as matchRes, but using a fast approximation to the match function

C++: core::scoring::electron_density::ElectronDensity::matchResFast(int, const class core::conformation::Residue &, const class core::pose::Pose &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, double) –> double

maxNominalRes(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity) → float

Return the highest possible resolution relection in reciprocal space for the given grid

C++: core::scoring::electron_density::ElectronDensity::maxNominalRes() –> double

periodic_mod(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, fracX: pyrosetta.rosetta.numeric.xyzVector_double_t, grid: pyrosetta.rosetta.numeric.xyzVector_double_t, origin: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::electron_density::ElectronDensity::periodic_mod(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

readMRCandResize(*args, **kwargs)

Overloaded function.

1. readMRCandResize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapfile: str) -> bool

2. readMRCandResize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapfile: str, reso: float) -> bool

3. readMRCandResize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapfile: str, reso: float, gridSpacing: float) -> bool

Load an MRC density map

C++: core::scoring::electron_density::ElectronDensity::readMRCandResize(const std::string &, double, double) –> bool

4. readMRCandResize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapin: pyrosetta.rosetta.std.istream, mapfile: str) -> bool

5. readMRCandResize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapin: pyrosetta.rosetta.std.istream, mapfile: str, reso: float) -> bool

6. readMRCandResize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapin: pyrosetta.rosetta.std.istream, mapfile: str, reso: float, gridSpacing: float) -> bool

Load an MRC density map

C++: core::scoring::electron_density::ElectronDensity::readMRCandResize(std::istream &, std::string, double, double) –> bool

reciprocalSpaceFilter(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, maxreso: float, minreso: float, fadewidth: float) → None

Filter the map in reciprocal space

C++: core::scoring::electron_density::ElectronDensity::reciprocalSpaceFilter(double, double, double) –> void

rescale_fastscoring_temp_bins(*args, **kwargs)

Overloaded function.

1. rescale_fastscoring_temp_bins(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose) -> None

2. rescale_fastscoring_temp_bins(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, pose: pyrosetta.rosetta.core.pose.Pose, init: bool) -> None

C++: core::scoring::electron_density::ElectronDensity::rescale_fastscoring_temp_bins(const class core::pose::Pose &, bool) –> void

resize(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, approxGridSpacing: float) → None

resize the map via FFT resampling

C++: core::scoring::electron_density::ElectronDensity::resize(double) –> void

scaleIntensities(*args, **kwargs)

Overloaded function.

1. scaleIntensities(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, I_tgt: pyrosetta.rosetta.utility.vector1_double, maxreso: float, minreso: float) -> None

2. scaleIntensities(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, I_tgt: pyrosetta.rosetta.utility.vector1_double, maxreso: float, minreso: float, S2_bin: bool) -> None

Scale map intensities to a target spectum

C++: core::scoring::electron_density::ElectronDensity::scaleIntensities(class utility::vector1<double, class std::allocator<double> >, double, double, bool) –> void

setAtomMask(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, newVal: float) → None

C++: core::scoring::electron_density::ElectronDensity::setAtomMask(double) –> void

setOrigin(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, newori: pyrosetta.rosetta.numeric.xyzVector_double_t) → None

C++: core::scoring::electron_density::ElectronDensity::setOrigin(class numeric::xyzVector<double>) –> void

setSCscaling(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, SC_scalingin: float) → None

C++: core::scoring::electron_density::ElectronDensity::setSCscaling(double) –> void

setScoreWindowContext(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, newVal: bool) → None

C++: core::scoring::electron_density::ElectronDensity::setScoreWindowContext(bool) –> void

setWindow(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, window_in: int) → None

C++: core::scoring::electron_density::ElectronDensity::setWindow(unsigned long) –> void

set_nres(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, nres: int) → None

set # of residues

C++: core::scoring::electron_density::ElectronDensity::set_nres(int) –> void

set_voxel_spacing(*args, **kwargs)

Overloaded function.

1. set_voxel_spacing(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, apix: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

set voxel spacing of the map

C++: core::scoring::electron_density::ElectronDensity::set_voxel_spacing(class numeric::xyzVector<double>) –> void

2. set_voxel_spacing(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, apix: float) -> None

set voxel spacing of the map

C++: core::scoring::electron_density::ElectronDensity::set_voxel_spacing(double) –> void

writeMRC(self: pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity, mapfilestem: str) → bool

(debugging) Write MRC mapfile

C++: core::scoring::electron_density::ElectronDensity::writeMRC(std::string) –> bool

class pyrosetta.rosetta.core.scoring.electron_density.KromerMann

Bases: pybind11_object

f0(self: pyrosetta.rosetta.core.scoring.electron_density.KromerMann, S2: float) → float

C++: core::scoring::electron_density::KromerMann::f0(double) –> double

class pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering

Bases: pybind11_object

B(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering, k: float) → float

C++: core::scoring::electron_density::OneGaussianScattering::B(double) const –> double

C(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering, k: float) → float

C++: core::scoring::electron_density::OneGaussianScattering::C(double) const –> double

a(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering) → int

C++: core::scoring::electron_density::OneGaussianScattering::a() const –> int

dk(*args, **kwargs)

Overloaded function.

1. dk(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering, B: float) -> float

2. dk(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering, B: float, lim: float) -> float

C++: core::scoring::electron_density::OneGaussianScattering::dk(double, double) const –> double

k(*args, **kwargs)

Overloaded function.

1. k(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering, B: float) -> float

2. k(self: pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering, B: float, lim: float) -> float

C++: core::scoring::electron_density::OneGaussianScattering::k(double, double) const –> double

pyrosetta.rosetta.core.scoring.electron_density.add_dens_scores_from_cmdline_to_scorefxn(scorefxn_: pyrosetta.rosetta.core.scoring.ScoreFunction) → None

update scorefxn with density scores from commandline

C++: core::scoring::electron_density::add_dens_scores_from_cmdline_to_scorefxn(class core::scoring::ScoreFunction &) –> void

pyrosetta.rosetta.core.scoring.electron_density.calc_per_rsd_score(pose: pyrosetta.rosetta.core.pose.Pose, score_type: pyrosetta.rosetta.core.scoring.ScoreType, per_rsd_score: pyrosetta.rosetta.std.map_unsigned_long_double, n_symm_subunit: int, weight: float) → None

Fill the weighted per-residue weighted score of a particular score type

Note, does not decompose pair-energies, but does work with symmetry

C++: core::scoring::electron_density::calc_per_rsd_score(class core::pose::Pose &, const enum core::scoring::ScoreType &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, unsigned long, double) –> void

pyrosetta.rosetta.core.scoring.electron_density.calculate_density_nbr(*args, **kwargs)

Overloaded function.

1. calculate_density_nbr(pose: pyrosetta.rosetta.core.pose.Pose, per_rsd_dens: pyrosetta.rosetta.std.map_unsigned_long_double, per_rsd_nbrdens: pyrosetta.rosetta.std.map_unsigned_long_double, syminfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo) -> None

2. calculate_density_nbr(pose: pyrosetta.rosetta.core.pose.Pose, per_rsd_dens: pyrosetta.rosetta.std.map_unsigned_long_double, per_rsd_nbrdens: pyrosetta.rosetta.std.map_unsigned_long_double, syminfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, mixed_sliding_window: bool) -> None

3. calculate_density_nbr(pose: pyrosetta.rosetta.core.pose.Pose, per_rsd_dens: pyrosetta.rosetta.std.map_unsigned_long_double, per_rsd_nbrdens: pyrosetta.rosetta.std.map_unsigned_long_double, syminfo: pyrosetta.rosetta.core.conformation.symmetry.SymmetryInfo, mixed_sliding_window: bool, sliding_window_size: int) -> None

Calculate the density and relative neighbor density score.

Map must be initialized to number of calculation residues.

C++: core::scoring::electron_density::calculate_density_nbr(class core::pose::Pose &, 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> > > &, class std::shared_ptr<const class core::conformation::symmetry::SymmetryInfo>, bool, unsigned long) –> void

pyrosetta.rosetta.core.scoring.electron_density.calculate_geometry(*args, **kwargs)

Overloaded function.

1. calculate_geometry(pose: pyrosetta.rosetta.core.pose.Pose, geometry: pyrosetta.rosetta.std.map_unsigned_long_double, n_symm_subunit: int) -> None

2. calculate_geometry(pose: pyrosetta.rosetta.core.pose.Pose, geometry: pyrosetta.rosetta.std.map_unsigned_long_double, n_symm_subunit: int, weight: float) -> None

Calculate the geometry score using cartesian scoring.

Map must be initialized to number of calculation residues.

C++: core::scoring::electron_density::calculate_geometry(class core::pose::Pose &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, unsigned long, double) –> void

pyrosetta.rosetta.core.scoring.electron_density.calculate_rama(*args, **kwargs)

Overloaded function.

1. calculate_rama(pose: pyrosetta.rosetta.core.pose.Pose, rama: pyrosetta.rosetta.std.map_unsigned_long_double, n_symm_subunit: int) -> None

2. calculate_rama(pose: pyrosetta.rosetta.core.pose.Pose, rama: pyrosetta.rosetta.std.map_unsigned_long_double, n_symm_subunit: int, weight: float) -> None

Calculate the geometry score using rama or sugar_bb

Map must be initialized to number of calculation residues.

C++: core::scoring::electron_density::calculate_rama(class core::pose::Pose &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, unsigned long, double) –> void

pyrosetta.rosetta.core.scoring.electron_density.conj_map_times(map_product: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, mapA: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t, mapB: pyrosetta.rosetta.ObjexxFCL.FArray3D_std_complex_double_t) → None

C++: core::scoring::electron_density::conj_map_times(class ObjexxFCL::FArray3D<struct std::complex<double> > &, const class ObjexxFCL::FArray3D<struct std::complex<double> > &, const class ObjexxFCL::FArray3D<struct std::complex<double> > &) –> void

pyrosetta.rosetta.core.scoring.electron_density.convolute_maps(mapA: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, mapB: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t) → pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t

C++: core::scoring::electron_density::convolute_maps(const class ObjexxFCL::FArray3D<double> &, const class ObjexxFCL::FArray3D<double> &) –> class ObjexxFCL::FArray3D<double>

pyrosetta.rosetta.core.scoring.electron_density.factorsLTE19(X: int) → bool

C++: core::scoring::electron_density::factorsLTE19(int) –> bool

pyrosetta.rosetta.core.scoring.electron_density.factorsLTE5(X: int) → bool

C++: core::scoring::electron_density::factorsLTE5(int) –> bool

pyrosetta.rosetta.core.scoring.electron_density.findSampling(MINSMP: float, NMUL: int) → int

C++: core::scoring::electron_density::findSampling(double, int) –> int

pyrosetta.rosetta.core.scoring.electron_density.findSampling5(MINSMP: float, NMUL: int) → int

C++: core::scoring::electron_density::findSampling5(double, int) –> int

pyrosetta.rosetta.core.scoring.electron_density.getDensityMap(*args, **kwargs)

Overloaded function.

1. getDensityMap() -> pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

2. getDensityMap(filename: str) -> pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

3. getDensityMap(filename: str, force_reload: bool) -> pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

The EDM instance

C++: core::scoring::electron_density::getDensityMap(const std::string &, bool) –> class core::scoring::electron_density::ElectronDensity &

pyrosetta.rosetta.core.scoring.electron_density.getDensityMap_legacy(*args, **kwargs)

Overloaded function.

1. getDensityMap_legacy() -> pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

2. getDensityMap_legacy(filename: str) -> pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

3. getDensityMap_legacy(filename: str, force_reload: bool) -> pyrosetta.rosetta.core.scoring.electron_density.ElectronDensity

The EDM instance

C++: core::scoring::electron_density::getDensityMap_legacy(const std::string &, bool) –> class core::scoring::electron_density::ElectronDensity &

pyrosetta.rosetta.core.scoring.electron_density.get_A(elt: str) → pyrosetta.rosetta.core.scoring.electron_density.OneGaussianScattering

C++: core::scoring::electron_density::get_A(std::string) –> class core::scoring::electron_density::OneGaussianScattering

pyrosetta.rosetta.core.scoring.electron_density.get_km(elt: str) → pyrosetta.rosetta.core.scoring.electron_density.KromerMann

C++: core::scoring::electron_density::get_km(std::string) –> class core::scoring::electron_density::KromerMann

pyrosetta.rosetta.core.scoring.electron_density.interp_dspline(*args, **kwargs)

Overloaded function.

1. interp_dspline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

2. interp_dspline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t, mirrored: bool) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::electron_density::interp_dspline(class ObjexxFCL::FArray3D<double> &, const class numeric::xyzVector<double> &, bool) –> class numeric::xyzVector<double>

3. interp_dspline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

4. interp_dspline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t, mirrored: bool) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: core::scoring::electron_density::interp_dspline(class ObjexxFCL::FArray3D<float> &, const class numeric::xyzVector<double> &, bool) –> class numeric::xyzVector<double>

5. interp_dspline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray4D_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t, slab: float, gradX: pyrosetta.rosetta.numeric.xyzVector_double_t, gradSlab: float) -> None

C++: core::scoring::electron_density::interp_dspline(class ObjexxFCL::FArray4D<double> &, const class numeric::xyzVector<double> &, double, class numeric::xyzVector<double> &, double &) –> void

pyrosetta.rosetta.core.scoring.electron_density.interp_spline(*args, **kwargs)

Overloaded function.

1. interp_spline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

2. interp_spline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t, mirrored: bool) -> float

spline interpolation with periodic boundaries

C++: core::scoring::electron_density::interp_spline(class ObjexxFCL::FArray3D<double> &, const class numeric::xyzVector<double> &, bool) –> double

3. interp_spline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

4. interp_spline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t, mirrored: bool) -> float

spline interpolation with periodic boundaries

C++: core::scoring::electron_density::interp_spline(class ObjexxFCL::FArray3D<float> &, const class numeric::xyzVector<double> &, bool) –> double

5. interp_spline(coeffs: pyrosetta.rosetta.ObjexxFCL.FArray4D_double_t, slab: float, idxX: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

4d interpolants

C++: core::scoring::electron_density::interp_spline(class ObjexxFCL::FArray4D<double> &, double, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.core.scoring.electron_density.pos_mod(*args, **kwargs)

Overloaded function.

1. pos_mod(x: int, y: int) -> int

C++: core::scoring::electron_density::pos_mod(int, int) –> int

2. pos_mod(x: float, y: float) -> float

C++: core::scoring::electron_density::pos_mod(float, float) –> float

3. pos_mod(x: float, y: float) -> float

C++: core::scoring::electron_density::pos_mod(double, double) –> double

class pyrosetta.rosetta.core.scoring.electron_density.poseCoord

Bases: pybind11_object

property B_

assign(self: pyrosetta.rosetta.core.scoring.electron_density.poseCoord, : pyrosetta.rosetta.core.scoring.electron_density.poseCoord) → pyrosetta.rosetta.core.scoring.electron_density.poseCoord

C++: core::scoring::electron_density::poseCoord::operator=(const struct core::scoring::electron_density::poseCoord &) –> struct core::scoring::electron_density::poseCoord &

property elt_

property x_

pyrosetta.rosetta.core.scoring.electron_density.pose_has_nonzero_Bs(pose: pyrosetta.rosetta.core.pose.Pose) → bool

helper function quickly guesses if a pose has non-zero B factors

C++: core::scoring::electron_density::pose_has_nonzero_Bs(const class core::pose::Pose &) –> bool

pyrosetta.rosetta.core.scoring.electron_density.spline_coeffs(*args, **kwargs)

Overloaded function.

1. spline_coeffs(data: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t) -> None

2. spline_coeffs(data: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, mirrored: bool) -> None

precompute spline coefficients (float array => core::Real coeffs)

C++: core::scoring::electron_density::spline_coeffs(const class ObjexxFCL::FArray3D<double> &, class ObjexxFCL::FArray3D<double> &, bool) –> void

3. spline_coeffs(data: pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t, coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t) -> None

4. spline_coeffs(data: pyrosetta.rosetta.ObjexxFCL.FArray3D_float_t, coeffs: pyrosetta.rosetta.ObjexxFCL.FArray3D_double_t, mirrored: bool) -> None

precompute spline coefficients (core::Real array => core::Real coeffs)

C++: core::scoring::electron_density::spline_coeffs(const class ObjexxFCL::FArray3D<float> &, class ObjexxFCL::FArray3D<double> &, bool) –> void

5. spline_coeffs(data: pyrosetta.rosetta.ObjexxFCL.FArray4D_double_t, coeffs: pyrosetta.rosetta.ObjexxFCL.FArray4D_double_t) -> None

C++: core::scoring::electron_density::spline_coeffs(const class ObjexxFCL::FArray4D<double> &, class ObjexxFCL::FArray4D<double> &) –> void