IMP::AddBoolFlag | |

IMP::AddFloatFlag | |

IMP::AddIntFlag | |

IMP::AddStringFlag | |

IMP::AdvancedFlag< T, ENABLED > | Use this to add an advanced flag to the program |

IMP.pmi.analysis.Alignment | Performs alignment and RMSD calculation for two sets of coordinates |

IMP.pmi1.analysis.Alignment | Performs alignment and RMSD calculation for two sets of coordinates |

IMP.multifit.cluster.AlignmentClustering | Clusters assembly models |

IMP::cnmultifit::AlignSymmetric | A class for fast alignment of a cyclic model to its density |

IMP.pmi.restraints.proteomics.AmbiguousCompositeRestraint | This restraint allows ambiguous cross-linking between multiple copies excluding between symmetric copies It allows name ambiguity |

IMP.pmi1.restraints.proteomics.AmbiguousCompositeRestraint | This restraint allows ambiguous crosslinking between multiple copies excluding between symmetric copies It allows name ambiguity |

IMP.isd.Analysis.Analysis | Class that produces analysis-related output, and is able to parse the output of a file produced by the Statistics class |

IMP.pmi.macros.AnalysisReplicaExchange | This class contains analysis utilities to investigate ReplicaExchange results |

IMP.pmi1.macros.AnalysisReplicaExchange | This class contains analysis utilities to investigate ReplicaExchange results |

IMP.pmi.macros.AnalysisReplicaExchange0 | A macro for running all the basic operations of analysis |

IMP.pmi1.macros.AnalysisReplicaExchange0 | A macro for running all the basic operations of analysis |

IMP::multifit::AnchorsData | Storage of anchors (points and edges) |

IMP.ArgumentParser | IMP-specific subclass of argparse.ArgumentParser |

IMP.pmi.mmcif.AsymUnit | A single asymmetric unit in the system |

IMP.pmi1.mmcif.AsymUnit | A single asymmetric unit in the system |

IMP.pmi.restraints.crosslinking.AtomicCrossLinkMSRestraint | Setup cross-link distance restraints at atomic level The "atomic" aspect is that it models the particle uncertainty with a Gaussian |

IMP::atom::AtomType | The type of an atom |

IMP::em2d::AverageDistanceLinkage | Functor for hierarchical clustering based on average-linkage |

IMP::core::BinormalTerm | A single binormal term in a MultipleBinormalRestraint |

IMP::atom::ForceFieldParameters::Bond | |

IMP::atom::BondGraph | Represent a bond graph as a boost graph |

IMP::algebra::BoundedGridRangeD< D > | |

IMP::algebra::DenseGridStorageD< 3, int > | |

IMP::algebra::GridD< 3, DenseGridStorageD< 3, int >, int, LogEmbeddingD< 3 > > | |

IMP::algebra::DenseIntLogGrid3D | |

IMP::algebra::DenseGridStorageD< 3, VT > | |

IMP::algebra::GridD< 3, DenseGridStorageD< 3, VT >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::DenseGrid3D< VT > | A dense grid of values |

IMP::algebra::DenseGridStorageD<-1, float > | |

IMP::algebra::GridD<-1, DenseGridStorageD<-1, float >, float, LogEmbeddingD<-1 > > | |

IMP::algebra::DenseFloatLogGridKD | |

IMP::algebra::DenseGridStorageD< D, VT > | |

IMP::algebra::GridD< D, DenseGridStorageD< D, VT >, VT, DefaultEmbeddingD< D > > | |

IMP::algebra::BoundedGridRangeD< 3 > | |

IMP::algebra::SparseGridStorageD< 3, VT, BoundedGridRangeD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, VT, BoundedGridRangeD< 3 > >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::SparseGrid3D< VT > | A sparse grid of values |

IMP::algebra::BoundingBoxD< D > | An axis-aligned bounding box |

IMP::algebra::BoundingBoxD< 3 > | |

IMP.pmi1.macros.BuildModel | A macro to build a Representation based on a Topology and lists of movers |

IMP.pmi1.macros.BuildModel1 | Building macro |

IMP.pmi.macros.BuildSystem | A macro to build a IMP::pmi::topology::System based on a TopologyReader object |

IMP::kinematics::CCDLoopClosure | CCD loop closure |

IMP::atom::ChainType | The type for a chain |

IMP::atom::CHARMMAtomTopology | A single atom in a CHARMM topology |

IMP::atom::CHARMMBondEndpoint | The end of a bond, angle, dihedral, improper, or internal coordinate |

IMP::atom::CHARMMBondParameters | The parameters for a CHARMM bond or angle |

IMP::atom::CHARMMConnection< D > | A connection (bond, angle, dihedral) between some number of endpoints |

IMP::atom::CHARMMConnection< 4 > | |

IMP::atom::CHARMMInternalCoordinate | A geometric relationship between four atoms |

IMP::atom::CHARMMDihedralParameters | The parameters for a CHARMM dihedral or improper |

IMP.pmi.restraints.stereochemistry.CharmmForceFieldRestraint | Enable CHARMM force field |

IMP.pmi1.restraints.stereochemistry.CharmmForceFieldRestraint | Enable CHARMM force field |

IMP.multifit.transforms.ChimeraFormatter | Each line in 'chimera' format lists the transformation index, the cross correlation score, and then the transformation for each component, as a rotation matrix (row-major order) and a translation in angstroms |

IMP.pmi.output.Cluster | A container for models organized into clusters |

IMP.pmi1.output.Cluster | A container for models organized into clusters |

IMP.pmi.analysis.Clustering | A class to cluster structures |

IMP.pmi1.analysis.Clustering | A class to cluster structures |

IMP::em2d::ClusterSet | A class to store the clusters generated during hierarchical clustering |

IMP::cnmultifit::CnSymmAxisDetector | Detect cn symmetry in proteins and density maps |

IMP::em::CoarseConvolution | Convolutes two grids |

IMP.pmi.tools.ColorChange | Change color code to hexadecimal to rgb |

IMP.pmi1.tools.ColorChange | Change color code to hexadecimal to rgb |

IMP.CommandDispatcher | Allow command line tools to easily implement multiple commands |

IMP::multi_state::CompareMultiStateModels | Utility class to help sort MultiStateModel objects |

IMP::em2d::CompleteLinkage | Functor for hierarchical clustering based on complete linkage |

IMP.pmi.restraints.proteomics.CompositeRestraint | Handleparticles a list of particles compositeparticles is a list of list of particles |

IMP.pmi1.restraints.proteomics.CompositeRestraint | Handleparticles is a selection tuple compositeparticles is a list of selection tuples |

IMP.pmi.samplers.ConjugateGradients | Sample using conjugate gradients |

IMP.pmi1.samplers.ConjugateGradients | Sample using conjugate gradients |

IMP.pmi1.restraints.crosslinking.ConnectivityCrossLinkMS | This restraint allows ambiguous crosslinking between multiple copies it is a variant of the SimplifiedCrossLinkMS |

IMP.pmi.restraints.proteomics.ConnectivityRestraint | Generate a connectivity restraint between domains setting up the restraint example: sel1 = IMP.atom.Selection(root_hier, molecule="Rpb3", residue_indexes=range(1,100)) sel2 = IMP.atom.Selection(root_hier, molecule="Rpb4", residue_indexes=range(1,100)) cr=restraints.ConnectivityRestraint((sel1, sel2), label='CR1') cr.add_to_model() Multistate support =No Resolution=Yes |

IMP.pmi.restraints.stereochemistry.ConnectivityRestraint | Create a restraint between consecutive TempResidue objects or an entire PMI Molecule object |

IMP.pmi1.restraints.proteomics.ConnectivityRestraint | Generate a connectivity restraint between domains setting up the restraint example: cr=restraints.ConnectivityRestraint(simo,["CCC",(1,100,"TTT"),(100,150,"AAA")]) cr.add_to_model() cr.set_label("CR1") Multistate support =No Selection type=selection tuple Resolution=Yes |

IMP.pmi1.restraints.stereochemistry.ConnectivityRestraint | This class creates a restraint between consecutive TempResidue objects OR an entire PMI MOlecule object |

IMP::algebra::ConnollySurfacePoint | Represent a point on the Connolly surface |

IMP.parallel.Context | A collection of tasks that run in the same environment |

IMP.pmi1.restraints.em.CrossCorrelationRestraint | Fit particles to an EM map |

IMP.pmi.io.crosslink.CrossLinkDataBase | This class handles a cross-link dataset and do filtering operations, adding cross-links, merge datasets.. |

IMP.pmi.io.crosslink.CrossLinkDataBaseFromStructure | This class generates a CrossLinkDataBase from a given structure |

IMP.pmi1.io.crosslink.CrossLinkDataBaseFromStructure | This class generates a CrossLinkDataBase from a given structure |

IMP.pmi.io.crosslink.CrossLinkDataBaseKeywordsConverter | This class is needed to convert the keywords from a generic database to the standard ones |

IMP.pmi1.io.crosslink.CrossLinkDataBaseKeywordsConverter | This class is needed to convert the keywords from a generic database to the standard ones |

IMP.pmi.restraints.crosslinking.CrossLinkingMassSpectrometryRestraint | Setup cross-link distance restraints from mass spectrometry data |

IMP.pmi1.nonmantained.CrossLinkMS | This class initializes a CrossLinkMS restraint and contains all useful information, such as the cross-link database, contained in self.pairs If restraint_file=None, it will proceed creating simulated data |

IMP.pmi.analysis.CrossLinkTable | Visualization of cross-links |

IMP.pmi1.analysis.CrossLinkTable | Visualization of crosslinks |

IMP.isd.TuneRex.CvEstimator | When created, estimates the heat capacity from the energies or from the indicator functions using the specified method |

IMP.EMageFit.database.Database2 | Class to manage a SQL database built with sqlite3 |

IMP.EMageFit.solutions_io.ResultsDB | Class for managing the results of the experiments |

IMP.pmi.output.DataEntry | A class to store data associated to a model |

IMP.pmi1.output.DataEntry | A class to store data associated to a model |

IMP::multifit::DataPointsAssignment | |

IMP::algebra::DefaultEmbeddingD< D > | Embed a grid as an evenly spaced axis aligned grid |

IMP::algebra::GridD< D, DenseGridStorageD< D, VT >, VT, DefaultEmbeddingD< D > > | |

IMP::algebra::GridD< D, SparseGridStorageD< D, VT, UnboundedGridRangeD< D > >, VT, DefaultEmbeddingD< D > > | |

IMP::algebra::SparseUnboundedGridD< D, VT > | A sparse, infinite grid of values |

IMP::algebra::DefaultEmbeddingD< 3 > | |

IMP::algebra::GridD< 3, DenseGridStorageD< 3, VT >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, Ints, UnboundedGridRangeD< 3 > >, Ints, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, VT, BoundedGridRangeD< 3 > >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, VT, UnboundedGridRangeD< 3 > >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::SparseUnboundedGrid3D< VT > | A sparse, infinite grid of values |

IMP.pmi.dof.DegreesOfFreedom | Simplify creation of constraints and movers for an IMP Hierarchy |

IMP.isd.demux_trajs.Demuxer | Uses column to demux a replica trajectory |

IMP::multifit::DensityDataPoints | Stores density voxels as a vector of Array1D |

IMP::em::DensityHeader | |

IMP::DerivativeAccumulator | Class for adding derivatives from restraints to the model |

IMP.test.DirectorObjectChecker | Check to make sure the number of director references is as expected |

IMP::em::DistanceMask | Calculates and stores a distance mask |

IMP.pmi.restraints.basic.DistanceRestraint | A simple distance restraint |

IMP.pmi.restraints.basic.DistanceToPointRestraint | Anchor a particle to a specific coordinate |

IMP.EMageFit.buildxlinks.DockOrder | Compute the order of the docking experiments |

IMP.multifit.transforms.DockRefFormatter | Each line in 'dockref' format lists the transformation for each component, as a set of three Euler angles (in radians about the fixed x, y and z axes) and a translation in angstroms |

IMP.EMageFit.domino_model.DominoModel | Management of a model using DOMINO |

IMP.pmi.restraints.stereochemistry.ElasticNetworkRestraint | Add harmonic restraints between all pairs |

IMP.pmi1.restraints.stereochemistry.ElasticNetworkRestraint | Add harmonic restraints between all pairs |

IMP.pmi.restraints.em2d.ElectronMicroscopy2D | Fit particles against a set of class averages by principal components |

IMP.pmi1.restraints.em2d.ElectronMicroscopy2D | Fit particles against a set of class averages by principal components |

IMP.pmi.restraints.em2d.ElectronMicroscopy2D_FFT | FFT based image alignment, developed by Javier Velazquez-Muriel |

IMP.pmi1.restraints.em2d.ElectronMicroscopy2D_FFT | FFT based image alignment, developed by Javier Velazquez-Muriel |

IMP::atom::ElementTable | |

IMP::multi_state::EnsembleGenerator | Enumeration of an ensemble of good scoring MultiStateModels |

IMP.pmi.mmcif.Entity | A single entity in the system |

IMP.pmi1.mmcif.Entity | A single entity in the system |

IMP.isd.Entry.Entry | The entry class represents a column in the statistics file |

IMP::npctransport::LinearInteractionPairScore::EvaluationCache | |

IMP::EvaluationState | |

IMP::example::ExampleTemplateClassD< D > | A line segment templated on the dimension |

IMP::Exception | The general base class for `IMP` exceptions |

IMP::EventException | An exception that signifies some event occurred |

IMP::IndexException | An exception for a request for an invalid member of a container |

IMP::IOException | An input/output exception |

IMP::ModelException | An exception which is thrown when the Model has attributes with invalid values |

IMP.parallel.Error | Base class for all errors specific to the parallel module |

IMP.parallel.NetworkError | Error raised if a problem occurs with the network |

IMP.parallel.NoMoreWorkersError | Error raised if all workers failed, so tasks cannot be run |

IMP.parallel.RemoteError | Error raised if a worker has an unhandled exception |

IMP::TypeException | An exception for an invalid type being passed to `IMP` |

IMP::ValueException | An exception for an invalid value being passed to `IMP` |

IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere | A class to create an excluded volume restraint for a set of particles at a given resolution |

IMP.pmi1.restraints.stereochemistry.ExcludedVolumeSphere | A class to create an excluded volume restraint for a set of particles at a given resolution |

IMP.pmi.restraints.basic.ExternalBarrier | Keeps all structures inside a sphere |

IMP.pmi.io.crosslink.FilterOperator | This class allows to create filter functions that can be passed to the CrossLinkDataBase in this way: |

IMP.pmi1.io.crosslink.FilterOperator | This class allows to create filter functions that can be passed to the CrossLinkDataBase in this way: |

IMP::saxs::FitParameters | Parameters of a fit, from ProfileFitter |

IMP::saxs::WeightedFitParameters | Parameters of a weighted fit, from WeightedProfileFitter |

IMP::multifit::FittingSolutionRecord | A fitting solution record |

IMP::em::FittingSolutions | A simple list of fitting solutions |

IMP.pmi.io.crosslink.FixedFormatParser | A class to handle different XL format with fixed format currently support ProXL |

IMP.pmi1.io.crosslink.FixedFormatParser | A class to handle different XL format with fixed format currently support ProXL |

IMP::Flag< T, ENABLED > | |

IMP::saxs::FormFactorTable | |

IMP.pmi.restraints.stereochemistry.FusionRestraint | Creates a restraint between the termini two polypeptides, to simulate the sequence connectivity |

IMP.pmi1.restraints.stereochemistry.FusionRestraint | This class creates a restraint between the termini two polypeptides, to simulate the sequence connectivity |

IMP.pmi.restraints.proteomics.FuzzyBoolean | Fully Ambiguous Restraint that can be built using boolean logic R |

IMP.pmi1.restraints.proteomics.FuzzyBoolean | Fully Ambiguous Restraint that can be built using boolean logic R |

IMP.pmi.restraints.em.GaussianEMRestraint | Fit Gaussian-decorated particles to an EM map (also represented with a set of Gaussians) |

IMP.pmi1.restraints.em.GaussianEMRestraint | Fit Gaussian-decorated particles to an EM map (also represented with a set of Gaussians) |

IMP.bayesianem.restraint.GaussianEMRestraintWrapper | Fit Gaussian-decorated particles to an EM map (also represented with a set of Gaussians) |

