doc/ref/nup84_8py_source.html

 ## \example kernel/nup84.py

 # Modify solve for a Nup84-like structure using a mix of rigid bodies

 # and coarse grained models using crosslinking data. In

 # addition, show how to visualize restraints and visualize the

 # rejected conformations. Both are useful things to do when trying to

 # figure out why optimization is not converging.


 from __future__ import print_function

 import IMP

 import IMP.atom

 import IMP.container

 import IMP.display

 import IMP.statistics

 import IMP.example

 import os

 import sys


 # not finished

 IMP.add_bool_flag("run", "Whether to run the program")


 # parse command line arguments so, eg profiling can be used

 IMP.setup_from_argv(sys.argv, "Nup84 example")


 if IMP.get_bool_flag("run") != "yes":

     exit(0)


 # First we define some basic parameters for the modeling effort


 # the spring constant to use, it doesn't really matter

 k = 10

 # the target resolution for the representation

 resolution = 100

 # the box to perform everything in, make it flat as it is a 2D structure

 bb = IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(-300, -300, -50),

                                IMP.algebra.Vector3D(300, 300, 50))


 # how many times to try to find a good solution

 number_of_sampling_attempts = 1

 number_of_mc_steps = 10000


 # Create a coarse grained protein with a given name, adding it to universe


 def add_protein_from_length(model, name, residues, parent, restraints,

                             excluded_volume_particles, optimized_particles):

     # Create a coarse grained protein with the passed residue information

     h = IMP.atom.create_protein(model, name, resolution, residues)


     parent.add_child(h)

     # Here, each of the constituent particles will be optimized independently

     leaves = IMP.atom.get_leaves(h)

     optimized_particles.extend(leaves)

     excluded_volume_particles.extend(leaves)


     # Ensure that the various particles of the protein stay connected

     r = IMP.atom.create_connectivity_restraint([IMP.atom.Selection(c)

                                                 for c in h.get_children()], k,

                                                "connect " + name)


     if r:

         # make sure there is an actual restraint

         restraints.append(r)

         r.set_maximum_score(k)


 # Create protein as a rigid body from a pdb file


 def add_protein_from_pdb(model, name, file, parent, restraints,

                          excluded_volume_particles, optimized_particles):

     # we should keep the original particles around so they get written


     # create an atomic representation from the pdb file

     t = IMP.atom.read_pdb(

         IMP.get_example_path(os.path.join("data", file)), model,

         IMP.atom.ATOMPDBSelector())

     # extract the chain from the file

     c = IMP.atom.Chain(IMP.atom.get_by_type(t, IMP.atom.CHAIN_TYPE)[0])

     # there is no reason to use all atoms, just approximate the pdb shape

     # instead

     s = IMP.atom.create_simplified_along_backbone(c, resolution / 2.0, True)

     s.set_name(name)

     # tear down what is left

     IMP.atom.destroy(t)

     # make the simplified structure rigid

     rb = IMP.atom.create_rigid_body(s)

     rb.set_coordinates_are_optimized(True)

     optimized_particles.append(rb)

     excluded_volume_particles.extend(s.get_children())

     parent.add_child(s)


 # Create protein as a rigid body from several pdb file

 def add_protein_from_pdbs(model, name, files, parent, restraints,

                           excluded_volume_particles, optimized_particles):

     h = IMP.atom.Hierarchy.setup_particle(IMP.Particle(model, name))

     for i, f in enumerate(files):

         add_protein_from_pdb(model, name + str(i), f, h, restraints,

                              excluded_volume_particles, optimized_particles)

     r = IMP.atom.create_connectivity_restraint([IMP.atom.Selection(c, hierarchy_types=[IMP.atom.FRAGMENT_TYPE])

                                                 for c in h.get_children()],

                                                k, "connect " + name)

     if r:

         restraints.append(r)

         r.set_maximum_score(k)


 # Create all the needed representation using the above functions


 def create_representation(model):

     restraints = []

     optimized_particles = []

     excluded_volume_particles = []

     universe = IMP.atom.Hierarchy.setup_particle(

         IMP.Particle(model, "the universe"))


     add_protein_from_length(model, "Nup85", 570, universe, restraints,

                             excluded_volume_particles, optimized_particles)


     # pin the c-terminus

     ct = IMP.atom.Selection(universe, molecule="Nup85",

                             hierarchy_types=[IMP.atom.FRAGMENT_TYPE],

                             terminus=IMP.atom.Selection.C)

     d = IMP.core.XYZ(ct.get_selected_particles()[0])

     d.set_coordinates(IMP.algebra.Vector3D(0, 0, 0))

     d.set_coordinates_are_optimized(False)


     add_protein_from_length(model, "Nup84", 460, universe, restraints,

                             excluded_volume_particles, optimized_particles)

     add_protein_from_length(model, "Nup145C", 442, universe, restraints,

                             excluded_volume_particles, optimized_particles)

     add_protein_from_length(

         model, "Nup120", [0, 500, 761], universe, restraints,

         excluded_volume_particles, optimized_particles)

     add_protein_from_length(

         model, "Nup133", [0, 450, 778, 1160], universe, restraints,

         excluded_volume_particles, optimized_particles)

     add_protein_from_pdb(model, "Seh1", "seh1.pdb", universe, restraints,

                          excluded_volume_particles, optimized_particles)

     add_protein_from_pdb(model, "Sec13", "sec13.pdb", universe, restraints,

                          excluded_volume_particles, optimized_particles)

     return universe, restraints, excluded_volume_particles, optimized_particles


 def add_distance_restraint(selection0, selection1, name, restraints):

     r = IMP.atom.create_distance_restraint(selection0, selection1, 0, k, name)

     r.set_maximum_score(k)

     restraints.append(r)


 def encode_data_as_restraints(universe, restraints):

     s0 = IMP.atom.Selection(

         hierarchy=universe, hierarchy_types=[IMP.atom.FRAGMENT_TYPE],

         molecule="Nup145C", residue_indexes=[(0, 423)])

     s1 = IMP.atom.Selection(

         hierarchy=universe, hierarchy_types=[IMP.atom.FRAGMENT_TYPE],

         molecule="Nup84")

     s2 = IMP.atom.Selection(

         hierarchy=universe, hierarchy_types=[IMP.atom.FRAGMENT_TYPE],

         molecule="Sec13")

     r = IMP.atom.create_connectivity_restraint(

         [s0, s1, s2], k, "Nup145C Nup84 Sec13")

     r.set_maximum_score(k)

     restraints.append(r)


     add_distance_restraint(

         IMP.atom.Selection(hierarchy=universe, molecule="Nup145C",

                            residue_indexes=[(0, 423)],

                            hierarchy_types=[

                                IMP.atom.FRAGMENT_TYPE]),

         IMP.atom.Selection(

             hierarchy=universe, molecule="Nup85",

             hierarchy_types=[

                 IMP.atom.FRAGMENT_TYPE]),

         "Num145C, Nup85", restraints)

     add_distance_restraint(

         IMP.atom.Selection(hierarchy=universe, molecule="Nup145C",

                            residue_indexes=[(0, 423)],

                            hierarchy_types=[

                                IMP.atom.FRAGMENT_TYPE]),

         IMP.atom.Selection(

             hierarchy=universe, molecule="Nup120",

             residue_indexes=[(500, 762)],

             hierarchy_types=[

                 IMP.atom.FRAGMENT_TYPE]),

         "Nup145C Nup120", restraints)

     add_distance_restraint(

         IMP.atom.Selection(hierarchy=universe, molecule="Nup84",

                            hierarchy_types=[

                                IMP.atom.FRAGMENT_TYPE]),

         IMP.atom.Selection(

             hierarchy=universe, molecule="Nup133",

             residue_indexes=[(778, 1160)],

             hierarchy_types=[

                 IMP.atom.FRAGMENT_TYPE]),

         "Nup84 Nup133", restraints)

     add_distance_restraint(

         IMP.atom.Selection(hierarchy=universe, molecule="Nup85",

                            hierarchy_types=[

                                IMP.atom.FRAGMENT_TYPE]),

         IMP.atom.Selection(

             hierarchy=universe, molecule="Seh1",

             hierarchy_types=[

                 IMP.atom.FRAGMENT_TYPE]),

         "Nup85 Seh1", restraints)

     add_distance_restraint(

         IMP.atom.Selection(hierarchy=universe, molecule="Nup145C",

                            residue_indexes=[(0, 423)],

                            hierarchy_types=[

                                IMP.atom.FRAGMENT_TYPE]),

         IMP.atom.Selection(

             hierarchy=universe, molecule="Sec13",

             hierarchy_types=[

                 IMP.atom.FRAGMENT_TYPE]),

         "Nup145C Sec13", restraints)


 # find acceptable conformations of the model

 def get_configurations(

     model,

     restraints,

     excluded_volume_particles,

         optimized_particles):

     #cpc= IMP.container.ClosePairContainer(representation.get_particles(), 0, 10)

     # evr= IMP.container.PairRestraint(IMP.core.SoftSpherePairScore(k), cpc,

     #                                 "Excluded Volume")

     scale = .5

     mc = IMP.core.MonteCarlo(model)

     movers = []

     for p in optimized_particles:

         if IMP.core.RigidBody.get_is_setup(p):

             mover = IMP.core.RigidBodyMover(

                 p, IMP.core.XYZR(p).get_radius() * scale,

                 .2 * scale)

             movers.append(mover)

         else:

             mover = IMP.core.BallMover(

                 [p], IMP.core.XYZR(p).get_radius() * scale)

             movers.append(mover)

     serial_mover = IMP.core.SerialMover(movers)

     mc.add_mover(serial_mover)

     scoring_function = IMP.core.IncrementalScoringFunction(

         optimized_particles, restraints)

     scoring_function.add_close_pair_score(IMP.core.SoftSpherePairScore(k), 0.0,

                                           excluded_volume_particles)


     configuration_set = IMP.ConfigurationSet(model)

     # must write our own sampler as IMP.core.MCCGSampler doesn't handle rigid

     # bodies

     for i in range(number_of_sampling_attempts):

         for p in optimized_particles:

             IMP.core.XYZ(p).set_coordinates(

                 IMP.algebra.get_random_vector_in(bb))

         mc.optimize(number_of_mc_steps)

         if scoring_function.get_had_good_score():

             configuration_set.save()

     return configuration_set


 model = IMP.Model()

 universe, restraints, excluded_volume_particles, optimized_particles = create_representation(

     model)

 encode_data_as_restraints(universe, restraints)


 configuration_set = get_configurations(model, restraints,

                                        excluded_volume_particles,

                                        optimized_particles)


 print("Found", configuration_set.get_number_of_configurations(), "good configurations")


 # now lets save them all to a file

 rmf_file_name = IMP.create_temporary_file_name("nup84", ".rmf")

 rmf = RMF.create_rmf_file(rmf_file_name)


 # we want to see the scores of the various restraints also

 IMP.rmf.add_restraints(rmf, restraints)

 # and the actual structures

 IMP.rmf.add_hierarchy(rmf, universe)


 for i in range(0, configuration_set.get_number_of_configurations()):

     configuration_set.load_configuration(i)

     # align all the configurations with the first so they display nicely

     # if we want to be fancy we can account for flips too

     if i == 0:

         base_coords = [IMP.core.XYZ(p).get_coordinates()

                        for p in optimized_particles]

     else:

         tr = IMP.algebra.get_transform_taking_first_to_second(

             optimized_particles, base_coords)

         IMP.core.transform(optimized_particles, tr)

     # update the restraint scores

     sf.evaluate(False)

     IMP.rmf.save_frame(rmf, str(i))


 print("You can now open", rmf_file_name, "in chimera")

