Example #1
0
core::MonteCarloMoverResult WeightMover::do_propose() {
  IMP_OBJECT_LOG;

  // store the old weights in case of reject
  oldweights_ = w_.get_weights();

  // Draw weights from a uniform distribution of variables that sum to one
  // taken from http://stats.stackexchange.com/questions/14059/
  //                     generate-uniformly-distributed-weights-that-sum-to-unity

  // get the old x
  Floats x;
  x.push_back(oldweights_[0]);
  for (unsigned i = 1; i < oldweights_.get_dimension() - 1; ++i) {
    x.push_back(oldweights_[i] + x[i - 1]);
  }

  // zero vector in D dimension
  algebra::VectorKD zero = algebra::get_zero_vector_kd(x.size());

  // generate random perturbation of old components
  algebra::VectorKD dX =
      algebra::get_random_vector_in(algebra::SphereKD(zero, radius_));

  // add perturbation to x and apply reflective boundaries
  for (unsigned i = 0; i < x.size(); ++i) {
    if (x[i] + dX[i] > 1.0)
      x[i] = 2.0 - x[i] - dX[i];
    else if (x[i] + dX[i] < 0.0)
      x[i] = -x[i] - dX[i];
    else
      x[i] += dX[i];
  }

  // sort the new x here
  std::sort(x.begin(), x.end(), std::less<double>());

  // get the new weights
  algebra::VectorKD newweights =
      algebra::get_zero_vector_kd(oldweights_.get_dimension());

  newweights[0] = x[0];
  for (unsigned i = 1; i < newweights.get_dimension() - 1; ++i) {
    newweights[i] = x[i] - x[i - 1];
  }
  newweights[newweights.get_dimension() - 1] = 1.0 - x[x.size() - 1];

  // set the new weights
  w_.set_weights(newweights);

  return core::MonteCarloMoverResult(
      ParticleIndexes(1, w_.get_particle()->get_index()), 1.0);
}
IMPCORE_BEGIN_NAMESPACE

OpenCubicSpline::OpenCubicSpline(const Floats &values,
                                 Float minrange, Float spacing,
                                 bool extend) :
  spacing_(spacing), inverse_spacing_(1.0/spacing_),
  spline_(values, spacing_, inverse_spacing_),
  minrange_(minrange), maxrange_(minrange_ + spacing_ * (values.size() - 1)),
  extend_(extend)
{
  IMP_USAGE_CHECK(spacing >0, "The spacing between values must be positive.");
  IMP_USAGE_CHECK(values.size() >=1, "You must provide at least one value.");
}
Example #3
0
Floats CrossLinkData::get_nonmarginal_elements(double sigmai,
                                               Floats dists) const {
  Floats probs;
  if (bias_) {
    for (unsigned n = 0; n < dists.size(); n++) {
      probs.push_back(get_biased_element(dists[n], sigmai));
    }
  }
  if (!bias_) {
    for (unsigned n = 0; n < dists.size(); n++) {
      probs.push_back(get_unbiased_element(dists[n], sigmai));
    }
  }
  return probs;
}
Floats CysteineCrossLinkData::get_omegas(Floats fmods, double omega0) const {
  Floats omegas;
  for (unsigned n = 0; n < fmods.size(); ++n) {

    double cumul = 0;
    double cumul2 = 0;

    for (unsigned j = 1; j < omega_grid_.size(); ++j) {
      double omj = omega_grid_[j];
      double omjm1 = omega_grid_[j - 1];
      double dom = omj - omjm1;

      double priorj = get_omega_prior(omj, omega0);
      double priorjm1 = get_omega_prior(omjm1, omega0);

      double pj = get_element(fexp_, fmods[n], omj) * priorj;
      double pjm1 = get_element(fexp_, fmods[n], omjm1) * priorjm1;

      double pj2 = get_element(fexp_, fmods[n], omj) * priorj * omj;
      double pjm12 = get_element(fexp_, fmods[n], omjm1) * priorjm1 * omjm1;

      cumul += (pj + pjm1) / 2.0 * dom;
      cumul2 += (pj2 + pjm12) / 2.0 * dom;
    }

    omegas.push_back(cumul2 / cumul);
  }
  return omegas;
}
Example #5
0
IMPSCOREFUNCTOR_BEGIN_INTERNAL_NAMESPACE