IMP::multifit::GeometricHash< T, D > | Geometric Hash table |

IMP::algebra::GeometricPrimitiveD< D > | Base class for geometric types |

IMP::algebra::GridD< 3, DenseGridStorageD< 3, int >, int, LogEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, DenseGridStorageD< 3, VT >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, Ints, UnboundedGridRangeD< 3 > >, Ints, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, VT, BoundedGridRangeD< 3 > >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, VT, UnboundedGridRangeD< 3 > >, VT, DefaultEmbeddingD< 3 > > | |

IMP::algebra::GridD< D, DenseGridStorageD< D, VT >, VT, DefaultEmbeddingD< D > > | |

IMP::algebra::GridD< D, SparseGridStorageD< D, VT, UnboundedGridRangeD< D > >, VT, DefaultEmbeddingD< D > > | |

IMP::algebra::GridD<-1, DenseGridStorageD<-1, float >, float, LogEmbeddingD<-1 > > | |

IMP::algebra::GridD< D, StorageT, Value, EmbeddingT > | A voxel grid in d-dimensional space |

IMP::algebra::PrincipalComponentAnalysisD< D > | Represent an eigen analysis of some data |

IMP::algebra::SphereD< D > | Represent a sphere in D-dimensions |

IMP::algebra::UnitSimplexBaseD< D > | Base class for a unit simplex embedded in D-dimensional real space |

IMP::algebra::UnitSimplexD< D > | Represent a unit simplex embedded in D-dimensional real space |

IMP::algebra::VectorBaseD< D > | A Cartesian vector in D-dimensions |

IMP::algebra::VectorD< D > | A Cartesian vector in D-dimensions |

IMP::algebra::VectorD< 2 > | |

IMP::algebra::VectorD< 3 > | |

IMP::algebra::VectorD< 4 > | |

IMP::statistics::HistogramD< D, Grid > | Dynamically build a histogram embedded in D-dimensional space |

IMP::algebra::SphereD< 3 > | |

IMP::algebra::UnitSimplexBaseD<-1 > | |

IMP::algebra::UnitSimplexD<-1 > | Represent a unit simplex embedded in d-dimensional real space |

IMP::algebra::VectorBaseD< 1 > | |

IMP::algebra::VectorBaseD< 2 > | |

IMP::algebra::VectorBaseD< 3 > | |

IMP::algebra::VectorBaseD< 4 > | |

IMP::algebra::VectorBaseD< 5 > | |

IMP::algebra::VectorBaseD< 6 > | |

IMP::algebra::VectorBaseD<-1 > | |

IMP::algebra::GeometricPrimitiveD< 2 > | |

IMP::algebra::LinearFit2D | Calculate line that fits best the input data points (Linear least squares) |

IMP::algebra::ParabolicFit2D | Calculate parabola that fits best the input data points |

IMP::algebra::Rotation2D | Represent a rotation in 2D space |

IMP::algebra::Transformation2D | Simple 2D transformation class |

IMP::algebra::GeometricPrimitiveD< 3 > | |

IMP::algebra::Cone3D | Represent a cone in 3D |

IMP::algebra::Cylinder3D | Represent a cylinder in 3D |

IMP::algebra::Ellipsoid3D | Represent an ellipsoid in 3D |

IMP::algebra::FixedXYZ | A simple class for returning XYZ Euler angles |

IMP::algebra::Gaussian3D | A Gaussian distribution in 3D |

IMP::algebra::Line3D | Simple implementation of lines in 3D |

IMP::algebra::Plane3D | Represent a plane in 3D |

IMP::algebra::Reflection3D | Reflect about a plane in 3D |

IMP::algebra::Rotation3D | 3D rotation class |

IMP::algebra::Segment3D | Simple implementation of segments in 3D |

IMP::algebra::SpherePatch3D | A sphere patch is defined as all points above the plane and on the sphere |

IMP::algebra::SphericalVector3D | Class to represent a 3D point in spherical coordinates |

IMP::algebra::Torus3D | Represent a torus in 3D |

IMP::algebra::Transformation3D | Simple 3D transformation class |

IMP::algebra::Triangle3D | Represent a triangle in 3D |

IMP::display::GeometryProcessor | Provide a standard geometry processing framework |

IMP::display::FilterGeometry | Remove geometry which is not above a plane |

IMP::display::Writer | Base class for writing geometry to a file |

IMP::display::PivyWriter | |

IMP::display::TextWriter | |

IMP::display::PymolWriter | Write a CGO file with the geometry |

IMP.pmi.analysis.GetModelDensity | Compute mean density maps from structures |

IMP.pmi1.analysis.GetModelDensity | Compute mean density maps from structures |

IMP.sampcon.precision_rmsd.GetModelDensity | Compute mean density maps from structures |

IMP.pmi.mmcif.GMMParser | Extract metadata from an EM density GMM file |

IMP.sampcon.good_scoring_model_selector.GoodScoringModelSelector | Select good-scoring models based on scores and/or data satisfaction |

IMP.spatiotemporal.graphNode.graphNode | A class to represent a node in a spatiotemporal process |

IMP::em2d::HasHigherCCC< T > | Comparison by value of the ccc |

IMP::em2d::HasLowerScore< T > | Compare two classes that return a score |

IMP.EMageFit.solutions_io.HeapRecord | The heapq algorithm is a min-heap |

IMP.pmi.restraints.stereochemistry.HelixRestraint | Enforce ideal Helix dihedrals and bonds for a selection at resolution 0 |

IMP.pmi1.restraints.stereochemistry.HelixRestraint | Enforce ideal Helix dihedrals and bonds for a selection at resolution 0 |

IMP.pmi1.tools.HierarchyDatabase | Store the representations for a system |

IMP::core::HierarchyTraits | Define the type for a type of hierarchy |

IMP::core::HierarchyVisitor | A visitor for traversal of a hierarchy |

IMP::core::HierarchyCounter | A simple functor to count the number of particles in a hierarchy |

IMP::core::ModifierVisitor | A visitor which applies a modifier to each Particle in a hierarchy |

IMP.isd.History.History | Class that contains the output of one replica, used by the Analysis class |

IMP::em::ImageHeader | Class to deal with the header of Electron Microscopy images in IMP |

IMP.modeller.IMPRestraints | A Modeller restraint which evaluates an IMP scoring function |

IMP::Index< Tag > | A typed index |

IMP::Index< ParticleIndexTag > | |

IMP::ParticleIndexAdaptor | Take Decorator, Particle or ParticleIndex |

IMP.EMageFit.buildxlinks.InitialDockingFromXlinks | Puts two subunits together using the Xlinkins restraints |

IMP::InputAdaptor | Convenience class to accept multiple input types |

IMP::atom::Selection | Select hierarchy particles identified by the biological name |

IMP::display::WriterAdaptor | |

IMP::domino::ParticlesAdaptor | |

IMP::PairContainerAdaptor | |

IMP::ParticleAdaptor | |

IMP::ParticleIndexAdaptor | Take Decorator, Particle or ParticleIndex |

IMP::ParticleIndexesAdaptor | Take Decorator, Particle or ParticleIndex |

IMP::ParticleIndexPairsAdaptor | Take ParticlePairs or ParticleIndexPairs |

IMP::QuadContainerAdaptor | |

IMP::RestraintsAdaptor | Provide a consistent interface for things that take Restraints as arguments |

IMP::ScoringFunctionAdaptor | |

IMP::SingletonContainerAdaptor | |

IMP::TextInput | |

IMP::TextOutput | |

IMP::TripletContainerAdaptor | |

IMP::InternalException | A general exception for an internal error in IMP |

IMP::em2d::IntsOrder | |

IMP.pmi.io.crosslink.JaccardDistanceMatrix | This class allows to compute and plot the distance between datasets |

IMP.pmi1.io.crosslink.JaccardDistanceMatrix | This class allows to compute and plot the distance between datasets |

IMP.pmi.restraints.parameters.JeffreysPrior | Wrapper for `IMP.isd.JeffreysRestraint` |

IMP::em::KernelParameters | Calculates and stores Gaussian kernel parameters |

IMP::em2d::LessPairBySecond< T > | Comparison of pairs by checking the second element |

IMP::algebra::LogEmbeddingD< D > | |

IMP::algebra::LogEmbeddingD< 3 > | |

IMP::algebra::GridD< 3, DenseGridStorageD< 3, int >, int, LogEmbeddingD< 3 > > | |

IMP::algebra::LogEmbeddingD<-1 > | |

IMP::algebra::GridD<-1, DenseGridStorageD<-1, float >, float, LogEmbeddingD<-1 > > | |

IMP.isd.demux_trajs.LogHolder | Manages information on a given simulation |

IMP::LRUCache< Generator, Checker > | Implement a simple least recently used cache |

IMP.parallel.Manager | Manages workers and contexts |

IMP.parallel.manager_communicator.ManagerCommunicator | For communicating from the manager to workers |

IMP.pmi.io.crosslink.MapCrossLinkDataBaseOnStructure | This class maps a CrossLinkDataBase on a given structure and save an rmf file with color-coded cross-links |

IMP.pmi1.io.crosslink.MapCrossLinkDataBaseOnStructure | This class maps a CrossLinkDataBase on a given structure and save an rmf file with color-coded crosslinks |

IMP::em2d::MasksManager | Management of projection masks |

IMP::em2d::MatchTemplateResult | |

IMP.pmi.restraints.npc.MembraneExclusionRestraint | Keep protein away from a half torus in the xy plane |

IMP.pmi1.restraints.npc.MembraneExclusionRestraint | Create Membrane Exclusion Restraint |

IMP.pmi.restraints.basic.MembraneRestraint | Restrain particles to be above, below, or inside a planar membrane |

IMP.pmi.restraints.npc.MembraneSurfaceLocationConditionalRestraint | Localize one protein on the surface of a half torus in the xy plane |

IMP.pmi1.restraints.npc.MembraneSurfaceLocationConditionalRestraint | Create Membrane Surface Location CONDITIONAL Restraint for Nup120 ALPS Motifs - Mutually Exclusive from (135,152,'Nup120') and (197,216,'Nup120') |

IMP.pmi.restraints.npc.MembraneSurfaceLocationRestraint | Localize protein on the surface of a half torus in the xy plane |

IMP.pmi1.restraints.npc.MembraneSurfaceLocationRestraint | Create Membrane Surface Location Restraint |

IMP::Memoizer< Generator, Checker > | Helper class for writing memoizers |

IMP::multifit::MergeTreeBuilder | Utility class for building merge trees |

IMP.pmi.MissingFileWarning | Warning for an expected, but missing, file |

IMP.modeller.ModelLoader | Read a Modeller model into IMP |

IMP::cnmultifit::MolCnSymmAxisDetector | Molecule symmetry detector |

IMP.pmi.samplers.MolecularDynamics | Sample using molecular dynamics |

IMP.pmi1.samplers.MolecularDynamics | Sample using molecular dynamics |

IMP.pmi.topology.Molecule | Stores a named protein chain |

IMP.pmi.samplers.MonteCarlo | Sample using Monte Carlo |

IMP.pmi1.samplers.MonteCarlo | Sample using Monte Carlo |

IMP.EMageFit.monte_carlo.MonteCarloRelativeMoves | Class to do Monte Carlo sampling by using as the set of movements relative positions between rigid bodies |

IMP::multi_state::MultiStateModel | Keep track of multiple states |

IMP::multi_state::MultiStateModelScore | Base class for MultiStateModel scoring classes |

IMP::multi_state::SAXSMultiCombinationScore< ScoringFunctionT > | |

IMP::multi_state::SAXSMultiStateModelScore< ScoringFunctionT > | |

IMP::NonCopyable | Base class for all objects that cannot be copied |

IMP::Object | Common base class for heavy weight `IMP` objects |

IMP::algebra::DynamicNearestNeighbor3D | Provide an incremental nearest neighbor search function |

IMP::algebra::NearestNeighborD< D > | Build a structure for finding nearest neighbors |

IMP::algebra::VectorKDMetric | The base class for a metric on VectorKDs |

IMP::algebra::EuclideanVectorKDMetric | The l2 norm on the distance vector |

IMP::algebra::MaxVectorKDMetric | |

IMP::atom::CHARMMResidueTopologyBase | Base class for all CHARMM residue-based topology |

IMP::atom::CHARMMIdealResidueTopology | The ideal topology of a single residue |

IMP::atom::CHARMMResidueTopology | The topology of a single residue in a model |

IMP::atom::CHARMMPatch | A CHARMM patch residue |

IMP::atom::CHARMMSegmentTopology | The topology of a single CHARMM segment in a model |

IMP::atom::CHARMMTopology | The topology of a complete CHARMM model |

IMP::atom::ForceFieldParameters | Storage and access to force field |

IMP::atom::CHARMMParameters | CHARMM force field parameters |

IMP::atom::Mol2Selector | A base class for choosing which Mol2 atoms to read |

IMP::atom::AllMol2Selector | Read all atoms |

IMP::atom::NonHydrogenMol2Selector | Defines a selector that will pick only non-hydrogen atoms |

IMP::atom::PDBSelector | Select which atoms to read from a PDB file |

IMP::atom::AllPDBSelector | Defines a selector that will pick every ATOM and HETATM record |

IMP::atom::AndPDBSelector | Select atoms which are selected by both selectors |

IMP::atom::AtomTypePDBSelector | Select all atoms of the given types |

IMP::atom::NonAlternativePDBSelector | Select all ATOM and HETATM records which are not alternatives |

IMP::atom::ATOMPDBSelector | Select all non-alternative ATOM records |

IMP::atom::CAlphaPDBSelector | Select all CA ATOM records |

IMP::atom::CBetaPDBSelector | Select all CB ATOM records |

IMP::atom::ChainPDBSelector | Select all ATOM and HETATM records with the given chain ids |

IMP::atom::CPDBSelector | Select all C (not CA or CB) ATOM records |

IMP::atom::HydrogenPDBSelector | Select all hydrogen ATOM and HETATM records |

IMP::atom::NonHydrogenPDBSelector | Select non hydrogen atoms |

IMP::atom::NonWaterNonHydrogenPDBSelector | Select non water and non hydrogen atoms |

IMP::atom::BackbonePDBSelector | Select all backbone (N,CA,C,O) ATOM records |

IMP::atom::NonWaterPDBSelector | Select all non-water non-alternative ATOM and HETATM records |

IMP::atom::NPDBSelector | Select all N ATOM records |

IMP::atom::PPDBSelector | Select all P (= phosphate) ATOM records |

IMP::atom::WaterPDBSelector | Select all non-water ATOM and HETATM records |

IMP::atom::NotPDBSelector | Select atoms which are not selected by a given selector |

IMP::atom::OrPDBSelector | Select atoms which are selected by either or both selectors |

IMP::atom::ResidueTypePDBSelector | Select all atoms in residues of the given types |

IMP::atom::XorPDBSelector | Select atoms which are selected by either selector but not both |

IMP::atom::SmoothingFunction | Base class for smoothing nonbonded interactions as a function of distance |

IMP::atom::ForceSwitch | Smooth interaction scores by switching the derivatives (force switch) |

IMP::Configuration | A class to store a configuration of a model |

IMP::ConfigurationSet | A class to store a set of configurations of a model |

IMP::core::ClosePairsFinder | A base class for algorithms to find spatial proximities |

IMP::core::BoxSweepClosePairsFinder | Find all nearby pairs by sweeping the bounding boxes |

IMP::core::GridClosePairsFinder | Find all nearby pairs by testing all pairs |

IMP::core::NearestNeighborsClosePairsFinder | Find all nearby pairs using the algebra::NearestNeighbor code |

IMP::core::QuadraticClosePairsFinder | Find all nearby pairs by testing all pairs |

IMP::core::RigidClosePairsFinder | Perform more efficient close pair finding when rigid bodies are involved |

IMP::misc::MetricClosePairsFinder< LowerBound, UpperBound > | |

IMP::core::DataObject< Data > | Helper class for creating an IMP object storing some data |

IMP::display::Geometry | The base class for geometry |

IMP::atom::SelectionGeometry | Display a Selection |

IMP::core::SurfaceGeometry | Display a Surface particle as a cylindrical disk |

IMP::display::BoundingBoxGeometry | Display a bounding box |