IMP::core::MonteCarlo
A Monte Carlo optimizer.
Definition: MonteCarlo.h:45

IMP::rmf::save_frame
RMF::FrameID save_frame(RMF::FileHandle file, std::string name="")
Save the current state of the linked objects as a new RMF frame.

IMP::setup_from_argv
Strings setup_from_argv(const Strings &argv, std::string description, std::string positional_description, int num_positional)

IMP::container
Various classes to hold sets of particles.

IMP::get_bool_flag
bool get_bool_flag(std::string name)

IMP::core::RigidBodyMover
Modify the transformation of a rigid body.
Definition: core/RigidBodyMover.h:26

IMP::core::BallMover
Modify a set of continuous variables by perturbing them within a ball.
Definition: core/BallMover.h:24

IMP::atom::read_pdb
void read_pdb(TextInput input, int model, Hierarchy h)

IMP::algebra::get_random_vector_in
Vector3D get_random_vector_in(const Cylinder3D &c)
Generate a random vector in a cylinder with uniform density.

IMP::statistics
Code to compute statistical measures.

IMP::Model
Class for storing model, its restraints, constraints, and particles.
Definition: Model.h:72

IMP::atom::create_protein
Hierarchy create_protein(Model *m, std::string name, double target_radius, const Ints domain_boundaries)

