IMPMULTIFIT_BEGIN_NAMESPACE
IMP::algebra::DenseGrid3D<float> ComplementarityRestraint::get_grid(
const kernel::ParticlesTemp &a, double thickness, double value,
double interior_thickness, double voxel) const {
internal::ComplementarityGridParameters params;
params.complementarity_thickness = Floats(1, thickness);
params.complementarity_value = Floats(1, value);
params.interior_thickness = interior_thickness;
params.interior_cutoff_distance = maximum_penetration_;
params.voxel_size = voxel;
IMP::algebra::DenseGrid3D<float> grid =
internal::get_complementarity_grid(a, params);
return grid;
}
void nsDisplayListSet::MoveTo(const nsDisplayListSet& aDestination) const
{
aDestination.BorderBackground()->AppendToTop(BorderBackground());
aDestination.BlockBorderBackgrounds()->AppendToTop(BlockBorderBackgrounds());
aDestination.Floats()->AppendToTop(Floats());
aDestination.Content()->AppendToTop(Content());
aDestination.PositionedDescendants()->AppendToTop(PositionedDescendants());
aDestination.Outlines()->AppendToTop(Outlines());
}
Floats ChainStatisticsOptimizerState::get_diffusion_coefficients() const {
if (positions_.empty()) return Floats();
base::Vector<algebra::Vector3Ds >
displacements(positions_[0].size(),
algebra::Vector3Ds( positions_.size()-1));
for (unsigned int i=1; i< positions_.size(); ++i) {
algebra::Transformation3D rel
= algebra::get_transformation_aligning_first_to_second(positions_[i-1],
positions_[i]);
for (unsigned int j=0; j < positions_[i].size(); ++j) {
displacements[j][i-1]= rel.get_transformed(positions_[i-1][j])
- positions_[i][j];
}
}
Floats ret;
for (unsigned int i=0; i < displacements.size(); ++i) {
ret.push_back(atom::get_diffusion_coefficient(displacements[i],
get_period()*get_dt()));
}
return ret;
}
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;
}
double SteepestDescent::do_optimize(unsigned int max_steps)
{
IMP_OBJECT_LOG;
Float last_score, new_score = 0.0;
// set up the indexes
FloatIndexes float_indexes=get_optimized_attributes();
Float current_step_size = step_size_;
// ... and space for the old values
algebra::VectorKD temp_derivs(Floats(float_indexes.size(), 0));
algebra::VectorKD temp_values(Floats(float_indexes.size(), 0));
for (unsigned int step = 0; step < max_steps; step++) {
// model.show(std::cout);
int cnt = 0;
// evaluate the last model state
last_score = get_scoring_function()->evaluate(true);
IMP_LOG(TERSE, "start score: " << last_score << std::endl);
// store the old values
for (unsigned int i = 0; i < temp_derivs.get_dimension(); i++) {
temp_derivs[i] = get_derivative(float_indexes[i]);
temp_values[i] = get_value(float_indexes[i]);
}
bool constant_score=false;
while (true) {
cnt++;
// try new values based on moving down the gradient at the current
// step size
IMP_LOG(VERBOSE, "step: "
<< temp_derivs * current_step_size << std::endl);
for (unsigned int i = 0; i < float_indexes.size(); i++) {
set_value(float_indexes[i],
temp_values[i] - temp_derivs[i]
* current_step_size);
}
// check the new model
new_score = get_scoring_function()->evaluate(false);
IMP_LOG(TERSE, "last score: " << last_score << " new score: "
<< new_score << " step size: " << current_step_size
<< std::endl);
// if the score got better, we'll take it
if (new_score < last_score) {
IMP_LOG(TERSE, "Accepting step of size "
<< current_step_size);
update_states();
if (new_score <= threshold_) {
IMP_LOG(TERSE, "Below threshold, returning." << std::endl);
return new_score;
}
current_step_size= std::min(current_step_size* 1.4,
max_step_size_);
break;
}
// if the score is the same, keep going one more time
if (std::abs(new_score- last_score) < .0000001) {
if (constant_score) {
break;
}
current_step_size *= 0.9;
constant_score = true;
} else {
constant_score=false;
current_step_size*=.7;
}
if (cnt>200) {
// stuck
for (unsigned int i = 0; i < float_indexes.size(); i++) {
set_value(float_indexes[i],
temp_values[i]);
}
IMP_LOG(TERSE, "Unable to find a good step. Returning" << std::endl);
return last_score;
}
if (current_step_size <.00000001) {
// here is as good as any place we found
update_states();
IMP_LOG(TERSE, "Unable to make progress, returning." << std::endl);
return new_score;
}
}
}
return new_score;
}