IMP::display::CylinderGeometry | Display a cylinder |

IMP::display::EllipsoidGeometry | Display a ellipsoid |

IMP::display::FilterGeometry | Remove geometry which is not above a plane |

IMP::display::GeometrySet | Group of set of geometric elements |

IMP::display::LabelGeometry | A text label for a ball in space |

IMP::display::PairGeometry | A base class for geometry contained in particles |

IMP::core::EdgePairGeometry | Display a segment connecting a pair of particles |

IMP::display::PairsGeometry | A base class for geometry from a set of particles |

IMP::core::EdgePairsGeometry | Display a segment for each pair in a IMP::PairContainer |

IMP::display::PlaneGeometry | Display a plane as truncated to a bounding box |

IMP::display::PointGeometry | Display a point |

IMP::display::PolygonGeometry | |

IMP::display::ReferenceFrameGeometry | Display a reference frame |

IMP::display::RestraintGeometry | Try to draw some stuff for a generic restraint |

IMP::display::RestraintSetGeometry | Geometry for a whole set of restraints |

IMP::display::SegmentGeometry | Display a segment |

IMP::core::RigidBodyTorque | |

IMP::display::SingletonGeometry | A base class for geometry contained in particles |

IMP::atom::BondGeometry | Display a Bond particle as a segment |

IMP::atom::HierarchyGeometry | Display an IMP::atom::Hierarchy particle as balls |

IMP::core::RigidBodyDerivativeGeometry | |

IMP::core::RigidBodyFrameGeometry | |

IMP::core::RigidBodyHierarchyGeometry | |

IMP::core::XYZDerivativeGeometry | |

IMP::core::XYZRGeometry | Display an IMP::core::XYZR particle as a ball |

IMP::npctransport::SitesGeometry | |

IMP::display::SingletonsGeometry | A base class for geometry from a set of particles |

IMP::atom::BondsGeometry | Display an IMP::SingletonContainer of Bond particles as segments |

IMP::atom::HierarchiesGeometry | Display an IMP::SingletonContainer of IMP::atom::Hierarchy particles as balls |

IMP::core::RigidBodyDerivativesGeometry | |

IMP::core::RigidBodyFramesGeometry | |

IMP::core::XYZDerivativesGeometry | |

IMP::core::XYZRsGeometry | Display an IMP::SingletonContainer of IMP::core::XYZR particles as balls |

IMP::npctransport::TypedSitesGeometry | |

IMP::display::SphereGeometry | Display a sphere |

IMP::display::SurfaceMeshGeometry | Display a surface mesh |

IMP::display::IsosurfaceGeometry | Display an isosurface of a density map |

IMP::display::SkinSurfaceGeometry | Display an isosurface of a density map |

IMP::display::TriangleGeometry | Display a triangle |

IMP::npc::SlabWithSphericalIndentGeometry | |

IMP::npc::SlabWithToroidalPoreWireGeometry | A decorator for a particle that represents a toroidal pore |

IMP::npctransport::SlabWithCylindricalPoreWireGeometry | XXXX |

IMP::npctransport::SlabWithToroidalPoreWireGeometry | XXXX |

IMP::display::Writer | Base class for writing geometry to a file |

IMP::domino::AssignmentContainer | The base class for containers of assignments |

IMP::domino::CappedAssignmentContainer | Store no more than a max number of states |

IMP::domino::HeapAssignmentContainer | Store a set of k top scoring assignments |

IMP::domino::ListAssignmentContainer | Simple storage of a set of Assignments |

IMP::domino::PackedAssignmentContainer | Store assignments in a compact form in memory |

IMP::domino::RangeViewAssignmentContainer | Expose a range [begin, end) of an inner assignment container to consumers |

IMP::domino::ReadAssignmentContainer | Read the assignments from binary data on disk |

IMP::domino::ReadHDF5AssignmentContainer | Store the assignments in an HDF5DataSet |

IMP::domino::SampleAssignmentContainer | Store a list of k assignments chosen from all those added to this table |

IMP::domino::WriteAssignmentContainer | Store the assignments on disk as binary data |

IMP::domino::WriteHDF5AssignmentContainer | Store the assignments in an HDF5DataSet |

IMP::domino::AssignmentsTable | |

IMP::domino::BranchAndBoundAssignmentsTable | |

IMP::domino::ListAssignmentsTable | |

IMP::domino::RecursiveAssignmentsTable | |

IMP::domino::SimpleAssignmentsTable | |

IMP::domino::ParticleStates | |

IMP::domino::CompoundStates | |

IMP::domino::IndexStates | |

IMP::domino::NestedRigidBodyStates | |

IMP::domino::PermutationStates | |

IMP::domino::RecursiveStates | |

IMP::domino::RigidBodyStates | |

IMP::domino::XYZStates | |

IMP::em2d::GridStates | |

IMP::em2d::ProjectionStates | |

IMP::multifit::FittingStates | |

IMP::domino::ParticleStatesTable | |

IMP::domino::RestraintCache | |

IMP::domino::SubsetFilter | |

IMP::em2d::DistanceFilter | SubsetFilter for checking overlap between projections and images |

IMP::domino::SubsetFilterTable | |

IMP::domino::DisjointSetsSubsetFilterTable | A base class |

IMP::domino::EqualitySubsetFilterTable | Do not allow two particles to be in the same state |

IMP::domino::EquivalenceAndExclusionSubsetFilterTable | Define sets of equivalent and exclusive particles |

IMP::domino::EquivalenceSubsetFilterTable | Define sets of equivalent particles |

IMP::domino::ExclusionSubsetFilterTable | Do not allow two particles to be in the same state |

IMP::domino::ListSubsetFilterTable | Maintain an explicit list of what states each particle is allowed to have |

IMP::domino::MinimumRestraintScoreSubsetFilterTable | Filter a configuration of the subset using the Model thresholds |

IMP::domino::PairListSubsetFilterTable | |

IMP::domino::ProbabilisticSubsetFilterTable | |

IMP::domino::RestraintScoreSubsetFilterTable | Filter a configuration of the subset using the Model thresholds |

IMP::em2d::DistanceFilterTable | |

IMP::example::ExampleSubsetFilterTable | |

IMP::em2d::CollisionCrossSection | Determine the collision cross section for some projections of particles |

IMP::em2d::Image | 2D Electron Microscopy images in IMP |

IMP::em2d::ImageReaderWriter | Virtual class for reader/writers of images |

IMP::em2d::JPGImageReaderWriter | Class to read and write EM images in JPG format |

IMP::em2d::SpiderImageReaderWriter | |

IMP::em2d::TIFFImageReaderWriter | Management of reading/writing TIFF images |

IMP::em2d::ProjectionFinder | Class to perform registration of model projections to images |

IMP::em2d::ScoreFunction | Base class for all scoring functions related to em2d |

IMP::em2d::ChiSquaredScore | Score based on Chi^2 = ((pixels_image - pixels_projection)/stddev_image)^2 |

IMP::em2d::EM2DScore | |

IMP::em2d::MeanAbsoluteDifference | Score based on the mean of the absolute difference |

IMP::em::CoarseCCatIntervals | Cross correlation coefficient calculator |

IMP::em::DensityMap | Class for handling density maps |

IMP::em::MapDistanceTransform | Class for getting the distance from the map envelope |

IMP::em::SampledDensityMap | Class for sampling a density map from particles |

IMP::em::SurfaceShellDensityMap | The class represents a molecule as shells of distance from the surface |

IMP::em::EnvelopeScore | Class for envelope based scoring using MapDistanceTransform |

IMP::em::MapReaderWriter | The base class to handle reading and writing of density maps |

IMP::em::EMReaderWriter | |

IMP::em::MRCReaderWriter | |

IMP::em::SpiderMapReaderWriter | Class to read EM maps (3D) in Spider and Xmipp formats |

IMP::em::XplorReaderWriter | |

IMP::em::PCAAligner | Fast alignment of points to a density map using principal components |

IMP::example::ExampleObject | An example simple object which is reference counted |

IMP::isd::BivariateFunction | Base class for functions of two variables |

IMP::isd::Covariance1DFunction | Covariance function |

IMP::isd::CrossLinkData | CrossLinkData |

IMP::isd::CysteineCrossLinkData | CysteineCrossLinkData |

IMP::isd::Distribution | Base class for all distributions, provided for common inheritance |

IMP::isd::OneDimensionalDistribution | Base class for distributions that are passed a single random variable |

IMP::isd::OneDimensionalSufficientDistribution | Base class for single-variate distributions that cache sufficient statistics |

IMP::isd::FNormal | FNormal |

IMP::isd::FStudentT | Joint Student's t-distribution of Function |

IMP::isd::PenalizedComplexityPrior | Penalized complexity prior |

IMP::isd::FretData | Auxiliary class for FRET_R restraint |

IMP::isd::GaussianProcessInterpolation | GaussianProcessInterpolation |

IMP::isd::MultivariateFNormalSufficient | MultivariateFNormalSufficient |

IMP::isd::UnivariateFunction | Base class for functions of one variable |

IMP::isd::GeneralizedGuinierPorodFunction | 1D mean function for SAS data |

IMP::isd::Linear1DFunction | Linear one-dimensional function |

IMP::isd::vonMises | VonMises |

IMP::isd::vonMisesSufficient | VonMisesSufficient |

IMP::kinematics::DirectionalDOF | |

IMP::kinematics::DOF | Representation of one degree of freedom (DOF) |

IMP::kinematics::DOFsSampler | Base class for sampling certain combinations of degrees of freedom |

IMP::kinematics::FibrilSampler | Simultaneous sampling of diheral angles and fibril symmetry operations |

IMP::kinematics::UniformBackboneSampler | Sample uniformly over a set of backbone dihedral joints |

IMP::kinematics::Joint | Base class for joints between rigid bodies in a kinematic tree |

IMP::kinematics::CompositeJoint | Joint that combines several inner joints, acting on the same rigid body pair |

IMP::kinematics::PrismaticJoint | Joint in which two rigid bodies may slide along a line |

IMP::kinematics::RevoluteJoint | Abstract class for all revolute joints |

IMP::kinematics::BondAngleRevoluteJoint | Joint that is parameterized as a bond angle between three particles |

IMP::kinematics::DihedralAngleRevoluteJoint | Joint that is parameterized as a dihedral angle between two planes |

IMP::kinematics::TransformationJoint | |

IMP::kinematics::KinematicForest | Define and manipulate a kinematic structure over a model |

IMP::kinematics::LocalPlanner | |

IMP::kinematics::PathLocalPlanner | Local planner that samples conformations on a path between two nodes |

IMP::kinematics::ProteinKinematics | |

IMP::kmeans::KMeans | |

IMP::Model | Class for storing model, its restraints, constraints, and particles |

IMP::Model | Class for storing model, its restraints, constraints, and particles |

IMP::ModelObject | Base class for objects in a Model that depend on other objects |

IMP::Container | Abstract class for containers of particles |

IMP::PairContainer | A shared container for Pairs |

IMP::atom::BondPairContainer | A container that returns pairs of the endpoints of the bonds |

IMP::container::AllBipartitePairContainer | |

IMP::container::AllPairContainer | Return all unordered pairs of particles taken from the SingletonContainer |

IMP::container::CloseBipartitePairContainer | Return all spatially-proximal pairs of particles (a,b) from the two SingletonContainers A and B, where a is in A and b is in B |

IMP::container::ClosePairContainer | Return all close unordered pairs of particles taken from the SingletonContainer |

IMP::container::ConnectingPairContainer | A container which keeps a set of pairs that connect a set of spheres |

IMP::container::ConsecutivePairContainer | A container which contains all consecutive particle pairs from an input list |

IMP::container::DynamicListPairContainer | Store a ParticleIndexPairs |

IMP::container::ExclusiveConsecutivePairContainer | |

IMP::container::ListPairContainer | Store a list of ParticleIndexPairs |

IMP::container::PairContainerSet | Stores a set of PairContainers |

IMP::QuadContainer | A shared container for Quads |

IMP::container::DynamicListQuadContainer | Store a ParticleIndexQuads |

IMP::container::ListQuadContainer | Store a list of ParticleIndexQuads |

IMP::container::QuadContainerSet | Stores a set of QuadContainers |

IMP::SingletonContainer | A shared container for Singletons |

IMP::container::DynamicListSingletonContainer | Store a ParticleIndexes |

IMP::container::ListSingletonContainer | Store a list of ParticleIndexes |

IMP::container::SingletonContainerSet | Stores a set of SingletonContainers |

IMP::TripletContainer | A shared container for Triplets |

IMP::container::DynamicListTripletContainer | Store a ParticleIndexTriplets |

IMP::container::ListTripletContainer | Store a list of ParticleIndexTriplets |

IMP::container::TripletContainerSet | Stores a set of TripletContainers |

IMP::core::MonteCarloMover | A base class for classes which perturb particles |

IMP::core::BallMover | Move continuous particle variables by perturbing them within a ball |

IMP::core::DirectionMover | Modify a direction |

IMP::core::LogNormalMover | Modify a set of continuous variables using a log-normal distribution |

IMP::core::NormalMover | Modify a set of continuous variables using a normal distribution |

IMP::core::RigidBodyMover | Modify the transformation of a rigid body |

IMP::em2d::RelativePositionMover | |

IMP::core::RigidBodyTunneler | Modify the transformation of a rigid body |

IMP::core::SerialMover | Applies a list of movers one at a time |

IMP::core::SubsetMover | Applies a subset of a list of movers |

IMP::core::SurfaceMover | Modify a surface orientation |

IMP::core::TransformationSymmetryMover | Modify the given TransformationSymmetry |

IMP::isd::MolecularDynamicsMover | Modify a set of continuous variables using a MD simulation |

IMP::isd::WeightMover | A mover that perturbs a Weight particle |

IMP::kinematics::DihedralMover | Modify a set of joints using a normal distribution |

IMP::kinematics::RevoluteJointMover | Modify a set of joints using a normal distribution |

IMP::pmi1::TransformMover | Modify the transformation of a rigid body |

IMP::pmi::TransformMover | Modify the transformation of a rigid body |

IMP::spb::BoxedMover | Move a particle and keep it in a box |

IMP::spb::CellMover | Apply a mover that moves particles inside the unit cell |

IMP::spb::PbcBoxedMover | Move a particle and keep it in a box |

IMP::spb::PbcBoxedRigidBodyMover | Modify the transformation of a rigid body |

IMP::spb::RigidBodyNewMover | Modify the transformation of a rigid body |

IMP::symmetry::BallMover | Move a particle and keep it in the primitive cell of a periodic lattice |

IMP::symmetry::RigidBodyMover | Move a rigid body and keep it in the primitive cell of a periodic lattice |

IMP::Optimizer | Base class for all optimizers |

IMP::atom::Simulator | The base class for simulators |

IMP::atom::BrownianDynamics | Simple Brownian dynamics simulator |

IMP::atom::BrownianDynamicsTAMD | Simple Brownian dynamics simulator |

IMP::npctransport::BrownianDynamicsTAMDWithSlabSupport | Simple Brownian dynamics simulator |

IMP::atom::MolecularDynamics | Simple molecular dynamics simulator |

IMP::isd::MolecularDynamics | Molecular dynamics optimizer on 1-D and 3-D particles |

IMP::spb::MolecularDynamicsWithWte | Simple molecular dynamics optimizer |

IMP::AttributeOptimizer | Base class for optimizers that act on individual attributes |

IMP::core::ConjugateGradients | Simple conjugate gradients optimizer |

IMP::core::SteepestDescent | A simple steepest descent optimizer |

IMP::gsl::GSLOptimizer | A base class for GSL-based optimizers |

IMP::gsl::ConjugateGradients | A conjugate gradients optimizer taken from GSL |

IMP::gsl::QuasiNewton | A quasi-Newton optimizer taken from GSL |

IMP::gsl::Simplex | A simplex optimizer taken from GSL |

IMP::core::MonteCarlo | A Monte Carlo optimizer |

IMP::core::MonteCarloWithLocalOptimization | This variant of Monte Carlo that relaxes after each move |

IMP::core::MonteCarloWithBasinHopping | This variant of Monte Carlo uses basis hopping |

IMP::isd::HybridMonteCarlo | Hybrid Monte Carlo optimizer |

IMP::spb::MonteCarloWithWte | MonteCarlo in the Well-Tempered Ensemble |

