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]);
}
}
}
Selection::Selection(const Hierarchies &h) : radius_(-1) {
if (h.empty()) {
m_ = nullptr;
return;
} else {
set_hierarchies(h[0].get_model(), IMP::internal::get_index(h));
}
}
// 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;
}
CHARMMTopology *CHARMMParameters::create_topology(Hierarchy hierarchy) const {
IMP_OBJECT_LOG;
IMP_NEW(CHARMMTopology, topology, (this));
Hierarchies chains = get_by_type(hierarchy, CHAIN_TYPE);
for (Hierarchies::iterator chainit = chains.begin(); chainit != chains.end();
++chainit) {
IMP_NEW(CHARMMSegmentTopology, segment, ());
Hierarchies residues = get_by_type(*chainit, RESIDUE_TYPE);
for (Hierarchies::iterator resit = residues.begin();
resit != residues.end(); ++resit) {
ResidueType restyp = Residue(*resit).get_residue_type();
try {
IMP_NEW(CHARMMResidueTopology, residue, (get_residue_topology(restyp)));
segment->add_residue(residue);
}
catch (base::ValueException) {
// If residue type is unknown, add empty topology for this residue
IMP_WARN_ONCE(
restyp.get_string(),
"Residue type "
<< restyp
<< " was not found in "
"topology library; using empty topology for this residue",
warn_context_);
IMP_NEW(CHARMMResidueTopology, residue, (restyp));
segment->add_residue(residue);
}
}
topology->add_segment(segment);
}
// keep clang happy
bool dumped = false;
IMP_IF_LOG(VERBOSE) {
dumped = true;
warn_context_.dump_warnings();
}
if (!dumped) {
warn_context_.clear_warnings();
}
// Topology objects are not designed to be added into other containers
topology->set_was_used(true);
return topology.release();
}
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;
}
