bauer/WHAM
1
0
Fork 0
mirror of https://github.com/dnlbauer/WHAM.git synced 2026-09-10 22:25:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Multithreading

Browse Source
This commit is contained in:
Daniel Bauer
2018-11-18 12:04:27 +01:00
parent 56b6cb247a
commit 6ed0e4c49c
6 changed files with 165 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/histogram.rs
View File

@@ -1,5 +1,4 @@
use std::fmt;
use std::cell::RefCell;
// One histogram
#[derive(Debug,Clone)]
@@ -54,7 +53,7 @@ pub struct Dataset {
bias_fc: Vec<f64>,
// bias value cache
bias: RefCell<Vec<Option<f64>>>,
bias: Vec<f64>,
// histogram weight
pub weights: Vec<f64>,
@@ -64,9 +63,9 @@ impl Dataset {
pub fn new(num_bins: usize, dimens_lengths: Vec<usize>, bin_width: Vec<f64>, hist_min: Vec<f64>, hist_max: Vec<f64>, bias_pos: Vec<f64>, bias_fc: Vec<f64>, kT: f64, histograms: Vec<Histogram>, cyclic: bool) -> Dataset {
let num_windows = histograms.len();
let bias: RefCell<Vec<Option<f64>>> = RefCell::new(vec![None; num_bins*num_windows]);
let bias: Vec<f64> = vec![0.0; num_bins*num_windows];
let weights = vec![1.0; num_windows];
Dataset{
let mut ds = Dataset{
num_windows,
num_bins,
dimens_lengths,
@@ -80,7 +79,15 @@ impl Dataset {
bias_fc,
bias,
weights
};
for window in 0..num_windows {
for bin in 0..num_bins {
let ndx = window * num_bins + bin;
ds.bias[ndx] = ds.calc_bias(bin, window);
}
}
ds
}
pub fn new_weighted(ds: Dataset, weights: Vec<f64>) -> Dataset {
@@ -113,45 +120,40 @@ impl Dataset {
}).collect()
}
pub fn get_bias(&self, bin: usize, window: usize) -> f64 {
let ndx = window * self.num_bins + bin;
self.bias[ndx]
}
// Harmonic bias calculation: bias = 0.5*k(dx)^2
// if cyclic is true, lowest and highest bins are assumed to be
// neighbors. This returns exp(U/kT) instead of U for better performance.
pub fn calc_bias(&self, bin: usize, window: usize) -> f64 {
let ndx = window * self.num_bins + bin;
let mut cache = self.bias.borrow_mut();
match cache[ndx] {
Some(val) => val,
None => {
let dimens = self.dimens_lengths.len();
fn calc_bias(&self, bin: usize, window: usize) -> f64 {
let dimens = self.dimens_lengths.len();
// index of the bias value depends on the window und dimension
let bias_ndx: Vec<usize> = (0..dimens)
.map(|dimen| { window * dimens + dimen }).collect();
// index of the bias value depends on the window und dimension
let bias_ndx: Vec<usize> = (0..dimens)
.map(|dimen| { window * dimens + dimen }).collect();
// find the N coords, force constants and bias coords
let coord = self.get_coords_for_bin(bin);
let bias_fc: Vec<f64> = bias_ndx.iter().map(|ndx| { self.bias_fc[*ndx] }).collect();
let bias_pos: Vec<f64> = bias_ndx.iter().map(|ndx| { self.bias_pos[*ndx] }).collect();
// find the N coords, force constants and bias coords
let coord = self.get_coords_for_bin(bin);
let bias_fc: Vec<f64> = bias_ndx.iter().map(|ndx| { self.bias_fc[*ndx] }).collect();
let bias_pos: Vec<f64> = bias_ndx.iter().map(|ndx| { self.bias_pos[*ndx] }).collect();
let mut bias_sum = 0.0;
for i in 0..dimens {
let mut dist = (coord[i] - bias_pos[i]).abs();
if self.cyclic { // periodic conditions
let hist_len = self.hist_max[i] - self.hist_min[i];
if dist > 0.5 * hist_len {
dist -= hist_len;
}
}
// store exp(U/kT) for better performance
bias_sum += 0.5 * bias_fc[i] * dist * dist
let mut bias_sum = 0.0;
for i in 0..dimens {
let mut dist = (coord[i] - bias_pos[i]).abs();
if self.cyclic { // periodic conditions
let hist_len = self.hist_max[i] - self.hist_min[i];
if dist > 0.5 * hist_len {
dist -= hist_len;
}
let bias_sum = (-bias_sum/self.kT).exp();
cache[ndx] = Some(bias_sum);
bias_sum
}
// store exp(U/kT) for better performance
bias_sum += 0.5 * bias_fc[i] * dist * dist
}
let bias_sum = (-bias_sum/self.kT).exp();
bias_sum
}
}
impl fmt::Display for Dataset {
@@ -247,11 +249,11 @@ mod tests {
let ds = Dataset::new(
5, // num bins
vec![1],
vec![1.0], // bin width
vec![0.0], // hist min
vec![9.0], // hist max
vec![7.5], // x0
vec![10.0], // fc
vec![1.0, 1.0], // bin width
vec![0.0, 0.0], // hist min
vec![5.0, 5.0], // hist max
vec![7.5, 7.5], // x0
vec![10.0, 10.0], // fc
300.0*k_B, // kT
vec![build_hist(), build_hist()], // hists
false // cyclic

24
src/lib.rs
View File

@@ -4,6 +4,7 @@
extern crate error_chain;
extern crate rand;
extern crate rgsl;
extern crate rayon;
pub mod io;
pub mod histogram;
@@ -13,6 +14,7 @@ use histogram::Dataset;
use std::f64;
use std::fmt;
use std::io::prelude::*;
use rayon::prelude::*;
// init error chain
pub mod errors { error_chain!{} }
@@ -57,10 +59,10 @@ fn is_converged(old_F: &[f64], new_F: &[f64], tolerance: f64) -> bool {
// estimate the probability of a bin of the histogram set based on given bias offsets (F)
// This evaluates the first WHAM equation for each bin.
fn calc_bin_probability(bin: usize, dataset: &Dataset, F: &[f64]) -> f64 {
let mut denom_sum: f64 = 0.0;
let mut denom_sum: f64 = 0.0;
let bin_count: f64 = dataset.get_weighted_bin_count(bin);
for (window, h) in dataset.histograms.iter().enumerate() {
let bias = dataset.calc_bias(bin, window);
let bias = dataset.get_bias(bin, window);
denom_sum += (dataset.weights[window] * h.num_points as f64) * bias * F[window];
}
bin_count / denom_sum
@@ -71,7 +73,7 @@ fn calc_bin_probability(bin: usize, dataset: &Dataset, F: &[f64]) -> f64 {
fn calc_window_F(window: usize, dataset: &Dataset, P: &[f64]) -> f64 {
let f: f64 = (0..dataset.num_bins).zip(P.iter()) // zip bins and P
.map(|bin_and_prob: (usize, &f64)| {
let bias = dataset.calc_bias(bin_and_prob.0, window);
let bias = dataset.get_bias(bin_and_prob.0, window);
bin_and_prob.1 * bias
}).sum();
1.0/f
@@ -80,18 +82,18 @@ fn calc_window_F(window: usize, dataset: &Dataset, P: &[f64]) -> f64 {
// One full WHAM iteration includes calculation of new probabilities P and
// new bias offsets F based on previous bias offsets F_prev. This updates
// the values in vectors F and P
fn perform_wham_iteration(dataset: &Dataset, F_prev: &[f64], F: &mut [f64], P: &mut [f64]) {
fn perform_wham_iteration(dataset: &Dataset, F_prev: &[f64], F: &mut Vec<f64>, P: &mut Vec<f64>) {
// evaluate first WHAM equation for each bin to
// estimage probabilities based on previous offsets (F_prev)
for bin in 0..dataset.num_bins {
P[bin] = calc_bin_probability(bin, dataset, F_prev);
}
// estimage probabilities based on previous offsets (F_prev))
(0..dataset.num_bins).into_par_iter()
.map(|bin| { calc_bin_probability(bin, dataset, F_prev) })
.collect_into_vec(P);
// evaluate second WHAM equation for each window to
// estimate new bias offsets from propabilities
for window in 0..dataset.num_windows {
F[window] = calc_window_F(window, dataset, P);
}
(0..dataset.num_windows).into_par_iter()
.map(|window| {calc_window_F(window, dataset, P)} )
.collect_into_vec(F);
}
pub fn perform_wham(cfg: &Config, dataset: &Dataset) -> Result<(Vec<f64>, Vec<f64>, Vec<f64>)> {