IMP::OptimizerState | Shared optimizer state that is invoked upon commitment of new coordinates |

IMP::atom::BerendsenThermostatOptimizerState | Maintains temperature during molecular dynamics |

IMP::atom::LangevinThermostatOptimizerState | Maintains temperature during molecular dynamics |

IMP::atom::RemoveRigidMotionOptimizerState | Removes rigid translation and rotation from the particles |

IMP::atom::RemoveTranslationOptimizerState | Removes rigid translation from the particles |

IMP::atom::VelocityScalingOptimizerState | Maintains temperature during molecular dynamics by velocity scaling |

IMP::atom::WritePDBOptimizerState | |

IMP::container::EventPairsOptimizerState | |

IMP::container::EventQuadsOptimizerState | |

IMP::container::EventSingletonsOptimizerState | |

IMP::container::EventTripletsOptimizerState | |

IMP::container::PairsOptimizerState | Apply a PairFunction to a PairContainer to maintain an invariant |

IMP::container::QuadsOptimizerState | Apply a QuadFunction to a QuadContainer to maintain an invariant |

IMP::container::SingletonsOptimizerState | Apply a SingletonFunction to a SingletonContainer to maintain an invariant |

IMP::container::TripletsOptimizerState | Apply a TripletFunction to a TripletContainer to maintain an invariant |

IMP::core::WriteRestraintScoresOptimizerState | Write the scores of the passed restraints to a file during optimization |

IMP::display::WriteOptimizerState | |

IMP::misc::DecayPairContainerOptimizerState | Maintain a pair container with a decaying list of pairs |

IMP::npctransport::BipartitePairsStatisticsOptimizerState | |

IMP::npctransport::BodyStatisticsOptimizerState | |

IMP::npctransport::ChainStatisticsOptimizerState | |

IMP::npctransport::GlobalStatisticsOptimizerState | |

IMP::npctransport::ParticleTransportStatisticsOptimizerState | |

IMP::rmf::SaveOptimizerState | Periodically dump the state of all associated objects into the RMF file |

IMP::SaveToConfigurationSetOptimizerState | |

IMP::Particle | Class to handle individual particles of a Model object |

IMP::Restraint | A restraint is a term in an `IMP` ScoringFunction |

IMP::atom::CAAngleRestraint | Angle restraint between three residues in CA-only representation |

IMP::atom::CADihedralRestraint | Dihedral restraint between five residues in CA-only representation |

IMP::atom::CHARMMStereochemistryRestraint | Enforce CHARMM stereochemistry on the given Hierarchy |

IMP::atom::EzRestraint | Ez Potential restraint |

IMP::atom::HelixRestraint | Restraint a set of residues to use ideal helix dihedrals and bonds |

IMP::bayesianem::GaussianEMRestraint | Creates a restraint between two Gaussian Mixture Models, "model" and "density" |

IMP::container::MinimumPairRestraint | Score based on the min or max PairScore over a set |

IMP::container::MinimumQuadRestraint | Score based on the min or max QuadScore over a set |

IMP::container::MinimumSingletonRestraint | Score based on the min or max SingletonScore over a set |

IMP::container::MinimumTripletRestraint | Score based on the min or max TripletScore over a set |

IMP::container::PairsRestraint | Applies a PairScore to each Pair in a list |

IMP::atom::ProteinLigandRestraint | Score a pair of molecules |

IMP::container::PredicatePairsRestraint | Applies a PairScore to each Pair in a list based on a predicate |

IMP::container::PredicateQuadsRestraint | Applies a QuadScore to each Quad in a list based on a predicate |

IMP::container::PredicateSingletonsRestraint | Applies a SingletonScore to each Singleton in a list based on a predicate |

IMP::container::PredicateTripletsRestraint | Applies a TripletScore to each Triplet in a list based on a predicate |

IMP::container::QuadsRestraint | Applies a QuadScore to each Quad in a list |

IMP::container::SingletonsRestraint | Applies a SingletonScore to each Singleton in a list |

IMP::container::TripletsRestraint | Applies a TripletScore to each Triplet in a list |

IMP::core::ConnectivityRestraint | Ensure that a set of particles remains connected with one another |

IMP::core::ConstantRestraint | Return a constant value |

IMP::core::DiameterRestraint | Restrain the diameter of a set of points |

IMP::core::DihedralRestraint | Dihedral restraint between four particles |

IMP::core::DistanceRestraint | Distance restraint between two particles |

IMP::core::ExcludedVolumeRestraint | Prevent a set of particles and rigid bodies from inter-penetrating |

IMP::core::MinimumRestraint | Score based on the minimum scoring members of a set of restraints |

IMP::core::MSConnectivityRestraint | Ensure that a set of particles remains connected with one another |

IMP::core::MultipleBinormalRestraint | Modeller-style multiple binormal (phi/psi) restraint |

IMP::core::PairRestraint | Applies a PairScore to a Pair |

IMP::core::QuadRestraint | Applies a QuadScore to a Quad |

IMP::core::RigidBodyUmbrella | Umbrella-like restraint for rigid bodies |

IMP::core::SingletonRestraint | Applies a SingletonScore to a Singleton |

IMP::core::TripletRestraint | Applies a TripletScore to a Triplet |

IMP::core::AngleRestraint | Angle restraint between three particles |

IMP::core::VolumeRestraint | A restraint that prevents spheres from inter-penetrating |

IMP::em2d::DummyRestraint | Dummy restraint between two particles |

IMP::em2d::Em2DRestraint | |

IMP::em2d::ParticlesDummyRestraint | Dummy restraint for a set of particles. Same use as DummyRestraint |

IMP::em2d::PCAFitRestraint | Fast scoring of Particles against electron microscopy class averages |

IMP::em2d::RigidBodiesImageFitRestraint | Fit rigid bodies to an image |

IMP::em::DensityFillingRestraint | Calculate score based on fit to EM map |

IMP::em::EnvelopeFitRestraint | A restraint for envelope-based scoring of particles in the density map |

IMP::em::EnvelopePenetrationRestraint | Calculate score based on fit to EM map |

IMP::em::FitRestraint | Calculate score based on fit to EM map |

IMP::em::FitRestraintBayesEM3D | Calculate score based on fit to EM map |

IMP::em::PCAFitRestraint | Calculate score based on fit to EM map |

IMP::example::ExampleComplexRestraint | Restrain the diameter of a set of points |

IMP::example::ExampleRestraint | Restrain a particle to be in the x,y plane |

IMP.example.PythonExampleRestraint | An example restraint written in Python |

IMP::isd::AmbiguousNOERestraint | Ambiguous NOE distance restraint between a number of pairs of particles |

IMP::isd::AmbiguousRestraint | Apply an ambiguous restraint by computing the d-norm |

IMP::isd::AtomicCrossLinkMSRestraint | Restrain atom pairs based on a set of crosslinks |

IMP::isd::CrossLinkMSRestraint | A restraint for ambiguous cross-linking MS data and multiple state approach |

IMP::isd::CysteineCrossLinkRestraint | A restraint for cysteine cross-linking data |

IMP::isd::FretRestraint | |

IMP::isd::GammaPrior | Uniform distribution with harmonic boundaries |

IMP::isd::GaussianEMRestraint | Restraint between two Gaussian Mixture Models, "model" and "density" |

IMP::isd::GaussianProcessInterpolationRestraint | Gaussian process restraint |

IMP::isd::GaussianRestraint | Normal probability distribution as a restraint |

IMP::isd::ISDRestraint | A base class for ISD Restraints |

IMP::isd::GaussianAnchorEMRestraint | Restraint between two sets of anchor points "model" and "EM density" |

IMP::pmi1::MembraneRestraint | Membrane Restraint |

IMP::pmi::MembraneRestraint | Membrane Restraint |

IMP::isd::JeffreysRestraint | |

IMP::isd::LognormalAmbiguousRestraint | |

IMP::isd::LognormalRestraint | Normal probability distribution as a restraint |

IMP::isd::MarginalHBondRestraint | Apply a lognormal distance restraint between two particles |

IMP::isd::MarginalNOERestraint | Apply an NOE distance restraint between two particles |

IMP::isd::NOERestraint | Apply an NOE distance restraint between two particles |

IMP::isd::NormalSigmaPCRestraint | A Penalized Complexity prior on sigma of a normal distribution |

IMP::isd::ResidueProteinProximityRestraint | |

IMP::isd::StudentTRestraint | A Student-t distribution restraint |

IMP::isd::TALOSRestraint | Phi/psi dihedral restraint between four particles, using data from TALOS |

IMP::isd::UniformPrior | Uniform distribution with harmonic boundaries |

IMP::isd::vonMisesKappaConjugateRestraint | Conjugate prior for the concentration parameter of a von Mises distribution |

IMP::isd::vonMisesKappaJeffreysRestraint | Jeffreys prior for the \(\kappa\) concentration parameter of a von Mises distribution |

IMP::isd::WeightRestraint | |

IMP.modeller.ModellerRestraints | An IMP restraint using all defined Modeller restraints |

IMP::multifit::ComplementarityRestraint | Compute the complementarity between two molecules |

IMP::multifit::DummyRestraint | A simple Restraint that always returns a score of zero |

IMP::multifit::RadiusOfGyrationRestraint | Ensure the radius of gyration of particles fits the predicted one |

IMP::multifit::WeightedExcludedVolumeRestraint | Calculate score based on fit to EM map |

IMP::npc::AssemblySymmetryByDihedralRestraint | Restrain two interparticle dihedrals to be the same |

IMP::npc::AssemblySymmetryByDistanceRestraint | Restrain two interparticle distances to be the same |

IMP::npc::CompositeRestraint | Score a set of particles that form a composite |

IMP::npc::MembraneExclusionRestraint | Try to keep particles away from a membrane |

IMP::npc::MembraneSurfaceLocationConditionalRestraint | Try to keep one set of particles localized on a membrane surface |

IMP::npc::MembraneSurfaceLocationRestraint | Try to keep particles localized on a membrane surface |

IMP::npc::OverallPositionRestraint | Restrain particle to a specific position |

IMP::npc::PerinuclearVolumeLocationRestraint | Try to keep particles on the perinuclear side of a membrane |

IMP::npc::PoreSideVolumeLocationRestraint | Try to keep particles on the pore side of a membrane |

IMP::npc::ProteinChainRestraint | Try to keep particle surfaces in contact in a chain |

IMP::npc::ProteinContactRestraint | Try to keep all particle surfaces in contact |

IMP::npc::ProteinProximityRestraint | Restrain a set of particles to be proximate to each other |

IMP::npc::XAxialPositionLowerRestraint | Restrain particles by their x coordinate |

IMP::npc::XAxialPositionRestraint | Restrain particles by their x coordinate |

IMP::npc::XAxialPositionUpperRestraint | Restrain particles by their x coordinate |

IMP::npc::XYRadialPositionLowerRestraint | Restrain particles by their distance from the z axis in the xy plane |

IMP::npc::XYRadialPositionRestraint | Restrain particles by their distance from the z axis in the xy plane |

IMP::npc::XYRadialPositionUpperRestraint | Restrain particles by their distance from the z axis in the xy plane |

IMP::npc::YAxialPositionLowerRestraint | Restrain particles by their y coordinate |

IMP::npc::YAxialPositionRestraint | Restrain particles by their y coordinate |

IMP::npc::YAxialPositionUpperRestraint | Restrain particles by their y coordinate |

IMP::npc::ZAxialPositionLowerRestraint | Restrain particles by their z coordinate |

IMP::npc::ZAxialPositionRestraint | Restrain particles by their z coordinate |

IMP::npc::ZAxialPositionUpperRestraint | Restrain particles by their z coordinate |

IMP::pmi1::CompositeRestraint | A restraint for ambiguous cross-linking MS data and multiple state approach |

IMP.pmi1.restraints.basic.BiStableDistanceRestraint | Python restraint with bistable potential Authors: G |

IMP.pmi1.restraints.basic.CylinderRestraint | PMI2 python restraint |

IMP.pmi1.restraints.proteomics.ConnectivityNetworkRestraint | Python restraint that computes the score for a composite of proteins Authors: G |

IMP.pmi1.restraints.proteomics.FuzzyRestraint | Fully Ambiguous Restraint that can be built using boolean logic R |

IMP::pmi1::SigmoidRestraintSphere | Simple sigmoidal score calculated between sphere surfaces |

IMP::pmi::CompositeRestraint | A restraint for ambiguous cross-linking MS data and multiple state approach |

IMP.pmi.restraints.basic.BiStableDistanceRestraint | Distance restraint with bistable potential Authors: G |

IMP.pmi.restraints.basic.CylinderRestraint | Restrain particles within (or outside) a cylinder |

IMP.pmi.restraints.proteomics.ConnectivityNetworkRestraint | Python restraint that computes the score for a composite of proteins Authors: G |

IMP.pmi.restraints.proteomics.FuzzyRestraint | Fully Ambiguous Restraint that can be built using boolean logic R |

IMP::RestraintSet | Object used to hold a set of restraints |

IMP::isd::LogWrapper | Calculate the -Log of a list of restraints |

IMP::pmi::CrossLinkRestraintSet | A RestraintSet subclass to track cross-link metadata |

IMP::saxs::Restraint | Calculate score based on fit to SAXS profile |

IMP::saxs::RadiusOfGyrationRestraint | Calculate score based on radius of gyration, taken from saxs profile |

IMP::spb::DiameterRgyrRestraint | Diameter and radius of gyration Restraint |

IMP::spb::DistanceTerminiRestraint | A distance restraint between protein termini |

IMP::spb::ISDRestraint | Apply an NOE distance restraint between two particles |

IMP::spb::EM2DRestraint | |

IMP::spb::UniformBoundedRestraint | |

IMP::spb::TwoStateGoModelRestraint | Two-state Go-Model Restraint |

IMP::ScoreState | ScoreStates maintain invariants in the Model |

IMP::Constraint | Implement a constraint on the Model |

IMP::container::PairsConstraint | Apply a PairFunction to a PairContainer to maintain an invariant |

IMP::container::QuadsConstraint | Apply a QuadFunction to a QuadContainer to maintain an invariant |

IMP::container::SingletonsConstraint | Apply a SingletonFunction to a SingletonContainer to maintain an invariant |

IMP::container::TripletsConstraint | Apply a TripletFunction to a TripletContainer to maintain an invariant |

IMP::core::LateralSurfaceConstraint | Constrain the center of a Surface for visualization |

IMP::core::PairConstraint | Apply a PairFunction to a Pair |

IMP::core::QuadConstraint | Apply a QuadFunction to a Quad |

IMP::core::SingletonConstraint | Apply a SingletonFunction to a Singleton |

IMP::core::SurfaceGeometryConstraint | Constrain a SurfaceGeometry to a Surface |

IMP::core::SurfaceSymmetryConstraint | Constrain orientation of surfaces with respect to rigid bodies |

IMP::core::TripletConstraint | Apply a TripletFunction to a Triplet |

IMP::example::ExampleConstraint | A trivial constraint that just increments a counter |

IMP.example.PythonExampleConstraint | An example Constraint written in Python |

IMP::container::DistributePairsScoreState | Distribute contents of one container into several based on predicates |

IMP::container::DistributeQuadsScoreState | Distribute contents of one container into several based on predicates |

IMP::container::DistributeSingletonsScoreState | Distribute contents of one container into several based on predicates |

IMP::container::DistributeTripletsScoreState | Distribute contents of one container into several based on predicates |

IMP::container::PairContainerStatistics | Track statistics on a PairContainer |

IMP::container::QuadContainerStatistics | Track statistics on a QuadContainer |

IMP::container::SingletonContainerStatistics | Track statistics on a SingletonContainer |

IMP::container::TripletContainerStatistics | Track statistics on a TripletContainer |

IMP::core::ChecksScoreState | Turn checks on with a given probability each evaluate call |

IMP::core::MoveStatisticsScoreState | Keep track of statistics about how particles move |

IMP::core::NeighborsTable | |

IMP::domino::DependencyScoreState | Add a dependency to the dependency graph |

IMP::em2d::ProjectionParametersScoreState | |

IMP::kinematics::KinematicForestScoreState | |

IMP::misc::StateAdaptor | Allow OptimizerStates to be used as ScoreStates |

IMP::ScoringFunction | Represents a scoring function on the model |