IMP::atom::ATOMPDBSelector
Select all non-alternative ATOM records.
Definition: pdb.h:63

IMP::atom::Hierarchy::setup_particle
static Hierarchy setup_particle(Model *m, ParticleIndex pi, ParticleIndexesAdaptor children=ParticleIndexesAdaptor())
Create a Hierarchy of level t by adding the needed attributes.
Definition: atom/Hierarchy.h:261

IMP::rmf::add_hierarchy
void add_hierarchy(RMF::FileHandle fh, atom::Hierarchy hs)

IMP::core::transform
void transform(XYZ a, const algebra::Transformation3D &tr)
Apply a transformation to the particle.

IMP::atom::get_by_type
Hierarchies get_by_type(Hierarchy mhd, GetByType t)
Gather all the molecular particles of a certain level in the hierarchy.

IMP::ConfigurationSet
A class to store a set of configurations of a model.
Definition: ConfigurationSet.h:28

IMP::core::XYZ
A decorator for a particle with x,y,z coordinates.
Definition: XYZ.h:30

IMP::rmf::add_restraints
void add_restraints(RMF::NodeHandle fh, const Restraints &hs)

IMP::atom::destroy
void destroy(Hierarchy d)
Delete the Hierarchy.

IMP::algebra::BoundingBoxD< 3 >

