IMPKERNEL_BEGIN_NAMESPACE
Optimizer::Optimizer(Model *m, std::string name)
: ModelObject(m, name) {
set_was_used(true);
stop_on_good_score_ = false;
}
void RecursiveAssignmentsTable::load_assignments(
const Subset &s, AssignmentContainer *pac) const {
set_was_used(true);
IMP_OBJECT_LOG;
IMP_NEW(SimpleAssignmentsTable, sac, (pst_, sft_, max_));
recursive_load_assignments(s, pst_, sft_, max_, sac, pac);
}
Optimizer::Optimizer(Model *m, std::string name): Object(name)
{
if (m) set_model(m);
set_was_used(true);
min_score_= -std::numeric_limits<double>::max();
stop_on_good_score_=false;
}
double RestraintCache::get_score(kernel::Restraint *r, const Subset &s,
const Assignment &a) const {
IMP_OBJECT_LOG;
set_was_used(true);
Slice slice = get_slice(r, s);
Assignment ra = slice.get_sliced(a);
return get_score(r, ra);
}
IMPKERNEL_BEGIN_NAMESPACE
Optimizer::Optimizer(): Object("Optimizer%1%")
{
set_was_used(true);
min_score_= -std::numeric_limits<double>::max();
stop_on_good_score_=false;
}
IMPKERNEL_BEGIN_NAMESPACE
Optimizer::Optimizer() : ModelObject("Optimizer%1%") {
IMPKERNEL_DEPRECATED_METHOD_DEF(2.1,
"Use the constructor that takes a model.");
set_was_used(true);
min_score_ = -std::numeric_limits<double>::max();
stop_on_good_score_ = false;
}
void TransformationAndReflectionSymmetry::apply_index(
kernel::Model *m, kernel::ParticleIndex pi) const {
IMP_USAGE_CHECK(!RigidBody::get_is_setup(m, pi),
"Particle must not be a rigid body particle");
set_was_used(true);
XYZ rd(Reference(m, pi).get_reference_particle());
XYZ d(m, pi);
d.set_coordinates(t_.get_transformed(r_.get_reflected(rd.get_coordinates())));
}
IntPairs BoxSweepClosePairsFinder::get_close_pairs(
const algebra::BoundingBox3Ds &bbs) const {
set_was_used(true);
IntPairs out;
Vector<BoxNBLBbox> boxes;
box_copy_particles_to_boxes(bbs, get_distance(), boxes);
CGAL::box_self_intersection_d(boxes.begin(), boxes.end(), BoxAddToList(out));
return out;
}
ParticlePairsTemp BoxSweepClosePairsFinder
::get_close_pairs( const ParticlesTemp &ca) const {
set_was_used(true);
ParticlePairsTemp out;
base::Vector<NBLBbox> boxes;
copy_particles_to_boxes(ca, get_distance(), boxes);
CGAL::box_self_intersection_d( boxes.begin(), boxes.end(), AddToList(out));
return out;
}
ConfigurationSet *Sampler::create_sample() const {
IMP_OBJECT_LOG;
set_was_used(true);
// IMP_LOG_TERSE( "Sampling " << num_opt << " particles."<<std::endl);
/*if (num_opt == 0) {
IMP_WARN("There are no particles to optimize."<<std::endl);
return nullptr;
}*/
return do_sample();
}
ParticleIndexPairs BoxSweepClosePairsFinder::get_close_pairs(
Model *m, const ParticleIndexes &ca) const {
set_was_used(true);
ParticleIndexPairs out;
Vector<NBLBbox> boxes;
copy_particles_to_boxes(m, ca, get_distance(), boxes);
CGAL::box_self_intersection_d(boxes.begin(), boxes.end(), AddToList(out));
return out;
}
IntPairs GridClosePairsFinder::get_close_pairs(
const algebra::BoundingBox3Ds &bas) const {
IMP_OBJECT_LOG;
set_was_used(true);
IntPairs out;
internal::BBHelper::fill_close_pairs(
internal::BBHelper::get_particle_set(bas.begin(), bas.end(), 0),
internal::BoundingBoxTraits(bas.begin(), bas.begin(), get_distance()),
internal::BBPairSink(out));
return out;
}
CHARMMParameters::CHARMMParameters(base::TextInput top_file,
base::TextInput par_file,
bool translate_names_to_pdb) {
// Parameter objects are not designed to be added into other containers
set_was_used(true);
read_topology_file(top_file, translate_names_to_pdb);
if (par_file != base::TextInput()) {
read_parameter_file(par_file);
}
}
double Optimizer::optimize(unsigned int max_steps) {
IMP_OBJECT_LOG;
set_has_required_score_states(true);
if (!get_model()) {
IMP_THROW("Must give the optimizer a model to optimize",
base::ValueException);
}
set_was_used(true);
set_is_optimizing_states(true);
double ret;
IMP_THREADS((ret, max_steps), ret = do_optimize(max_steps););
double Optimizer::optimize(unsigned int max_steps) {
IMP_OBJECT_LOG;
if (!model_) {
IMP_THROW("Must give the optimizer a model to optimize",
base::ValueException);
}
set_was_used(true);
set_is_optimizing_states(true);
double ret= do_optimize(max_steps);
set_is_optimizing_states(false);
return ret;
}
ParticleIndexPairs GridClosePairsFinder::get_close_pairs(
Model *m, const ParticleIndexes &ca,
const ParticleIndexes &cb) const {
IMP_OBJECT_LOG;
set_was_used(true);
ParticleIndexPairs out;
internal::ParticleIndexHelper::fill_close_pairs(
internal::ParticleIndexHelper::get_particle_set(ca.begin(), ca.end(), 0),
internal::ParticleIndexHelper::get_particle_set(cb.begin(), cb.end(), 1),
internal::ParticleIndexTraits(m, get_distance()),
internal::ParticleIndexPairSink(m, access_pair_filters(), out));
return out;
}
ParticleIndexPairs GridClosePairsFinder::get_close_pairs(
Model *m, const ParticleIndexes &c) const {
IMP_OBJECT_LOG;
set_was_used(true);
IMP_LOG_TERSE("Rebuilding NBL with Grid and cutoff " << get_distance()
<< std::endl);
ParticleIndexPairs out;
internal::ParticleIndexHelper::fill_close_pairs(
internal::ParticleIndexHelper::get_particle_set(c.begin(), c.end(), 0),
internal::ParticleIndexTraits(m, get_distance()),
internal::ParticleIndexPairSink(m, access_pair_filters(), out));
return out;
}
void ConfigurationSet::load_configuration(int i) const {
set_was_used(true);
IMP_OBJECT_LOG;
IMP_CHECK_OBJECT(this);
IMP_USAGE_CHECK(i < static_cast<int>(get_number_of_configurations())
&& i >= -1,
"Invalid configuration requested.");
if (i==-1) {
base_->load_configuration();
} else {
configurations_[i]->load_configuration();
}
}
ParticleIndexPairs BoxSweepClosePairsFinder::get_close_pairs(
kernel::Model *m, const kernel::ParticleIndexes &ca,
const kernel::ParticleIndexes &cb) const {
set_was_used(true);
base::Vector<NBLBbox> boxes0, boxes1;
copy_particles_to_boxes(m, ca, get_distance(), boxes0);
copy_particles_to_boxes(m, cb, get_distance(), boxes1);
kernel::ParticleIndexPairs out;
CGAL::box_intersection_d(boxes0.begin(), boxes0.end(), boxes1.begin(),
boxes1.end(), AddToList(out));
return out;
}
bool MinimumRestraintScoreSubsetFilter
::get_is_ok(const Assignment &state) const{
IMP_OBJECT_LOG;
set_was_used(true);
unsigned int bad_count=0;
for (unsigned int i=0; i< rs_.size(); ++i) {
double s= rc_->get_score(rs_[i], slices_[i].get_sliced(state));
if (s >= std::numeric_limits<double>::max()) {
++bad_count;
if (bad_count>max_) break;
}
}
return bad_count <= max_;
}
double Optimizer::optimize(unsigned int max_steps) {
IMP_OBJECT_LOG;
if (!scoring_function_) {
IMP_WARN("No scoring function provided - using Model's implicit "
"scoring function (deprecated). Recommend you use a "
"ScoringFunction object instead." << std::endl);
}
set_has_required_score_states(true);
set_was_used(true);
set_is_optimizing_states(true);
double ret;
IMP_THREADS((ret, max_steps), {
ret = do_optimize(max_steps);
});
void TransformationSymmetry::apply_index(kernel::Model *m,
kernel::ParticleIndex pi) const {
set_was_used(true);
if (RigidBody::get_is_setup(m, pi)) {
RigidBody rrb(Reference(m, pi).get_reference_particle());
RigidBody rb(m, pi);
// We do the non-lazy version in order as it is hard
// for the dependency checker to get the dependencies right
// Is it really? We should check this.
rb.set_reference_frame_lazy(algebra::ReferenceFrame3D(
t_ * rrb.get_reference_frame().get_transformation_to()));
} else {
XYZ rd(Reference(m, pi).get_reference_particle());
XYZ d(m, pi);
d.set_coordinates(t_.get_transformed(rd.get_coordinates()));
}
}
ParticleIndexPairs QuadraticClosePairsFinder::get_close_pairs(
kernel::Model *m, const kernel::ParticleIndexes &pt) const {
set_was_used(true);
IMP_OBJECT_LOG;
IMP_LOG_TERSE("Adding close pairs from "
<< pt.size() << " particles with threshold " << get_distance()
<< std::endl);
kernel::ParticleIndexPairs ret;
for (unsigned int i = 0; i < pt.size(); ++i) {
for (unsigned int j = 0; j < i; ++j) {
if (get_are_close(m, pt[i], pt[j])) {
ret.push_back(kernel::ParticleIndexPair(pt[i], pt[j]));
}
}
}
return ret;
}
ParticleIndexPairs QuadraticClosePairsFinder::get_close_pairs(
kernel::Model *m, const kernel::ParticleIndexes &pta,
const kernel::ParticleIndexes &ptb) const {
set_was_used(true);
IMP_OBJECT_LOG;
IMP_LOG_TERSE("Quadratic add_close_pairs called with "
<< pta.size() << " and " << ptb.size() << std::endl);
kernel::ParticleIndexPairs ret;
for (unsigned int i = 0; i < pta.size(); ++i) {
for (unsigned int j = 0; j < ptb.size(); ++j) {
if (get_are_close(m, pta[i], ptb[j])) {
ret.push_back(kernel::ParticleIndexPair(pta[i], ptb[j]));
}
}
}
return ret;
}
IntPairs NearestNeighborsClosePairsFinder::get_close_pairs(
const algebra::BoundingBox3Ds &bas,
const algebra::BoundingBox3Ds &bbs) const {
set_was_used(true);
IMP_OBJECT_LOG;
IMP_LOG_TERSE("Quadratic add_close_pairs called with "
<< bas.size() << " and " << bbs.size() << std::endl);
IntPairs ret;
const double d2 = get_distance() / 2.0;
for (unsigned int i = 0; i < bas.size(); ++i) {
algebra::BoundingBox3D bi = bas[i] + d2;
for (unsigned int j = 0; j < bbs.size(); ++j) {
algebra::BoundingBox3D bj = bbs[j] + d2;
if (get_interiors_intersect(bi, bj)) {
ret.push_back(IntPair(i, j));
}
}
}
return ret;
}
IntPairs QuadraticClosePairsFinder::get_close_pairs(
const algebra::BoundingBox3Ds &bbs) const {
set_was_used(true);
IMP_OBJECT_LOG;
IMP_LOG_TERSE("Adding close pairs from "
<< bbs.size() << " boxes with threshold " << get_distance()
<< std::endl);
IntPairs ret;
const double d2 = get_distance() / 2.0;
for (unsigned int i = 0; i < bbs.size(); ++i) {
algebra::BoundingBox3D bi = bbs[i] + d2;
for (unsigned int j = 0; j < i; ++j) {
algebra::BoundingBox3D bj = bbs[j] + d2;
if (get_interiors_intersect(bi, bj)) {
ret.push_back(IntPair(i, j));
}
}
}
return ret;
}
double Simulator::do_simulate(double time) {
IMP_FUNCTION_LOG;
set_was_used(true);
ParticleIndexes ps = get_simulation_particle_indexes();
setup(ps);
double target = current_time_ + time;
boost::scoped_ptr<boost::progress_display> pgs;
if (get_log_level() == PROGRESS) {
pgs.reset(new boost::progress_display(time / max_time_step_));
}
while (current_time_ < target) {
last_time_step_ = do_step(ps, max_time_step_);
current_time_ += last_time_step_;
update_states();
if (get_log_level() == PROGRESS) {
++(*pgs);
}
}
return Optimizer::get_scoring_function()->evaluate(false);
}
void ConfigurationSet::save_configuration() {
IMP_OBJECT_LOG;
set_was_used(true);
IMP_LOG_TERSE( "Adding configuration to set " << get_name() << std::endl);
configurations_.push_back(new Configuration(model_, base_));
}
Optimizer::Optimizer(kernel::Model *m, std::string name)
: ModelObject(m, name) {
set_was_used(true);
min_score_ = -std::numeric_limits<double>::max();
stop_on_good_score_ = false;
}
RealRCTree(It b, It e)
: tree(b, e) {
set_was_used(true);
}
