Struct DFTD3Param 

pub struct DFTD3Param { /* private fields */ }

Basic struct for damping parameters, representing a parametrization of a DFT-D3 method.

The damping parameters contained in the object are immutable. To change the parametrization, a new object must be created. Furthermore, the object is opaque to the user and the contained data cannot be accessed directly.

Note

This struct is better not be initialized by user. Structs that implements DFTD3ParamAPI should be used for parameter initialization.

This struct is considered as a low-level parameter interface. This object does not have its official python wrapper correspondent. So use this struct with caution.

Official python wrapper provides (not exactly) abstract class DampingParam, which corresponds DFTD3ParamAPI in this project.

Implementations

impl DFTD3Param

pub fn new_zero_damping_f( s6: f64, s8: f64, s9: f64, rs6: f64, rs8: f64, alp: f64, ) -> Result<Self, DFTD3Error>

Create new zero damping parameters (failable)

pub fn new_zero_damping( s6: f64, s8: f64, s9: f64, rs6: f64, rs8: f64, alp: f64, ) -> Self

Create new zero damping parameters

Examples found in repository

examples/energy_r2scan_d3zero.rs (lines 66-73)

fn main_test() {
    // atom indices
    let numbers = vec![6, 6, 6, 6, 6, 6, 53, 1, 1, 1, 1, 1, 16, 1, 6, 1, 1, 1];
    // geometry in angstrom
    #[rustfmt::skip]
    let positions = vec![
        -0.755422531,  -0.796459123,  -1.023590391,
         0.634274834,  -0.880017014,  -1.075233285,
         1.406955202,   0.199695367,  -0.653144334,
         0.798863737,   1.361204515,  -0.180597909,
        -0.593166787,   1.434312023,  -0.133597923,
        -1.376239198,   0.359205222,  -0.553258516,
        -1.514344238,   3.173268101,   0.573601106,
         1.110906949,  -1.778801728,  -1.440619836,
         1.399172302,   2.197767355,   0.147412751,
         2.486417780,   0.142466525,  -0.689380574,
        -2.454252250,   0.422581120,  -0.512807958,
        -1.362353593,  -1.630564523,  -1.348743149,
        -3.112683203,   6.289227834,   1.226984439,
        -4.328789697,   5.797771251,   0.973373089,
        -2.689135032,   6.703163830,  -0.489062886,
        -1.684433029,   7.115457372,  -0.460265708,
        -2.683867206,   5.816530502,  -1.115183775,
        -3.365330613,   7.451201412,  -0.890098894,
    ];
    // convert angstrom to bohr
    let positions = positions.iter().map(|&x| x / 0.52917721067).collect::<Vec<f64>>();
    // generate DFTD3 model
    let model = DFTD3Model::new(&numbers, &positions, None, None);
    // explicitly set DFTD3 parameters
    for atm in [true, false] {
        let energy_ref = if atm { -0.01410721853585842 } else { -0.014100267345314462 };

        let param = DFTD3ZeroDampingParamBuilder::default()
            .s8(1.683)
            .rs6(1.139)
            .s9(if atm { 1.0 } else { 0.0 })
            .init();
        // obtain the dispersion energy without gradient and sigma
        let (energy, _, _) = model.get_dispersion(&param, false).into();

        println!("Dispersion energy: {}", energy);
        assert!((energy - energy_ref).abs() < 1e-9);

        // this way to provide custom damping parameter is also valid
        let param = DFTD3ZeroDampingParam {
            s6: 1.0,
            s8: 1.683,
            rs6: 1.139,
            rs8: 1.0,
            alp: 14.0,
            s9: if atm { 1.0 } else { 0.0 },
        };
        let param = param.new_param();
        // obtain the dispersion energy without gradient and sigma
        let (energy, _, _) = model.get_dispersion(&param, false).into();

        println!("Dispersion energy: {}", energy);
        assert!((energy - energy_ref).abs() < 1e-9);

        // this way to provide custom damping parameter is also valid
        let param = DFTD3Param::new_zero_damping(
            1.0,                         // s6
            1.683,                       // s8
            if atm { 1.0 } else { 0.0 }, // s9
            1.139,                       // rs6
            1.0,                         // rs8
            14.0,                        // alp
        );
        // obtain the dispersion energy without gradient and sigma
        let (energy, _, _) = model.get_dispersion(&param, false).into();

        println!("Dispersion energy: {}", energy);
        assert!((energy - energy_ref).abs() < 1e-9);
    }
}