IMP::core::RestraintsScoringFunction | Create a scoring function on a list of restraints |

IMP::mpi::ReplicaExchange | A class to implement Hamiltonian Replica Exchange |

IMP::multifit::AssemblyHeader | Holds data about the assembly density needed for optimization |

IMP::multifit::ComponentHeader | Holds data about a component needed for optimization |

IMP::multifit::Ensemble | An ensemble of fitting solutions |

IMP::multifit::FFTFitting | Fit a molecule inside its density by local or global FFT |

IMP::multifit::FFTFittingOutput | Storage of the results from an FFT fit |

IMP::multifit::ProbabilisticAnchorGraph | Probabilistic anchor graph |

IMP::multifit::ProteomicsData | Storage of proteomics data |

IMP::multifit::ProteomicsEMAlignmentAtomic | Align proteomics graph to EM density map |

IMP::multifit::SettingsData | Holds header data for optimization |

IMP::npctransport::FGChain | |

IMP::npctransport::ParticleFactory | Factory that produces diffusing particles with specified attributes |

IMP::npctransport::Scoring | Scoring associated with a SimulationData object |

IMP::npctransport::SimulationData | Store all parameters for a simulation |

IMP::npctransport::Statistics | Statistics and order parameters about the simulations |

IMP::PairModifier | A base class for modifiers of ParticlePairsTemp |

IMP::PairPredicate | Abstract predicate function |

IMP::atom::BondedPairFilter | A filter for bonds |

IMP::atom::SameResiduePairFilter | |

IMP::atom::SoapPairFilter | Filter atom pairs for SOAP |

IMP::atom::StereochemistryPairFilter | A filter that excludes bonds, angles and dihedrals |

IMP::container::ConsecutivePairFilter | |

IMP::container::ExclusiveConsecutivePairFilter | |

IMP::container::InContainerPairFilter | A filter which returns true if a container contains the Pair |

IMP::core::AllSamePairPredicate | Return true (1) if all members of the tuple are the same |

IMP::core::CoinFlipPairPredicate | Return true (1) with a fixed probability |

IMP::core::ConstantPairPredicate | Always return a constant value |

IMP::core::IsCollisionPairPredicate | Return 1 if two XYZRs collide |

IMP::core::OrderedTypePairPredicate | Return a unique predicate value for each ordered set of ParticleTypes |

IMP::core::UnorderedTypePairPredicate | Return a unique predicate value for each unordered set of ParticleTypes |

IMP::misc::CommonEndpointPairFilter | Return true for any pair of bonds sharing an endpoint |

IMP::spb::SameParticlePairFilter | |

IMP::spb::SameRigidBodyPairFilter | |

IMP::PairScore | Abstract class for scoring object(s) of type ParticleIndexPair |

IMP::score_functor::DistancePairScore< LinearInteractionScore > | |

IMP::npctransport::FunctorLinearInteractionPairScore | Score a pair of particles |

IMP::score_functor::DistancePairScore< LinearSoftSphereScore > | |

IMP::npctransport::FunctorLinearSoftSpherePairScore | Score a pair of particles |

IMP::score_functor::DistancePairScore< score_functor::Dope > | |

IMP::atom::DopePairScore | Score pair of atoms based on DOPE |

IMP::score_functor::DistancePairScore< score_functor::LoopStatistical > | |

IMP::atom::LoopStatisticalPairScore | Score atoms based on the Fiser/Melo loop modeling statistical potential |

IMP::score_functor::DistancePairScore< score_functor::Statistical< Key, BIPARTITE, INTERPOLATE, SPARSE > > | |

IMP::core::StatisticalPairScore< Key, BIPARTITE, INTERPOLATE, SPARSE > | |

IMP::score_functor::DistancePairScore< score_functor::Statistical< ProteinLigandType, BIPARTITE, INTERPOLATE, false > > | |

IMP::core::StatisticalPairScore< ProteinLigandType, true, false > | |

IMP::atom::ProteinLigandAtomPairScore | |

IMP::score_functor::DistancePairScoreWithCache< score_functor::OrientedSoap > | |

IMP::atom::OrientedSoapPairScore | Score a pair of atoms using an orientation-dependent SOAP score |

IMP::atom::CoulombPairScore | Coulomb (electrostatic) score between a pair of particles |

IMP::atom::LennardJonesPairScore | Lennard-Jones score between a pair of particles |

IMP::container::MinimumPairScore | Evaluate the min or max n particle_pair scores of the passed set |

IMP::core::ClosePairsPairScore | Apply the score to all pairs whose spheres are within a distance threshold |

IMP::core::DistancePairScore | Score a pair of particles based on the distance between their centers |

IMP::core::HarmonicDistancePairScore | Score distance between two particle centers using a harmonic function |

IMP::core::HarmonicSphereDistancePairScore | A harmonic score on the distance between two spheres |

IMP::core::HarmonicSurfaceDepthPairScore | A harmonic score on the depth of a sphere's surface below a surface |

IMP::core::HarmonicSurfaceDistancePairScore | A harmonic score on the distance between a surface and a sphere surface |

IMP::core::HarmonicSurfaceHeightPairScore | A harmonic score on the height of a sphere's surface above a surface |

IMP::core::HarmonicUpperBoundSphereDiameterPairScore | A harmonic upper bound on the diameter of the span of two spheres |

IMP::core::HarmonicUpperBoundSphereDistancePairScore | A harmonic upper bound on the distance between two spheres |

IMP::core::KClosePairsPairScore | Apply a score to a fixed number of close pairs from the two sets |

IMP::core::RigidBodyDistancePairScore | Accelerated computation of the distance between two rigid bodies |

IMP::core::NormalizedSphereDistancePairScore | A score on the normalized distance between the surfaces of two spheres |

IMP::core::RefinedPairsPairScore | Generate pairs to score by applying a Refiner |

IMP::core::RigidBodyAnglePairScore | Score on the crossing angle between two rigid bodies |

IMP::core::SoftSpherePairScore | |

IMP::core::SoftSubSurfacePairScore | A harmonic score that keeps a sphere's surface below a surface |

IMP::core::SoftSuperSurfacePairScore | A harmonic score that keeps a sphere's surface above a surface |

IMP::core::SphereDistancePairScore | A score on the distance between the surfaces of two spheres |

IMP::core::SurfaceDepthPairScore | A score on the depth of a sphere's surface below a surface |

IMP::core::SurfaceDistancePairScore | A score on the distance between a surface and a sphere surface |

IMP::core::SurfaceHeightPairScore | A score on the height of a sphere's surface above a surface |

IMP::core::TransformedDistancePairScore | Apply a function to the distance between two particles after transforming the second |

IMP::core::TypedPairScore | Delegate to another PairScore depending on particle types |

IMP::core::WeightedSphereDistancePairScore | A score on a weighted distance between the surfaces of two spheres |

IMP::example::ExamplePairScore | Apply a harmonic to the distance between two particles |

IMP.example.PythonExamplePairScore | An example PairScore written in Python |

IMP::isd::RepulsiveDistancePairScore | A repulsive potential on the distance between two atoms |

IMP::misc::LogPairScore | Track the pairs of particles passed |

IMP::misc::LowestRefinedPairScore | Refine both particles with the refiner and score on the lowest pair |

IMP::misc::SoftCylinderPairScore | Apply a function to the distance between the cylinders defined by two bonds |

IMP::npc::MinimumSphereDistancePairScore | Apply a UnaryFunction to the minimum transformed sphere-sphere distance |

IMP::npc::SlabWithSphericalIndentMBMScore | |

IMP::npc::SlabWithToroidalPoreGoPairScore | Apply a harmonic to the distance between a particle and the normal to toroidal membrane |

IMP::npc::SlabWithToroidalPoreMBMScore | Apply harmonic walls to the distance between a particle and the normal to toroidal membrane |

IMP::npc::SphericalIndentSurfaceDepthPairScore | |

IMP::npc::ToroidalPoreSurfaceDepthPairScore | Apply repulsive force to the distance between a particle and the normal to toroidal membrane |

IMP::npctransport::AnchorToCylidnricalPorePairScore | |

IMP::npctransport::HarmonicWellPairScore | |

IMP::npctransport::LinearInteractionPairScore | |

IMP::npctransport::SitesPairScore | Apply a function to the distance between two particles with a set of specific binding sites |

IMP::npctransport::LinearSoftSpherePairScore | |

IMP::npctransport::LinearWellPairScore | |

IMP::npctransport::SlabWithCylindricalPorePairScore | XXXX |

IMP::npctransport::SlabWithToroidalPorePairScore | Score for a slab with a toroidal pore |

IMP::score_functor::DistancePairScore< DistanceScoreT > | Create efficient distance-based pair scores |

IMP::score_functor::DistancePairScoreWithCache< DistanceScoreT > | Create efficient distance-based pair scores, with cache |

IMP::score_functor::SurfaceDepthPairScore< DistanceScoreT > | Create efficient surface depth-based pair scores |

IMP::score_functor::SurfaceDistancePairScore< DistanceScoreT > | Create efficient surface distance-based pair scores |

IMP::score_functor::SurfaceHeightPairScore< DistanceScoreT > | Create efficient surface height-based pair scores |

IMP::spb::AttributeDistancePairScore | Apply a function to an attribute |

IMP::spb::KinkPairScore | Score on the crossing angles between two helices |

IMP::spb::RigidBodyPackingScore | Score on the crossing angles between two helices |

IMP::QuadModifier | A base class for modifiers of ParticleQuadsTemp |

IMP::QuadPredicate | Abstract predicate function |

IMP::container::InContainerQuadFilter | A filter which returns true if a container contains the Quad |

IMP::core::AllSameQuadPredicate | Return true (1) if all members of the tuple are the same |

IMP::core::CoinFlipQuadPredicate | Return true (1) with a fixed probability |

IMP::core::ConstantQuadPredicate | Always return a constant value |

IMP::core::OrderedTypeQuadPredicate | Return a unique predicate value for each ordered set of ParticleTypes |

IMP::core::UnorderedTypeQuadPredicate | Return a unique predicate value for each unordered set of ParticleTypes |

IMP::QuadScore | Abstract class for scoring object(s) of type ParticleIndexQuad |

IMP::container::MinimumQuadScore | Evaluate the min or max n particle_quad scores of the passed set |

IMP::Refiner | Abstract class to implement hierarchical methods |

IMP::atom::BondEndpointsRefiner | Return the endpoints of a bond |

IMP::core::ChildrenRefiner | Return the hierarchy children of a particle |

IMP::core::FixedRefiner | The refiner can refine any particle by returning a fixed set |

IMP::core::LeavesRefiner | Return the hierarchy leaves under a particle |

IMP::core::TableRefiner | A lookup based particle refiner |

IMP::multifit::RigidLeavesRefiner | Return all rigid body members that are also hierarchy leaves |

IMP::RestraintInfo | Report key:value information on restraints |

IMP::rmf::LoadLink | |

IMP::rmf::SimpleLoadLink< O > | |

IMP::rmf::SimpleLoadLink< Particle > | |

IMP::rmf::HierarchyLoadLink | |

IMP::npctransport::HierarchyWithSitesLoadLink | Load sites data from an RMF file |

IMP::rmf::SaveLink | |

IMP::rmf::SimpleSaveLink< O > | |

IMP::rmf::SimpleSaveLink< Particle > | |

IMP::rmf::HierarchySaveLink | |

IMP::npctransport::HierarchyWithSitesSaveLink | Save sites data to an RMF file |

IMP::rotamer::RotamerCalculator | A class performing the rotations of atoms in the residues |

IMP::rotamer::RotamerLibrary | A class storing a whole rotamer library read from a file |

IMP::Sampler | Base class for all samplers |

IMP::core::MCCGSampler | A simple sampler |

IMP::domino::DiscreteSampler | A base class for discrete samplers in Domino2 |

IMP::domino::BranchAndBoundSampler | Sample best solutions using BranchAndBound |

IMP::domino::DominoSampler | Sample best solutions using Domino |

IMP::kinematics::RRT | Simple implementation of the Rapidly-exploring Random Trees algorithm |

IMP::saxs::ChiFreeScore | |

IMP::saxs::ChiScore | |

IMP::saxs::ChiScoreLog | |

IMP::saxs::DerivativeCalculator | |

IMP::saxs::Profile | |

IMP::saxs::ProfileFitter< ScoringFunctionT > | Fit two profiles with user-defined scoring function as a template parameter |

IMP::saxs::WeightedProfileFitter< ScoringFunctionT > | Fitting of multiple profiles to the experimental one |

IMP::saxs::RatioVolatilityScore | |

IMP::saxs::RigidBodiesProfileHandler | Handle the profile for a set of particles, which may include rigid bodies |

IMP::SingletonModifier | A base class for modifiers of ParticlesTemp |

IMP::atom::CoverBond | Cover a bond with a sphere |

IMP::core::CentroidOfRefined | Set a particle to be the centroid of the refined particles |

IMP::core::CoverRefined | Set the position and radius of a particle to enclose the refined |

IMP::core::DerivativesFromRefined | Accumulate the derivatives of the refined particles |

IMP::core::DerivativesToRefined | Copy the derivatives from a coarse particle to its refined particles |

IMP::core::Transform | Apply a transformation to a passed particle |

IMP::core::TransformationAndReflectionSymmetry | Set the coordinates of a particle to be a transformed version of a reference |

IMP::core::TransformationSymmetry | Set the coordinates of a particle to be a transformed version of a reference |

IMP::core::WeightedDerivativesToRefined | Copy the derivatives from a coarse particle to its refined particles |

IMP::example::ExampleSingletonModifier | An example singleton modifier |

IMP.example.PythonExampleSingletonModifier | An example SingletonModifier written in Python |

IMP::pmi1::InternalCoordinatesConstraint | An example singleton modifier |

IMP::spb::NuisanceRangeModifier | Ensure that a Nuisance stays within its set range |

IMP::spb::TransformationSymmetry | Set the coordinates of a particle to be a transformed version of a reference |

IMP::SingletonPredicate | Abstract predicate function |

IMP::container::InContainerSingletonFilter | A filter which returns true if a container contains the Singleton |

IMP::core::AllSameSingletonPredicate | Return true (1) if all members of the tuple are the same |

IMP::core::AttributeSingletonPredicate | Return the value of an int attribute as the predicate value |

IMP::core::CoinFlipSingletonPredicate | Return true (1) with a fixed probability |

IMP::core::ConstantSingletonPredicate | Always return a constant value |

IMP::core::InBoundingBox3DSingletonPredicate | Return 1 if the XYZ is in the bounding box, 0 otherwise |

IMP::core::OrderedTypeSingletonPredicate | Return a unique predicate value for each ordered set of ParticleTypes |

IMP::core::UnorderedTypeSingletonPredicate | Return a unique predicate value for each unordered set of ParticleTypes |

IMP::SingletonScore | Abstract class for scoring object(s) of type ParticleIndex |

IMP::core::GenericAttributeSingletonScore< core::Harmonic > | |

IMP::npctransport::PoreRadiusSingletonScore | |

IMP::atom::AngleSingletonScore | Score the angle based on a UnaryFunction, |

IMP::atom::BondSingletonScore | Score the bond based on a UnaryFunction, |

IMP::atom::DihedralSingletonScore | Score the dihedral angle |

IMP::atom::ImproperSingletonScore | Score the improper dihedral based on a UnaryFunction, |

IMP::container::MinimumSingletonScore | Evaluate the min or max n particle scores of the passed set |

IMP::core::GenericAttributeSingletonScore< UF > | Apply a function to an attribute |

IMP::core::GenericBoundingBox3DSingletonScore< UF > | |

IMP::core::GenericBoundingSphere3DSingletonScore< UF > | Score XYZ or XYZR particles based on how far outside a sphere they are |

IMP::core::GenericDistanceToSingletonScore< UF > | Apply a function to the distance to a fixed point |

IMP::core::PredicateSingletonScore< Predicate, Score > | |

IMP::core::SphereDistanceToSingletonScore | Apply a function to the distance to a fixed point |

IMP::npctransport::ExcludeZRangeSingletonScore | Exclude particles from the given range of z coordinates |

IMP::npctransport::HarmonicSpringSingletonScore | |

IMP::npctransport::ZBiasSingletonScore | Score that biases particles to go down the Z axis |

