ModelObjectsTemp CoreClosePairContainer::do_get_inputs() const {
ModelObjectsTemp ret;
ret.push_back(c_);
ret.push_back(score_state_);
ret.push_back(moved_);
return ret;
}
ModelObjectsTemp ConnectivityRestraint::do_get_inputs() const {
if (!sc_) return ModelObjectsTemp();
ModelObjectsTemp ret;
ret += ps_->get_inputs(get_model(), sc_->get_all_possible_indexes());
ret.push_back(sc_);
return ret;
}
ModelObjectsTemp MovedSingletonContainer::get_score_state_inputs() const {
ModelObjectsTemp ret =
IMP::get_particles(get_model(), pc_->get_indexes());
ret.push_back(pc_);
ret += get_extra_inputs();
return ret;
}
ModelObjectsTemp EnvelopePenetrationRestraint::do_get_inputs() const {
ModelObjectsTemp pt;
for (ParticleConstIterator it = particles_begin(); it != particles_end();
++it) {
pt.push_back(*it);
}
return pt;
}
ModelObjectsTemp KinematicForestScoreState::do_get_outputs() const {
ModelObjectsTemp ret;
ret += atoms_;
for (unsigned int i = 0; i < rbs_.size(); i++) {
ret.push_back(rbs_[i]);
}
return ret;
}
ModelObjectsTemp DensityFillingRestraint::do_get_inputs() const {
ModelObjectsTemp pt;
for (ParticleConstIterator it = particles_begin(); it != particles_end();
++it) {
pt.push_back(*it);
}
return pt;
}
IMPKINEMATICS_BEGIN_NAMESPACE
ModelObjectsTemp KinematicForestScoreState::do_get_inputs() const {
ModelObjectsTemp ret;
ret += atoms_;
for (unsigned int i = 0; i < rbs_.size(); i++) {
ret.push_back(rbs_[i]);
}
return ret;
}
ParticleIndexes DummyPairContainer::get_all_possible_indexes() const {
ParticleIndexes ret = c_->get_all_possible_indexes();
ModelObjectsTemp mos =
cpf_->get_inputs(get_model(), c_->get_indexes());
for (unsigned int i = 0; i < mos.size(); ++i) {
ModelObject *o = mos[i];
Particle *p = dynamic_cast<Particle *>(o);
if (p) ret.push_back(p->get_index());
}
return ret;
}
ModelObjectsTemp CoreClosePairContainer::get_score_state_inputs()
const {
ParticleIndexes all = c_->get_all_possible_indexes();
ModelObjectsTemp ret = IMP::get_particles(get_model(), all);
for (unsigned int i = 0; i < get_number_of_pair_filters(); ++i) {
ret += get_pair_filter(i)->get_inputs(get_model(), all);
}
ret += cpf_->get_inputs(get_model(), all);
ret.push_back(c_);
ret.push_back(moved_);
return ret;
}
ModelObjectsTemp RevoluteJointMover::do_get_inputs() const {
ModelObjectsTemp ret;
core::RigidMembers tmp(joints_[0]->get_parent_node().get_rigid_members());
for (unsigned int i = 0; i < tmp.size(); ++i)
ret.push_back(tmp[i]); //->get_particle());
for (unsigned int j = 0; j < joints_.size(); ++j) {
tmp = joints_[j]->get_child_node().get_rigid_members();
for (unsigned int i = 0; i < tmp.size(); ++i)
ret.push_back(tmp[i]); //->get_particle());
}
return ret;
}
ModelObjectsTemp SameResiduePairFilter::do_get_inputs(
Model *m, const ParticleIndexes &pis) const {
ModelObjectsTemp ret = IMP::get_particles(m, pis);
for (unsigned int i = 0; i < pis.size(); ++i) {
if (Atom::get_is_setup(m, pis[i])) {
Particle *parent = Hierarchy(m, pis[i]).get_parent();
if (parent) {
ret.push_back(parent);
}
}
}
return ret;
}
ParticleIndexes MonteCarlo::get_movable_particles() const {
ParticleIndexes movable;
for (unsigned int i = 0; i < get_number_of_movers(); ++i) {
ModelObjectsTemp t = get_mover(i)->get_outputs();
for (unsigned int j = 0; j < t.size(); ++j) {
ModelObject *mo = t[j];
if (dynamic_cast<Particle *>(mo)) {
movable.push_back(dynamic_cast<Particle *>(mo)->get_index());
}
}
}
return movable;
}
ModelObjectsTemp BondedPairFilter::do_get_inputs(
Model *m, const ParticleIndexes &pis) const {
ModelObjectsTemp ret = IMP::get_particles(m, pis);
for (unsigned int i = 0; i < pis.size(); ++i) {
if (Bonded::get_is_setup(m, pis[i])) {
Bonded b(m, pis[i]);
for (unsigned int i = 0; i < b.get_number_of_bonds(); ++i) {
ret.push_back(b.get_bond(i));
}
}
}
return ret;
}
ScoreStatesTemp get_required_score_states(const ModelObjectsTemp &mos,
ScoreStatesTemp exclude) {
if (mos.empty()) return ScoreStatesTemp();
ScoreStatesTemp ret;
for (unsigned int i = 0; i < mos.size(); ++i) {
mos[0]->get_model()->do_set_has_required_score_states(mos[i], true);
ret += mos[i]->get_required_score_states();
}
std::sort(ret.begin(), ret.end());
std::sort(exclude.begin(), exclude.end());
ScoreStatesTemp diff;
std::set_difference(ret.begin(), ret.end(), exclude.begin(), exclude.end(),
std::back_inserter(diff));
return get_update_order(diff);
}
void HybridMonteCarlo::do_step()
{
//gibbs sampler on x and v
//persistence=p samples p times x and once v
//However because it's constant E, a rejected move
//will result in recalculating the same move up to p times
//until it is either accepted or the velocities are redrawn
//since p has to be independent of the outcome (markov property)
//we avoid recalculating the trajectory on rejection by just trying
//it over and over without doing the md again.
persistence_counter_ += 1;
if (persistence_counter_ == persistence_)
{
persistence_counter_ = 0;
//boltzmann constant in kcal/mol
static const double kB = 8.31441 / 4186.6;
md_->assign_velocities(get_kt() / kB);
}
ParticleIndexes all_optimized_particles;
{
ModelObjectsTemp op = get_model()->get_optimized_particles();
for (unsigned int i = 0; i< op.size(); ++i) {
all_optimized_particles.push_back(dynamic_cast<Particle*>(op[i].get())
->get_index());
}
}
double last = do_evaluate(all_optimized_particles);
core::MonteCarloMoverResult moved = do_move();
double energy = do_evaluate(all_optimized_particles);
bool accepted = do_accept_or_reject_move(energy, last,
moved.get_proposal_ratio());
while ((!accepted) && (persistence_counter_ < persistence_-1))
{
persistence_counter_ += 1;
accepted = do_accept_or_reject_move(energy, last,
moved.get_proposal_ratio());
}
/*std::cout << "hmc"
<< " old " << last
<< " new " << energy
<< " delta " << energy-last
<< " accepted " << accepted
<<std::endl;*/
}
kernel::ModelObjectsTemp RigidBodyUmbrella::do_get_inputs() const {
kernel::Model *m = get_model();
ModelObjectsTemp ret;
//reference rb
ret.push_back(m->get_particle(ref_));
kernel::ParticleIndexes pref(
RigidBody(m, ref_).get_member_indexes());
for (unsigned i=0; i<pref.size(); i++)
ret.push_back(m->get_particle(pref[i]));
//target rb
ret.push_back(m->get_particle(pi_));
kernel::ParticleIndexes iref(
RigidBody(m, pi_).get_member_indexes());
for (unsigned i=0; i<iref.size(); i++)
ret.push_back(m->get_particle(iref[i]));
return ret;
}
ParticlesTemp get_output_particles(const ModelObjectsTemp &mo) {
ParticlesTemp ret;
for (unsigned int i = 0; i < mo.size(); ++i) {
ModelObject *o = mo[i];
Particle *p = dynamic_cast<Particle *>(o);
if (p)
ret.push_back(p);
else {
ret += get_output_particles(o->get_inputs());
}
}
return ret;
}
ContainersTemp get_output_containers(const ModelObjectsTemp &mo) {
ContainersTemp ret;
for (unsigned int i = 0; i < mo.size(); ++i) {
ModelObject *o = mo[i];
Container *p = dynamic_cast<Container *>(o);
if (p)
ret.push_back(p);
else {
ret += get_output_containers(o->get_inputs());
}
}
return ret;
}
ModelObjectsTemp GaussianProcessInterpolation::get_inputs()
const {
ModelObjectsTemp ret;
ModelObjectsTemp ret1 = mean_function_->get_inputs();
ret.insert(ret.end(), ret1.begin(), ret1.end());
ret.push_back(sigma_);
ModelObjectsTemp ret2 = covariance_function_->get_inputs();
ret.insert(ret.end(), ret2.begin(), ret2.end());
return ret;
}
ModelObjectsTemp HelixRestraint::do_get_inputs() const {
ModelObjectsTemp ps;
Model *m = get_model();
for (IMP::Vector<IMP::PointerMember<
core::MultipleBinormalRestraint> >::const_iterator td = dihedral_rs_.begin();
td != dihedral_rs_.end(); ++td){
ModelObjectsTemp bps = (*td)->get_inputs();
ps.insert(ps.end(), bps.begin(), bps.end());
}
for (ParticleIndexPairs::const_iterator tb = bonds_ON_.begin();
tb != bonds_ON_.end(); ++tb) {
ps.push_back(m->get_particle((*tb)[0]));
ps.push_back(m->get_particle((*tb)[1]));
}
return ps;
}
// We also need to know which particles are used (as some are
// used, but don't create interactions).
ModelObjectsTemp Em2DRestraint::do_get_inputs() const {
ModelObjectsTemp ret = particles_container_->get_particles();
ret.push_back(particles_container_);
return ret;
}
ModelObjectsTemp ParticlesDummyRestraint::do_get_inputs() const {
ModelObjectsTemp ret = container_->get_particles();
ret.push_back(container_);
return ret;
}
ModelObjectsTemp DummyPairContainer::do_get_inputs() const {
ModelObjectsTemp ret =
cpf_->get_inputs(get_model(), c_->get_indexes());
ret.push_back(c_);
return ret;
}
void ModelObject::validate_outputs() const {
if (!get_has_dependencies()) return;
IMP_IF_CHECK(USAGE_AND_INTERNAL) {
IMP_CHECK_OBJECT(this);
ModelObjectsTemp ret = do_get_outputs();
std::sort(ret.begin(), ret.end());
ret.erase(std::unique(ret.begin(), ret.end()), ret.end());
ModelObjectsTemp saved = get_model()->get_dependency_graph_outputs(this);
std::sort(saved.begin(), saved.end());
ModelObjectsTemp intersection;
std::set_intersection(saved.begin(), saved.end(), ret.begin(), ret.end(),
std::back_inserter(intersection));
IMP_USAGE_CHECK(
intersection.size() == ret.size(),
"Dependencies changed without invalidating dependencies."
<< " Make sure you call set_has_dependencies(false) any "
<< "time the list of dependencies changed. Object is " << get_name()
<< " of type " << get_type_name());
}
}
ModelObjectsTemp MovedSingletonContainer::do_get_inputs() const {
ModelObjectsTemp ret;
ret.push_back(pc_);
ret.push_back(score_state_);
return ret;
}
