void add_pdb_radii(Hierarchies hs) { for (unsigned int i = 0; i < hs.size(); ++i) { add_pdb_radii(hs[i]); canonicalize(hs[i]); } IMP_IF_CHECK(USAGE_AND_INTERNAL) { for (unsigned int i = 0; i < hs.size(); ++i) { if (!hs[i].get_is_valid(true)) { IMP_ERROR("Invalid hierarchy produced "); IMP_ERROR_WRITE(IMP::core::show<Hierarchy>(hs[i], IMP_STREAM)); throw InternalException("Bad hierarchy"); // should clean up } } } }
void ProteinLigandRestraint::initialize(Hierarchy protein, Hierarchy ligand) { add_protein_ligand_score_data(protein); add_protein_ligand_score_data(ligand); IMP_IF_CHECK(USAGE) { Hierarchies pr = get_by_type(protein, RESIDUE_TYPE); for (unsigned int i = 0; i < pr.size(); ++i) { IMP_USAGE_CHECK(!get_is_heterogen(pr[i]), "Some of protein is actually a heterogen " << pr[i]); } Hierarchies lr = get_by_type(ligand, RESIDUE_TYPE); for (unsigned int i = 0; i < lr.size(); ++i) { IMP_USAGE_CHECK(get_is_heterogen(lr[i]), "Some of ligand is actually protein " << lr[i]); } } }
// write approximate function, remove rigid bodies for intermediates core::RigidBody create_rigid_body(const Hierarchies &h, std::string name) { if (h.empty()) return core::RigidBody(); for (unsigned int i = 0; i < h.size(); ++i) { IMP_USAGE_CHECK(h[i].get_is_valid(true), "Invalid hierarchy passed."); } kernel::Particle *rbp = new kernel::Particle(h[0]->get_model()); rbp->set_name(name); kernel::ParticlesTemp all; for (unsigned int i = 0; i < h.size(); ++i) { kernel::ParticlesTemp cur = rb_process(h[i]); all.insert(all.end(), cur.begin(), cur.end()); } core::RigidBody rbd = core::RigidBody::setup_particle(rbp, all); rbd.set_coordinates_are_optimized(true); for (unsigned int i = 0; i < h.size(); ++i) { IMP_INTERNAL_CHECK(h[i].get_is_valid(true), "Invalid hierarchy produced"); } return rbd; }
Hierarchy create_simplified_along_backbone(Hierarchy in, int num_res, bool keep_detailed) { Hierarchies chains = get_by_type(in, CHAIN_TYPE); if (chains.size() > 1) { Hierarchy root = Hierarchy::setup_particle( new Particle(in->get_model(), in->get_name())); for (unsigned int i = 0; i < chains.size(); ++i) { Chain chain(chains[i].get_particle()); root.add_child( create_simplified_along_backbone(chain, num_res, keep_detailed)); } return root; } else if (chains.size() == 1) { // make sure to cast it to chain to get the right overload return create_simplified_along_backbone(Chain(chains[0]), num_res, keep_detailed); } else { IMP_THROW("No chains to simplify", ValueException); } }
Hierarchy create_fragment(const Hierarchies &ps) { IMP_USAGE_CHECK(!ps.empty(), "Need some particles"); Hierarchy parent = ps[0].get_parent(); unsigned int index = ps[0].get_child_index(); IMP_IF_CHECK(USAGE) { for (unsigned int i = 0; i < ps.size(); ++i) { IMP_USAGE_CHECK(ps[i].get_parent() == parent, "Parents don't match"); } } kernel::Particle *fp = new kernel::Particle(parent.get_particle()->get_model()); Hierarchy fd = Fragment::setup_particle(fp); for (unsigned int i = 0; i < ps.size(); ++i) { parent.remove_child(ps[i]); fd.add_child(ps[i]); } parent.add_child_at(fd, index); return fd; }
void add_protein_ligand_score_data(Hierarchy h) { Hierarchies atoms = get_by_type(h, ATOM_TYPE); for (unsigned int i = 0; i < atoms.size(); ++i) { add_protein_ligand_score_data(Atom(atoms[i])); } }
// argv[1] file_name_type should contain file type e.g. ".mol2" void write_mol2(Hierarchy rhd, TextOutput file) { Hierarchies hs = get_by_type(rhd, RESIDUE_TYPE); for (unsigned int i = 0; i < hs.size(); ++i) { write_molecule_mol2(hs[i], file); } }
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; }