Ejemplo n.º 1
0
int get_dump_interval_in_frames(const ::npctransport_proto::Assignment& a,
                                double time_step) {
  int ret = get_frames_from_ns(a.dump_interval_ns(), time_step);
  IMP_LOG(VERBOSE, "dump interval = " << ret << " frames, "
            << a.dump_interval_ns() << " ns, time step " << time_step
            << std::endl);
  return ret;
}
Ejemplo n.º 2
0
int get_dump_interval_in_frames
(const ::npctransport_proto::Assignment& config, double time_step)
{
  const double fs_in_ns = 1000000;
  double ret =
    config.dump_interval_ns() *  fs_in_ns / time_step;
  if(ret == 0) ret = 1; // make sure at least every frame
  std::cout << "dump interval = " << std::ceil(ret) << " frames, "
            << config.dump_interval_ns() << " ns, time step " << time_step
            << std::endl;;
  return std::ceil(ret);
}
Ejemplo n.º 3
0
int get_number_of_frames(const ::npctransport_proto::Assignment& a,
                         double time_step) {
  int ret = get_frames_from_ns(a.simulation_time_ns(), time_step);
  if (ret > a.maximal_number_of_frames()) {
    IMP_THROW(
        "number of frames " << ret << ", which is required for simulation time"
                            << a.simulation_time_ns()
                            << " exceeds the specified maximal value "
                            << a.maximal_number_of_frames(),
        IMP::ValueException);
  }
  return ret;
}
Ejemplo n.º 4
0
int get_output_statistics_interval_in_frames
( const ::npctransport_proto::Assignment& a,
  double time_step,
  double default_value_ns)
{
  double ns = default_value_ns;
  if(a.has_output_statistics_interval_ns()) {
    ns = a.output_statistics_interval_ns() ;
  }
  int ret = get_frames_from_ns(ns, time_step);
  IMP_LOG(VERBOSE, "output stats interval = "
            << ret  << " frames, converted from "
            << ns << " ns, time step " << time_step
            << std::endl);
  return ret;
}
Ejemplo n.º 5
0
int get_number_of_frames
(const ::npctransport_proto::Assignment& config, double time_step)
{
  const double fs_in_ns = 1000000;
  int ret = std::ceil(config.simulation_time_ns() * fs_in_ns / time_step);
  if(ret == 0) ret = 1; // make sure at least every frame
  if(ret > config.maximal_number_of_frames()){
    IMP_THROW("number of frames " << ret
              << ", which is required for simulation time"
              << config.simulation_time_ns()
              << " exceeds the specified maximal value "
              << config.maximal_number_of_frames() ,
              IMP::base::ValueException);
  }
  return ret;
}
Ejemplo n.º 6
0
double get_close_pairs_range(const ::npctransport_proto::Assignment& a) {
  double max_range = std::numeric_limits<double>::epsilon();
  UPDATE_MAX(range, a.nonspecific_range);
  for (int i = 0; i < a.interactions_size(); ++i) {
    max_range= std::max(max_range,
                        get_close_pairs_range_for_interaction(a, i));
  }
  return max_range;
}
Ejemplo n.º 7
0
double get_close_pairs_range(const ::npctransport_proto::Assignment& config) {
  double max_range= config.interaction_range().value();
  UPDATE_MAX(range, config.nonspecific_range);
  double max_range_factor= 1;
  for ( int i=0; i< config.fgs_size(); ++i) {
    UPDATE_MAX(range_factor, config.fgs(i).interaction_range_factor);
  }
  for ( int i=0; i< config.floaters_size(); ++i) {
    UPDATE_MAX(range_factor, config.floaters(i).interaction_range_factor);
  }
  for ( int i=0; i< config.interactions_size(); ++i) {
    if (config.interactions(i).has_interaction_range()) {
      UPDATE_MAX(range, config.interactions(i).interaction_range);
    }
  }
  return get_close_pairs_range(max_range, max_range_factor);
}
Ejemplo n.º 8
0
double get_time_step(const ::npctransport_proto::Assignment& a,
                     double max_trans_relative_to_radius)
{
  // NOTE: this is not a tight bound - a tight bound would involve
  // computing time step for each interactions (factored by relevant
  // constants and accounting for particle radii and interaction range
  // / k). So this is a conservative time step choice in that respect.
  double time_step_factor = a.time_step_factor().value();
  double max_d_factor = 1.0;
  double min_radius = std::numeric_limits<double>::max(); // in A
  double min_range = std::numeric_limits<double>::max(); // in A
  double max_k = 0.0; // in kcal/mol/A

  UPDATE_MAX(k, a.backbone_k);  // TODO: is this valid for harmonic k?
  if(a.nonspecific_range().value()>0.0 &&
     a.nonspecific_k().value()>0.0) {
    UPDATE_MAX(k, a.nonspecific_k);
    UPDATE_MIN(range, a.nonspecific_range);
  }
  UPDATE_MAX(k, a.excluded_volume_k);
  for (int i = 0; i < a.fgs_size(); ++i) {
    UPDATE_MAX(d_factor, a.fgs(i).d_factor);
    UPDATE_MIN(radius, a.fgs(i).radius);
  }
  for (int i = 0; i < a.floaters_size(); ++i) {
    UPDATE_MAX(d_factor, a.floaters(i).d_factor);
    UPDATE_MIN(radius, a.floaters(i).radius);
  }
  double base_k = a.interaction_k().value();
  double base_range = a.interaction_range().value();

  // go over all interaction and compute their maximal k (in kcal/mol/A)
  // and minimum range (in A)
  for (int i = 0; i < a.interactions_size(); ++i) {
    double k=base_k;
    double range=base_range;
    if (a.interactions(i).has_interaction_k()) {
      k=a.interactions(i).interaction_k().value();
    }
    if (a.interactions(i).has_interaction_range()) {
      range=a.interactions(i).interaction_range().value();
    }
    // factor k and range + retrieve particles radii
    std::string type0=a.interactions(i).type0();
    std::string type1=a.interactions(i).type1();
    double R0(-1.0);
    double R1(-1.0);
    bool is_found0= false;
    bool is_found1= false;
    for(int ii=0; ii<a.floaters_size(); ii++){
      if(a.floaters(ii).type()==type0){
        if(a.floaters(ii).interactions().value()==0){
          range=0.0; // skip
          continue;
        }
        k*=a.floaters(ii).interaction_k_factor().value();
        range*=a.floaters(ii).interaction_range_factor().value();
        R0=a.floaters(ii).radius().value();
        is_found0= true;
      }
      if(a.floaters(ii).type()==type1){
        if(a.floaters(ii).interactions().value()==0){
          range=0.0; // skip
          continue;
        }
        k*=a.floaters(ii).interaction_k_factor().value();
        range*=a.floaters(ii).interaction_range_factor().value();
        R1=a.floaters(ii).radius().value();
        is_found1= true;
      }
    }
    for(int ii=0; ii<a.fgs_size(); ii++){
      if(is_fg_type_match(type0, a.fgs(ii))){
        if(a.fgs(ii).interactions().value()==0){
          range=0.0; // skip
          continue;
        }
        k*=a.fgs(ii).interaction_k_factor().value();
        range*=a.fgs(ii).interaction_range_factor().value();
        R0=a.fgs(ii).radius().value();
        is_found0= true;
      }
      if(is_fg_type_match(type1, a.fgs(ii))){
        if(a.fgs(ii).interactions().value()==0){
          range=0.0; // skip
          continue;
        }
        k*=a.fgs(ii).interaction_k_factor().value();
        range*=a.fgs(ii).interaction_range_factor().value();
        R1=a.fgs(ii).radius().value();
        is_found1= true;
      }
    }
    if(!is_found0 || !is_found1){
      IMP_LOG(TERSE, "get_time_step() - ignoring interaction "
                << type0 << "-" << type1
                << " since no particles of one these types are defined"
                << std::endl);
      continue;
    }
    // compute skewed range if needed
    bool is_orientational=false;
    if(a.interactions(i).has_range_sigma0_deg() &&
       a.interactions(i).has_range_sigma1_deg()) {
      if(a.interactions(i).range_sigma0_deg().value()!=0.0 &&
         a.interactions(i).range_sigma1_deg().value()!=0.0) {
        is_orientational=true;
      }
    }
    if(is_orientational && range > 0.0 && is_found0 && is_found1){
      IMP_USAGE_CHECK(R0>0.0 && R1>0.0,
                      "R0 or R1 could not be found for type " << type0
                      << " or type " << type1 << std::endl);
      k*=0.5*range; // the maximal force for this interction
      const double pi = 3.1415926535897;
      double range_sigma0_rad=a.interactions(i).range_sigma0_deg().value()*pi/180.0;
      double range_sigma1_rad=a.interactions(i).range_sigma1_deg().value()*pi/180.0;
      double chord0=2*R0*std::sin(range_sigma0_rad/2.0);
      double chord1=2*R1*std::sin(range_sigma1_rad/2.0);
      double min_chord=std::min(chord0,chord1);
      range=std::min(range, min_chord);
    } // if is_orientation
    if(range>0.0 && k>0.0) {
      max_k=std::max(max_k, k);
      min_range=std::min(min_range, range);
    }
  } // for interactions(i)

  IMP_LOG(VERBOSE, "get_time_step(): "
            << " max_d_factor " << max_d_factor
            << " max-k " << max_k
            << " min-range " << min_range
            << " max-trans-relative-to-R " << max_trans_relative_to_radius
            << " time-step-factor " << time_step_factor
            << std::endl);
  double dT_fs= get_time_step(max_d_factor, max_k, min_radius, min_range,
                              max_trans_relative_to_radius, time_step_factor);
  IMP_LOG(VERBOSE, "dT = " << dT_fs << " [fs]" << std::endl);
  return dT_fs;

}
Ejemplo n.º 9
0
double get_time_step(const ::npctransport_proto::Assignment& config,
                     double max_trans_relative_to_radius) {
  double time_step_factor= config.time_step_factor().value();
  double max_d_factor=1;
  double min_radius=std::numeric_limits<double>::max();
  double max_k=0;
  UPDATE_MAX(k, config.interaction_k);
  UPDATE_MAX(k, config.backbone_k); // TODO: is this valid for harmonic k?
  UPDATE_MAX(k, config.nonspecific_k);
  UPDATE_MAX(k, config.excluded_volume_k);
  double max_k_factor=1;
  for ( int i=0; i< config.fgs_size(); ++i) {
    UPDATE_MAX(d_factor, config.fgs(i).d_factor);
    UPDATE_MIN(radius, config.fgs(i).radius);
    UPDATE_MAX(k_factor, config.fgs(i).interaction_k_factor);
  }
  for ( int i=0; i< config.floaters_size(); ++i) {
    UPDATE_MAX(d_factor, config.floaters(i).d_factor);
    UPDATE_MIN(radius, config.floaters(i).radius);
    UPDATE_MAX(k_factor, config.floaters(i).interaction_k_factor);
  }
  for ( int i=0; i< config.interactions_size(); ++i) {
    if (config.interactions(i).has_interaction_k()) {
      UPDATE_MAX(k_factor, config.interactions(i).interaction_k);
    }
  }

  return get_time_step(max_d_factor,
                       max_k*max_k_factor,
                       min_radius,
                       max_trans_relative_to_radius,
                       time_step_factor);
}