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;
}