IMP::spb::TiltSingletonScore | Apply a function to the distance to a fixed point |

IMP::statistics::Embedding | Store data to be clustered for embedding based algorithms |

IMP::em::HighDensityEmbedding | |

IMP::statistics::ConfigurationSetXYZEmbedding | Embed a configuration using the XYZ coordinates of a set of particles |

IMP::statistics::ParticleEmbedding | |

IMP::statistics::RecursivePartitionalClusteringEmbedding | |

IMP::statistics::VectorDEmbedding | Simply return the coordinates of a VectorD |

IMP::statistics::Metric | Store data to be clustered for distance metric based algorithms |

IMP::spb::ChiSquareMetric | |

IMP::spb::ContactMapMetric | |

IMP::spb::DistanceRMSDMetric | |

IMP::spb::RMSDMetric | |

IMP::statistics::ChiSquareMetric | Compute the distance between two configurations using chi2 |

IMP::statistics::ConfigurationSetRMSDMetric | |

IMP::statistics::EuclideanMetric | |

IMP::statistics::RecursivePartitionalClusteringMetric | Represent a metric for clustering data that has already been clustered once |

write_a_metric.MyMetric | |

IMP::statistics::PartitionalClustering | A base class for clustering results where each item is in one cluster |

IMP::statistics::PartitionalClusteringWithCenter | |

IMP::TripletModifier | A base class for modifiers of ParticleTripletsTemp |

IMP::TripletPredicate | Abstract predicate function |

IMP::container::InContainerTripletFilter | A filter which returns true if a container contains the Triplet |

IMP::core::AllSameTripletPredicate | Return true (1) if all members of the tuple are the same |

IMP::core::CoinFlipTripletPredicate | Return true (1) with a fixed probability |

IMP::core::ConstantTripletPredicate | Always return a constant value |

IMP::core::OrderedTypeTripletPredicate | Return a unique predicate value for each ordered set of ParticleTypes |

IMP::core::UnorderedTypeTripletPredicate | Return a unique predicate value for each unordered set of ParticleTypes |

IMP::TripletScore | Abstract class for scoring object(s) of type ParticleIndexTriplet |

IMP::container::MinimumTripletScore | Evaluate the min or max n particle_triplet scores of the passed set |

IMP::core::AngleTripletScore | Apply a function to the angle between three particles |

IMP::UnaryFunction | Abstract single variable functor class for score functions |

IMP::core::ClosedCubicSpline | Closed cubic spline function |

IMP::core::Cosine | Cosine function |

IMP::core::Harmonic | Harmonic function (symmetric about the mean) |

IMP::core::HarmonicLowerBound | Lower bound harmonic function (non-zero when feature < mean) |

IMP::core::HarmonicUpperBound | Upper bound harmonic function (non-zero when feature > mean) |

IMP::core::HarmonicWell | A well with harmonic barriers |

IMP::core::Linear | Linear function |

IMP::core::SurfaceTetheredChain | Score on surface-to-end distance of chain tethered to impenetrable surface |

IMP::core::TruncatedHarmonic< DIRECTION > | A function that is harmonic over an bounded interval |

IMP::core::WeightedSum | Weighted sum of unary functions |

IMP::core::WeightedSumOfExponential | Negative logarithm of weighted sum of negative exponential of unary functions |

IMP::example::ExampleUnaryFunction | A simple unary function |

IMP.example.PythonExampleUnaryFunction | An example UnaryFunction written in Python |

IMP::misc::FreelyJointedChain | Score on end-to-end distance of freely jointed chain |

IMP::misc::WormLikeChain | Worm-like-chain energy for polymer chains |

IMP::score_functor::ScoreUnaryFunction< Score, D > | |

IMP::spb::Gaussian | Gaussian function (symmetric about the mean) |

IMP::score_functor::ScoreUnaryFunction< score_functor::OpenCubicSpline > | |

IMP::core::OpenCubicSpline | An OpenCubicSpline |

IMP::Undecorator | |

IMP::RAII | Temporarily change something; undo the change when this object is destroyed |

IMP::benchmark::Profiler | |

IMP::CreateLogContext | Create a new log context |

IMP::ScopedAddCacheAttribute< Key, Value > | |

IMP::ScopedSetAttribute< Key, Value > | |

IMP::SetCheckState | A class to change and restore check state |

IMP::SetLogState | A class to change and restore log state |

IMP::SetLogTarget | Temporarily set log target |

IMP::SetNumberOfThreads | |

IMP.pmi.tools.OrderedDefaultDict | Store objects in order they were added, but with default type |

IMP.pmi1.tools.OrderedDefaultDict | Store objects in order they were added, but with default type |

IMP.pmi.output.Output | Class for easy writing of PDBs, RMFs, and stat files |

IMP.pmi1.output.Output | Class for easy writing of PDBs, RMFs, and stat files |

IMP.pmi.output.OutputStatistics | Collect statistics from ProcessOutput.get_fields() |

IMP.pmi1.output.OutputStatistics | Collect statistics from ProcessOutput.get_fields() |

IMP.pmi.ParameterWarning | Warning for probably incorrect input parameters |

IMP::ParticleInputs | Base class for objects that take particle arguments and read from them |

IMP::core::ClosePairsFinder | A base class for algorithms to find spatial proximities |

IMP::PairModifier | A base class for modifiers of ParticlePairsTemp |

IMP::PairPredicate | Abstract predicate function |

IMP::PairScore | Abstract class for scoring object(s) of type ParticleIndexPair |

IMP::QuadModifier | A base class for modifiers of ParticleQuadsTemp |

IMP::QuadPredicate | Abstract predicate function |

IMP::QuadScore | Abstract class for scoring object(s) of type ParticleIndexQuad |

IMP::Refiner | Abstract class to implement hierarchical methods |

IMP::SingletonModifier | A base class for modifiers of ParticlesTemp |

IMP::SingletonPredicate | Abstract predicate function |

IMP::SingletonScore | Abstract class for scoring object(s) of type ParticleIndex |

IMP::TripletModifier | A base class for modifiers of ParticleTripletsTemp |

IMP::TripletPredicate | Abstract predicate function |

IMP::TripletScore | Abstract class for scoring object(s) of type ParticleIndexTriplet |

IMP::ParticleOutputs | Base class for objects that take particle arguments and modify them |

IMP::PairModifier | A base class for modifiers of ParticlePairsTemp |

IMP::QuadModifier | A base class for modifiers of ParticleQuadsTemp |

IMP::SingletonModifier | A base class for modifiers of ParticlesTemp |

IMP::TripletModifier | A base class for modifiers of ParticleTripletsTemp |

IMP.pmi.topology.PDBSequences | Data structure for reading and storing sequence data from PDBs |

IMP.isd.utils.Pipe | Implements a FIFO pipe that merges lists (see self.put) |

IMP.pmi.restraints.stereochemistry.PlaneDihedralRestraint | Restrain the dihedral between planes defined by three particles |

IMP::Pointer< O > | A smart pointer to a reference counted object |

IMP::Pointer< const IMP::atom::CHARMMParameters > | |

IMP::Pointer< const IMP::statistics::internal::XYZDataPoints > | |

IMP::Pointer< container::DynamicListPairContainer > | |

IMP::Pointer< core::HarmonicUpperBound > | |

IMP::Pointer< domino::ParticleStatesTable > | |

IMP::Pointer< domino::RestraintCache > | |

IMP::Pointer< em::DensityMap > | |

IMP::Pointer< em::SampledDensityMap > | |

IMP::Pointer< IMP::atom::CHARMMIdealResidueTopology > | |

IMP::Pointer< IMP::atom::CHARMMPatch > | |

IMP::Pointer< IMP::Configuration > | |

IMP::Pointer< IMP::ConfigurationSet > | |

IMP::Pointer< IMP::domino::AssignmentContainer > | |

IMP::Pointer< IMP::domino::AssignmentsTable > | |

IMP::Pointer< IMP::domino::ParticleStatesTable > | |

IMP::Pointer< IMP::domino::RestraintCache > | |

IMP::Pointer< IMP::em2d::Image > | |

IMP::Pointer< IMP::em2d::ImageReaderWriter > | |

IMP::Pointer< IMP::em2d::ProjectionFinder > | |

IMP::Pointer< IMP::em2d::ScoreFunction > | |

IMP::Pointer< IMP::IMP::Particle > | |

IMP::Pointer< IMP::isd::FStudentT > | |

IMP::Pointer< IMP::isd::MolecularDynamics > | |

IMP::Pointer< IMP::isd::PenalizedComplexityPrior > | |

IMP::Pointer< IMP::isd::vonMisesSufficient > | |

IMP::Pointer< IMP::Model > | |

IMP::Pointer< IMP::Object > | |

IMP::Pointer< IMP::PairContainer > | |

IMP::Pointer< IMP::Particle > | |

IMP::Pointer< IMP::QuadContainer > | |

IMP::Pointer< IMP::RestraintSet > | |

IMP::Pointer< IMP::saxs::DerivativeCalculator > | |

IMP::Pointer< IMP::saxs::Profile > | |

IMP::Pointer< IMP::saxs::ProfileFitter< IMP::saxs::ChiScore > > | |

IMP::Pointer< IMP::saxs::RigidBodiesProfileHandler > | |

IMP::Pointer< IMP::ScoreState > | |

IMP::Pointer< IMP::ScoringFunction > | |

IMP::Pointer< IMP::SingletonContainer > | |

IMP::Pointer< IMP::TripletContainer > | |

IMP::Pointer< IMP::UnaryFunction > | |

IMP::Pointer< internal::ConjugateGradientEigen > | |

IMP::Pointer< internal::KMdata > | |

IMP::Pointer< internal::KMfilterCenters > | |

IMP::Pointer< internal::ListSelectionPredicate > | |

IMP::Pointer< internal::RigidBodyHierarchy > | |

IMP::PointerMember< O > | A smart pointer to a ref-counted Object that is a class member |

IMP::PointerMember< algebra::NearestNeighbor3D > | |

IMP::PointerMember< algebra::NearestNeighbor6D > | |

IMP::PointerMember< atom::BrownianDynamics > | |

IMP::PointerMember< const IMP::rotamer::RotamerLibrary > | |

IMP::PointerMember< const IMP::saxs::Profile > | |

IMP::PointerMember< const saxs::Profile > | |

IMP::PointerMember< container::CloseBipartitePairContainer > | |

IMP::PointerMember< container::ClosePairContainer > | |

IMP::PointerMember< container::PredicatePairsRestraint > | |

IMP::PointerMember< core::Harmonic > | |

IMP::PointerMember< core::HarmonicDistancePairScore > | |

IMP::PointerMember< core::internal::MovedSingletonContainer > | |

IMP::PointerMember< core::TableRefiner > | |

IMP::PointerMember< display::Geometry > | |

IMP::PointerMember< domino::ParticleStatesTable > | |

IMP::PointerMember< domino::RestraintScoreSubsetFilterTable > | |

IMP::PointerMember< em2d::Image > | |

IMP::PointerMember< em::DensityMap > | |

IMP::PointerMember< GaussianProcessInterpolationScoreState > | |

IMP::PointerMember< IMP::atom::AngleSingletonScore > | |

IMP::PointerMember< IMP::atom::BondSingletonScore > | |

IMP::PointerMember< IMP::atom::DihedralSingletonScore > | |

IMP::PointerMember< IMP::atom::ImproperSingletonScore > | |

IMP::PointerMember< IMP::atom::PDBSelector > | |

IMP::PointerMember< IMP::atom::SmoothingFunction > | |

IMP::PointerMember< IMP::Configuration > | |

IMP::PointerMember< IMP::ConfigurationSet > | |

IMP::PointerMember< IMP::container::CloseBipartitePairContainer > | |

IMP::PointerMember< IMP::container::ConsecutivePairContainer > | |

IMP::PointerMember< IMP::core::ClosePairsFinder > | |

IMP::PointerMember< IMP::core::OrderedTypePairPredicate > | |

IMP::PointerMember< IMP::core::RestraintsScoringFunction > | |

IMP::PointerMember< IMP::core::RigidClosePairsFinder > | |

IMP::PointerMember< IMP::core::SoftSpherePairScore > | |

IMP::PointerMember< IMP::core::SurfaceGeometry > | |

IMP::PointerMember< IMP::core::TransformationSymmetry > | |

IMP::PointerMember< IMP::display::Writer > | |

IMP::PointerMember< IMP::domino::AssignmentsTable > | |

IMP::PointerMember< IMP::domino::ParticleStates > | |

IMP::PointerMember< IMP::domino::ParticleStatesTable > | |

IMP::PointerMember< IMP::domino::RestraintCache > | |

IMP::PointerMember< IMP::em2d::ScoreFunction > | |

IMP::PointerMember< IMP::em::DensityMap > | |

IMP::PointerMember< IMP::em::EnvelopeScore > | |

IMP::PointerMember< IMP::em::MapDistanceTransform > | |

IMP::PointerMember< IMP::em::PCAAligner > | |

IMP::PointerMember< IMP::em::SampledDensityMap > | |

IMP::PointerMember< IMP::IMP::PairContainer > | |

IMP::PointerMember< IMP::IMP::Particle > | |

IMP::PointerMember< IMP::IMP::Restraint > | |

IMP::PointerMember< IMP::IMP::SingletonContainer > | |

IMP::PointerMember< IMP::IMP::UnaryFunction > | |

IMP::PointerMember< IMP::isd::BivariateFunction > | |

IMP::PointerMember< IMP::isd::CrossLinkData > | |

IMP::PointerMember< IMP::isd::CysteineCrossLinkData > | |

IMP::PointerMember< IMP::isd::FNormal > | |

IMP::PointerMember< IMP::isd::FretData > | |

IMP::PointerMember< IMP::isd::GaussianProcessInterpolation > | |

IMP::PointerMember< IMP::isd::MolecularDynamics > | |

IMP::PointerMember< IMP::isd::MolecularDynamicsMover > | |

IMP::PointerMember< IMP::isd::MultivariateFNormalSufficient > | |

IMP::PointerMember< IMP::isd::UnivariateFunction > | |

IMP::PointerMember< IMP::kinematics::DirectionalDOF > | |

IMP::PointerMember< IMP::kinematics::DOFsSampler > | |

IMP::PointerMember< IMP::kinematics::LocalPlanner > | |

IMP::PointerMember< IMP::Model > | |

IMP::PointerMember< IMP::multifit::AssemblyHeader > | |

IMP::PointerMember< IMP::npctransport::GlobalStatisticsOptimizerState > | |

IMP::PointerMember< IMP::npctransport::IMP::npctransport::Scoring > | |

IMP::PointerMember< IMP::npctransport::IMP::npctransport::Statistics > | |

IMP::PointerMember< IMP::Object > | |

IMP::PointerMember< IMP::Optimizer > | |

IMP::PointerMember< IMP::OptimizerState > | |

IMP::PointerMember< IMP::PairContainer > | |

IMP::PointerMember< IMP::PairModifier > | |

IMP::PointerMember< IMP::PairPredicate > | |

IMP::PointerMember< IMP::PairScore > | |

IMP::PointerMember< IMP::Particle > | |

IMP::PointerMember< IMP::QuadContainer > | |

IMP::PointerMember< IMP::QuadModifier > | |

IMP::PointerMember< IMP::QuadPredicate > | |

IMP::PointerMember< IMP::QuadScore > | |

IMP::PointerMember< IMP::Refiner > | |

IMP::PointerMember< IMP::Restraint > | |

IMP::PointerMember< IMP::RestraintSet > | |

IMP::PointerMember< IMP::saxs::Profile > | |

IMP::PointerMember< IMP::ScoreState > | |

IMP::PointerMember< IMP::ScoringFunction > | |

IMP::PointerMember< IMP::SingletonContainer > | |

IMP::PointerMember< IMP::SingletonModifier > | |

IMP::PointerMember< IMP::SingletonPredicate > | |

IMP::PointerMember< IMP::SingletonScore > | |

IMP::PointerMember< IMP::statistics::Embedding > | |

IMP::PointerMember< IMP::statistics::Metric > | |

IMP::PointerMember< IMP::statistics::PartitionalClustering > | |

IMP::PointerMember< IMP::TripletContainer > | |

IMP::PointerMember< IMP::TripletModifier > | |

IMP::PointerMember< IMP::TripletPredicate > | |

