void assign_blame(const RestraintsTemp &rs,
const ParticlesTemp &ps, FloatKey attribute) {
IMP_FUNCTION_LOG;
for (unsigned int i = 0; i < ps.size(); ++i) {
if (ps[i]->has_attribute(attribute)) {
ps[i]->set_value(attribute, 0);
} else {
ps[i]->add_attribute(attribute, 0, false);
}
}
Restraints drs;
for (unsigned int i = 0; i < rs.size(); ++i) {
Pointer<Restraint> rd = rs[i]->create_decomposition();
if (rd) {
drs.push_back(rd);
}
}
IMP_NEW(RestraintsScoringFunction, rsf, (drs));
rsf->evaluate(false);
DependencyGraph dg = get_dependency_graph(IMP::internal::get_model(rs));
// attempt to get around boost/gcc bug and the most vexing parse
DependencyGraphVertexIndex dgi((IMP::get_vertex_index(dg)));
ControlledBy controlled_by;
for (unsigned int i = 0; i < ps.size(); ++i) {
ParticlesTemp cps = get_dependent_particles(ps[i], ps, dg, dgi);
IMP_INTERNAL_CHECK(cps.size() > 0, "No dependent particles for " << ps[i]);
for (unsigned int j = 0; j < cps.size(); ++j) {
controlled_by[cps[j]] = ps[i];
}
}
for (unsigned int i = 0; i < drs.size(); ++i) {
distribute_blame(drs[i], controlled_by, attribute, 1.0);
}
}
void MolecularDynamicsMover::do_reject() {
IMP_OBJECT_LOG;
ParticlesTemp ps = md_->get_simulation_particles();
unsigned nparts = ps.size();
IMP_USAGE_CHECK(coordinates_.size() == ps.size(),
"The list of particles that move has been changed!");
IMP_USAGE_CHECK(velocities_.size() == ps.size(),
"The list of particles that move has been changed!");
for (unsigned i = 0; i < nparts; i++) {
bool isnuisance = Nuisance::get_is_setup(ps[i]);
bool isxyz = core::XYZ::get_is_setup(ps[i]);
IMP_USAGE_CHECK(isnuisance || isxyz,
"Particle " << ps[i] << " is neither nuisance nor xyz!");
if (isnuisance) {
IMP_USAGE_CHECK(coordinates_[i].size() == 1,
"wrong size for coordinates_[" << i << "] !");
IMP_USAGE_CHECK(velocities_[i].size() == 1, "wrong size for velocities_["
<< i << "] !");
Nuisance(ps[i]).set_nuisance(coordinates_[i][0]);
ps[i]->set_value(FloatKey("vel"), velocities_[i][0]);
}
if (isxyz) {
IMP_USAGE_CHECK(coordinates_[i].size() == 3,
"wrong size for coordinates_[" << i << "] !");
IMP_USAGE_CHECK(velocities_[i].size() == 3, "wrong size for velocities_["
<< i << "] !");
core::XYZ(ps[i]).set_coordinate(0, coordinates_[i][0]);
core::XYZ(ps[i]).set_coordinate(1, coordinates_[i][1]);
core::XYZ(ps[i]).set_coordinate(2, coordinates_[i][2]);
ps[i]->set_value(FloatKey("vx"), velocities_[i][0]);
ps[i]->set_value(FloatKey("vy"), velocities_[i][1]);
ps[i]->set_value(FloatKey("vz"), velocities_[i][2]);
}
}
}
display::Geometries create_blame_geometries(const RestraintsTemp &rs,
const ParticlesTemp &ps,
double max, std::string name) {
IMP_FUNCTION_LOG;
FloatKey key("blame temporary key");
assign_blame(rs, ps, key);
if (max == NO_MAX) {
max = -NO_MAX;
for (unsigned int i = 0; i < ps.size(); ++i) {
max = std::max(ps[i]->get_value(key), max);
}
IMP_LOG_TERSE("Maximum blame value is " << max << std::endl);
}
display::Geometries ret;
for (unsigned int i = 0; i < ps.size(); ++i) {
double colorv;
if (max == 0) {
colorv = 0;
} else {
colorv =
display::get_linear_color_map_value(0, max, ps[i]->get_value(key));
}
display::Color c = display::get_hot_color(colorv);
IMP_NEW(XYZRGeometry, g, (ps[i]));
if (!name.empty()) {
g->set_name(name);
}
g->set_color(c);
ret.push_back(g);
}
return ret;
}
void destroy(Hierarchy d) {
ParticlesTemp all;
//core::Hierarchy h=d;
core::gather(d, True(), std::back_inserter(all));
for (unsigned int i=0; i< all.size(); ++i) {
if (Bonded::particle_is_instance(all[i])) {
Bonded b(all[i]);
while (b.get_number_of_bonds() > 0) {
destroy_bond(b.get_bond(b.get_number_of_bonds()-1));
}
}
Hierarchy hc(all[i]);
while (hc.get_number_of_children() > 0) {
hc.remove_child(hc.get_child(hc.get_number_of_children()-1));
}
}
// If this Hierarchy has a parent, remove the relationship
Hierarchy parent = d.get_parent();
if (parent) {
parent.remove_child(d);
}
for (unsigned int i=0; i< all.size(); ++i) {
all[i]->get_model()->remove_particle(all[i]);
}
}
double get_radius_of_gyration(const ParticlesTemp& ps) {
IMP_USAGE_CHECK(ps.size() > 0, "No particles provided");
bool mass = Mass::get_is_setup(ps[0]);
bool radii = core::XYZR::get_is_setup(ps[0]);
algebra::Vector3D cm(0, 0, 0);
double total = 0;
for (unsigned int i = 0; i < ps.size(); ++i) {
double weight = get_weight(mass, radii, ps[i]);
total += weight;
cm += core::XYZ(ps[i]).get_coordinates() * weight;
}
cm /= total;
double ret = 0;
for (unsigned int i = 0; i < ps.size(); ++i) {
double c;
if (radii) {
c = .6 * square(core::XYZR(ps[i]).get_radius());
} else {
c = 0;
}
double d = get_squared_distance(core::XYZ(ps[i]).get_coordinates(), cm);
ret += get_weight(mass, radii, ps[i]) * (d + c);
}
return std::sqrt(ret / total);
}
float get_actual_radius_of_gyration(ParticlesTemp ps) {
algebra::Vector3D cm(0,0,0);
for (unsigned int i=0; i< ps.size(); ++i) {
cm+= core::XYZ(ps[i]).get_coordinates();
}
cm/=ps.size();
double ret=0;
for (unsigned int i=0; i < ps.size(); ++i) {
double d= get_distance(core::XYZ(ps[i]).get_coordinates(),cm);
ret+= d;
}
return ret/ps.size();
}
IMPEM_BEGIN_NAMESPACE
FitRestraint::FitRestraint(
ParticlesTemp ps,
DensityMap *em_map,
FloatPair norm_factors,
FloatKey weight_key,
float scale,
bool use_rigid_bodies,
KernelType kt
): Restraint(IMP::internal::get_model(ps),
"Fit restraint"),kt_(kt)
{
use_rigid_bodies_=use_rigid_bodies;
IMP_LOG(TERSE,"Load fit restraint with the following input:"<<
"number of particles:"<<ps.size()<<" scale:"<<scale<<
"\n");
// special_treatment_of_particles_outside_of_density_=
// special_treatment_of_particles_outside_of_density;
target_dens_map_ = em_map;
weight_key_=weight_key;
norm_factors_=norm_factors;
IMP_IF_CHECK(USAGE) {
for (unsigned int i=0; i< ps.size(); ++i) {
IMP_USAGE_CHECK(core::XYZR::particle_is_instance(ps[i]),
"Particle " << ps[i]->get_name()
<< " is not XYZR"
<< std::endl);
IMP_USAGE_CHECK(ps[i]->has_attribute(weight_key),
"Particle " << ps[i]->get_name()
<< " is missing the mass "<< weight_key
<< std::endl);
}
}
scalefac_ = scale;
store_particles(ps);
IMP_LOG(TERSE,"after adding "<< all_ps_.size()<<" particles"<<std::endl);
model_dens_map_ = new SampledDensityMap(*em_map->get_header(),kt_);
model_dens_map_->set_particles(get_as<ParticlesTemp>(all_ps_),weight_key);
kernel_params_=model_dens_map_->get_kernel_params();
dist_mask_=new DistanceMask(model_dens_map_->get_header());
IMP_LOG(TERSE,"going to initialize_model_density_map"<<std::endl);
initialize_model_density_map(weight_key);
IMP_LOG(TERSE,"going to initialize derivatives"<<std::endl);
// initialize the derivatives
dv_.insert(dv_.end(),all_ps_.size(),algebra::Vector3D(0.,0.,0.));
// normalize the target density data
//target_dens_map->std_normalize();
IMP_LOG(TERSE, "Finish initialization" << std::endl);
}
IMPCORE_BEGIN_NAMESPACE
FixedRefiner::FixedRefiner(const ParticlesTemp &ps)
: Refiner("FixedRefiner%d", true) {
IMP_USAGE_CHECK(ps.size()>0, "cannot refine with empty particle list");
IMP_LOG_VERBOSE("Created fixed particle refiner with "
<< ps.size() << " particles" << std::endl);
m_ = ps[0]->get_model();
for(unsigned int i = 0; i < ps.size(); i++){
IMP_USAGE_CHECK(m_ == ps[i]->get_model(),
"refiner assumes all particles are from the same model");
pis_.push_back(ps[i]->get_index());
}
}
void CollisionCrossSection::set_model_particles(
const ParticlesTemp &ps) {
IMP_LOG_TERSE("CollisionCrossSection: Model particles set"
<< std::endl);
for (unsigned int i = 0; i < ps.size(); ++i) {
IMP_USAGE_CHECK(
(core::XYZR::get_is_setup(ps[i]) && atom::Mass::get_is_setup(ps[i])),
"Particle " << i << " does not have the required attributes"
<< std::endl);
}
masks_manager_->create_masks(ps);
// Compute projections
collision_cross_section_ = 0.0;
for (unsigned int i = 0; i < n_projections_; ++i) {
ProjectingOptions options(pixel_size_, resolution_);
do_project_particles(ps, average_projection_, regs_[i].get_rotation(),
pixel_size_ * regs_[i].get_shift_3d(), options,
masks_manager_);
collision_cross_section_ += get_projected_area(average_projection_);
}
collision_cross_section_ /= static_cast<double>(n_projections_);
particles_set_ = true;
}
IMPCORE_BEGIN_NAMESPACE
FixedRefiner::FixedRefiner(const ParticlesTemp &ps):
Refiner("FixedRefiner%d"), ps_(ps){
IMP_LOG(VERBOSE, "Created fixed particle refiner with " << ps.size()
<< " particles" << std::endl);
}
void MolecularDynamicsMover::save_coordinates() {
IMP_OBJECT_LOG;
ParticlesTemp ps = md_->get_simulation_particles();
unsigned nparts = ps.size();
coordinates_.clear();
coordinates_.reserve(nparts);
velocities_.clear();
velocities_.reserve(nparts);
for (unsigned i = 0; i < nparts; i++) {
bool isnuisance = Nuisance::get_is_setup(ps[i]);
bool isxyz = core::XYZ::get_is_setup(ps[i]);
IMP_USAGE_CHECK(isnuisance || isxyz,
"Particle " << ps[i] << " is neither nuisance nor xyz!");
if (isnuisance) {
std::vector<double> x(1, Nuisance(ps[i]).get_nuisance());
coordinates_.push_back(x);
std::vector<double> v(1, ps[i]->get_value(FloatKey("vel")));
velocities_.push_back(v);
}
if (isxyz) {
std::vector<double> coords;
core::XYZ d(ps[i]);
coords.push_back(d.get_coordinate(0));
coords.push_back(d.get_coordinate(1));
coords.push_back(d.get_coordinate(2));
coordinates_.push_back(coords);
std::vector<double> v;
v.push_back(ps[i]->get_value(FloatKey("vx")));
v.push_back(ps[i]->get_value(FloatKey("vy")));
v.push_back(ps[i]->get_value(FloatKey("vz")));
velocities_.push_back(v);
}
}
}
unsigned int MSConnectivityRestraint::ParticleMatrix::add_type(
const ParticlesTemp &ps) {
protein_by_class_.push_back(Ints());
for (unsigned int i = 0; i < ps.size(); ++i) {
unsigned int n = particles_.size();
particles_.push_back(ParticleData(ps[i], current_id_));
protein_by_class_.back().push_back(n);
}
return current_id_++;
}
base::Vector<char>
write_particles_to_buffer(const ParticlesTemp &particles,
const FloatKeys &keys) {
if (particles.empty() || keys.empty()) {
return base::Vector<char>();
}
unsigned int size= particles.size()*keys.size()*sizeof(double);
base::Vector<char> ret(size);
write_particles_to_buffer(particles, keys, &ret.front(), size);
return ret;
}
void ParticlesDataPoints::populate_data_points(ParticlesTemp ps) {
ps_ = get_as<Particles>(ps);
int dim = atts_.size();
for(unsigned int i=0;i<ps.size();i++) {
data_.push_back(Array1DD(dim));
for(int d=0;d<dim;d++) {
data_[i][d] = double(ps[i]->get_value(atts_[d]));
}
vecs_.push_back(core::XYZ(ps[i]).get_coordinates());
}
}
void DerivativesToRefined
::apply(Particle *p,
DerivativeAccumulator &da) const
{
ParticlesTemp ps = refiner_->get_refined(p);
for (unsigned int i=0; i< ps.size(); ++i) {
for (unsigned int j=0; j< ks_.size(); ++j) {
Float f= p->get_derivative(ks_[j]);
ps[i]->add_to_derivative(ks_[j], f, da);
}
}
}
InteractionGraph get_interaction_graph(ScoringFunctionAdaptor rsi,
const ParticlesTemp &ps) {
if (ps.empty()) return InteractionGraph();
InteractionGraph ret(ps.size());
Restraints rs =
create_decomposition(rsi->create_restraints());
// Model *m= ps[0]->get_model();
boost::unordered_map<ModelObject *, int> map;
InteractionGraphVertexName pm = boost::get(boost::vertex_name, ret);
DependencyGraph dg = get_dependency_graph(ps[0]->get_model());
DependencyGraphVertexIndex index = IMP::get_vertex_index(dg);
/*IMP_IF_LOG(VERBOSE) {
IMP_LOG_VERBOSE( "dependency graph is \n");
IMP::internal::show_as_graphviz(dg, std::cout);
}*/
for (unsigned int i = 0; i < ps.size(); ++i) {
ParticlesTemp t = get_dependent_particles(
ps[i], ParticlesTemp(ps.begin(), ps.end()), dg, index);
for (unsigned int j = 0; j < t.size(); ++j) {
IMP_USAGE_CHECK(map.find(t[j]) == map.end(),
"Currently particles which depend on more "
<< "than one particle "
<< "from the input set are not supported."
<< " Particle \"" << t[j]->get_name()
<< "\" depends on \"" << ps[i]->get_name()
<< "\" and \""
<< ps[map.find(t[j])->second]->get_name() << "\"");
map[t[j]] = i;
}
IMP_IF_LOG(VERBOSE) {
IMP_LOG_VERBOSE("Particle \"" << ps[i]->get_name() << "\" controls ");
for (unsigned int i = 0; i < t.size(); ++i) {
IMP_LOG_VERBOSE("\"" << t[i]->get_name() << "\" ");
}
IMP_LOG_VERBOSE(std::endl);
}
pm[i] = ps[i];
}
IMP::Restraints all_rs = IMP::get_restraints(rs);
for (Restraints::const_iterator it = all_rs.begin();
it != all_rs.end(); ++it) {
ModelObjectsTemp pl = (*it)->get_inputs();
add_edges(ps, pl, map, *it, ret);
}
/* Make sure that composite score states (eg the normalizer for
rigid body rotations) don't induce interactions among unconnected
particles.*/
ScoreStatesTemp ss = get_required_score_states(rs);
for (ScoreStatesTemp::const_iterator it = ss.begin(); it != ss.end(); ++it) {
ModelObjectsTemps interactions = (*it)->get_interactions();
for (unsigned int i = 0; i < interactions.size(); ++i) {
add_edges(ps, interactions[i], map, *it, ret);
}
}
IMP_INTERNAL_CHECK(boost::num_vertices(ret) == ps.size(),
"Wrong number of vertices " << boost::num_vertices(ret)
<< " vs " << ps.size());
return ret;
}
void RestraintCache::add_restraints(const RestraintsAdaptor &rs) {
IMP_OBJECT_LOG;
if (rs.empty()) return;
Model *m = rs[0]->get_model();
DependencyGraph dg = get_dependency_graph(m);
ParticleStatesTable *pst = cache_.get_generator().get_particle_states_table();
DepMap dependencies;
ParticlesTemp allps = pst->get_particles();
DependencyGraphVertexIndex index = IMP::get_vertex_index(dg);
for (unsigned int i = 0; i < allps.size(); ++i) {
ParticlesTemp depp =
get_dependent_particles(allps[i], allps, dg, index);
for (unsigned int j = 0; j < depp.size(); ++j) {
dependencies[depp[j]].push_back(allps[i]);
}
dependencies[allps[i]].push_back(allps[i]);
IMP_LOG_TERSE("Particle " << Showable(allps[i]) << " controls "
<< dependencies[allps[i]] << std::endl);
}
for (unsigned int i = 0; i < rs.size(); ++i) {
Pointer<Restraint> r = rs[i]->create_decomposition();
IMP_IF_LOG(TERSE) {
IMP_LOG_TERSE("Before:" << std::endl);
IMP_LOG_WRITE(TERSE, show_restraint_hierarchy(rs[i]));
}
if (r) {
IMP_LOG_TERSE("after:" << std::endl);
IMP_LOG_WRITE(TERSE, show_restraint_hierarchy(r));
add_restraint_internal(r, next_index_, nullptr,
std::numeric_limits<double>::max(), Subset(),
dependencies);
}
++next_index_;
}
IMP_IF_LOG(TERSE) {
IMP_LOG_WRITE(TERSE, show_restraint_information(IMP_STREAM));
}
}
ParticleIndexes Refiner::get_refined_indexes(Model *m,
ParticleIndex pi) const {
ParticlesTemp ps = get_refined( m->get_particle(pi) );
IMP_IF_CHECK(USAGE_AND_INTERNAL) {
for(unsigned int i = 0; i < ps.size(); i++) {
if (ps[i]->get_model() != m) {
IMP_THROW("Refined particles model does not match parent model - "
"this is critical if get_refined_indexes() is used.",
IMP::ValueException);
}
}
}
return get_indexes(ps);
}
ParticlePairsTemp get_possible_interactions(const ParticlesTemp &ps,
double max_distance,
ParticleStatesTable *pst) {
if (ps.empty()) return ParticlePairsTemp();
ParticleStatesList psl;
ParticlesTemp all= pst->get_particles();
unsigned int max=0;
for (unsigned int i=0; i< all.size(); ++i) {
psl.push_back( pst->get_particle_states(all[i]));
max= std::max(psl[i]->get_number_of_particle_states(), max);
}
algebra::BoundingBox3Ds bbs(ps.size());
for (unsigned int i=0; i< max; ++i) {
for (unsigned int j=0; j< all.size(); ++j) {
psl[j]->load_particle_state(std::min(i,
psl[j]->get_number_of_particle_states()-1),
all[j]);
}
ps[0]->get_model()->update();
for (unsigned int j=0; j< ps.size(); ++j) {
core::XYZ d(ps[j]);
bbs[j]+= d.get_coordinates();
}
}
for (unsigned int j=0; j< ps.size(); ++j) {
core::XYZR d(ps[j]);
bbs[j]+= d.get_radius() + max_distance;
}
IMP_NEW(core::GridClosePairsFinder, gcpf, ());
gcpf->set_distance(max_distance);
IntPairs ips= gcpf->get_close_pairs(bbs);
ParticlePairsTemp ret(ips.size());
for (unsigned int i=0; i< ips.size(); ++i) {
ret[i]= ParticlePair(ps[ips[i].first], ps[ips[i].second]);
}
return ret;
}
Ints get_partial_index(const ParticlesTemp &particles,
const Subset &subset, const Subsets &excluded) {
for (unsigned int i=0; i< excluded.size(); ++i) {
bool all=true;
for (unsigned int j=0; j< particles.size(); ++j) {
if (!std::binary_search(excluded[i].begin(), excluded[i].end(),
particles[j])) {
all=false;
break;
}
}
if (all) {
return Ints();
}
}
Ints ret(particles.size(), -1);
for (unsigned int i=0; i< particles.size(); ++i) {
Subset::const_iterator it= std::lower_bound(subset.begin(),
subset.end(), particles[i]);
if (it!= subset.end() && *it == particles[i]) {
ret[i]= it-subset.begin();
}
}
IMP_IF_LOG(VERBOSE) {
IMP_LOG(VERBOSE, "Returning ");
for (unsigned int i=0; i< ret.size(); ++i) {
IMP_LOG(VERBOSE, ret[i] << " ");
}
IMP_LOG(VERBOSE, "for ");
for (unsigned int i=0; i< particles.size(); ++i) {
IMP_LOG(VERBOSE, particles[i]->get_name() << " ");
}
IMP_LOG(VERBOSE, " subset " << subset << std::endl);
}
return ret;
}
IMPMULTIFIT_BEGIN_NAMESPACE
void add_surface_index(core::Hierarchy mh, Float apix, FloatKey shell_key,
FloatKey, FloatKey) {
ParticlesTemp ps = core::get_leaves(mh);
Pointer<em::SurfaceShellDensityMap> shell_map =
new em::SurfaceShellDensityMap(ps, apix);
for (unsigned int i = 0; i < ps.size(); i++) {
IMP_INTERNAL_CHECK(!ps[i]->has_attribute(shell_key),
"Particle " << ps[i]->get_name()
<< " already has shell attribute"
<< std::endl);
ps[i]->add_attribute(
shell_key, shell_map->get_value(core::XYZ(ps[i]).get_coordinates()));
}
}
Subset RestraintCache::get_subset(Restraint *r,
const DepMap &dependencies) const {
ParticlesTemp ups = IMP::get_input_particles(r->get_inputs());
std::sort(ups.begin(), ups.end());
ups.erase(std::unique(ups.begin(), ups.end()), ups.end());
ParticlesTemp outps;
for (unsigned int i = 0; i < ups.size(); ++i) {
DepMap::const_iterator it = dependencies.find(ups[i]);
if (it != dependencies.end()) {
outps = outps + it->second;
}
}
std::sort(outps.begin(), outps.end());
outps.erase(std::unique(outps.begin(), outps.end()), outps.end());
return Subset(outps);
}
void do_project_particles(const ParticlesTemp &ps, cv::Mat &m2,
const algebra::Rotation3D &R,
const algebra::Vector3D &translation,
const ProjectingOptions &options,
MasksManagerPtr masks) {
IMP_LOG_VERBOSE("Projecting particles" << std::endl);
if (m2.empty()) {
IMP_THROW("Cannot project on a empty matrix", ValueException);
}
if (masks == MasksManagerPtr()) {
// Create the masks
masks = MasksManagerPtr(
new MasksManager(options.resolution, options.pixel_size));
masks->create_masks(ps);
}
// Centroid
unsigned long n_particles = ps.size();
// core::XYZRsTemp xyzrs(ps);
core::XYZRs xyzrs(ps);
algebra::Vector3D centroid = core::get_centroid(xyzrs);
// clear data before creating a new projection
if (options.clear_matrix_before_projecting) m2.setTo(0.0);
// Project
double invp = 1.0 / options.pixel_size;
for (unsigned long i = 0; i < n_particles; i++) {
// Coordinates respect to the centroid
algebra::Vector3D p = xyzrs[i].get_coordinates() - centroid;
// Pixel after transformation to project in Z axis
// Not necessary to compute pz, is going to be ignored
double pix_x = invp * (R.get_rotated_one_coordinate(p, 0) + translation[0]);
double pix_y = invp * (R.get_rotated_one_coordinate(p, 1) + translation[1]);
IMP_USAGE_CHECK(!IMP::isnan(pix_x) || !IMP::isnan(pix_y),
"do_project_particles: "
<< n_particles << " resolution " << options.resolution
<< " pixel size " << options.pixel_size << std::endl);
// Apply mask
ProjectionMaskPtr mask = masks->find_mask(atom::Mass(ps[i]).get_mass());
algebra::Vector2D pix(pix_x, pix_y);
mask->apply(m2, pix);
}
IMP_LOG_VERBOSE("END of do_project_particles" << std::endl);
}
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;
}
ParticleIndexesAdaptor::ParticleIndexesAdaptor(const ParticlesTemp &ps)
: tmp_(new ParticleIndexes(ps.size())), val_(tmp_.get()) {
*tmp_ = get_indexes(ps);
}
double
get_slack_estimate(const ParticlesTemp& ps,
double upper_bound,
double step,
const RestraintsTemp &restraints,
bool derivatives,
Optimizer *opt,
ClosePairContainer *cpc) {
std::vector<Data> datas;
for (double slack=0; slack< upper_bound; slack+= step) {
IMP_LOG(VERBOSE, "Computing for " << slack << std::endl);
datas.push_back(Data());
datas.back().slack=slack;
{
boost::timer imp_timer;
int count=0;
base::SetLogState sl(opt->get_model(), SILENT);
do {
cpc->set_slack(slack);
cpc->update();
++count;
} while (imp_timer.elapsed()==0);
datas.back().ccost= imp_timer.elapsed()/count;
IMP_LOG(VERBOSE, "Close pair finding cost "
<< datas.back().ccost << std::endl);
}
{
boost::timer imp_timer;
double score=0;
int count=0;
int iters=1;
base::SetLogState sl(opt->get_model(), SILENT);
do {
for ( int j=0; j< iters; ++j) {
for (unsigned int i=0; i< restraints.size(); ++i) {
score+=restraints[i]->evaluate(derivatives);
// should restore
}
}
count += iters;
iters*=2;
} while (imp_timer.elapsed()==0);
datas.back().rcost= imp_timer.elapsed()/count;
IMP_LOG(VERBOSE, "Restraint evaluation cost "
<< datas.back().rcost << std::endl);
}
}
int ns=100;
int last_ns=1;
int opt_i=-1;
std::vector<Floats > dists(1, Floats(1,0.0));
std::vector< std::vector<algebra::Vector3D> >
pos(1, std::vector<algebra::Vector3D>(ps.size()));
for (unsigned int j=0; j< ps.size(); ++j) {
pos[0][j]=core::XYZ(ps[j]).get_coordinates();
}
do {
IMP_LOG(VERBOSE, "Stepping from " << last_ns << " to " << ns << std::endl);
dists.resize(ns, Floats(ns, 0.0));
for ( int i=0; i< last_ns; ++i) {
dists[i].resize(ns, 0.0);
}
pos.resize(ns, std::vector<algebra::Vector3D>(ps.size()));
base::SetLogState sl(opt->get_model(), SILENT);
for ( int i=last_ns; i< ns; ++i) {
opt->optimize(1);
for (unsigned int j=0; j< ps.size(); ++j) {
pos[i][j]=core::XYZ(ps[j]).get_coordinates();
}
}
for ( int i=last_ns; i< ns; ++i) {
for ( int j=0; j< i; ++j) {
double md=0;
for (unsigned int k=0; k< ps.size(); ++k) {
md= std::max(md, algebra::get_distance(pos[i][k], pos[j][k]));
}
dists[i][j]=md;
dists[j][i]=md;
}
}
// estimate lifetimes from slack
for (unsigned int i=0; i< datas.size(); ++i) {
Ints deaths;
for ( int j=0; j< ns; ++j) {
for ( int k=j+1; k < ns; ++k) {
if (dists[j][k]> datas[i].slack) {
deaths.push_back(k-j);
break;
}
}
}
std::sort(deaths.begin(), deaths.end());
// kaplan meier estimator
double ml=0;
if (deaths.empty()) {
ml= ns;
} else {
//double l=1;
IMP_INTERNAL_CHECK(deaths.size() < static_cast<unsigned int>(ns),
"Too much death");
double S=1;
for (unsigned int j=0; j< deaths.size(); ++j) {
double n= ns-j;
double t=(n-1.0)/n;
ml+=(S-t*S)*deaths[j];
S*=t;
}
}
datas[i].lifetime=ml;
IMP_LOG(VERBOSE, "Expected life of " << datas[i].slack
<< " is " << datas[i].lifetime << std::endl);
}
/**
C(s) is cost to compute
R(s) is const to eval restraints
L(s) is lifetime of slack
minimize C(s)/L(s)+R(s)
*/
// smooth
for (unsigned int i=1; i< datas.size()-1; ++i) {
datas[i].rcost=(datas[i].rcost+ datas[i-1].rcost+datas[i+1].rcost)/3.0;
datas[i].ccost=(datas[i].ccost+ datas[i-1].ccost+datas[i+1].ccost)/3.0;
datas[i].lifetime=(datas[i].lifetime
+ datas[i-1].lifetime+datas[i+1].lifetime)/3.0;
}
double min= std::numeric_limits<double>::max();
for (unsigned int i=0; i< datas.size(); ++i) {
double v= datas[i].rcost+ datas[i].ccost/datas[i].lifetime;
IMP_LOG(VERBOSE, "Cost of " << datas[i].slack << " is " << v
<< " from " << datas[i].rcost
<< " " << datas[i].ccost << " " << datas[i].lifetime
<< std::endl);
if (v < min) {
min=v;
opt_i=i;
}
}
last_ns=ns;
ns*=2;
IMP_LOG(VERBOSE, "Opt is " << datas[opt_i].slack << std::endl);
// 2 for the value, 2 for the doubling
// if it more than 1000, just decide that is enough
} while (datas[opt_i].lifetime > ns/4.0 && ns <1000);
return datas[opt_i].slack;
}
void write_pdb(const ParticlesTemp& ps, TextOutput out) {
IMP_FUNCTION_LOG;
int last_index = 0;
bool use_input_index = true;
for (unsigned int i = 0; i < ps.size(); ++i) {
if (Atom(ps[i]).get_input_index() != last_index + 1) {
use_input_index = false;
break;
} else {
++last_index;
}
}
for (unsigned int i = 0; i < ps.size(); ++i) {
if (Atom::get_is_setup(ps[i])) {
Atom ad(ps[i]);
Residue rd = get_residue(ad);
// really dumb and slow, fix later
char chain;
Chain c = get_chain(rd);
if (c) {
chain = c.get_id()[0];
} else {
chain = ' ';
}
int inum = i+1;
if (i>=99999) inum=99999;
out.get_stream() << get_pdb_string(
core::XYZ(ps[i]).get_coordinates(),
use_input_index ? ad.get_input_index()
: static_cast<int>(inum),
ad.get_atom_type(), rd.get_residue_type(), chain,
rd.get_index(), rd.get_insertion_code(),
ad.get_occupancy(), ad.get_temperature_factor(),
ad.get_element());
if (!out) {
IMP_THROW("Error writing to file in write_pdb", IOException);
}
}
else if (Residue::get_is_setup(ps[i])) { // if C-alpha residue is available
Residue rd = IMP::atom::Residue(ps[i]);
// comment 1 by SJ - TODO: How to retrieve the correct chain information without an hierarchy?
char chain;
Chain c = get_chain(rd);
if (c) {
chain = c.get_id()[0];
} else {
chain = ' ';
}
// comment 2 by SJ - TODO: The C-alpha residues are not sorted yet. We need to sort the residues similarly to what PMI does.
out.get_stream() << get_pdb_string(
core::XYZ(ps[i]).get_coordinates(),
static_cast<int>(i + 1),
IMP::atom::AT_CA, rd.get_residue_type(), chain,
rd.get_index(), ' ',
1.0, IMP::core::XYZR(ps[i]).get_radius());
}
else { // if a coarse-grained BEAD is available
Ints resindexes = IMP::atom::Fragment(ps[i]).get_residue_indexes();
int resindex = (int)resindexes.front() + (int)(resindexes.size()/2);
// comment 1 by SJ - TODO: How to retrieve the correct chain information without an hierarchy?
char chain = ' ';
// comment 3 by SJ - TODO: The BEADs are not sorted yet. We need to sort the residues similarly to what PMI does.
// comment 4 by SJ - TODO: currently IMP does not allow "BEA" as a residue name, while PMI allows it. Thus "UNK" was used instead.
out.get_stream() << get_pdb_string(
core::XYZ(ps[i]).get_coordinates(),
static_cast<int>(i + 1),
IMP::atom::AT_CA, IMP::atom::UNK, chain,
(int)resindex, ' ',
1.0, IMP::core::XYZR(ps[i]).get_radius());
}
}
}
SubsetGraph get_restraint_graph(ScoringFunctionAdaptor in,
const ParticleStatesTable *pst) {
RestraintsTemp rs =
IMP::create_decomposition(in->create_restraints());
// ScoreStatesTemp ss= get_required_score_states(rs);
SubsetGraph ret(rs.size()); // + ss.size());
IMP_LOG_TERSE("Creating restraint graph on " << rs.size() << " restraints."
<< std::endl);
boost::unordered_map<Particle *, int> map;
SubsetGraphVertexName pm = boost::get(boost::vertex_name, ret);
DependencyGraph dg = get_dependency_graph(rs[0]->get_model());
DependencyGraphVertexIndex index = IMP::get_vertex_index(dg);
/*IMP_IF_LOG(VERBOSE) {
IMP_LOG_VERBOSE( "dependency graph is \n");
IMP::internal::show_as_graphviz(dg, std::cout);
}*/
Subset ps = pst->get_subset();
for (unsigned int i = 0; i < ps.size(); ++i) {
ParticlesTemp t = get_dependent_particles(
ps[i], ParticlesTemp(ps.begin(), ps.end()), dg, index);
for (unsigned int j = 0; j < t.size(); ++j) {
IMP_USAGE_CHECK(map.find(t[j]) == map.end(),
"Currently particles which depend on more "
<< "than one particle "
<< "from the input set are not supported."
<< " Particle \"" << t[j]->get_name()
<< "\" depends on \"" << ps[i]->get_name()
<< "\" and \""
<< ps[map.find(t[j])->second]->get_name() << "\"");
map[t[j]] = i;
}
IMP_IF_LOG(VERBOSE) {
IMP_LOG_VERBOSE("Particle \"" << ps[i]->get_name() << "\" controls ");
for (unsigned int i = 0; i < t.size(); ++i) {
IMP_LOG_VERBOSE("\"" << t[i]->get_name() << "\" ");
}
IMP_LOG_VERBOSE(std::endl);
}
}
for (unsigned int i = 0; i < rs.size(); ++i) {
ParticlesTemp pl = IMP::get_input_particles(rs[i]->get_inputs());
std::sort(pl.begin(), pl.end());
pl.erase(std::unique(pl.begin(), pl.end()), pl.end());
Subset os(pl);
for (unsigned int j = 0; j < pl.size(); ++j) {
pl[j] = ps[map[pl[j]]];
}
std::sort(pl.begin(), pl.end());
pl.erase(std::unique(pl.begin(), pl.end()), pl.end());
Subset s(pl);
IMP_LOG_VERBOSE("Subset for restraint " << rs[i]->get_name() << " is " << s
<< " from " << os << std::endl);
pm[i] = s;
}
/*ScoreStatesTemp ss= get_required_score_states(rs);
for (ScoreStatesTemp::const_iterator it= ss.begin();
it != ss.end(); ++it) {
ParticlesTemp pl= (*it)->get_input_particles();
add_edges(ps, pl, map, *it, ret);
ParticlesTemp opl= (*it)->get_output_particles();
add_edges(ps, opl, map, *it, ret);
}
IMP_INTERNAL_CHECK(boost::num_vertices(ret) == ps.size(),
"Wrong number of vertices "
<< boost::num_vertices(ret)
<< " vs " << ps.size());*/
for (unsigned int i = 0; i < boost::num_vertices(ret); ++i) {
for (unsigned int j = 0; j < i; ++j) {
if (get_intersection(pm[i], pm[j]).size() > 0) {
boost::add_edge(i, j, ret);
IMP_LOG_VERBOSE("Connecting " << rs[i]->get_name() << " with "
<< rs[j]->get_name() << std::endl);
}
}
}
return ret;
}