RawOpenCubicSpline::RawOpenCubicSpline(const Floats &values, double spacing,
                                       double inverse_spacing)
    : values_(values) {
  IMP_USAGE_CHECK(spacing > 0, "The spacing between values must be positive.");
  IMP_USAGE_CHECK(values.size() >= 1, "You must provide at least one value.");
  int npoints = values_.size();
  // Precalculate second derivatives for a natural cubic spline (open) by
  // inversion of the tridiagonal matrix (Thomas algorithm)
  second_derivs_.resize(npoints);
  Floats tmp(npoints);

  // Forward elimination phase
  second_derivs_[0] = 0.;
  tmp[0] = 0.;

  double inverse_doublespacing = 1.0 / (spacing + spacing);
  for (int i = 1; i < npoints - 1; ++i) {
    Float m = 0.5 * second_derivs_[i - 1] + 2.;
    second_derivs_[i] = -0.5 / m;
    tmp[i] = (6. * ((values_[i + 1] - values_[i]) * inverse_spacing -
                    (values_[i] - values_[i - 1]) * inverse_spacing) *
                  inverse_doublespacing -
              0.5 * tmp[i - 1]) /
             m;
  }
  // Backward substitution phase
  second_derivs_[npoints - 1] = 0.;
  for (int i = npoints - 2; i >= 0; --i) {
    second_derivs_[i] = second_derivs_[i] * second_derivs_[i + 1] + tmp[i];
  }
  /*IMP_LOG_TERSE( "Initialized spline with " << values.size() << " values "
    << "with spacing " << spacing << std::endl);*/
}
Example #6
0
Floats FStudentT::evaluate_derivative_FX(const Floats FXs) const {
  Floats dervs;
  double c = (N_ + nu_) / IMP::square(sigma_) / (nu_ + t2_);
  for (unsigned int i = 0; i < FXs.size(); i++) {
    dervs.push_back(c * (FXs[i] - FM_));
  }
  return dervs;
}
Example #7
0
IMPCORE_BEGIN_NAMESPACE

RigidBodyUmbrella::RigidBodyUmbrella(kernel::Model *m, kernel::ParticleIndex pi,
                                     kernel::ParticleIndex ref, Floats x0,
                                     double alpha, double k, std::string name)
    : Restraint(m, name), pi_(pi), ref_(ref), x0_(x0), alpha_(alpha),
      k_(k) {
  IMP_USAGE_CHECK(x0.size() == 7, "Wrong size for x0, should be 7");
}
Example #8
0
void FStudentT::do_update_sufficient_statistics(Floats FXs) {
  N_ = FXs.size();
  sumFX_ = FXs[0];
  sumFX2_ = IMP::square(FXs[0]);
  LogJX_ = 0.;
  for (unsigned int i = 1; i < N_; ++i) {
    sumFX_ += FXs[i];
    sumFX2_ += IMP::square(FXs[i]);
  }
}
Example #9
0
Floats CrossLinkData::get_marginal_elements(double sigma, Floats dists) const {
  Floats probs;
  unsigned is = get_closest(sigma_grid_, sigma);
  for (unsigned n = 0; n < dists.size(); n++) {

    unsigned id = get_closest(dist_grid_, dists[n]);
    probs.push_back(grid_[is][id]);
  }
  return probs;
}
Floats CysteineCrossLinkData::get_nonmarginal_elements(double fexp,
                                                       Floats fmods,
                                                       double omega) const {
  Floats probs;

  for (unsigned n = 0; n < fmods.size(); n++) {
    probs.push_back(get_element(fexp, fmods[n], omega));
  }
  return probs;
}
IMPISD_BEGIN_NAMESPACE