IMP::PointerMember< IMP::TripletScore > | |

IMP::PointerMember< IMP::UnaryFunction > | |

IMP::PointerMember< internal::PairContainerIndex > | |

IMP::PointerMember< internal::QuadContainerIndex > | |

IMP::PointerMember< internal::SingletonContainerIndex > | |

IMP::PointerMember< internal::TripletContainerIndex > | |

IMP::PointerMember< kinematics::IMP::kinematics::KinematicForest > | |

IMP::PointerMember< multifit::IMP::multifit::ProteomicsData > | |

IMP::PointerMember< PairScore > | |

IMP::PointerMember< Predicate > | |

IMP::PointerMember< rmf::SaveOptimizerState > | |

IMP::PointerMember< ScoringFunctionT > | |

IMP::PointerMember< Table > | |

IMP::PointerMember< UF > | |

IMP::score_functor::PointToSphereDistance< BaseDistanceScore > | |

IMP::em2d::PolarResamplingParameters | |

IMP.pmi.analysis.Precision | A class to evaluate the precision of an ensemble |

IMP.pmi1.analysis.Precision | A class to evaluate the precision of an ensemble |

IMP.pmi.output.ProcessOutput | A class for reading stat files (either rmf or ascii v1 and v2) |

IMP.pmi1.output.ProcessOutput | A class for reading stat files (either rmf or ascii v1 and v2) |

IMP::saxs::ProfileClustering | |

IMP::em2d::ProjectingParameters | Parameters needed for the core projection routine |

IMP::em2d::Em2DRestraintParameters | Parameters used by Em2DRestraint and ProjectionFinder |

IMP::em2d::ProjectingOptions | Parameters given as options to the get_projections() functions |

IMP::em2d::ProjectionMask | |

IMP::multifit::ProteinsAnchorsSamplingSpace | Stores the anchors sampling space for each protein |

IMP.pmi.output.ProtocolOutput | Base class for capturing a modeling protocol |

IMP.pmi.mmcif.ProtocolOutput | Class to encode a modeling protocol as mmCIF |

IMP.pmi1.output.ProtocolOutput | Base class for capturing a modeling protocol |

IMP.pmi1.mmcif.ProtocolOutput | Class to encode a modeling protocol as mmCIF |

IMP.pmi.restraints.stereochemistry.PseudoAtomicRestraint | Add bonds and improper dihedral restraints for the CBs |

IMP.pmi1.restraints.stereochemistry.PseudoAtomicRestraint | Add bonds and improper dihedral restraints for the CBs |

IMP::PythonDirectedGraph | |

IMP::em::RadiusDependentDistanceMask | |

IMP.test.RefCountChecker | Check to make sure the number of C++ object references is as expected |

IMP::algebra::ReferenceFrame3D | A reference frame in 3D |

IMP::em2d::RegistrationResult | Class to manage registration results |

IMP.pmi.samplers.ReplicaExchange | Sample using replica exchange |

IMP.pmi1.samplers.ReplicaExchange | Sample using replica exchange |

IMP.pmi.macros.ReplicaExchange | A macro to help setup and run replica exchange |

IMP.pmi1.macros.ReplicaExchange0 | A macro to help setup and run replica exchange |

IMP.pmi1.representation.Representation | Set up the representation of all proteins and nucleic acid macromolecules |

IMP.pmi.alphabets.ResidueAlphabet | Map between FASTA codes and residue types |

IMP.pmi.restraints.stereochemistry.ResidueAngleRestraint | Add angular restraint between triplets of consecutive residues/beads to enforce the stereochemistry |

IMP.pmi1.restraints.stereochemistry.ResidueAngleRestraint | Add angular restraint between triplets of consecutive residues/beads to enforce the stereochemistry |

IMP.pmi.restraints.stereochemistry.ResidueBondRestraint | Add bond restraint between pair of consecutive residues/beads to enforce the stereochemistry |

IMP.pmi1.restraints.stereochemistry.ResidueBondRestraint | Add bond restraint between pair of consecutive residues/beads to enforce the stereochemistry |

IMP.pmi.restraints.stereochemistry.ResidueDihedralRestraint | Add dihedral restraints between quadruplet of consecutive residues/beads to enforce the stereochemistry |

IMP.pmi1.restraints.stereochemistry.ResidueDihedralRestraint | Add dihedral restraints between quadruplet of consecutive residues/beads to enforce the stereochemistry |

IMP.pmi.io.crosslink.ResiduePairListParser | A class to handle different styles of site pairs parsers |

IMP.pmi1.io.crosslink.ResiduePairListParser | A class to handle different styles of site pairs parsers |

IMP.pmi.restraints.basic.ResidueProteinProximityRestraint | Restrain residue/residues to bind to unknown location in a target |

IMP::rotamer::ResidueRotamer | A class storing the rotated coordinates of the atoms in the residue |

IMP::atom::ResidueType | The type for a residue |

IMP.pmi1.restraints.RestraintBase | Base class for PMI restraints, which wrap `IMP.Restraint` (s) |

IMP.pmi1.restraints.basic.DistanceRestraint | A simple distance restraint |

IMP.pmi1.restraints.basic.DistanceToPointRestraint | Restraint for anchoring a particle to a specific coordinate |

IMP.pmi1.restraints.basic.ExternalBarrier | Restraint to keep all structures inside sphere |

IMP.pmi1.restraints.crosslinking.AtomicCrossLinkMSRestraint | Setup cross-link distance restraints at atomic level The "atomic" aspect is that it models the particle uncertainty with a Gaussian The noise in the data and the structural uncertainty of cross-linked amino-acids is inferred using Bayes' theory of probability |

IMP.pmi1.restraints.crosslinking.CrossLinkingMassSpectrometryRestraint | Setup cross-link distance restraints from mass spectrometry data |

IMP.pmi1.restraints.parameters.JeffreysPrior | Wrapper for `IMP.isd.JeffreysRestraint` |

IMP.pmi1.restraints.parameters.WeightRestraint | Wrapper for an `IMP.isd.WeightRestraint` |

IMP.pmi1.restraints.saxs.SAXSISDRestraint | Basic SAXS restraint using ISD |

IMP.pmi1.restraints.saxs.SAXSRestraint | Basic SAXS restraint |

IMP.pmi1.restraints.stereochemistry.PlaneDihedralRestraint | Restrain the dihedral between planes defined by three particles |

IMP.pmi1.analysis.RMSD | Compute the RMSD (without alignment) taking into account the copy ambiguity |

IMP.pmi.analysis.RMSD | Compute the RMSD (without alignment) taking into account the copy ambiguity |

IMP.pmi1.io.RMSDOutput | A helper output based on dist to initial coordinates |

IMP::rotamer::RotamerAngleTuple | A simple class storing chi angles and their probability |

IMP::kinematics::RRT::RRTNode | Simple RRT node implementation |

IMP.pmi.restraints.saxs.SAXSISDRestraint | Basic SAXS restraint using ISD |

IMP.pmi.restraints.saxs.SAXSRestraint | Basic SAXS restraint |

IMP::score_functor::Score | A functor for computing a distance based score for D particles |

IMP::score_functor::AddScores< BaseDistanceScore0, BaseDistanceScore1 > | |

IMP::score_functor::Harmonic | |

IMP::score_functor::HarmonicLowerBound | |

IMP::score_functor::HarmonicUpperBound | |

IMP::score_functor::LinearLowerBound | |

IMP::npctransport::LinearInteraction | |

IMP::score_functor::OpenCubicSpline | Open cubic spline function |

IMP::score_functor::Statistical< Key, BIPARTITE, INTERPOLATE, SPARSE > | |

IMP::score_functor::UnaryFunctionEvaluate | |

IMP::score_functor::Statistical< DopeType, false, false > | |

IMP::score_functor::Soap | Score pairs of atoms based on SOAP |

IMP::score_functor::Statistical< DopeType, false, true > | |

IMP::score_functor::Dope | Score pair of atoms based on DOPE |

IMP::score_functor::Statistical< LoopStatisticalType, false, true > | |

IMP::score_functor::LoopStatistical | Score atoms based on the Fiser/Melo loop modeling statistical potential |

IMP::score_functor::Statistical< ProteinLigandType, BIPARTITE, INTERPOLATE, false > | |

IMP::score_functor::ScoreWithCache | A cached functor for computing a distance based score for D particles |

IMP::score_functor::OrientedSoap | Orientation-dependent SOAP score |

IMP.pmi1.restraints.stereochemistry.SecondaryStructure | Experimental, requires isd_emxl for now |

IMP::em2d::SegmentationParameters | Class to provide all the parameters to the segmentation function |

IMP.pmi.tools.Segments | This class stores integers in ordered compact lists eg: [[1,2,3],[6,7,8]] the methods help splitting and merging the internal lists Example: s=Segments([1,2,3]) is [[1,2,3]] s.add(4) is [[1,2,3,4]] (add right) s.add(3) is [[1,2,3,4]] (item already existing) s.add(7) is [[1,2,3,4],[7]] (new list) s.add([8,9]) is [[1,2,3,4],[7,8,9]] (add item right) s.add([5,6]) is [[1,2,3,4,5,6,7,8,9]] (merge) s.remove(3) is [[1,2],[4,5,6,7,8,9]] (split) etc |

IMP.pmi1.tools.Segments | This class stores integers in ordered compact lists eg: [[1,2,3],[6,7,8]] the methods help splitting and merging the internal lists Example: s=Segments([1,2,3]) is [[1,2,3]] s.add(4) is [[1,2,3,4]] (add right) s.add(3) is [[1,2,3,4]] (item already existing) s.add(7) is [[1,2,3,4],[7]] (new list) s.add([8,9]) is [[1,2,3,4],[7,8,9]] (add item right) s.add([5,6]) is [[1,2,3,4,5,6,7,8,9]] (merge) s.remove(3) is [[1,2],[4,5,6,7,8,9]] (split) etc |

IMP.pmi1.topology.Sequences | A dictionary-like wrapper for reading and storing sequence data |

IMP.pmi.topology.Sequences | A dictionary-like wrapper for reading and storing sequence data |

IMP.pmi.restraints.proteomics.SetupConnectivityNetworkRestraint | Generates and wraps a IMP.pmi.ConnectivityRestraint between domains example: cr=restraints.ConnectivityNetworkRestraint( simo,["CCC",(1,100,"TTT"),(100,150,"AAA")]) cr.add_to_model() cr.set_label("CR1") |

IMP.pmi1.restraints.proteomics.SetupConnectivityNetworkRestraint | Generates and wraps a IMP.pmi1.ConnectivityRestraint between domains example: cr=restraints.ConnectivityNetworkRestraint(simo,["CCC",(1,100,"TTT"),(100,150,"AAA")]) cr.add_to_model() cr.set_label("CR1") |

IMP.pmi1.restraints.proteomics.SetupMembraneRestraint | |

IMP.isd.shared_functions.sfo_common | Nonspecific methods used across all shared function objects |

IMP::score_functor::Shift< BaseDistanceScore > | |

IMP::Showable | Helper class to aid in output of `IMP` classes to streams |

IMP::em2d::SingleLinkage | Functor for hierarchical clustering based on single linkage |

IMP::score_functor::SingletonStatistical< Key, INTERPOLATE > | Create a single key/single particle statistical potential from a file |

IMP::npctransport::SitesPairScoreParameters | |

IMP::saxs::SolventAccessibleSurface | |

IMP::algebra::SparseGridStorageD< D, VT, Base, Map > | |

IMP::algebra::SparseGridStorageD< D, VT, Base > | |

IMP::SparseSymmetricPairMemoizer< Generator, Checker > | |

IMP::score_functor::SphereDistance< BaseDistanceScore > | |

IMP::em::SpiderHeader | Header for Spider images. IMP-EM is designed to be compatible with it |

IMP.pmi.topology.State | Stores a list of Molecules all with the same State index |

IMP.isd.Statistics.Statistics | Statistics gathering and printing class for ISD gibbs sampling |

IMP.pmi.tools.Stopwatch | Collect timing information |

IMP.pmi1.tools.Stopwatch | Collect timing information |

IMP.pmi.StructureWarning | Warning related to handling of structures |

SurfacesGeometry | Display an IMP::SingletonContainer of Surface particles as cylindrical disks |

IMP.pmi1.restraints.stereochemistry.SymmetryRestraint | Create harmonic restraints between the reference and (transformed) clones |

IMP.pmi.restraints.stereochemistry.SymmetryRestraint | Create harmonic restraints between the reference and (transformed) clones |

IMP.pmi.topology.System | Represent the root node of the global IMP.atom.Hierarchy |

IMP.isd.TALOSReader.TALOSReader | Reads a TALOS file, or a TALOS folder, and stores the data |

IMP.pmi.topology.TempResidue | Temporarily stores residue information, even without structure available |

IMP.test.TestCase | Super class for IMP test cases |

IMP.test.ApplicationTestCase | Super class for simple IMP application test cases |

IMP.pmi1.tools.ThreeToOneConverter | This class converts three to one letter codes, and return X for any unknown codes |

IMP.pmi.plotting.topology.TopologyPlot | A class to read RMF files and make a network contact map |

IMP.pmi1.plotting.topology.TopologyPlot | A class to read RMF files and make a network contact map |

IMP.pmi1.topology.TopologyReader | Automatically setup System and Degrees of Freedom with a formatted text file |

IMP.pmi.topology.TopologyReader | Automatically setup System and Degrees of Freedom with a formatted text file |

IMP.pmi.io.TotalScoreOutput | A helper output for model evaluation |

IMP.pmi1.io.TotalScoreOutput | A helper output for model evaluation |

IMP.EMageFit.imp_general.io.Transformation3DToText | Parseable output for a IMP Transformation3D |

IMP.EMageFit.imp_general.io.ReferenceFrameToText | Transform a IMP reference frame into parseable output |

IMP::algebra::UnboundedGridRangeD< D > | |

IMP::algebra::SparseGridStorageD< D, VT, UnboundedGridRangeD< D > > | |

IMP::algebra::GridD< D, SparseGridStorageD< D, VT, UnboundedGridRangeD< D > >, VT, DefaultEmbeddingD< D > > | |

IMP::algebra::UnboundedGridRangeD< 3 > | |

IMP::algebra::SparseGridStorageD< 3, Ints, UnboundedGridRangeD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, Ints, UnboundedGridRangeD< 3 > >, Ints, DefaultEmbeddingD< 3 > > | |

IMP::algebra::SparseGridStorageD< 3, VT, UnboundedGridRangeD< 3 > > | |

IMP::algebra::GridD< 3, SparseGridStorageD< 3, VT, UnboundedGridRangeD< 3 > >, VT, DefaultEmbeddingD< 3 > > | |

IMP::UncheckedWeakPointer< O > | A weak pointer to an Object or RefCountedObject |

IMP::UncheckedWeakPointer< IMP::npctransport::SimulationData > | |

IMP::UncheckedWeakPointer< IMP::Optimizer > | |

IMP::UsageException | An exception for an invalid usage of `IMP` |

IMP::Value | Base class for a simple primitive-like type |

IMP::Array< 2, Key > | |

IMP::Array< 2, ParticleIndex > | |

IMP::Array< 4, ParticleIndex > | |

IMP::ConstVector< IMP::WeakPointer< Particle >, Particle * > | |

IMP::domino::Subset | Represent a subset of the particles being optimized |

IMP::ConstVector< int > | |

IMP::domino::Assignment | Store a configuration of a subset |

IMP::ConstVector< unsigned int > | |

IMP::domino::Order | Store a persistent ordering for a subset based on the list |

IMP::domino::Slice | Store a subset of a subset or assignment |

IMP::algebra::ExtendedGridIndexD< D > | An index in an infinite grid on space |

IMP::algebra::GridIndexD< D > | Represent a real cell in a grid (one within the bounding box) |

IMP::Array< D, Data, SwigData > | A class to store a fixed array of same-typed values |

IMP::atom::PDBRecord | Represent a single ATOM/HETATM "line" in PDB or mmCIF format |

IMP::ConstVector< Data, SwigData > | Store an array of values of the same type |

IMP::core::MonteCarloMoverResult | Return value of the MonteCarloMover::propose() function |

IMP::Decorator | Interface to specialized Particle types (e.g. atoms) |

IMP::atom::Angle | A particle that describes an angle between three particles |