pub fn load_zero_damping_f(method: &str, atm: bool) -> Result<Self, DFTD3Error>

Load zero damping parameters from internal storage (failable)

pub fn load_zero_damping(method: &str, atm: bool) -> Self

Load zero damping parameters from internal storage

pub fn new_rational_damping_f( s6: f64, s8: f64, s9: f64, a1: f64, a2: f64, alp: f64, ) -> Result<Self, DFTD3Error>

Create new rational damping parameters (failable)

pub fn new_rational_damping( s6: f64, s8: f64, s9: f64, a1: f64, a2: f64, alp: f64, ) -> Self

Create new rational damping parameters

pub fn load_rational_damping_f( method: &str, atm: bool, ) -> Result<Self, DFTD3Error>

Load rational damping parameters from internal storage (failable)

pub fn load_rational_damping(method: &str, atm: bool) -> Self

Load rational damping parameters from internal storage

pub fn new_mzero_damping_f( s6: f64, s8: f64, s9: f64, rs6: f64, rs8: f64, alp: f64, bet: f64, ) -> Result<Self, DFTD3Error>

Create new modified zero damping parameters (failable)

pub fn new_mzero_damping( s6: f64, s8: f64, s9: f64, rs6: f64, rs8: f64, alp: f64, bet: f64, ) -> Self

Create new modified zero damping parameters

pub fn load_mzero_damping_f(method: &str, atm: bool) -> Result<Self, DFTD3Error>

Load modified zero damping parameters from internal storage (failable)

pub fn load_mzero_damping(method: &str, atm: bool) -> Self

Load modified zero damping parameters from internal storage

pub fn new_mrational_damping_f( s6: f64, s8: f64, s9: f64, a1: f64, a2: f64, alp: f64, ) -> Result<Self, DFTD3Error>

Create new modified rational damping parameters (failable)

pub fn new_mrational_damping( s6: f64, s8: f64, s9: f64, a1: f64, a2: f64, alp: f64, ) -> Self

Create new modified rational damping parameters

pub fn load_mrational_damping_f( method: &str, atm: bool, ) -> Result<Self, DFTD3Error>

Load modified rational damping parameters from internal storage (failable)

pub fn load_mrational_damping(method: &str, atm: bool) -> Self

Load modified rational damping parameters from internal storage

pub fn new_optimizedpower_damping_f( s6: f64, s8: f64, s9: f64, a1: f64, a2: f64, alp: f64, bet: f64, ) -> Result<Self, DFTD3Error>

Create new optimized damping parameters (failable)

pub fn new_optimizedpower_damping( s6: f64, s8: f64, s9: f64, a1: f64, a2: f64, alp: f64, bet: f64, ) -> Self

Create new optimized damping parameters

pub fn load_optimizedpower_damping_f( method: &str, atm: bool, ) -> Result<Self, DFTD3Error>

Load optimized damping parameters from internal storage (failable)

pub fn load_optimizedpower_damping(method: &str, atm: bool) -> Self

Load optimized damping parameters from internal storage

pub fn new_cso_damping_f( s6: f64, s9: f64, a1: f64, a2: f64, a3: f64, a4: f64, alp: f64, ) -> Result<Self, DFTD3Error>

Create new CSO damping parameters (failable)

pub fn new_cso_damping( s6: f64, s9: f64, a1: f64, a2: f64, a3: f64, a4: f64, alp: f64, ) -> Self

Create new CSO damping parameters

pub fn load_cso_damping_f(method: &str, atm: bool) -> Result<Self, DFTD3Error>

Load CSO damping parameters from internal storage (failable)

pub fn load_cso_damping(method: &str, atm: bool) -> Self

Load CSO damping parameters from internal storage

Trait Implementations

impl Drop for DFTD3Param

fn drop(&mut self)

Executes the destructor for this type.