GaussianProcessInterpolation::GaussianProcessInterpolation(
    FloatsList x, Floats sample_mean, Floats sample_std, unsigned n_obs,
    UnivariateFunction *mean_function, BivariateFunction *covariance_function,
    Particle *sigma, double sparse_cutoff)
    : Object("GaussianProcessInterpolation%1%"),
      x_(x),
      n_obs_(n_obs),
      mean_function_(mean_function),
      covariance_function_(covariance_function),
      sigma_(sigma),
      cutoff_(sparse_cutoff) {
  // O(M)
  // store dimensions
  M_ = x.size();
  N_ = x[0].size();
  sigma_val_ = Scale(sigma_).get_nuisance();
  // basic checks
  IMP_USAGE_CHECK(sample_mean.size() == M_,
                  "sample_mean should have the same size as x");
  IMP_USAGE_CHECK(sample_std.size() == M_,
                  "sample_std should have the same size as x");
  IMP_USAGE_CHECK(mean_function->get_ndims_x() == N_,
                  "mean_function should have " << N_ << " input dimensions");
  IMP_USAGE_CHECK(mean_function->get_ndims_y() == 1,
                  "mean_function should have 1 output dimension");
  IMP_USAGE_CHECK(covariance_function->get_ndims_x1() == N_,
                  "covariance_function should have "
                      << N_ << " input dimensions for first vector");
  IMP_USAGE_CHECK(covariance_function->get_ndims_x2() == N_,
                  "covariance_function should have "
                      << N_ << " input dimensions for second vector");
  IMP_USAGE_CHECK(covariance_function->get_ndims_y() == 1,
                  "covariance_function should have 1 output dimension");
  // set all flags to false = need update.
  force_mean_update();
  force_covariance_update();
  // compute needed matrices
  compute_I(sample_mean);
  compute_S(sample_std);
}
Floats CysteineCrossLinkData::get_marginal_elements(Floats fmods,
                                                    double omega0) const {
  Floats probs;
  unsigned is = get_closest(omega0_grid_, omega0);
  for (unsigned n = 0; n < fmods.size(); n++) {

    unsigned id = get_closest(fmod_grid_, fmods[n]);
    probs.push_back(grid_[is][id]);
  }
  return probs;
}
Example #13
0
algebra::Vector3Ds ProbabilisticAnchorGraph::get_particle_anchors(
    Particle *p, float min_prob) const {
  Floats probs = get_particle_probabilities(p);
  algebra::Vector3Ds anchors;
  for (unsigned int i = 0; i < probs.size(); i++) {
    if (probs[i] >= min_prob) {
      anchors.push_back(positions_[i]);
    }
  }
  return anchors;
}
Example #14
0
void ChiSquareMetric::add_configuration(Floats data, Floats stddev,
                                        double weight) {
  // store weight
  weight_.push_back(weight);
  // if the constructor for normal chi2 is used, store non-normalized data
  if (constr_type_ == 0) {
    datas_.push_back(data);
    // standard deviation
    stddev_.push_back(stddev);
    // else normalize vector (data-data_exp)/stddev
  } else {
    double norm2 = 0.;
    for (unsigned i = 0; i < data.size(); ++i) {
      norm2 += pow((data[i] - data_exp_[i]) / stddev[i], 2);
    }
    norm_.push_back(sqrt(norm2));
    for (unsigned i = 0; i < data.size(); ++i) {
      data[i] = (data[i] - data_exp_[i]) / stddev[i];
    }
    datas_.push_back(data);
  }
  return;
}
Example #15
0
internal::Coord RigidBodyUmbrella::interpolate(double lambda, Floats x1,
                                               Floats x2) const {
    //checks
    IMP_USAGE_CHECK(x1.size() == 7, "Wrong size for x1, should be 7");
    IMP_USAGE_CHECK(x2.size() == 7, "Wrong size for x2, should be 7");
    IMP_USAGE_CHECK(lambda >= 0, "lambda should be >=0");
    IMP_USAGE_CHECK(lambda <= 1, "lambda should be <=1");
    //centroid
    IMP_Eigen::Vector3d cx1,cx2,cx0;
    cx1 << x1[0], x1[1], x1[2];
    cx2 << x2[0], x2[1], x2[2];
    cx0 = (1-lambda)*cx1 + lambda*cx2;
    //quaternion
    IMP_Eigen::Quaterniond qx1(x1[3],x1[4],x1[5],x1[6]);
    IMP_Eigen::Quaterniond qx2(x2[3],x2[4],x2[5],x2[6]);
    IMP_Eigen::Quaterniond qx0(qx1.slerp(lambda,qx2));
    qx0.normalize();
    //return it
    internal::Coord x0;
    x0.coms.push_back(cx0);
    x0.quats.push_back(qx0);
    return x0;
}
Example #16
0
Coord::Coord(Floats fl) {
  IMP_USAGE_CHECK(fl.size() % 7 == 0, "coordinates must be multiple of 7");
  unsigned nrbs = fl.size()/7;
  for (unsigned i = 0; i < nrbs; i++) {
    Eigen::Vector3d com;
    com << fl[3 * i], fl[3 * i + 1], fl[3 * i + 2];
    coms.push_back(com);
    Eigen::Quaterniond quat(fl[3 * nrbs + 4 * i], fl[3 * nrbs + 4 * i + 1],
                            fl[3 * nrbs + 4 * i + 2],
                            fl[3 * nrbs + 4 * i + 3]);
    quat.normalize();
    quats.push_back(quat);
  }
}
Example #17
0
IMPALGEBRA_BEGIN_NAMESPACE

