Ejemplo n.º 1
0
void ConnectivityRestraint::add_particles(const kernel::ParticlesTemp &ps) {
  if (!sc_ && !ps.empty()) {
    sc_ = new IMP::internal::InternalListSingletonContainer(
        ps[0]->get_model(), "connectivity list");
  }
  get_list(sc_)->add(IMP::internal::get_index(ps));
}
Ejemplo n.º 2
0
Selection::Selection(const kernel::ParticlesTemp &h) : radius_(-1) {
  if (h.empty()) {
    m_ = nullptr;
    return;
  } else {
    set_hierarchies(h[0]->get_model(), IMP::get_indexes(h));
  }
}
Ejemplo n.º 3
0
/** Take a set of core::XYZR particles and relax them relative to a set of
    restraints. Excluded volume is handle separately, so don't include it
in the passed list of restraints. */
void optimize_balls(const kernel::ParticlesTemp &ps, const kernel::RestraintsTemp &rs,
                    const PairPredicates &excluded,
                    const OptimizerStates &opt_states, base::LogLevel ll) {
    // make sure that errors and log messages are marked as coming from this
    // function
    IMP_FUNCTION_LOG;
    base::SetLogState sls(ll);
    IMP_ALWAYS_CHECK(!ps.empty(), "No kernel::Particles passed.", ValueException);
    kernel::Model *m = ps[0]->get_model();
    //double scale = core::XYZR(ps[0]).get_radius();

    IMP_NEW(core::SoftSpherePairScore, ssps, (10));
    IMP_NEW(core::ConjugateGradients, cg, (m));
    cg->set_optimizer_states(opt_states);
    {
        // set up restraints for cg
        IMP_NEW(container::ListSingletonContainer, lsc, (ps));
        IMP_NEW(container::ClosePairContainer, cpc,
                (lsc, 0, core::XYZR(ps[0]).get_radius()));
        cpc->add_pair_filters(excluded);
        base::Pointer<kernel::Restraint> r
            = container::create_restraint(ssps.get(), cpc.get());
        cg->set_scoring_function(rs + kernel::RestraintsTemp(1, r.get()));
        cg->set_optimizer_states(opt_states);
    }
    IMP_NEW(core::MonteCarlo, mc, (m));
    mc->set_optimizer_states(opt_states);
    IMP_NEW(core::IncrementalScoringFunction, isf, (ps, rs));
    {
        // set up MC
        mc->add_mover(create_serial_mover(ps));
        // we are special casing the nbl term for montecarlo, but using all for CG
        mc->set_incremental_scoring_function(isf);
        // use special incremental support for the non-bonded part
        isf->add_close_pair_score(ssps, 0, ps, excluded);
        // make pointer vector
    }

    IMP_LOG_PROGRESS("Performing initial optimization" << std::endl);
    {
        boost::ptr_vector<ScopedSetFloatAttribute> attrs;
        for (unsigned int j = 0; j < attrs.size(); ++j) {
            attrs.push_back(
                new ScopedSetFloatAttribute(ps[j], core::XYZR::get_radius_key(), 0));
        }
        cg->optimize(1000);
    }
    // shrink each of the particles, relax the configuration, repeat
    for (int i = 0; i < 11; ++i) {
        boost::ptr_vector<ScopedSetFloatAttribute> attrs;
        double factor = .1 * i;
        IMP_LOG_PROGRESS("Optimizing with radii at " << factor << " of full"
                         << std::endl);
        for (unsigned int j = 0; j < ps.size(); ++j) {
            attrs.push_back(
                new ScopedSetFloatAttribute(ps[j], core::XYZR::get_radius_key(),
                                            core::XYZR(ps[j]).get_radius() * factor));
        }
        // changed all radii
        isf->set_moved_particles(isf->get_movable_indexes());
        for (int j = 0; j < 5; ++j) {
            mc->set_kt(100.0 / (3 * j + 1));
            mc->optimize(ps.size() * (j + 1) * 100);
            double e = cg->optimize(10);
            IMP_LOG_PROGRESS("Energy is " << e << std::endl);
            if (e < .000001) break;
        }
    }
}