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;
}
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);
}
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;
}
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;
}
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;
}
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;
}
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);
}
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;
}
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);
}