LinearFit2D::LinearFit2D(const algebra::Vector2Ds& data,
                         const Floats &errors) {
  // check that there are at least 3 points
  IMP_USAGE_CHECK(data.size() > 1,
                  "At least 2 points are required for LinearFit2D "
                  << data.size() << " given");
  IMP_USAGE_CHECK(errors.empty() || errors.size()==data.size(),
                  "Either there must be no error bars given or one per"
                  << " point.");
  find_regression(data, errors);
  evaluate_error(data, errors);
}
Example #18
0
Floats CrossLinkData::get_omegas(double sigma, Floats dists) const {
  Floats omegas;
  for (unsigned n = 0; n < dists.size(); ++n) {

    double cumul = 0;
    double cumul2 = 0;

    if (!bias_) {
      for (unsigned j = 1; j < omega_grid_.size(); ++j) {
        double omj = omega_grid_[j];
        double omjm1 = omega_grid_[j - 1];
        double dom = omj - omjm1;

        double pj = get_unbiased_element(dists[n], omj * sigma) / omj;
        double pjm1 = get_unbiased_element(dists[n], omjm1 * sigma) / omjm1;

        double pj2 = get_unbiased_element(dists[n], omj * sigma);
        double pjm12 = get_unbiased_element(dists[n], omjm1 * sigma);

        cumul += (pj + pjm1) / 2.0 * dom;
        cumul2 += (pj2 + pjm12) / 2.0 * dom;
      }
    }

    if (bias_) {
      for (unsigned j = 1; j < omega_grid_.size(); ++j) {
        double omj = omega_grid_[j];
        double omjm1 = omega_grid_[j - 1];
        double dom = omj - omjm1;

        double pj = get_biased_element(dists[n], omj * sigma) / omj;
        double pjm1 = get_biased_element(dists[n], omjm1 * sigma) / omjm1;

        double pj2 = get_biased_element(dists[n], omj * sigma);
        double pjm12 = get_biased_element(dists[n], omjm1 * sigma);

        cumul += (pj + pjm1) / 2.0 * dom;
        cumul2 += (pj2 + pjm12) / 2.0 * dom;
      }
    }

    omegas.push_back(cumul2 / cumul);
  }
  return omegas;
}
Example #19
0
void EM2DRestraint::init_grid(const Floats& sigma_grid) {
  for (unsigned i = 0; i < fmod_grid_.size(); ++i) {
    double fmod = fmod_grid_[i];

    double cumul = 0;

    for (unsigned j = 1; j < sigma_grid.size(); ++j) {
      double sj = sigma_grid[j];
      double sjm1 = sigma_grid[j - 1];
      double ds = sj - sjm1;

      double pj = get_element(fmod, sj) / sj;
      double pjm1 = get_element(fmod, sjm1) / sjm1;

      cumul += (pj + pjm1) / 2.0 * ds;
    }
    // add marginal element
    grid_.push_back(cumul);
  }
}
Example #20
0
void FretData::init_grids
     (const Floats& d_grid_int, Float R0, Float Rmin, Float Rmax, bool do_limit)
{
  // grid on distance between termini
  for(unsigned l=0; l<d_term_.size(); ++l){
   // grid on sigma
   for(unsigned i=0; i<s_grid_.size(); ++i){
    // grid on distance between center of GMM
    for(unsigned j=0; j<d_center_.size(); ++j){
     Float marg=0.;
     Float norm=0.;
     unsigned kmin=0;
     unsigned kmax=d_grid_int.size();
     // find boundaries for marginalization
     if(do_limit){
      kmin=get_closest(d_grid_int,std::max(Rmin,d_term_[l]-Rmax));
      kmax=get_closest(d_grid_int,d_term_[l]+Rmax);
     }
     // do the marginalization
     for(unsigned k=kmin+1; k<kmax; ++k){

      Float dx = d_grid_int[k] - d_grid_int[k-1];

      Float prob   = get_probability(d_grid_int[k],   d_center_[j], s_grid_[i]);
      Float probm1 = get_probability(d_grid_int[k-1], d_center_[j], s_grid_[i]);

      Float kernel   = get_kernel( d_grid_int[k],   R0 );
      Float kernelm1 = get_kernel( d_grid_int[k-1], R0 );

      marg += ( kernel * prob + kernelm1 * probm1 ) / 2.0 * dx;
      norm += ( prob + probm1 ) / 2.0 * dx;
     }
     // store in grid_ and norm_
     grid_.push_back(marg);
     norm_.push_back(norm);
    }
   }
  }
}
Example #21
0
Floats _pass_floats(const Floats &in) {
  for (unsigned int i = 0; i < in.size(); ++i) {
    std::cout << in[i] << " ";
  }
  return in;
}
Example #22
0
CrossLinkData::CrossLinkData(Floats dist_grid, Floats omega_grid,
                             Floats sigma_grid, Floats pot_x_grid,
                             Floats pot_value_grid, double don, double doff,
                             int prior_type)
    : Object("Data Structure for CrossLinkMSRestraint %1%") {
  prior_type_ = prior_type;
  bias_ = true;
  // this constructor calculates the marginal likelihood using a biasing
  // potential
  // obtained from Free energy calculations.

  // Store dist grid
  dist_grid_ = dist_grid;

  // Store omega grid
  omega_grid_ = omega_grid;

  // Store sigma grid
  sigma_grid_ = sigma_grid;

  // Store the potential x coordinates
  pot_x_grid_ = pot_x_grid;

  // Store the normalized potential
  double cumul = 0;
  for (unsigned j = 1; j < pot_value_grid.size(); ++j) {
    double xj = pot_x_grid_[j];
    double xjm1 = pot_x_grid_[j - 1];
    double dx = xj - xjm1;
    double pj = pot_value_grid[j];
    double pjm1 = pot_value_grid[j - 1];
    cumul += (pj + pjm1) / 2.0 * dx;
  }

  for (unsigned i = 0; i < pot_value_grid.size(); ++i) {
    pot_value_grid_.push_back(pot_value_grid[i] / cumul);
  }

  for (unsigned k = 0; k < sigma_grid_.size(); ++k) {

    double sigma = sigma_grid_[k];

    Floats grid;

    for (unsigned i = 0; i < dist_grid_.size(); ++i) {

      double dist = dist_grid_[i];
      double cumul = 0;

      for (unsigned j = 1; j < omega_grid_.size(); ++j) {

        double omj = omega_grid_[j];
        double omjm1 = omega_grid_[j - 1];

        double dom = omj - omjm1;

        double pj;
        double pjm1;

        if (prior_type_ == 0) {
          pj = get_biased_element(dist, omj * sigma) / omj;
          pjm1 = get_biased_element(dist, omjm1 * sigma) / omjm1;
        } else {
          pj = get_biased_element(dist, omj) * get_omega_prior(omj, sigma);
          pjm1 =
              get_biased_element(dist, omjm1) * get_omega_prior(omjm1, sigma);
        }
        cumul += (pj + pjm1) / 2.0 * dom;
      }

      // switching cumul to zero between don and doff
      if (dist > doff) {
        cumul = 0.;
      }
      if (dist > don && dist <= doff) {
        cumul *= pow(doff * doff - dist * dist, 2) *
                 (doff * doff + 2. * dist * dist - 3. * don * don) /
                 pow(doff * doff - don * don, 3);
      }
      grid.push_back(cumul);
    }
    grid_.push_back(grid);
  }
}