IMP::core::RigidBody::get_is_setup
static bool get_is_setup(const IMP::ParticleAdaptor &p)
Definition: rigid_bodies.h:147

IMP::example
Example module.

IMP::get_example_path
std::string get_example_path(std::string file_name)
Return the full path to one of this module's example files.

IMP::atom::create_simplified_along_backbone
Hierarchy create_simplified_along_backbone(Chain input, const IntRanges &residue_segments, bool keep_detailed=false)

IMP::algebra::Vector3D
VectorD< 3 > Vector3D
Definition: VectorD.h:395

IMP::atom::create_rigid_body
IMP::core::RigidBody create_rigid_body(Hierarchy h)

IMP::Particle
Class to handle individual model particles.
Definition: Particle.h:37

IMP::atom::create_distance_restraint
Restraint * create_distance_restraint(const Selection &n0, const Selection &n1, double x0, double k, std::string name="Distance%1%")

IMP::atom::Chain
Store info for a chain of a protein.
Definition: Chain.h:21

IMP::atom::create_connectivity_restraint
Restraint * create_connectivity_restraint(const Selections &s, double x0, double k, std::string name="Connectivity%1%")
Create a restraint connecting the selections.

IMP::core::SoftSpherePairScore
Definition: SphereDistancePairScore.h:180

IMP::core::IncrementalScoringFunction
Definition: IncrementalScoringFunction.h:38

IMP::display
Output IMP model data in various file formats.

IMP::atom
Functionality for loading, creating, manipulating and scoring atomic structures.

IMP::add_bool_flag
void add_bool_flag(std::string name, std::string description)

IMP::atom::get_leaves
Hierarchies get_leaves(const Selection &h)

IMP::atom::Selection
Select hierarchy particles identified by the biological name.
Definition: Selection.h:65

IMP::core::SerialMover
Applies a list of movers one at a time.
Definition: SerialMover.h:23

IMP::create_temporary_file_name
std::string create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="")
Create a temporary file.

IMP::core::XYZR
A decorator for a particle with x,y,z coordinates and a radius.
Definition: XYZR.h:27