IMP::atom::AngularVelocity | A particle with angular velocity |

IMP::atom::Bond | A decorator for wrapping a particle representing a molecular bond |

IMP::atom::Bonded | A decorator for a particle which has bonds |

IMP::atom::CenterOfMass | A particle that is the center of mass of other particles |

IMP::atom::Dihedral | A particle that describes a dihedral angle between four particles |

IMP::atom::LinearVelocity | A particle with linear (XYZ) velocity |

IMP::atom::Mass | Add mass to a particle |

IMP::atom::SecondaryStructureResidue | A decorator for a residue with probability of secondary structure |

IMP::atom::StructureSource | Store strings describing the source of this structure fragment |

IMP::atom::TAMDParticle | |

IMP::core::Direction | A decorator for a particle that represents a direction in 3D |

IMP::core::DirectionAngle | A decorator for an angle between two directions |

IMP::core::Hierarchy | A decorator for helping deal with a generalized hierarchy |

IMP::atom::Hierarchy | The standard decorator for manipulating molecular structures |

IMP::atom::Atom | A decorator for a particle representing an atom |

IMP::atom::CHARMMAtom | A decorator for an atom that has a defined CHARMM type |

IMP::atom::Chain | Store info for a chain of a protein |

IMP::atom::Domain | A decorator to associate a particle with a part of a protein |

IMP::atom::Fragment | A decorator to associate a particle with a part of a protein/DNA/RNA |

IMP::atom::Molecule | A decorator for a molecule |

IMP::atom::Copy | A decorator for keeping track of copies of a molecule |

IMP.pmi1.topology.PMIMoleculeHierarchy | Extends the functionality of IMP.atom.Molecule |

IMP.pmi.topology.PMIMoleculeHierarchy | Extends the functionality of IMP.atom.Molecule |

IMP::atom::Representation | A decorator for a representation |

IMP::atom::Residue | A decorator for a residue |

IMP::atom::State | Associate an integer "state" index with a hierarchy node |

IMP.pmi1.output.RMFHierarchyHandler | Class to allow more advanced handling of RMF files |

IMP.pmi1.output.StatHierarchyHandler | Class to link stat files to several rmf files |

IMP.pmi.output.RMFHierarchyHandler | Class to allow more advanced handling of RMF files |

IMP.pmi.output.StatHierarchyHandler | Class to link stat files to several rmf files |

IMP::core::Provenance | Track how parts of the system were created |

IMP::core::ClusterProvenance | Track creation of a system fragment from clustering |

IMP::core::CombineProvenance | Track creation of a system fragment by combination |

IMP::core::FilterProvenance | Track creation of a system fragment by filtering |

IMP::core::SampleProvenance | Track creation of a system fragment from sampling |

IMP::core::ScriptProvenance | Track creation of a system fragment from running a script |

IMP::core::SoftwareProvenance | Track creation of a system fragment from running some software |

IMP::core::StructureProvenance | Track creation of a system fragment from a PDB file |

IMP::core::Provenanced | Tag part of the system to track how it was created |

IMP::core::Reference | A particle that has an associated reference particle |

IMP::core::Typed | A decorator for classifying particles in your system |

IMP::core::XYZ | A decorator for a particle with x,y,z coordinates |

IMP::atom::Charged | A decorator for a point particle that has an electrostatic charge |

IMP::atom::Diffusion | A decorator for a diffusing particle with a diffusion coefficient |

IMP::atom::RigidBodyDiffusion | |

IMP::core::Centroid | A particle that is the geometric centroid of other particles |

IMP::atom::TAMDCentroid | |

IMP::core::RigidBody | A decorator for a rigid body |

IMP::core::Gaussian | |

IMP::kinematics::KinematicNode | A rigid body that is connected by a joint to other rigid bodies |

IMP::core::RigidBodyMember | A member of a rigid body, it has internal (local) coordinates |

IMP::core::NonRigidMember | A decorator for a particle that is part of a rigid body but not rigid |

IMP::core::RigidMember | |

IMP::core::Surface | A decorator for a particle that represents a surface, its coordinates, and orientation |

IMP::core::XYZR | A decorator for a particle with x,y,z coordinates and a radius |

IMP::atom::LennardJones | A decorator for a particle that has a Lennard-Jones potential well |

IMP::core::Cover | A particle which covers a set of other particles |

IMP::misc::CustomXYZR | A decorator for a particle with x,y,z coordinates and a radius |

IMP::display::Colored | A particle with a color |

IMP::em2d::ProjectionParameters | |

IMP::em::Voxel | |

IMP::example::ExampleDecorator | A simple decorator which adds a name to a particle |

IMP::isd::Nuisance | Add nuisance parameter to particle |

IMP::isd::Scale | Add scale parameter to particle |

IMP::isd::Switching | Add switching parameter to particle |

IMP::isd::Weight | Add weights to a particle |

IMP::npc::SlabWithPore | |

IMP::npc::SlabWithToroidalPore | |

IMP::npc::SlabWithSphericalIndent | A decorator for a particle that represents a slab containing a spherical cap indent |

IMP::npctransport::RelaxingSpring | A decorator for a spring particle connecting two diffusing particles |

IMP::npctransport::SlabWithPore | |

IMP::npctransport::SlabWithCylindricalPore | |

IMP::npctransport::SlabWithToroidalPore | |

IMP::npctransport::Transporting | A decorator for a particle transporting through a barrier |

IMP::pmi1::Resolution | Add resolution to a particle |

IMP::pmi1::Symmetric | Add symmetric attribute to a particle |

IMP::pmi1::Uncertainty | Add uncertainty to a particle |

IMP::pmi::Resolution | Add resolution to a particle |

IMP::pmi::Symmetric | Add symmetric attribute to a particle |

IMP::pmi::Uncertainty | Add uncertainty to a particle |

IMP::spb::HelixDecorator | Add helix parameters to a particle |

IMP::display::Color | Represent an RGB color |

IMP::FloatIndex | A FloatIndex identifies an optimized attribute in a model |

IMP::Key< ID > | A base class for Keys |

IMP::ScoreAccumulator | Class for adding up scores during ScoringFunction evaluation |

IMP::Vector< T, Allocator > | A more `IMP-like` version of the `std::vector` |

IMP::IndexVector< Tag, T, Allocator, Equal > | Implements a vector tied to a particular index of type Index<Tag> |

IMP::ParticleIndexPairsAdaptor | Take ParticlePairs or ParticleIndexPairs |

IMP::VersionInfo | Version and module information for Objects |

IMP::Key< 0 > | |

IMP::Key< 1 > | |

IMP::Key< 3 > | |

IMP::Key< 34897493 > | |

IMP::Key< 4 > | |

IMP::Key< 6 > | |

IMP::Key< 8974343 > | |

IMP::Key< 90784334 > | |

IMP::Vector< algebra::Vector3D > | |

IMP::Vector< algebra::Vector3Ds > | |

IMP::Vector< algebra::VectorKD > | |

IMP::Vector< AP > | |

IMP::Vector< Assignment > | |

IMP::Vector< AtomFactorCoefficients > | |

IMP::Vector< CHARMMAngle > | |

IMP::Vector< CHARMMBond > | |

IMP::Vector< CHARMMDihedral > | |

IMP::Vector< CHARMMInternalCoordinate > | |

IMP::Vector< core::RigidBody > | |

IMP::Vector< Data > | |

IMP::Vector< double > | |

IMP::Vector< FittingSolutionRecord > | |

IMP::Vector< Float > | |

IMP::Vector< FloatIndex > | |

IMP::Vector< FloatKey > | |

IMP::Vector< FloatRange > | |

IMP::Vector< Floats > | |

IMP::Vector< Hierarchy > | |

IMP::Vector< IMP::algebra::VectorD< D > > | |

IMP::Vector< IMP::atom::CHARMMAtomTopology > | |

IMP::Vector< IMP::atom::CHARMMBondEndpoint > | |

IMP::Vector< IMP::atom::ForceFieldParameters::Bond > | |

IMP::Vector< IMP::IMP::PointerMember< core::MultipleBinormalRestraint > > | |

IMP::Vector< IMP::Index > | |

IMP::Vector< IMP::multi_state::MultiStateModelScore * > | |

IMP::Vector< IMP::Pointer< DihedralAngleRevoluteJoint > > | |

IMP::Vector< IMP::Pointer< DOF > > | |

IMP::Vector< IMP::Pointer< Geometry > > | |

IMP::Vector< IMP::Pointer< Image > > | |

IMP::Vector< IMP::Pointer< IMP::Configuration > > | |

IMP::Vector< IMP::Pointer< IMP::Particle >, std::allocator< IMP::Pointer< IMP::Particle > > > | |

IMP.IndexVector< ParticleIndexTag, IMP.Pointer< IMP.Particle > > | |

IMP::Vector< IMP::Pointer< Joint > > | |

IMP::Vector< IMP::Pointer< MonteCarloMover > > | |

IMP::Vector< IMP::Pointer< O > > | |

IMP::Vector< IMP::Pointer< PairContainer > > | |

IMP::Vector< IMP::Pointer< PairScore > > | |

IMP::Vector< IMP::Pointer< Particle > > | |

IMP::Vector< IMP::Pointer< Profile > > | |

IMP::Vector< IMP::Pointer< QuadScore > > | |

IMP::Vector< IMP::Pointer< Restraint > > | |

IMP::Vector< IMP::Pointer< RevoluteJoint > > | |

IMP::Vector< IMP::Pointer< SampledDensityMap > > | |

IMP::Vector< IMP::Pointer< SingletonScore > > | |

IMP::Vector< IMP::Pointer< SubsetFilterTable > > | |

IMP::Vector< IMP::Pointer< SurfaceShellDensityMap > > | |

IMP::Vector< IMP::Pointer< TransformationJoint > > | |

IMP::Vector< IMP::Pointer< TripletScore > > | |

IMP::Vector< IMP::Pointer< UnaryFunction > > | |

IMP::Vector< IMP::PointerMember< Score > > | |

IMP::Vector< IMP::Vector > | |

IMP::Vector< IMP::Vector, std::allocator< IMP::Vector > > | |

IMP.IndexVector< ParticleIndexTag, IMP.Vector > | |

IMP::Vector< IMP::Vector< double > > | |

IMP::Vector< IMP::WeakPointer< Container > > | |

IMP::Vector< IMP::WeakPointer< Restraint > > | |

IMP::Vector< Index > | |

IMP::Vector< Int > | |

IMP::Vector< int > | |

IMP::Vector< IntPair > | |

IMP::Vector< Ints > | |

IMP::Vector< IntsList > | |

IMP::Vector< Key > | |

IMP::Vector< ParticleIndex, std::allocator< ParticleIndex > > | |

IMP::Vector< ParticleIndexPair, std::allocator< ParticleIndexPair > > | |

IMP::Vector< ParticleIndexQuad, std::allocator< ParticleIndexQuad > > | |

IMP::Vector< ParticleIndexTriplet, std::allocator< ParticleIndexTriplet > > | |

IMP::Vector< ParticlePair > | |

IMP::Vector< Pointer< Particle > > | |

IMP::Vector< ReferenceFrame3D > | |

IMP::Vector< RegistrationResult > | |

IMP::Vector< RestraintSetData > | |

IMP::Vector< RigidBody > | |

IMP::Vector< Rotation3D > | |

IMP::Vector< Slice > | |

IMP::Vector< Sphere3D > | |

IMP::Vector< std::pair< internal::CHARMMDihedralNames, CHARMMDihedralParameters > > | |

IMP::Vector< std::string > | |

IMP::Vector< String > | |

IMP::Vector< Transformation3D > | |

IMP.Vector< unsigned > | |

IMP::Vector< unsigned int > | |

IMP::Vector< VectorD< 2 > > | |

IMP::Vector< VectorD< 3 > > | |

IMP::Vector< VectorD<-1 > > | |

IMP::Vector< WeakPointer< Particle > > | |

IMP::domino::ParticlesAdaptor | |

IMP::Vector< XYZ > | |

IMP::Vector< XYZR > | |

**std::vector< T >** | STL class |

IMP::saxs::Distribution< algebra::Vector3D > | |

IMP::saxs::DeltaDistributionFunction | |

IMP::saxs::Distribution< double > | |

IMP::saxs::RadialDistributionFunction | |

IMP::kinematics::DOFValues | A class that holds DOF values for DOFs |

IMP::saxs::Distribution< ValueT > | |

IMP::WarningContext | Warnings with the same key within the context are only output once |

IMP::WeakPointer< O > | Smart pointer to Object-derived classes that does not refcount |

IMP::WeakPointer< atom::Simulator > | |

IMP::WeakPointer< IMP::atom::Simulator > | |

IMP::WeakPointer< IMP::Model > | |

IMP::WeakPointer< IMP::npctransport::IMP::npctransport::Statistics > | |

IMP::WeakPointer< IMP::npctransport::SimulationData > | |

IMP::WeakPointer< IMP::Particle > | |

IMP::WeakPointer< IMP::Restraint > | |

IMP.pmi.restraints.parameters.WeightRestraint | Wrapper for an `IMP.isd.WeightRestraint` |

IMP::score_functor::WeightScore< BaseDistanceScore > | |

IMP.parallel.Worker | Representation of a single worker |

IMP.parallel.LocalWorker | A worker running on the same machine as the manager |

IMP.parallel.WorkerArray | Representation of an array of workers |

IMP.parallel.SGEPEWorkerArray | An array of workers in a Sun Grid Engine system parallel environment |

IMP.parallel.SGEQsubWorkerArray | An array of workers on a Sun Grid Engine system, started with 'qsub' |

IMP.mmcif.util.Writer | Convert one or more IMP Models and/or RMF frames to mmCIF or BinaryCIF |

IMP.EMageFit.buildxlinks.Xlink | Class defining a cross-link |

IMP.EMageFit.buildxlinks.XlinksDict | Description of crosslinking restraints as a python dictionary |

IMP.pmi1.io.xltable.XLTable | Class to read, analyze, and plot xlink data on contact maps Canonical way to read the data: 1) load sequences and name them 2) load coordinates for those sequences from PDB file 3) add crosslinks 4) create contact map 5) plot |

IMP.pmi1.restraints.npc.XYRadialPositionLowerRestraint | Create XYRadial Position Lower restraints |

IMP.pmi.restraints.npc.XYRadialPositionLowerRestraint | Restrain a protein's distance from the z axis to above a lower bound |

IMP.pmi1.restraints.npc.XYRadialPositionRestraint | Create XYRadial Position Restraint |

IMP.pmi.restraints.npc.XYRadialPositionRestraint | Restrain a protein's distance from the z axis to within a given range |

IMP.pmi1.restraints.npc.XYRadialPositionUpperRestraint | Create XYRadial Position Upper restraints |

IMP.pmi.restraints.npc.XYRadialPositionUpperRestraint | Restrain a protein's distance from the z axis to below an upper bound |

IMP.pmi.restraints.npc.YAxialPositionLowerRestraint | Restrain a protein's y coordinate to above a lower bound |

IMP.pmi1.restraints.npc.YAxialPositionLowerRestraint | Create Y-Axial Position Lower restraints |

IMP.pmi.restraints.npc.YAxialPositionRestraint | Restrain a protein's y coordinate to within a given range |

IMP.pmi1.restraints.npc.YAxialPositionRestraint | Create Y-Axial Position restraints |

IMP.pmi.restraints.npc.YAxialPositionUpperRestraint | Restrain a protein's y coordinate to below an upper bound |

IMP.pmi1.restraints.npc.YAxialPositionUpperRestraint | Create Y-Axial Position Upper restraints |

IMP.pmi.restraints.npc.ZAxialPositionLowerRestraint | Restrain a protein's z coordinate to above a lower bound |

IMP.pmi1.restraints.npc.ZAxialPositionLowerRestraint | Create Z-Axial Position Lower restraints |

IMP.pmi.restraints.npc.ZAxialPositionRestraint | Restrain a protein's z coordinate to within a given range |

IMP.pmi1.restraints.npc.ZAxialPositionRestraint | Create Z-Axial Position restraints |

IMP.pmi1.restraints.npc.ZAxialPositionUpperRestraint | Create Z-Axial Position Upper restraints |

IMP.pmi.restraints.npc.ZAxialPositionUpperRestraint | Restrain a protein's z coordinate to below an upper bound |