core::RigidBody setup_as_rigid_body(Hierarchy h) { IMP_USAGE_CHECK(h.get_is_valid(true), "Invalid hierarchy passed to setup_as_rigid_body"); IMP_WARN("create_rigid_body should be used instead of setup_as_rigid_body" << " as the former allows one to get volumes correct at coarser" << " levels of detail."); core::RigidBody rbd = core::RigidBody::setup_particle(h, get_leaves(h)); rbd.set_coordinates_are_optimized(true); kernel::ParticlesTemp internal = core::get_internal(h); for (unsigned int i = 0; i < internal.size(); ++i) { if (internal[i] != h) { core::RigidMembers leaves(get_leaves(Hierarchy(internal[i]))); if (!leaves.empty()) { algebra::ReferenceFrame3D rf = core::get_initial_reference_frame( get_as<kernel::ParticlesTemp>(leaves)); core::RigidBody::setup_particle(internal[i], rf); } } } IMP_INTERNAL_CHECK(h.get_is_valid(true), "Invalid hierarchy produced"); return rbd; }
Hierarchy create_protein(Model *m, std::string name, double resolution, int number_of_residues, int first_residue_index, double volume, bool ismol) { double mass = atom::get_mass_from_number_of_residues(number_of_residues) / 1000; if (volume < 0) { volume = atom::get_volume_from_mass(mass * 1000); } // assume a 20% overlap in the beads to make the protein not too bumpy double overlap_frac = .2; std::pair<int, double> nr = compute_n(volume, resolution, overlap_frac); Hierarchy pd = Hierarchy::setup_particle(new Particle(m)); Ints residues; for (int i = 0; i < number_of_residues; ++i) { residues.push_back(i + first_residue_index); } atom::Fragment::setup_particle(pd, residues); if (ismol) Molecule::setup_particle(pd); pd->set_name(name); for (int i = 0; i < nr.first; ++i) { Particle *pc; if (nr.first > 1) { pc = new Particle(m); std::ostringstream oss; oss << name << "-" << i; pc->set_name(oss.str()); atom::Fragment pcd = atom::Fragment::setup_particle(pc); Ints indexes; for (int j = i * (number_of_residues / nr.first) + first_residue_index; j < (i + 1) * (number_of_residues / nr.first) + first_residue_index; ++j) { indexes.push_back(j); } pcd.set_residue_indexes(indexes); pd.add_child(pcd); } else { pc = pd; } core::XYZR xyzd = core::XYZR::setup_particle(pc); xyzd.set_radius(nr.second); atom::Mass::setup_particle(pc, mass / nr.first); } IMP_INTERNAL_CHECK(pd.get_is_valid(true), "Invalid hierarchy produced " << pd); return pd; }
IMP::core::RigidBody create_compatible_rigid_body(Hierarchy h, Hierarchy reference) { ParticlesTemp hl= get_leaves(h); ParticlesTemp rl= get_leaves(reference); algebra::Transformation3D tr = algebra::get_transformation_aligning_first_to_second(rl, hl); algebra::Transformation3D rtr = core::RigidMember(reference).get_rigid_body().\ get_reference_frame().get_transformation_to(); algebra::Transformation3D rbtr= tr*rtr; Particle *rbp= new Particle(h->get_model()); rbp->set_name(h->get_name()+" rigid body"); ParticlesTemp all = rb_process(h); core::RigidBody rbd = core::RigidBody::setup_particle(rbp, algebra::ReferenceFrame3D(rbtr)); for (unsigned int i=0; i< all.size(); ++i) { rbd.add_member(all[i]); } rbd.set_coordinates_are_optimized(true); IMP_INTERNAL_CHECK(h.get_is_valid(true), "Invalid hierarchy produced"); return rbd; }
Hierarchy create_simplified_along_backbone(Chain in, const IntRanges &residue_segments, bool keep_detailed) { IMP_USAGE_CHECK(in.get_is_valid(true), "Chain " << in << " is not valid."); if (in.get_number_of_children() == 0 || residue_segments.empty()) { IMP_LOG_TERSE("Nothing to simplify in " << (in ? in->get_name() : "nullptr") << " with " << residue_segments.size() << " segments.\n"); return Hierarchy(); } for (unsigned int i = 0; i < residue_segments.size(); ++i) { IMP_USAGE_CHECK(residue_segments[i].first < residue_segments[i].second, "Residue intervals must be non-empty"); } IMP_IF_LOG(VERBOSE) { for (unsigned int i = 0; i < residue_segments.size(); ++i) { IMP_LOG_VERBOSE("[" << residue_segments[i].first << "..." << residue_segments[i].second << ") "); } IMP_LOG_VERBOSE(std::endl); } unsigned int cur_segment = 0; Hierarchies cur; Hierarchy root = create_clone_one(in); for (unsigned int i = 0; i < in.get_number_of_children(); ++i) { Hierarchy child = in.get_child(i); int index = Residue(child).get_index(); IMP_LOG_VERBOSE("Processing residue " << index << " with range " << residue_segments[cur_segment].first << " " << residue_segments[cur_segment].second << std::endl); if (index >= residue_segments[cur_segment].first && index < residue_segments[cur_segment].second) { } else if (!cur.empty()) { IMP_LOG_VERBOSE("Added particle for " << residue_segments[cur_segment].first << "..." << residue_segments[cur_segment].second << std::endl); Hierarchy cur_approx = create_approximation_of_residues(cur); root.add_child(cur_approx); if (keep_detailed) { for (unsigned int j = 0; j < cur.size(); ++j) { cur[j].get_parent().remove_child(cur[j]); cur_approx.add_child(cur[j]); } } cur.clear(); ++cur_segment; } cur.push_back(child); } if (!cur.empty()) { root.add_child(create_approximation_of_residues(cur)); } /*#ifdef IMP_ATOM_USE_IMP_CGAL double ov= get_volume(in); double cv= get_volume(root); double scale=1; ParticlesTemp rt= get_by_type(root, XYZR_TYPE); Floats radii(rt.size()); for (unsigned int i=0; i< rt.size(); ++i) { core::XYZR d(rt[i]); radii[i]=d.get_radius(); } do { show(root); double f= ov/cv*scale; scale*=.95; IMP_LOG_TERSE( "Bumping radius by " << f << std::endl); for (unsigned int i=0; i< rt.size(); ++i) { core::XYZR d(rt[i]); d.set_radius(radii[i]*f); } double nv=get_volume(root); IMP_LOG_TERSE( "Got volume " << nv << " " << ov << std::endl); if (nv < ov) { break; } } while (true); #else #endif*/ IMP_INTERNAL_CHECK(root.get_is_valid(true), "Invalid hierarchy produced " << root); return root; }