From e5243563d70066e021b48897d03463dd35b803c7 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Mon, 21 Mar 2022 18:49:44 +0100 Subject: [PATCH 01/15] Started implementation of enum for equation of state object --- Cargo.lock | 391 ++++------------------------ Cargo.toml | 12 +- examples/pcsaft_phase_diagram.ipynb | 4 +- examples/user_defined_eos.ipynb | 4 +- src/eos.rs | 200 ++++++++++++++ src/lib.rs | 32 +-- src/pcsaft.rs | 19 ++ 7 files changed, 287 insertions(+), 375 deletions(-) create mode 100644 src/eos.rs create mode 100644 src/pcsaft.rs diff --git a/Cargo.lock b/Cargo.lock index 081872f43..724ab929d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -13,20 +13,14 @@ dependencies = [ [[package]] name = "ang" -version = "0.5.0" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47a1c6e70361eb28c1d29ef6b84f9fd024670627b087c1974abe739547679b06" +checksum = "b2f3bc27814924dc962d2ddaa50922a3f4765f1d5ad3249a44adfa92ba49c9ea" dependencies = [ "approx 0.5.1", "num-traits", ] -[[package]] -name = "anyhow" -version = "1.0.55" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "159bb86af3a200e19a068f4224eae4c8bb2d0fa054c7e5d1cacd5cef95e684cd" - [[package]] name = "approx" version = "0.4.0" @@ -45,47 +39,12 @@ dependencies = [ "num-traits", ] -[[package]] -name = "argmin" -version = "0.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fc077a0240b05e5df4e658e4ad8a3d42b856e3136d4a05ac8330e0a9170d39e" -dependencies = [ - "anyhow", - "approx 0.5.1", - "bincode", - "instant", - "num", - "num-complex 0.4.0", - "paste 1.0.6", - "rand", - "rand_xorshift", - "serde", - "serde_json", - "slog", - "slog-async", - "slog-json", - "slog-term", - "thiserror", -] - [[package]] name = "assert_float_eq" version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4cea652ffbedecf29e9cd41bb4c066881057a42c0c119040f022802b26853e77" -[[package]] -name = "atty" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" -dependencies = [ - "hermit-abi", - "libc", - "winapi", -] - [[package]] name = "autocfg" version = "1.1.0" @@ -107,12 +66,6 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" -[[package]] -name = "cfg-if" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" - [[package]] name = "cfg-if" version = "1.0.0" @@ -125,7 +78,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "crossbeam-utils", ] @@ -135,7 +88,7 @@ version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "crossbeam-epoch", "crossbeam-utils", ] @@ -146,7 +99,7 @@ version = "0.9.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c00d6d2ea26e8b151d99093005cb442fb9a37aeaca582a03ec70946f49ab5ed9" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "crossbeam-utils", "lazy_static", "memoffset", @@ -159,7 +112,7 @@ version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "lazy_static", ] @@ -173,27 +126,6 @@ dependencies = [ "syn", ] -[[package]] -name = "dirs-next" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" -dependencies = [ - "cfg-if 1.0.0", - "dirs-sys-next", -] - -[[package]] -name = "dirs-sys-next" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" -dependencies = [ - "libc", - "redox_users", - "winapi", -] - [[package]] name = "either" version = "1.6.1" @@ -202,11 +134,13 @@ checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" [[package]] name = "feos" -version = "0.1.0" +version = "0.1.1" dependencies = [ "feos-core", "feos-dft", "feos-pcsaft", + "ndarray", + "numpy", "pyo3", "quantity", ] @@ -214,11 +148,9 @@ dependencies = [ [[package]] name = "feos-core" version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4d8ed0e9a4b62b8fa3b00b05d4ea48d2b7b4ecd3b94c5068a3c8ba16e7db38e" +source = "git+https://github.com/feos-org/feos-core#2d4bee11b295164ca2842c6ea00bc87ea866f955" dependencies = [ "approx 0.4.0", - "argmin", "either", "indexmap", "ndarray", @@ -235,14 +167,12 @@ dependencies = [ [[package]] name = "feos-dft" version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ccd23aac81c48193db0cd43f3def308b9fc1e3e689544f5fc572ab4b6d556689" +source = "git+https://github.com/feos-org/feos-dft?branch=v0.2.0#ab341c8cf526c98de0bd95f4028d8ff1453b2ed3" dependencies = [ "ang", "feos-core", "gauss-quad", "libc", - "log", "ndarray", "ndarray-stats", "num-dual", @@ -258,15 +188,13 @@ dependencies = [ [[package]] name = "feos-pcsaft" version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "216e30f84822a190ad8ae7f337eb41de8c492ae1d011f1dd278d3f94f54d850e" +source = "git+https://github.com/feos-org/feos-pcsaft#0c90a9438fa4be89d09e360d909b07623b3a0de7" dependencies = [ "feos-core", "feos-dft", "indexmap", "lazy_static", "ndarray", - "num", "num-dual", "num-traits", "numpy", @@ -274,7 +202,6 @@ dependencies = [ "quantity", "serde", "serde_json", - "thiserror", ] [[package]] @@ -300,7 +227,7 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "libc", "wasi", ] @@ -343,24 +270,10 @@ dependencies = [ [[package]] name = "indoc" -version = "0.3.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47741a8bc60fb26eb8d6e0238bbb26d8575ff623fdc97b1a2c00c050b9684ed8" -dependencies = [ - "indoc-impl", - "proc-macro-hack", -] - -[[package]] -name = "indoc-impl" -version = "0.3.6" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce046d161f000fffde5f432a0d034d0341dc152643b2598ed5bfce44c4f3a8f0" +checksum = "e7906a9fababaeacb774f72410e497a1d18de916322e33797bb2cd29baa23c9e" dependencies = [ - "proc-macro-hack", - "proc-macro2", - "quote", - "syn", "unindent", ] @@ -370,29 +283,17 @@ version = "0.1.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", ] [[package]] name = "inventory" -version = "0.1.11" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0eb5160c60ba1e809707918ee329adb99d222888155835c6feedba19f6c3fd4" +checksum = "ce6b5d8c669bfbad811d95ddd7a1c6cf9cfdbf2777e59928b6f3fa8ff54f72a0" dependencies = [ "ctor", "ghost", - "inventory-impl", -] - -[[package]] -name = "inventory-impl" -version = "0.1.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e41b53715c6f0c4be49510bb82dee2c1e51c8586d885abe65396e82ed518548" -dependencies = [ - "proc-macro2", - "quote", - "syn", ] [[package]] @@ -437,15 +338,6 @@ dependencies = [ "scopeguard", ] -[[package]] -name = "log" -version = "0.4.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710" -dependencies = [ - "cfg-if 1.0.0", -] - [[package]] name = "matrixmultiply" version = "0.3.2" @@ -479,7 +371,7 @@ dependencies = [ "approx 0.4.0", "matrixmultiply", "num-complex 0.3.1", - "num-rational 0.3.2", + "num-rational", "num-traits", "rand", "rand_distr", @@ -527,31 +419,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "num" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606" -dependencies = [ - "num-bigint", - "num-complex 0.4.0", - "num-integer", - "num-iter", - "num-rational 0.4.0", - "num-traits", -] - -[[package]] -name = "num-bigint" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f" -dependencies = [ - "autocfg", - "num-integer", - "num-traits", -] - [[package]] name = "num-complex" version = "0.3.1" @@ -572,9 +439,9 @@ dependencies = [ [[package]] name = "num-dual" -version = "0.4.1" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa84ea3793263de40ee1c90e005fd4e986307588888349d008a6d8f3031a5a98" +checksum = "94e9754dd55a17ac8f047ff0817339956aafa5e7c4e0469866273ab464749956" dependencies = [ "ndarray", "num-traits", @@ -591,17 +458,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "num-iter" -version = "0.1.42" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59" -dependencies = [ - "autocfg", - "num-integer", - "num-traits", -] - [[package]] name = "num-rational" version = "0.3.2" @@ -613,18 +469,6 @@ dependencies = [ "num-traits", ] -[[package]] -name = "num-rational" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a" -dependencies = [ - "autocfg", - "num-bigint", - "num-integer", - "num-traits", -] - [[package]] name = "num-traits" version = "0.2.14" @@ -645,22 +489,12 @@ dependencies = [ "libc", ] -[[package]] -name = "num_threads" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97ba99ba6393e2c3734791401b66902d981cb03bf190af674ca69949b6d5fb15" -dependencies = [ - "libc", -] - [[package]] name = "numpy" -version = "0.15.1" +version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f3a190dd1aa88ee0de91e59e970d5b85cfa079a9ff6531b69f811ccd0c2a6e1" +checksum = "383ae168529a39fc97cbc1d9d4fa865377731a519bc27553ed96f50594de7c45" dependencies = [ - "cfg-if 0.1.10", "libc", "ndarray", "num-complex 0.4.0", @@ -691,7 +525,7 @@ version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "instant", "libc", "redox_syscall", @@ -699,31 +533,12 @@ dependencies = [ "winapi", ] -[[package]] -name = "paste" -version = "0.1.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45ca20c77d80be666aef2b45486da86238fabe33e38306bd3118fe4af33fa880" -dependencies = [ - "paste-impl", - "proc-macro-hack", -] - [[package]] name = "paste" version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0744126afe1a6dd7f394cb50a716dbe086cb06e255e53d8d0185d82828358fb5" -[[package]] -name = "paste-impl" -version = "0.1.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d95a7db200b97ef370c8e6de0088252f7e0dfff7d047a28528e47456c0fc98b6" -dependencies = [ - "proc-macro-hack", -] - [[package]] name = "petgraph" version = "0.6.0" @@ -749,12 +564,6 @@ dependencies = [ "num-integer", ] -[[package]] -name = "proc-macro-hack" -version = "0.5.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" - [[package]] name = "proc-macro2" version = "1.0.36" @@ -766,36 +575,47 @@ dependencies = [ [[package]] name = "pyo3" -version = "0.15.1" +version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cf01dbf1c05af0a14c7779ed6f3aa9deac9c3419606ac9de537a2d649005720" +checksum = "a378727d5fdcaafd15b5afe9842cff1c25fdc43f62a162ffda2263c57ad98703" dependencies = [ - "cfg-if 1.0.0", + "cfg-if", "indoc", "inventory", "libc", "parking_lot", - "paste 0.1.18", "pyo3-build-config", + "pyo3-ffi", "pyo3-macros", "unindent", ] [[package]] name = "pyo3-build-config" -version = "0.15.1" +version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbf9e4d128bfbddc898ad3409900080d8d5095c379632fbbfbb9c8cfb1fb852b" +checksum = "4fbb27a3e96edd34c13d97d0feefccc90a79270c577c66e19d95af8323823dfc" dependencies = [ "once_cell", ] +[[package]] +name = "pyo3-ffi" +version = "0.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b719fff844bcf3f911132112ec06527eb195f6a98e0c42cf97e1118929fd4ea" +dependencies = [ + "libc", + "pyo3-build-config", +] + [[package]] name = "pyo3-macros" -version = "0.15.1" +version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67701eb32b1f9a9722b4bc54b548ff9d7ebfded011c12daece7b9063be1fd755" +checksum = "f795e52d3320abb349ca28b501a7112154a87f353fae1c811deecd58e99cfa9b" dependencies = [ + "proc-macro2", "pyo3-macros-backend", "quote", "syn", @@ -803,9 +623,9 @@ dependencies = [ [[package]] name = "pyo3-macros-backend" -version = "0.15.1" +version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f44f09e825ee49a105f2c7b23ebee50886a9aee0746f4dd5a704138a64b0218a" +checksum = "39e03aa57a3bb7b96982958088df38302a139df4eef54671bc595f26556cb75b" dependencies = [ "proc-macro2", "pyo3-build-config", @@ -815,9 +635,9 @@ dependencies = [ [[package]] name = "quantity" -version = "0.4.1" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b15db13204846e85161d1d29198d2bc31364351142a7fca3f408c6b373d5616d" +checksum = "59a60bb21406ddb4ad64794c13aecd1c23069ca4418a1460286829a1656a5e84" dependencies = [ "ang", "approx 0.4.0", @@ -849,7 +669,6 @@ dependencies = [ "libc", "rand_chacha", "rand_core", - "serde", ] [[package]] @@ -869,7 +688,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7" dependencies = [ "getrandom", - "serde", ] [[package]] @@ -882,16 +700,6 @@ dependencies = [ "rand", ] -[[package]] -name = "rand_xorshift" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f" -dependencies = [ - "rand_core", - "serde", -] - [[package]] name = "rawpointer" version = "0.2.1" @@ -932,16 +740,6 @@ dependencies = [ "bitflags", ] -[[package]] -name = "redox_users" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64" -dependencies = [ - "getrandom", - "redox_syscall", -] - [[package]] name = "regex" version = "1.5.4" @@ -982,12 +780,6 @@ dependencies = [ "transpose", ] -[[package]] -name = "rustversion" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f" - [[package]] name = "ryu" version = "1.0.9" @@ -1040,50 +832,7 @@ dependencies = [ "approx 0.4.0", "num-complex 0.3.1", "num-traits", - "paste 1.0.6", -] - -[[package]] -name = "slog" -version = "2.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06" - -[[package]] -name = "slog-async" -version = "2.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "766c59b252e62a34651412870ff55d8c4e6d04df19b43eecb2703e417b097ffe" -dependencies = [ - "crossbeam-channel", - "slog", - "take_mut", - "thread_local", -] - -[[package]] -name = "slog-json" -version = "2.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70f825ce7346f40aa318111df5d3a94945a7fdca9081584cb9b05692fb3dfcb4" -dependencies = [ - "serde", - "serde_json", - "slog", - "time", -] - -[[package]] -name = "slog-term" -version = "2.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87d29185c55b7b258b4f120eab00f48557d4d9bc814f41713f449d35b0f8977c" -dependencies = [ - "atty", - "slog", - "term", - "thread_local", - "time", + "paste", ] [[package]] @@ -1122,23 +871,6 @@ dependencies = [ "unicode-xid", ] -[[package]] -name = "take_mut" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60" - -[[package]] -name = "term" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f" -dependencies = [ - "dirs-next", - "rustversion", - "winapi", -] - [[package]] name = "thiserror" version = "1.0.30" @@ -1159,33 +891,6 @@ dependencies = [ "syn", ] -[[package]] -name = "thread_local" -version = "1.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180" -dependencies = [ - "once_cell", -] - -[[package]] -name = "time" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "004cbc98f30fa233c61a38bc77e96a9106e65c88f2d3bef182ae952027e5753d" -dependencies = [ - "itoa", - "libc", - "num_threads", - "time-macros", -] - -[[package]] -name = "time-macros" -version = "0.2.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25eb0ca3468fc0acc11828786797f6ef9aa1555e4a211a60d64cc8e4d1be47d6" - [[package]] name = "transpose" version = "0.2.1" diff --git a/Cargo.toml b/Cargo.toml index d68f32baa..7873cde08 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,11 +16,13 @@ categories = ["science"] crate-type = ["cdylib"] [dependencies] -quantity = { version = "0.4", features = ["python"] } -feos-core = { version = "0.1", features = ["python"] } -feos-dft = { version = "0.1", features = ["python"] } -feos-pcsaft = { version = "0.1", features = ["python"] } +quantity = { version = "0.5", features = ["python"] } +feos-core = { git = "https://github.com/feos-org/feos-core", features = ["python"] } +feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "v0.2.0" } +feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"] } +numpy = { version = "0.16" } +ndarray = { version = "0.15", features=["approx"] } [dependencies.pyo3] -version = "0.15" +version = "0.16" features = ["extension-module", "abi3", "abi3-py37"] diff --git a/examples/pcsaft_phase_diagram.ipynb b/examples/pcsaft_phase_diagram.ipynb index 4672b0679..589c8db08 100644 --- a/examples/pcsaft_phase_diagram.ipynb +++ b/examples/pcsaft_phase_diagram.ipynb @@ -476,7 +476,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -490,7 +490,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.1" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/examples/user_defined_eos.ipynb b/examples/user_defined_eos.ipynb index e2276d7bd..850bfab4f 100644 --- a/examples/user_defined_eos.ipynb +++ b/examples/user_defined_eos.ipynb @@ -1474,7 +1474,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1488,7 +1488,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.1" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/src/eos.rs b/src/eos.rs new file mode 100644 index 000000000..5853ad18a --- /dev/null +++ b/src/eos.rs @@ -0,0 +1,200 @@ +use feos_core::cubic::PengRobinson; +// use feos_core::{ +// impl_equation_of_state, impl_estimator, impl_state, impl_state_entropy_scaling, +// impl_state_molarweight, impl_virial_coefficients, impl_vle_state, +// }; +// use feos_core::{DensityInitialization, State}; +// use feos_core::{EquationOfState, HelmholtzEnergy}; +use feos_core::python::cubic::PyPengRobinsonParameters; +use feos_core::python::user_defined::PyEoSObj; +use feos_core::*; +use feos_pcsaft::python::PyPcSaftParameters; +use feos_pcsaft::{PcSaft, PcSaftOptions}; +use ndarray::Array1; +use numpy::convert::ToPyArray; +use numpy::{PyArray1, PyArray2}; +use pyo3::exceptions::PyValueError; +use pyo3::prelude::*; +use quantity::python::*; +use quantity::si::*; +use std::collections::HashMap; +use std::rc::Rc; + +pub enum Eos { + PcSaft(PcSaft), + PengRobinson(PengRobinson), + Python(PyEoSObj), +} + +impl EquationOfState for Eos { + fn components(&self) -> usize { + match self { + Eos::PcSaft(eos) => eos.components(), + Eos::PengRobinson(eos) => eos.components(), + Eos::Python(eos) => eos.components(), + } + } + + fn compute_max_density(&self, moles: &Array1) -> f64 { + match self { + Eos::PcSaft(eos) => eos.compute_max_density(moles), + Eos::PengRobinson(eos) => eos.compute_max_density(moles), + Eos::Python(eos) => eos.compute_max_density(moles), + } + } + + fn subset(&self, component_list: &[usize]) -> Self { + match self { + Eos::PcSaft(eos) => Self::PcSaft(eos.subset(component_list)), + Eos::PengRobinson(eos) => Self::PengRobinson(eos.subset(component_list)), + Eos::Python(eos) => Self::Python(eos.subset(component_list)), + } + } + + fn residual(&self) -> &[Box] { + match self { + Eos::PcSaft(eos) => eos.residual(), + Eos::PengRobinson(eos) => eos.residual(), + Eos::Python(eos) => eos.residual(), + } + } +} + +impl MolarWeight for Eos { + fn molar_weight(&self) -> SIArray1 { + match self { + Eos::PcSaft(eos) => eos.molar_weight(), + Eos::PengRobinson(eos) => eos.molar_weight(), + Eos::Python(eos) => eos.molar_weight(), + } + } +} + +impl EntropyScaling for Eos { + fn viscosity_reference( + &self, + temperature: SINumber, + volume: SINumber, + moles: &SIArray1, + ) -> EosResult { + match self { + Eos::PcSaft(eos) => eos.viscosity_reference(temperature, volume, moles), + _ => unimplemented!(), + } + } + + fn viscosity_correlation(&self, s_res: f64, x: &Array1) -> EosResult { + match self { + Eos::PcSaft(eos) => eos.viscosity_correlation(s_res, x), + _ => unimplemented!(), + } + } + + fn diffusion_reference( + &self, + temperature: SINumber, + volume: SINumber, + moles: &SIArray1, + ) -> EosResult { + match self { + Eos::PcSaft(eos) => eos.diffusion_reference(temperature, volume, moles), + _ => unimplemented!(), + } + } + + fn diffusion_correlation(&self, s_res: f64, x: &Array1) -> EosResult { + match self { + Eos::PcSaft(eos) => eos.diffusion_correlation(s_res, x), + _ => unimplemented!(), + } + } + + fn thermal_conductivity_reference( + &self, + temperature: SINumber, + volume: SINumber, + moles: &SIArray1, + ) -> EosResult { + match self { + Eos::PcSaft(eos) => eos.thermal_conductivity_reference(temperature, volume, moles), + _ => unimplemented!(), + } + } + + fn thermal_conductivity_correlation(&self, s_res: f64, x: &Array1) -> EosResult { + match self { + Eos::PcSaft(eos) => eos.thermal_conductivity_correlation(s_res, x), + _ => unimplemented!(), + } + } +} + +#[pyclass(name = "EquationOfState", unsendable)] +#[derive(Clone)] +pub struct PyEos(pub Rc); + +#[pymethods] +impl PyEos { + /// PCP-SAFT equation of state. + #[args( + max_eta = "0.5", + max_iter_cross_assoc = "50", + tol_cross_assoc = "1e-10", + dq_variant = "\"dq35\"" + )] + #[staticmethod] + pub fn pcsaft( + parameters: PyPcSaftParameters, + max_eta: f64, + max_iter_cross_assoc: usize, + tol_cross_assoc: f64, + dq_variant: &str, + ) -> Self { + let options = PcSaftOptions { + max_eta, + max_iter_cross_assoc, + tol_cross_assoc, + dq_variant: dq_variant.into(), + }; + Self(Rc::new(Eos::PcSaft(PcSaft::with_options( + parameters.0.clone(), + options, + )))) + } + + /// Peng-Robinson equation of state. + #[staticmethod] + pub fn peng_robinson(parameters: PyPengRobinsonParameters) -> Self { + Self(Rc::new(Eos::PengRobinson(PengRobinson::new( + parameters.0.clone(), + )))) + } + + /// Generate equation of state from Python class. + #[staticmethod] + fn python(obj: Py) -> PyResult { + Ok(Self(Rc::new(Eos::Python(PyEoSObj::new(obj)?)))) + } +} + +impl_equation_of_state!(PyEos); +impl_virial_coefficients!(PyEos); +impl_state!(Eos, PyEos); +impl_state_molarweight!(Eos, PyEos); +impl_state_entropy_scaling!(Eos, PyEos); +impl_vle_state!(Eos, PyEos); + +#[pymodule] +pub fn eos(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +} diff --git a/src/lib.rs b/src/lib.rs index 1b2250a73..c5419c8da 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,21 +1,16 @@ -use feos_core::python::{PyInit_cubic, PyInit_user_defined}; -use feos_dft::python::PyInit_feos_dft; -use feos_pcsaft::python::PyInit_feos_pcsaft; use pyo3::prelude::*; use pyo3::wrap_pymodule; -use quantity::python::PyInit_quantity; +use quantity::python::__PYO3_PYMODULE_DEF_QUANTITY; +mod eos; +use eos::__PYO3_PYMODULE_DEF_EOS; +mod pcsaft; +use pcsaft::__PYO3_PYMODULE_DEF_PCSAFT; #[pymodule] pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pymodule!(quantity))?; - - m.add_wrapped(wrap_pymodule!(user_defined))?; - m.add_wrapped(wrap_pymodule!(cubic))?; - - m.add_wrapped(wrap_pymodule!(feos_dft))?; - - m.add_wrapped(wrap_pymodule!(feos_pcsaft))?; - + m.add_wrapped(wrap_pymodule!(eos))?; + m.add_wrapped(wrap_pymodule!(pcsaft))?; py.run( "\ import sys @@ -25,17 +20,8 @@ quantity.SIArray2.__module__ = 'feos.si' quantity.SIArray3.__module__ = 'feos.si' quantity.SIArray4.__module__ = 'feos.si' sys.modules['feos.si'] = quantity - -sys.modules['feos.user_defined'] = user_defined -sys.modules['feos.cubic'] = cubic - -sys.modules['feos.fmt'] = feos_dft - -sys.modules['feos.pcsaft'] = feos_pcsaft -sys.modules['feos.pcsaft.eos'] = feos_pcsaft.eos -sys.modules['feos.pcsaft.eos.utils'] = feos_pcsaft.eos.utils -sys.modules['feos.pcsaft.dft'] = feos_pcsaft.dft -sys.modules['feos.pcsaft.dft.utils'] = feos_pcsaft.dft.utils +sys.modules['feos.eos'] = eos +sys.modules['feos.pcsaft'] = pcsaft ", None, Some(m.dict()), diff --git a/src/pcsaft.rs b/src/pcsaft.rs new file mode 100644 index 000000000..e5b728d7e --- /dev/null +++ b/src/pcsaft.rs @@ -0,0 +1,19 @@ +use feos_pcsaft::python::{PyPcSaftParameters, PyPcSaftRecord, PyPureRecord, PySegmentRecord}; +use pyo3::prelude::*; +use feos_core::python::parameter::*; +use feos_core::python::joback::PyJobackRecord; + +#[pymodule] +pub fn pcsaft(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +} \ No newline at end of file From d3e5ced300dc1d78482715657daea533950d9405 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Tue, 22 Mar 2022 10:21:14 +0100 Subject: [PATCH 02/15] Import cleanup --- src/eos.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/eos.rs b/src/eos.rs index 5853ad18a..63728db35 100644 --- a/src/eos.rs +++ b/src/eos.rs @@ -1,10 +1,4 @@ use feos_core::cubic::PengRobinson; -// use feos_core::{ -// impl_equation_of_state, impl_estimator, impl_state, impl_state_entropy_scaling, -// impl_state_molarweight, impl_virial_coefficients, impl_vle_state, -// }; -// use feos_core::{DensityInitialization, State}; -// use feos_core::{EquationOfState, HelmholtzEnergy}; use feos_core::python::cubic::PyPengRobinsonParameters; use feos_core::python::user_defined::PyEoSObj; use feos_core::*; From 36d26dab8dc27d22471d8ba21e99146fa6cec080 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Tue, 22 Mar 2022 17:05:41 +0100 Subject: [PATCH 03/15] Added PeTS equation of state --- Cargo.lock | 20 ++ Cargo.toml | 1 + examples/Pets_eos_binary_caseI.ipynb | 313 +++++++++++++++++++++++++++ src/eos.rs | 50 ++++- src/lib.rs | 4 + src/pets.rs | 17 ++ 6 files changed, 404 insertions(+), 1 deletion(-) create mode 100644 examples/Pets_eos_binary_caseI.ipynb create mode 100644 src/pets.rs diff --git a/Cargo.lock b/Cargo.lock index 724ab929d..f5cc199af 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -139,6 +139,7 @@ dependencies = [ "feos-core", "feos-dft", "feos-pcsaft", + "feos-pets", "ndarray", "numpy", "pyo3", @@ -204,6 +205,25 @@ dependencies = [ "serde_json", ] +[[package]] +name = "feos-pets" +version = "0.1.0" +source = "git+https://github.com/feos-org/feos-pets#82895eea1c20ea3f59a6137bf19ec38ddb04114a" +dependencies = [ + "feos-core", + "feos-dft", + "indexmap", + "lazy_static", + "ndarray", + "num-dual", + "num-traits", + "numpy", + "pyo3", + "quantity", + "serde", + "serde_json", +] + [[package]] name = "fixedbitset" version = "0.4.1" diff --git a/Cargo.toml b/Cargo.toml index 7873cde08..430beb30f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,6 +20,7 @@ quantity = { version = "0.5", features = ["python"] } feos-core = { git = "https://github.com/feos-org/feos-core", features = ["python"] } feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "v0.2.0" } feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"] } +feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"] } numpy = { version = "0.16" } ndarray = { version = "0.15", features=["approx"] } diff --git a/examples/Pets_eos_binary_caseI.ipynb b/examples/Pets_eos_binary_caseI.ipynb new file mode 100644 index 000000000..fee442f34 --- /dev/null +++ b/examples/Pets_eos_binary_caseI.ipynb @@ -0,0 +1,313 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "confident-curtis", + "metadata": {}, + "source": [ + "# PeTS Equation of State - Binary Mixture (Pseudo Pure Fluid)" + ] + }, + { + "cell_type": "markdown", + "id": "duplicate-hydrogen", + "metadata": {}, + "source": [ + "Original publication of the _perturbation theory for truncated and shifted Lennard-Jones fluids_ (PeTS) of M. Heier, S. Stephan, J. Liu, W.G. Chapman, H. Hasse, K. Langenbach, Mol. Phys. **116**, 2083 (2018);\n", + "https://doi.org/10.1080/00268976.2018.1447153" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "distinguished-sessions", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from feos.eos import *\n", + "from feos.si import *\n", + "from feos.pets import PetsParameters\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "significant-antibody", + "metadata": {}, + "source": [ + "## Specifying PeTS Parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dirty-renaissance", + "metadata": {}, + "outputs": [], + "source": [ + "epsilon_k = 1.0 * KELVIN\n", + "sigma = 1.0 * ANGSTROM" + ] + }, + { + "cell_type": "markdown", + "id": "organized-remainder", + "metadata": {}, + "source": [ + "## Definition of Reference Data\n", + "\n", + "The molecular simulation reference data is taken from J. Vrabec, G.K. Kedia, G. Fuchs, H. Hasse, Mol. Phys. **104**, 1509 (2006);\n", + "https://doi.org/10.1080/00268970600556774\n", + "\n", + "Critical point reference data is taken from the original publication of M. Heier, S. Stephan, J. Liu, W.G. Chapman, Mol. Phys. **116**, 2083 (2018);\n", + "https://doi.org/10.1080/00268976.2018.1447153" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "western-classic", + "metadata": {}, + "outputs": [], + "source": [ + "# Dara from Vrabec et al. (2006)\n", + "data = np.array([\n", + " [0.64, 0.00217, 0.8176, 0.00351, 5.7118],\n", + " [0.67, 0.00335, 0.8024, 0.00525, 5.5910],\n", + " [0.70, 0.00479, 0.7866, 0.00727, 5.4666],\n", + " [0.73, 0.00697, 0.7704, 0.01036, 5.325 ],\n", + " [0.76, 0.00944, 0.7538, 0.01374, 5.179 ],\n", + " [0.79, 0.01241, 0.7361, 0.01776, 5.022 ],\n", + " [0.82, 0.01640, 0.7181, 0.0233, 4.844 ],\n", + " [0.85, 0.0214, 0.6986, 0.0303, 4.639 ],\n", + " [0.88, 0.0274, 0.6784, 0.0392, 4.413 ],\n", + " [0.91, 0.0336, 0.6556, 0.0483, 4.172 ],\n", + " [0.94, 0.0417, 0.6309, 0.0616, 3.87 ],\n", + " [0.97, 0.0504, 0.6032, 0.0763, 3.56 ],\n", + " [1.00, 0.0606, 0.5712, 0.0960, 3.18 ],\n", + " [1.03, 0.0730, 0.530, 0.127, 2.63 ],\n", + " [1.06, 0.0855, 0.463, 0.168, 1.88 ]]\n", + ")\n", + "\n", + "df = pd.DataFrame(data, columns=['T*', 'p*', 'rho^L*', 'rho^V*', 'Delta^LV h*'])\n", + "\n", + "# Critical point data extracted from Heier et al. (2018), figure 1; unclear origin\n", + "T_c = 1.0850094876660341\n", + "p_c = 0.10073800738007378\n", + "rho_c = 0.3194085027726432\n", + "\n", + "# Critical point data extracted from Vrabec et al. (2018)\n", + "T_c_vrabec = 1.0779\n", + "p_c_vrabec = np.exp(3.1664 - 5.9809 / T_c_vrabec + 0.01498 / T_c_vrabec**3)\n", + "rho_c_vrabec = 0.3190\n", + "\n", + "# Critical point data extracted from Heier et al. (2018), figure 1; critical point of original PeTS implementation\n", + "T_c_pets_heier = 1.0884250474383301\n", + "p_c_pets_heier = 0.10184501845018448\n", + "rho_c_pets_heier = 0.3077634011090573" + ] + }, + { + "cell_type": "markdown", + "id": "surface-undergraduate", + "metadata": {}, + "source": [ + "## Definition of PeTS Equation of State" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "regulated-sequence", + "metadata": {}, + "outputs": [], + "source": [ + "pets = EquationOfState.pets(PetsParameters.from_lists(epsilon_k=[epsilon_k/KELVIN]*2, sigma=[sigma/ANGSTROM]*2))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cloudy-generic", + "metadata": {}, + "outputs": [], + "source": [ + "cp = State.critical_point_pure(eos=pets)\n", + "\n", + "T_c_pets = cp[0].temperature\n", + "p_c_pets = cp[0].pressure()\n", + "rho_c_pets = cp[0].density\n", + "\n", + "T_c_pets_red = cp[0].temperature / epsilon_k" + ] + }, + { + "cell_type": "markdown", + "id": "provincial-score", + "metadata": {}, + "source": [ + "## Phase Diagram of Pseudo Pure Fluid (Binary Mixture of the Same Component)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "intermediate-parallel", + "metadata": {}, + "outputs": [], + "source": [ + "temps = np.linspace(0.64, 0.99*T_c_pets_red, 101) # PhaseEquilibrium.bubble_point_tx() not converging to two phases close to critical point\n", + "p_sat = np.zeros(temps.shape)\n", + "rho_sat = np.zeros([temps.shape[0], 2])\n", + "pressure_ic = None\n", + "\n", + "for i, temperature in enumerate(np.nditer(temps)):\n", + " pe = PhaseEquilibrium.bubble_point_tx(eos=pets, temperature=temperature * epsilon_k, liquid_molefracs=np.array([0.5, 0.5]), pressure=pressure_ic, tol_inner=1e-7)\n", + " p_sat[i] = pe.liquid.pressure() / (epsilon_k * KB / sigma**3)\n", + " rho_sat[i, 0] = pe.vapor.density * (NAV * sigma**3)\n", + " rho_sat[i, 1] = pe.liquid.density * (NAV * sigma**3)\n", + "\n", + " pressure_ic = pe.vapor.pressure() * 1.03" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "taken-journalist", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(1,2, figsize=(14,5))\n", + "\n", + "ax[0].plot(temps, p_sat, color='tab:blue', label='this PeTS implementation')\n", + "ax[0].scatter(df['T*'], df['p*'], marker='s', color='tab:orange', label='simulation data Vrabec et al. (2006)')\n", + "ax[0].scatter(T_c_vrabec, p_c_vrabec, marker='o', color='tab:orange', label='critical point Vrabec et al. (2018)')\n", + "ax[0].scatter(T_c, p_c, marker='o', color='tab:red', label='critical point Heier et al. (2018); unclear origin')\n", + "ax[0].scatter(T_c_pets_heier, p_c_pets_heier, marker='o', color='tab:green', label='critical point PeTS Heier et al. (2018)')\n", + "ax[0].scatter(T_c_pets/epsilon_k, p_c_pets/(epsilon_k * KB / sigma**3), marker='x', color='tab:red', label='critical point this PeTS implementation')\n", + "ax[0].set_title('Vapor-Liquid Coexistence - Vapor Pressure')\n", + "ax[0].set_xlabel(r'$T* = \\frac{T}{\\frac{\\epsilon}{k_\\mathrm{B}}}$')\n", + "ax[0].set_ylabel(r'$p* = \\frac{p}{\\frac{\\epsilon}{\\sigma^3}}$')\n", + "ax[0].set_xlim(0.6, 1.2)\n", + "ax[0].set_ylim(0.0, 0.11)\n", + "ax[0].legend(loc='upper left')\n", + "ax[0].grid()\n", + "\n", + "ax[1].plot(temps, rho_sat[:,0], color='tab:blue', label='this PeTS implementation')\n", + "ax[1].plot(temps, rho_sat[:,1], color='tab:blue')\n", + "ax[1].scatter(df['T*'], df['rho^L*'], marker='s', color='tab:orange', label='simulation data Vrabec et al. (2006)')\n", + "ax[1].scatter(df['T*'], df['rho^V*'], marker='s', color='tab:orange')\n", + "ax[1].scatter(T_c, rho_c, marker='o', color='tab:red', label='critical point Heier et al. (2018); unclear origin')\n", + "ax[1].scatter(T_c_vrabec, rho_c_vrabec, marker='o', color='tab:orange', label='critical point Vrabec et al. (2018)')\n", + "ax[1].scatter(T_c_pets_heier, rho_c_pets_heier, marker='o', color='tab:green', label='critical point PeTS Heier et al. (2018)')\n", + "ax[1].scatter(T_c_pets/epsilon_k, rho_c_pets*NAV*sigma**3, marker='x', color='tab:red', label='critical point this PeTS implementation')\n", + "ax[1].set_title('Vapor-Liquid Coexistence - Saturated Densities')\n", + "ax[1].set_xlabel(r'$T* = \\frac{T}{\\frac{\\epsilon}{k_\\mathrm{B}}}$')\n", + "ax[1].set_ylabel(r'$\\rho* = \\rho \\sigma^3$')\n", + "ax[1].set_xlim(0.6, 1.1)\n", + "ax[1].set_ylim(0.0, 0.9)\n", + "ax[1].legend(loc='center left')\n", + "ax[1].grid()" + ] + }, + { + "cell_type": "markdown", + "id": "surface-implement", + "metadata": {}, + "source": [ + "## Binary Phase Diagram - Pressure-Composition of Pseudo Pure Fluid (Binary Mixture of the Same Component)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "marine-background", + "metadata": {}, + "outputs": [], + "source": [ + "dia_p = PhaseDiagramBinary.new_pxy(eos=pets, temperature=1*epsilon_k)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "still-twelve", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots(1, 2, figsize=(20,5))\n", + "ax[0].scatter(dia_p.liquid_molefracs, dia_p.pressure/(epsilon_k * KB / sigma**3), color='tab:red', marker='s')\n", + "ax[0].scatter(dia_p.vapor_molefracs, dia_p.pressure/(epsilon_k * KB / sigma**3), color='tab:blue', marker='x')\n", + "ax[0].set_xlim(0, 1)\n", + "ax[0].set_ylim(0, 0.15)\n", + "ax[0].set_xlabel(r'$x_1, x_2$')\n", + "ax[0].set_ylabel(r'$p* = \\frac{p}{\\frac{\\epsilon}{\\sigma^3}}$')\n", + "\n", + "\n", + "ax[1].plot([0, 1], [0, 1], color='black')\n", + "ax[1].scatter(dia_p.liquid_molefracs, dia_p.vapor_molefracs, color='tab:orange', marker='s')\n", + "ax[1].set_xlim(0, 1)\n", + "ax[1].set_ylim(0, 1)\n", + "ax[1].set_xlabel(r'$x_1$')\n", + "ax[1].set_ylabel(r'$y_1$');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "776e456c-8659-4ee0-b18f-289de111ae09", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "feos-enum", + "language": "python", + "name": "feos-enum" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/eos.rs b/src/eos.rs index 63728db35..e2d15e867 100644 --- a/src/eos.rs +++ b/src/eos.rs @@ -4,6 +4,8 @@ use feos_core::python::user_defined::PyEoSObj; use feos_core::*; use feos_pcsaft::python::PyPcSaftParameters; use feos_pcsaft::{PcSaft, PcSaftOptions}; +use feos_pets::python::PyPetsParameters; +use feos_pets::{Pets, PetsOptions}; use ndarray::Array1; use numpy::convert::ToPyArray; use numpy::{PyArray1, PyArray2}; @@ -18,6 +20,7 @@ pub enum Eos { PcSaft(PcSaft), PengRobinson(PengRobinson), Python(PyEoSObj), + Pets(Pets), } impl EquationOfState for Eos { @@ -26,6 +29,7 @@ impl EquationOfState for Eos { Eos::PcSaft(eos) => eos.components(), Eos::PengRobinson(eos) => eos.components(), Eos::Python(eos) => eos.components(), + Eos::Pets(eos) => eos.components(), } } @@ -34,6 +38,7 @@ impl EquationOfState for Eos { Eos::PcSaft(eos) => eos.compute_max_density(moles), Eos::PengRobinson(eos) => eos.compute_max_density(moles), Eos::Python(eos) => eos.compute_max_density(moles), + Eos::Pets(eos) => eos.compute_max_density(moles), } } @@ -42,6 +47,7 @@ impl EquationOfState for Eos { Eos::PcSaft(eos) => Self::PcSaft(eos.subset(component_list)), Eos::PengRobinson(eos) => Self::PengRobinson(eos.subset(component_list)), Eos::Python(eos) => Self::Python(eos.subset(component_list)), + Eos::Pets(eos) => Self::Pets(eos.subset(component_list)), } } @@ -50,6 +56,7 @@ impl EquationOfState for Eos { Eos::PcSaft(eos) => eos.residual(), Eos::PengRobinson(eos) => eos.residual(), Eos::Python(eos) => eos.residual(), + Eos::Pets(eos) => eos.residual(), } } } @@ -60,6 +67,7 @@ impl MolarWeight for Eos { Eos::PcSaft(eos) => eos.molar_weight(), Eos::PengRobinson(eos) => eos.molar_weight(), Eos::Python(eos) => eos.molar_weight(), + Eos::Pets(eos) => eos.molar_weight(), } } } @@ -129,7 +137,26 @@ pub struct PyEos(pub Rc); #[pymethods] impl PyEos { - /// PCP-SAFT equation of state. + /// Initialize PC-SAFT equation of state. + /// + /// Parameters + /// ---------- + /// parameters : PcSaftParameters + /// The parameters of the PC-Saft equation of state to use. + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// max_iter_cross_assoc : unsigned integer, optional + /// Maximum number of iterations for cross association. Defaults to 50. + /// tol_cross_assoc : float + /// Tolerance for convergence of cross association. Defaults to 1e-10. + /// dq_variant : {'dq35', 'dq44'}, optional + /// Combination rule used in the dipole/quadrupole term. Defaults to 'dq35' + /// + /// Returns + /// ------- + /// PcSaft + /// The PC-SAFT equation of state that can be used to compute thermodynamic + /// states. #[args( max_eta = "0.5", max_iter_cross_assoc = "50", @@ -169,6 +196,27 @@ impl PyEos { fn python(obj: Py) -> PyResult { Ok(Self(Rc::new(Eos::Python(PyEoSObj::new(obj)?)))) } + + /// Initialize PeTS equation of state. + /// + /// Parameters + /// ---------- + /// parameters : PetsParameters + /// The parameters of the PeTS equation of state to use. + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// + /// Returns + /// ------- + /// Pets + /// The PeTS equation of state that can be used to compute thermodynamic + /// states. + #[args(max_eta = "0.5")] + #[staticmethod] + fn pets(parameters: PyPetsParameters, max_eta: f64) -> Self { + let options = PetsOptions { max_eta }; + Self(Rc::new(Eos::Pets(Pets::with_options(parameters.0.clone(), options)))) + } } impl_equation_of_state!(PyEos); diff --git a/src/lib.rs b/src/lib.rs index c5419c8da..9a407a14a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,12 +5,15 @@ mod eos; use eos::__PYO3_PYMODULE_DEF_EOS; mod pcsaft; use pcsaft::__PYO3_PYMODULE_DEF_PCSAFT; +mod pets; +use pets::__PYO3_PYMODULE_DEF_PETS; #[pymodule] pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pymodule!(quantity))?; m.add_wrapped(wrap_pymodule!(eos))?; m.add_wrapped(wrap_pymodule!(pcsaft))?; + m.add_wrapped(wrap_pymodule!(pets))?; py.run( "\ import sys @@ -22,6 +25,7 @@ quantity.SIArray4.__module__ = 'feos.si' sys.modules['feos.si'] = quantity sys.modules['feos.eos'] = eos sys.modules['feos.pcsaft'] = pcsaft +sys.modules['feos.pets'] = pets ", None, Some(m.dict()), diff --git a/src/pets.rs b/src/pets.rs new file mode 100644 index 000000000..ac4920225 --- /dev/null +++ b/src/pets.rs @@ -0,0 +1,17 @@ +use feos_core::python::joback::PyJobackRecord; +use feos_core::python::parameter::*; +use feos_pets::python::{PyPetsParameters, PyPetsRecord, PyPureRecord}; +use pyo3::prelude::*; + +#[pymodule] +pub fn pets(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +} From 485eeef9b97cbd656092f23a9abdd3fa17ed4fd3 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Fri, 8 Apr 2022 14:21:15 +0200 Subject: [PATCH 04/15] Added DFT, restructured package modules --- Cargo.lock | 162 +++++++++++++++++++--------------- src/cubic.rs | 17 ++++ src/dft.rs | 241 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/eos.rs | 130 ++++++++++++++++----------- src/lib.rs | 8 ++ 5 files changed, 433 insertions(+), 125 deletions(-) create mode 100644 src/cubic.rs create mode 100644 src/dft.rs diff --git a/Cargo.lock b/Cargo.lock index f5cc199af..f89e787fe 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -74,9 +74,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "crossbeam-channel" -version = "0.5.2" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa" +checksum = "5aaa7bd5fb665c6864b5f963dd9097905c54125909c7aa94c9e18507cdbe6c53" dependencies = [ "cfg-if", "crossbeam-utils", @@ -95,10 +95,11 @@ dependencies = [ [[package]] name = "crossbeam-epoch" -version = "0.9.7" +version = "0.9.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c00d6d2ea26e8b151d99093005cb442fb9a37aeaca582a03ec70946f49ab5ed9" +checksum = "1145cf131a2c6ba0615079ab6a638f7e1973ac9c2634fcbeaaad6114246efe8c" dependencies = [ + "autocfg", "cfg-if", "crossbeam-utils", "lazy_static", @@ -108,9 +109,9 @@ dependencies = [ [[package]] name = "crossbeam-utils" -version = "0.8.7" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6" +checksum = "0bf124c720b7686e3c2663cf54062ab0f68a88af2fb6a030e87e30bf721fcb38" dependencies = [ "cfg-if", "lazy_static", @@ -118,9 +119,9 @@ dependencies = [ [[package]] name = "ctor" -version = "0.1.21" +version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ccc0a48a9b826acdf4028595adc9db92caea352f7af011a3034acd172a52a0aa" +checksum = "f877be4f7c9f246b183111634f75baa039715e3f46ce860677d3b19a69fb229c" dependencies = [ "quote", "syn", @@ -149,7 +150,7 @@ dependencies = [ [[package]] name = "feos-core" version = "0.1.5" -source = "git+https://github.com/feos-org/feos-core#2d4bee11b295164ca2842c6ea00bc87ea866f955" +source = "git+https://github.com/feos-org/feos-core#7c61e48da1ea8db8a106e1e8634c26114df27ab8" dependencies = [ "approx 0.4.0", "either", @@ -168,7 +169,7 @@ dependencies = [ [[package]] name = "feos-dft" version = "0.1.3" -source = "git+https://github.com/feos-org/feos-dft?branch=v0.2.0#ab341c8cf526c98de0bd95f4028d8ff1453b2ed3" +source = "git+https://github.com/feos-org/feos-dft?branch=v0.2.0#30300daf1f1e9d6fb1845d743757725b680a78fb" dependencies = [ "ang", "feos-core", @@ -189,7 +190,7 @@ dependencies = [ [[package]] name = "feos-pcsaft" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pcsaft#0c90a9438fa4be89d09e360d909b07623b3a0de7" +source = "git+https://github.com/feos-org/feos-pcsaft#fc32a8509c0f23f2b9fb82a1a161e63a7ded0bc9" dependencies = [ "feos-core", "feos-dft", @@ -208,7 +209,7 @@ dependencies = [ [[package]] name = "feos-pets" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pets#82895eea1c20ea3f59a6137bf19ec38ddb04114a" +source = "git+https://github.com/feos-org/feos-pets#6e2c618fead48ab0051fffcdbdc98b35f9d543fc" dependencies = [ "feos-core", "feos-dft", @@ -243,9 +244,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.5" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d39cd93900197114fa1fcb7ae84ca742095eed9442088988ae74fa744e930e77" +checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad" dependencies = [ "cfg-if", "libc", @@ -280,9 +281,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "1.8.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223" +checksum = "0f647032dfaa1f8b6dc29bd3edb7bbef4861b8b8007ebb118d6db284fd59f6ee" dependencies = [ "autocfg", "hashbrown", @@ -297,15 +298,6 @@ dependencies = [ "unindent", ] -[[package]] -name = "instant" -version = "0.1.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" -dependencies = [ - "cfg-if", -] - [[package]] name = "inventory" version = "0.2.2" @@ -339,9 +331,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.119" +version = "0.2.122" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4" +checksum = "ec647867e2bf0772e28c8bcde4f0d19a9216916e890543b5a03ed8ef27b8f259" [[package]] name = "libm" @@ -351,10 +343,11 @@ checksum = "33a33a362ce288760ec6a508b94caaec573ae7d3bbbd91b87aa0bad4456839db" [[package]] name = "lock_api" -version = "0.4.6" +version = "0.4.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b" +checksum = "327fa5b6a6940e4699ec49a9beae1ea4845c6bab9314e4f84ac68742139d8c53" dependencies = [ + "autocfg", "scopeguard", ] @@ -524,40 +517,38 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5" +checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9" [[package]] name = "parking_lot" -version = "0.11.2" +version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" +checksum = "87f5ec2493a61ac0506c0f4199f99070cbe83857b0337006a30f3e6719b8ef58" dependencies = [ - "instant", "lock_api", "parking_lot_core", ] [[package]] name = "parking_lot_core" -version = "0.8.5" +version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216" +checksum = "995f667a6c822200b0433ac218e05582f0e2efa1b922a3fd2fbaadc5f87bab37" dependencies = [ "cfg-if", - "instant", "libc", "redox_syscall", "smallvec", - "winapi", + "windows-sys", ] [[package]] name = "paste" -version = "1.0.6" +version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0744126afe1a6dd7f394cb50a716dbe086cb06e255e53d8d0185d82828358fb5" +checksum = "0c520e05135d6e763148b6426a837e239041653ba7becd2e538c076c738025fc" [[package]] name = "petgraph" @@ -586,18 +577,18 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.36" +version = "1.0.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" +checksum = "ec757218438d5fda206afc041538b2f6d889286160d649a86a24d37e1235afd1" dependencies = [ "unicode-xid", ] [[package]] name = "pyo3" -version = "0.16.2" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a378727d5fdcaafd15b5afe9842cff1c25fdc43f62a162ffda2263c57ad98703" +checksum = "6b3e99c4c3e790e4fc365b42b70c1f7801f42eadc4ea648fa327e6f5ca29f215" dependencies = [ "cfg-if", "indoc", @@ -612,18 +603,19 @@ dependencies = [ [[package]] name = "pyo3-build-config" -version = "0.16.2" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fbb27a3e96edd34c13d97d0feefccc90a79270c577c66e19d95af8323823dfc" +checksum = "2486b96281859ff0a3929ba6467b13751627b974f7137362db38e2bed14b2094" dependencies = [ "once_cell", + "target-lexicon", ] [[package]] name = "pyo3-ffi" -version = "0.16.2" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b719fff844bcf3f911132112ec06527eb195f6a98e0c42cf97e1118929fd4ea" +checksum = "dd9de1d94557751599f8bd321f10e6c1ef2801067acb58c91138deef2ae83a17" dependencies = [ "libc", "pyo3-build-config", @@ -631,9 +623,9 @@ dependencies = [ [[package]] name = "pyo3-macros" -version = "0.16.2" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f795e52d3320abb349ca28b501a7112154a87f353fae1c811deecd58e99cfa9b" +checksum = "0b9584049129b1cfb615243391a6345c726690271ae195ffd6aa3766177296aa" dependencies = [ "proc-macro2", "pyo3-macros-backend", @@ -643,12 +635,11 @@ dependencies = [ [[package]] name = "pyo3-macros-backend" -version = "0.16.2" +version = "0.16.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39e03aa57a3bb7b96982958088df38302a139df4eef54671bc595f26556cb75b" +checksum = "b6c4717e6a55c51a9958eda1f5481ff7f62cccd21f45309c10e4731cb7198dbc" dependencies = [ "proc-macro2", - "pyo3-build-config", "quote", "syn", ] @@ -673,9 +664,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.15" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145" +checksum = "632d02bff7f874a36f33ea8bb416cd484b90cc66c1194b1a1110d067a7013f58" dependencies = [ "proc-macro2", ] @@ -753,18 +744,18 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.2.10" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff" +checksum = "62f25bc4c7e55e0b0b7a1d43fb893f4fa1361d0abe38b9ce4f323c2adfe6ef42" dependencies = [ "bitflags", ] [[package]] name = "regex" -version = "1.5.4" +version = "1.5.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461" +checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286" dependencies = [ "aho-corasick", "memchr", @@ -882,15 +873,21 @@ checksum = "a3ff2f71c82567c565ba4b3009a9350a96a7269eaa4001ebedae926230bc2254" [[package]] name = "syn" -version = "1.0.86" +version = "1.0.91" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b" +checksum = "b683b2b825c8eef438b77c36a06dc262294da3d5a5813fac20da149241dcd44d" dependencies = [ "proc-macro2", "quote", "unicode-xid", ] +[[package]] +name = "target-lexicon" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7fa7e55043acb85fca6b3c01485a2eeb6b69c5d21002e273c79e465f43b7ac1" + [[package]] name = "thiserror" version = "1.0.30" @@ -946,23 +943,44 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" [[package]] -name = "winapi" -version = "0.3.9" +name = "windows-sys" +version = "0.34.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +checksum = "5acdd78cb4ba54c0045ac14f62d8f94a03d10047904ae2a40afa1e99d8f70825" dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_msvc", ] [[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" +name = "windows_aarch64_msvc" +version = "0.34.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +checksum = "17cffbe740121affb56fad0fc0e421804adf0ae00891205213b5cecd30db881d" [[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" +name = "windows_i686_gnu" +version = "0.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2564fde759adb79129d9b4f54be42b32c89970c18ebf93124ca8870a498688ed" + +[[package]] +name = "windows_i686_msvc" +version = "0.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cd9d32ba70453522332c14d38814bceeb747d80b3958676007acadd7e166956" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfce6deae227ee8d356d19effc141a509cc503dfd1f850622ec4b0f84428e1f4" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.34.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +checksum = "d19538ccc21819d01deaf88d6a17eae6596a12e9aafdbb97916fb49896d89de9" diff --git a/src/cubic.rs b/src/cubic.rs new file mode 100644 index 000000000..45cb01685 --- /dev/null +++ b/src/cubic.rs @@ -0,0 +1,17 @@ +use feos_core::python::joback::PyJobackRecord; +use feos_core::python::parameter::*; +use feos_core::python::cubic::*; +use pyo3::prelude::*; + +#[pymodule] +pub fn cubic(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +} diff --git a/src/dft.rs b/src/dft.rs new file mode 100644 index 000000000..1ac26a3bc --- /dev/null +++ b/src/dft.rs @@ -0,0 +1,241 @@ +use feos_core::*; +use feos_dft::adsorption::*; +use feos_dft::fundamental_measure_theory::FMTVersion; +use feos_dft::interface::*; +use feos_dft::python::*; +use feos_dft::solvation::*; +use feos_dft::*; +use feos_pcsaft::python::PyPcSaftParameters; +use feos_pcsaft::{PcSaftFunctional, PcSaftOptions}; +use feos_pets::python::PyPetsParameters; +use feos_pets::{PetsFunctional, PetsOptions}; +use ndarray::{Array1, Array2}; +use numpy::convert::ToPyArray; +use numpy::{PyArray1, PyArray2, PyArray4}; +use pyo3::exceptions::PyValueError; +use pyo3::prelude::*; +use quantity::python::*; +use quantity::si::*; +use std::collections::HashMap; +use std::rc::Rc; + +pub enum FunctionalVariant { + PcSaftFunctional(PcSaftFunctional), + PetsFunctional(PetsFunctional), +} + +impl From> for FunctionalVariant { + fn from(f: DFT) -> Self { + Self::PcSaftFunctional(f.functional) + } +} + +impl From> for FunctionalVariant { + fn from(f: DFT) -> Self { + Self::PetsFunctional(f.functional) + } +} + +impl HelmholtzEnergyFunctional for FunctionalVariant { + fn subset(&self, component_list: &[usize]) -> DFT { + match self { + FunctionalVariant::PcSaftFunctional(functional) => DFT::new_homosegmented( + functional.subset(component_list).into(), + &functional.parameters.m, + ), + FunctionalVariant::PetsFunctional(functional) => DFT::new_homosegmented( + functional.subset(component_list).into(), + &Array1::::ones(functional.parameters.sigma.len()), + ), + } + } + + fn compute_max_density(&self, moles: &Array1) -> f64 { + match self { + FunctionalVariant::PcSaftFunctional(functional) => { + functional.compute_max_density(moles) + } + FunctionalVariant::PetsFunctional(functional) => functional.compute_max_density(moles), + } + } + + fn contributions(&self) -> &[Box] { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.contributions(), + FunctionalVariant::PetsFunctional(functional) => functional.contributions(), + } + } + + fn ideal_gas(&self) -> &dyn IdealGasContribution { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.ideal_gas(), + FunctionalVariant::PetsFunctional(functional) => functional.ideal_gas(), + } + } +} + +impl MolarWeight for FunctionalVariant { + fn molar_weight(&self) -> SIArray1 { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.molar_weight(), + FunctionalVariant::PetsFunctional(functional) => functional.molar_weight(), + } + } +} + +impl FluidParameters for FunctionalVariant { + fn epsilon_k_ff(&self) -> Array1 { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.epsilon_k_ff(), + FunctionalVariant::PetsFunctional(functional) => functional.epsilon_k_ff(), + } + } + + fn sigma_ff(&self) -> &Array1 { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.sigma_ff(), + FunctionalVariant::PetsFunctional(functional) => functional.sigma_ff(), + } + } + + fn m(&self) -> Array1 { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.m(), + FunctionalVariant::PetsFunctional(functional) => functional.m(), + } + } +} + +impl PairPotential for FunctionalVariant { + fn pair_potential(&self, r: &Array1) -> Array2 { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.pair_potential(r), + FunctionalVariant::PetsFunctional(functional) => functional.pair_potential(r), + } + } +} + +#[pyclass(name = "Functional", unsendable)] +#[derive(Clone)] +pub struct PyFunctional(pub Rc>); + +#[pymethods] +impl PyFunctional { + /// PC-SAFT Helmholtz energy functional. + /// + /// Parameters + /// ---------- + /// parameters: PcSaftParameters + /// The set of PC-SAFT parameters. + /// fmt_version: FMTVersion, optional + /// The specific variant of the FMT term. Defaults to FMTVersion.WhiteBear + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// max_iter_cross_assoc : unsigned integer, optional + /// Maximum number of iterations for cross association. Defaults to 50. + /// tol_cross_assoc : float + /// Tolerance for convergence of cross association. Defaults to 1e-10. + /// dq_variant : {'dq35', 'dq44'}, optional + /// Combination rule used in the dipole/quadrupole term. Defaults to 'dq35' + /// + /// Returns + /// ------- + /// PcSaftFunctional + #[args( + fmt_version = "FMTVersion::WhiteBear", + max_eta = "0.5", + max_iter_cross_assoc = "50", + tol_cross_assoc = "1e-10", + dq_variant = "\"dq35\"" + )] + #[staticmethod] + #[pyo3( + text_signature = "(parameters, fmt_version, max_eta, max_iter_cross_assoc, tol_cross_assoc, dq_variant)" + )] + fn pcsaft( + parameters: PyPcSaftParameters, + fmt_version: FMTVersion, + max_eta: f64, + max_iter_cross_assoc: usize, + tol_cross_assoc: f64, + dq_variant: &str, + ) -> Self { + let options = PcSaftOptions { + max_eta, + max_iter_cross_assoc, + tol_cross_assoc, + dq_variant: dq_variant.into(), + }; + let m = parameters.0.m.clone(); + Self(Rc::new(DFT::new_homosegmented( + PcSaftFunctional::with_options(parameters.0, fmt_version, options).into(), + &m, + ))) + } + + /// PeTS Helmholtz energy functional without simplifications + /// for pure components. + /// + /// Parameters + /// ---------- + /// parameters: PetsParameters + /// The set of PeTS parameters. + /// fmt_version: FMTVersion, optional + /// The specific variant of the FMT term. Defaults to FMTVersion.WhiteBear + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// + /// Returns + /// ------- + /// PetsFunctional + #[args(fmt_version = "FMTVersion::WhiteBear", max_eta = "0.5")] + #[staticmethod] + #[pyo3(text_signature = "(parameters, fmt_version, max_eta)")] + fn new_full(parameters: PyPetsParameters, fmt_version: FMTVersion, max_eta: f64) -> Self { + let options = PetsOptions { max_eta }; + let m = Array1::::ones(parameters.0.sigma.len()); + Self(Rc::new(DFT::new_homosegmented( + PetsFunctional::with_options(parameters.0, fmt_version, options).into(), + &m, + ))) + } +} + +impl_equation_of_state!(PyFunctional); + +impl_state!(DFT, PyFunctional); +impl_state_molarweight!(DFT, PyFunctional); +impl_phase_equilibrium!(DFT, PyFunctional); + +impl_planar_interface!(FunctionalVariant); +impl_surface_tension_diagram!(FunctionalVariant); + +impl_pore!(FunctionalVariant, PyFunctional); +impl_adsorption!(FunctionalVariant, PyFunctional); + +impl_pair_correlation!(FunctionalVariant); +impl_solvation_profile!(FunctionalVariant); + +#[pymodule] +pub fn dft(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::() +} diff --git a/src/eos.rs b/src/eos.rs index e2d15e867..65199f638 100644 --- a/src/eos.rs +++ b/src/eos.rs @@ -16,63 +16,63 @@ use quantity::si::*; use std::collections::HashMap; use std::rc::Rc; -pub enum Eos { +pub enum EosVariant { PcSaft(PcSaft), PengRobinson(PengRobinson), Python(PyEoSObj), Pets(Pets), } -impl EquationOfState for Eos { +impl EquationOfState for EosVariant { fn components(&self) -> usize { match self { - Eos::PcSaft(eos) => eos.components(), - Eos::PengRobinson(eos) => eos.components(), - Eos::Python(eos) => eos.components(), - Eos::Pets(eos) => eos.components(), + EosVariant::PcSaft(eos) => eos.components(), + EosVariant::PengRobinson(eos) => eos.components(), + EosVariant::Python(eos) => eos.components(), + EosVariant::Pets(eos) => eos.components(), } } fn compute_max_density(&self, moles: &Array1) -> f64 { match self { - Eos::PcSaft(eos) => eos.compute_max_density(moles), - Eos::PengRobinson(eos) => eos.compute_max_density(moles), - Eos::Python(eos) => eos.compute_max_density(moles), - Eos::Pets(eos) => eos.compute_max_density(moles), + EosVariant::PcSaft(eos) => eos.compute_max_density(moles), + EosVariant::PengRobinson(eos) => eos.compute_max_density(moles), + EosVariant::Python(eos) => eos.compute_max_density(moles), + EosVariant::Pets(eos) => eos.compute_max_density(moles), } } fn subset(&self, component_list: &[usize]) -> Self { match self { - Eos::PcSaft(eos) => Self::PcSaft(eos.subset(component_list)), - Eos::PengRobinson(eos) => Self::PengRobinson(eos.subset(component_list)), - Eos::Python(eos) => Self::Python(eos.subset(component_list)), - Eos::Pets(eos) => Self::Pets(eos.subset(component_list)), + EosVariant::PcSaft(eos) => Self::PcSaft(eos.subset(component_list)), + EosVariant::PengRobinson(eos) => Self::PengRobinson(eos.subset(component_list)), + EosVariant::Python(eos) => Self::Python(eos.subset(component_list)), + EosVariant::Pets(eos) => Self::Pets(eos.subset(component_list)), } } fn residual(&self) -> &[Box] { match self { - Eos::PcSaft(eos) => eos.residual(), - Eos::PengRobinson(eos) => eos.residual(), - Eos::Python(eos) => eos.residual(), - Eos::Pets(eos) => eos.residual(), + EosVariant::PcSaft(eos) => eos.residual(), + EosVariant::PengRobinson(eos) => eos.residual(), + EosVariant::Python(eos) => eos.residual(), + EosVariant::Pets(eos) => eos.residual(), } } } -impl MolarWeight for Eos { +impl MolarWeight for EosVariant { fn molar_weight(&self) -> SIArray1 { match self { - Eos::PcSaft(eos) => eos.molar_weight(), - Eos::PengRobinson(eos) => eos.molar_weight(), - Eos::Python(eos) => eos.molar_weight(), - Eos::Pets(eos) => eos.molar_weight(), + EosVariant::PcSaft(eos) => eos.molar_weight(), + EosVariant::PengRobinson(eos) => eos.molar_weight(), + EosVariant::Python(eos) => eos.molar_weight(), + EosVariant::Pets(eos) => eos.molar_weight(), } } } -impl EntropyScaling for Eos { +impl EntropyScaling for EosVariant { fn viscosity_reference( &self, temperature: SINumber, @@ -80,14 +80,14 @@ impl EntropyScaling for Eos { moles: &SIArray1, ) -> EosResult { match self { - Eos::PcSaft(eos) => eos.viscosity_reference(temperature, volume, moles), + EosVariant::PcSaft(eos) => eos.viscosity_reference(temperature, volume, moles), _ => unimplemented!(), } } fn viscosity_correlation(&self, s_res: f64, x: &Array1) -> EosResult { match self { - Eos::PcSaft(eos) => eos.viscosity_correlation(s_res, x), + EosVariant::PcSaft(eos) => eos.viscosity_correlation(s_res, x), _ => unimplemented!(), } } @@ -99,14 +99,14 @@ impl EntropyScaling for Eos { moles: &SIArray1, ) -> EosResult { match self { - Eos::PcSaft(eos) => eos.diffusion_reference(temperature, volume, moles), + EosVariant::PcSaft(eos) => eos.diffusion_reference(temperature, volume, moles), _ => unimplemented!(), } } fn diffusion_correlation(&self, s_res: f64, x: &Array1) -> EosResult { match self { - Eos::PcSaft(eos) => eos.diffusion_correlation(s_res, x), + EosVariant::PcSaft(eos) => eos.diffusion_correlation(s_res, x), _ => unimplemented!(), } } @@ -118,14 +118,14 @@ impl EntropyScaling for Eos { moles: &SIArray1, ) -> EosResult { match self { - Eos::PcSaft(eos) => eos.thermal_conductivity_reference(temperature, volume, moles), + EosVariant::PcSaft(eos) => eos.thermal_conductivity_reference(temperature, volume, moles), _ => unimplemented!(), } } fn thermal_conductivity_correlation(&self, s_res: f64, x: &Array1) -> EosResult { match self { - Eos::PcSaft(eos) => eos.thermal_conductivity_correlation(s_res, x), + EosVariant::PcSaft(eos) => eos.thermal_conductivity_correlation(s_res, x), _ => unimplemented!(), } } @@ -133,10 +133,10 @@ impl EntropyScaling for Eos { #[pyclass(name = "EquationOfState", unsendable)] #[derive(Clone)] -pub struct PyEos(pub Rc); +pub struct PyEosVariant(pub Rc); #[pymethods] -impl PyEos { +impl PyEosVariant { /// Initialize PC-SAFT equation of state. /// /// Parameters @@ -154,7 +154,7 @@ impl PyEos { /// /// Returns /// ------- - /// PcSaft + /// EquationOfState /// The PC-SAFT equation of state that can be used to compute thermodynamic /// states. #[args( @@ -164,6 +164,7 @@ impl PyEos { dq_variant = "\"dq35\"" )] #[staticmethod] + #[pyo3(text_signature = "(parameters, max_eta, max_iter_cross_assoc, tol_cross_assoc, dq_variant)")] pub fn pcsaft( parameters: PyPcSaftParameters, max_eta: f64, @@ -177,27 +178,50 @@ impl PyEos { tol_cross_assoc, dq_variant: dq_variant.into(), }; - Self(Rc::new(Eos::PcSaft(PcSaft::with_options( + Self(Rc::new(EosVariant::PcSaft(PcSaft::with_options( parameters.0.clone(), options, )))) } /// Peng-Robinson equation of state. + /// + /// Parameters + /// ---------- + /// parameters : PengRobinsonParameters + /// The parameters of the PR equation of state to use. + /// + /// Returns + /// ------- + /// EquationOfState + /// The PR equation of state that can be used to compute thermodynamic + /// states. #[staticmethod] + #[pyo3(text_signature = "(parameters)")] pub fn peng_robinson(parameters: PyPengRobinsonParameters) -> Self { - Self(Rc::new(Eos::PengRobinson(PengRobinson::new( + Self(Rc::new(EosVariant::PengRobinson(PengRobinson::new( parameters.0.clone(), )))) } - /// Generate equation of state from Python class. + /// Equation of state from a Python class. + /// + /// Parameters + /// ---------- + /// obj : Class + /// A python class implementing the necessary methods + /// to be used as equation of state. + /// + /// Returns + /// ------- + /// EquationOfState #[staticmethod] + #[pyo3(text_signature = "(obj)")] fn python(obj: Py) -> PyResult { - Ok(Self(Rc::new(Eos::Python(PyEoSObj::new(obj)?)))) + Ok(Self(Rc::new(EosVariant::Python(PyEoSObj::new(obj)?)))) } - /// Initialize PeTS equation of state. + /// PeTS equation of state. /// /// Parameters /// ---------- @@ -208,35 +232,35 @@ impl PyEos { /// /// Returns /// ------- - /// Pets + /// EquationOfState /// The PeTS equation of state that can be used to compute thermodynamic /// states. #[args(max_eta = "0.5")] #[staticmethod] + #[pyo3(text_signature = "(parameters, max_eta)")] fn pets(parameters: PyPetsParameters, max_eta: f64) -> Self { let options = PetsOptions { max_eta }; - Self(Rc::new(Eos::Pets(Pets::with_options(parameters.0.clone(), options)))) + Self(Rc::new(EosVariant::Pets(Pets::with_options( + parameters.0.clone(), + options, + )))) } } -impl_equation_of_state!(PyEos); -impl_virial_coefficients!(PyEos); -impl_state!(Eos, PyEos); -impl_state_molarweight!(Eos, PyEos); -impl_state_entropy_scaling!(Eos, PyEos); -impl_vle_state!(Eos, PyEos); +impl_equation_of_state!(PyEosVariant); +impl_virial_coefficients!(PyEosVariant); +impl_state!(EosVariant, PyEosVariant); +impl_state_molarweight!(EosVariant, PyEosVariant); +impl_state_entropy_scaling!(EosVariant, PyEosVariant); +impl_phase_equilibrium!(EosVariant, PyEosVariant); #[pymodule] pub fn eos(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; - m.add_class::()?; - m.add_class::()?; + m.add_class::()?; m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - Ok(()) + m.add_class::()?; + m.add_class::() } diff --git a/src/lib.rs b/src/lib.rs index 9a407a14a..ccbc8eb7f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,6 +3,10 @@ use pyo3::wrap_pymodule; use quantity::python::__PYO3_PYMODULE_DEF_QUANTITY; mod eos; use eos::__PYO3_PYMODULE_DEF_EOS; +mod dft; +use dft::__PYO3_PYMODULE_DEF_DFT; +mod cubic; +use cubic::__PYO3_PYMODULE_DEF_CUBIC; mod pcsaft; use pcsaft::__PYO3_PYMODULE_DEF_PCSAFT; mod pets; @@ -12,6 +16,8 @@ use pets::__PYO3_PYMODULE_DEF_PETS; pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pymodule!(quantity))?; m.add_wrapped(wrap_pymodule!(eos))?; + m.add_wrapped(wrap_pymodule!(dft))?; + m.add_wrapped(wrap_pymodule!(cubic))?; m.add_wrapped(wrap_pymodule!(pcsaft))?; m.add_wrapped(wrap_pymodule!(pets))?; py.run( @@ -24,6 +30,8 @@ quantity.SIArray3.__module__ = 'feos.si' quantity.SIArray4.__module__ = 'feos.si' sys.modules['feos.si'] = quantity sys.modules['feos.eos'] = eos +sys.modules['feos.dft'] = dft +sys.modules['feos.cubic'] = cubic sys.modules['feos.pcsaft'] = pcsaft sys.modules['feos.pets'] = pets ", From 3d54532d67ec6ecc0e064538b4138e9816cb0aa6 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Fri, 8 Apr 2022 14:22:49 +0200 Subject: [PATCH 05/15] Fixed name for PeTS python constructor --- src/dft.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dft.rs b/src/dft.rs index 1ac26a3bc..44cd51875 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -191,7 +191,7 @@ impl PyFunctional { #[args(fmt_version = "FMTVersion::WhiteBear", max_eta = "0.5")] #[staticmethod] #[pyo3(text_signature = "(parameters, fmt_version, max_eta)")] - fn new_full(parameters: PyPetsParameters, fmt_version: FMTVersion, max_eta: f64) -> Self { + fn pets(parameters: PyPetsParameters, fmt_version: FMTVersion, max_eta: f64) -> Self { let options = PetsOptions { max_eta }; let m = Array1::::ones(parameters.0.sigma.len()); Self(Rc::new(DFT::new_homosegmented( From 3b64710539864183777b3e834c86d969a111f956 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Fri, 8 Apr 2022 15:40:32 +0200 Subject: [PATCH 06/15] Update dependencies and cleanup --- Cargo.lock | 5 ++--- Cargo.toml | 6 +++--- src/dft.rs | 49 +++++++++++++++++++++++++------------------------ 3 files changed, 30 insertions(+), 30 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f89e787fe..112c2551b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -169,7 +169,7 @@ dependencies = [ [[package]] name = "feos-dft" version = "0.1.3" -source = "git+https://github.com/feos-org/feos-dft?branch=v0.2.0#30300daf1f1e9d6fb1845d743757725b680a78fb" +source = "git+https://github.com/feos-org/feos-dft?branch=new_dft_struct#513efd6b3e92a457f2460c8c2e927f8fad0d9c30" dependencies = [ "ang", "feos-core", @@ -190,7 +190,7 @@ dependencies = [ [[package]] name = "feos-pcsaft" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pcsaft#fc32a8509c0f23f2b9fb82a1a161e63a7ded0bc9" +source = "git+https://github.com/feos-org/feos-pcsaft?branch=new_dft_struct#f015c43325b7a73201b1d73aceea56729006cc0a" dependencies = [ "feos-core", "feos-dft", @@ -209,7 +209,6 @@ dependencies = [ [[package]] name = "feos-pets" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pets#6e2c618fead48ab0051fffcdbdc98b35f9d543fc" dependencies = [ "feos-core", "feos-dft", diff --git a/Cargo.toml b/Cargo.toml index 430beb30f..27f8971a4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,9 +18,9 @@ crate-type = ["cdylib"] [dependencies] quantity = { version = "0.5", features = ["python"] } feos-core = { git = "https://github.com/feos-org/feos-core", features = ["python"] } -feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "v0.2.0" } -feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"] } -feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"] } +feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "new_dft_struct" } +feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"], branch = "new_dft_struct" } +feos-pets = { path = "../feos-pets", features = ["python"] } numpy = { version = "0.16" } ndarray = { version = "0.15", features=["approx"] } diff --git a/src/dft.rs b/src/dft.rs index 44cd51875..0e5d43d5c 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -24,29 +24,34 @@ pub enum FunctionalVariant { PetsFunctional(PetsFunctional), } -impl From> for FunctionalVariant { - fn from(f: DFT) -> Self { - Self::PcSaftFunctional(f.functional) +impl From for FunctionalVariant { + fn from(f: PcSaftFunctional) -> Self { + Self::PcSaftFunctional(f) } } -impl From> for FunctionalVariant { - fn from(f: DFT) -> Self { - Self::PetsFunctional(f.functional) +impl From for FunctionalVariant { + fn from(f: PetsFunctional) -> Self { + Self::PetsFunctional(f) } } impl HelmholtzEnergyFunctional for FunctionalVariant { fn subset(&self, component_list: &[usize]) -> DFT { match self { - FunctionalVariant::PcSaftFunctional(functional) => DFT::new_homosegmented( - functional.subset(component_list).into(), - &functional.parameters.m, - ), - FunctionalVariant::PetsFunctional(functional) => DFT::new_homosegmented( - functional.subset(component_list).into(), - &Array1::::ones(functional.parameters.sigma.len()), - ), + FunctionalVariant::PcSaftFunctional(functional) => { + functional.subset(component_list).into() + } + FunctionalVariant::PetsFunctional(functional) => { + functional.subset(component_list).into() + } + } + } + + fn molecule_shape(&self) -> MoleculeShape { + match self { + FunctionalVariant::PcSaftFunctional(functional) => functional.molecule_shape(), + FunctionalVariant::PetsFunctional(functional) => functional.molecule_shape(), } } @@ -100,8 +105,8 @@ impl FluidParameters for FunctionalVariant { fn m(&self) -> Array1 { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.m(), - FunctionalVariant::PetsFunctional(functional) => functional.m(), + FunctionalVariant::PcSaftFunctional(functional) => FluidParameters::m(functional), + FunctionalVariant::PetsFunctional(functional) => FluidParameters::m(functional), } } } @@ -166,11 +171,9 @@ impl PyFunctional { tol_cross_assoc, dq_variant: dq_variant.into(), }; - let m = parameters.0.m.clone(); - Self(Rc::new(DFT::new_homosegmented( + Self(Rc::new( PcSaftFunctional::with_options(parameters.0, fmt_version, options).into(), - &m, - ))) + )) } /// PeTS Helmholtz energy functional without simplifications @@ -193,11 +196,9 @@ impl PyFunctional { #[pyo3(text_signature = "(parameters, fmt_version, max_eta)")] fn pets(parameters: PyPetsParameters, fmt_version: FMTVersion, max_eta: f64) -> Self { let options = PetsOptions { max_eta }; - let m = Array1::::ones(parameters.0.sigma.len()); - Self(Rc::new(DFT::new_homosegmented( + Self(Rc::new( PetsFunctional::with_options(parameters.0, fmt_version, options).into(), - &m, - ))) + )) } } From db081e1c083030fb0aa3a9abeac7338d4a94c2a6 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Fri, 8 Apr 2022 16:01:42 +0200 Subject: [PATCH 07/15] Remove 'm' method from FluidParameters trait --- Cargo.lock | 4 ++-- src/dft.rs | 7 ------- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 112c2551b..c881a05de 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -169,7 +169,7 @@ dependencies = [ [[package]] name = "feos-dft" version = "0.1.3" -source = "git+https://github.com/feos-org/feos-dft?branch=new_dft_struct#513efd6b3e92a457f2460c8c2e927f8fad0d9c30" +source = "git+https://github.com/feos-org/feos-dft?branch=new_dft_struct#4c0853179ad421ef9bbbbfaabe45990641626560" dependencies = [ "ang", "feos-core", @@ -190,7 +190,7 @@ dependencies = [ [[package]] name = "feos-pcsaft" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pcsaft?branch=new_dft_struct#f015c43325b7a73201b1d73aceea56729006cc0a" +source = "git+https://github.com/feos-org/feos-pcsaft?branch=new_dft_struct#b9614a39c64c2bb77c41705db69eee3ddf349c76" dependencies = [ "feos-core", "feos-dft", diff --git a/src/dft.rs b/src/dft.rs index 0e5d43d5c..0a2ecad0a 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -102,13 +102,6 @@ impl FluidParameters for FunctionalVariant { FunctionalVariant::PetsFunctional(functional) => functional.sigma_ff(), } } - - fn m(&self) -> Array1 { - match self { - FunctionalVariant::PcSaftFunctional(functional) => FluidParameters::m(functional), - FunctionalVariant::PetsFunctional(functional) => FluidParameters::m(functional), - } - } } impl PairPotential for FunctionalVariant { From cb974ec95c0c2dfaff804f15db69ec1225cea101 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Fri, 8 Apr 2022 16:27:01 +0200 Subject: [PATCH 08/15] Added FMT functional --- src/dft.rs | 44 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 3 deletions(-) diff --git a/src/dft.rs b/src/dft.rs index 0a2ecad0a..39a96388a 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -1,6 +1,6 @@ use feos_core::*; use feos_dft::adsorption::*; -use feos_dft::fundamental_measure_theory::FMTVersion; +use feos_dft::fundamental_measure_theory::{FMTFunctional, FMTVersion}; use feos_dft::interface::*; use feos_dft::python::*; use feos_dft::solvation::*; @@ -22,6 +22,7 @@ use std::rc::Rc; pub enum FunctionalVariant { PcSaftFunctional(PcSaftFunctional), PetsFunctional(PetsFunctional), + FMTFunctional(FMTFunctional), } impl From for FunctionalVariant { @@ -36,6 +37,12 @@ impl From for FunctionalVariant { } } +impl From for FunctionalVariant { + fn from(f: FMTFunctional) -> Self { + Self::FMTFunctional(f) + } +} + impl HelmholtzEnergyFunctional for FunctionalVariant { fn subset(&self, component_list: &[usize]) -> DFT { match self { @@ -45,6 +52,9 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { FunctionalVariant::PetsFunctional(functional) => { functional.subset(component_list).into() } + FunctionalVariant::FMTFunctional(functional) => { + functional.subset(component_list).into() + } } } @@ -52,6 +62,7 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.molecule_shape(), FunctionalVariant::PetsFunctional(functional) => functional.molecule_shape(), + FunctionalVariant::FMTFunctional(functional) => functional.molecule_shape(), } } @@ -61,6 +72,7 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { functional.compute_max_density(moles) } FunctionalVariant::PetsFunctional(functional) => functional.compute_max_density(moles), + FunctionalVariant::FMTFunctional(functional) => functional.compute_max_density(moles), } } @@ -68,6 +80,7 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.contributions(), FunctionalVariant::PetsFunctional(functional) => functional.contributions(), + FunctionalVariant::FMTFunctional(functional) => functional.contributions(), } } @@ -75,6 +88,7 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.ideal_gas(), FunctionalVariant::PetsFunctional(functional) => functional.ideal_gas(), + FunctionalVariant::FMTFunctional(functional) => functional.ideal_gas(), } } } @@ -84,6 +98,7 @@ impl MolarWeight for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.molar_weight(), FunctionalVariant::PetsFunctional(functional) => functional.molar_weight(), + _ => unimplemented!(), } } } @@ -93,6 +108,7 @@ impl FluidParameters for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.epsilon_k_ff(), FunctionalVariant::PetsFunctional(functional) => functional.epsilon_k_ff(), + FunctionalVariant::FMTFunctional(functional) => functional.epsilon_k_ff(), } } @@ -100,6 +116,7 @@ impl FluidParameters for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.sigma_ff(), FunctionalVariant::PetsFunctional(functional) => functional.sigma_ff(), + FunctionalVariant::FMTFunctional(functional) => functional.sigma_ff(), } } } @@ -109,6 +126,7 @@ impl PairPotential for FunctionalVariant { match self { FunctionalVariant::PcSaftFunctional(functional) => functional.pair_potential(r), FunctionalVariant::PetsFunctional(functional) => functional.pair_potential(r), + FunctionalVariant::FMTFunctional(functional) => functional.pair_potential(r), } } } @@ -138,7 +156,7 @@ impl PyFunctional { /// /// Returns /// ------- - /// PcSaftFunctional + /// Functional #[args( fmt_version = "FMTVersion::WhiteBear", max_eta = "0.5", @@ -183,7 +201,7 @@ impl PyFunctional { /// /// Returns /// ------- - /// PetsFunctional + /// Functional #[args(fmt_version = "FMTVersion::WhiteBear", max_eta = "0.5")] #[staticmethod] #[pyo3(text_signature = "(parameters, fmt_version, max_eta)")] @@ -193,6 +211,26 @@ impl PyFunctional { PetsFunctional::with_options(parameters.0, fmt_version, options).into(), )) } + + /// Helmholtz energy functional for hard sphere systems. + /// + /// Parameters + /// ---------- + /// sigma : numpy.ndarray[float] + /// The diameters of the hard spheres in Angstrom. + /// fmt_version : FMTVersion + /// The specific variant of the FMT term. + /// + /// Returns + /// ------- + /// Functional + #[staticmethod] + #[pyo3(text_signature = "(sigma, version)")] + fn fmt(sigma: &PyArray1, fmt_version: FMTVersion) -> Self { + Self(Rc::new( + FMTFunctional::new(&sigma.to_owned_array(), fmt_version).into(), + )) + } } impl_equation_of_state!(PyFunctional); From c5605ffb910d30dd75f290fc1df237be0be372dd Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Fri, 8 Apr 2022 16:50:19 +0200 Subject: [PATCH 09/15] Update dependencies to github --- Cargo.lock | 5 +++-- Cargo.toml | 6 +++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c881a05de..4d7a7bdba 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -169,7 +169,7 @@ dependencies = [ [[package]] name = "feos-dft" version = "0.1.3" -source = "git+https://github.com/feos-org/feos-dft?branch=new_dft_struct#4c0853179ad421ef9bbbbfaabe45990641626560" +source = "git+https://github.com/feos-org/feos-dft?branch=v0.2.0#42a8fbec2d4e45545f79e850e2ced2d0d010cf52" dependencies = [ "ang", "feos-core", @@ -190,7 +190,7 @@ dependencies = [ [[package]] name = "feos-pcsaft" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pcsaft?branch=new_dft_struct#b9614a39c64c2bb77c41705db69eee3ddf349c76" +source = "git+https://github.com/feos-org/feos-pcsaft#04ff8f48966889a64b31e60027be7ceb960875d3" dependencies = [ "feos-core", "feos-dft", @@ -209,6 +209,7 @@ dependencies = [ [[package]] name = "feos-pets" version = "0.1.0" +source = "git+https://github.com/feos-org/feos-pets?branch=new_dft_struct#079a1326cb14d03a5166677cce0fc98895433185" dependencies = [ "feos-core", "feos-dft", diff --git a/Cargo.toml b/Cargo.toml index 27f8971a4..7bdd7f9b1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,9 +18,9 @@ crate-type = ["cdylib"] [dependencies] quantity = { version = "0.5", features = ["python"] } feos-core = { git = "https://github.com/feos-org/feos-core", features = ["python"] } -feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "new_dft_struct" } -feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"], branch = "new_dft_struct" } -feos-pets = { path = "../feos-pets", features = ["python"] } +feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "v0.2.0" } +feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"] } +feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"], branch = "new_dft_struct" } numpy = { version = "0.16" } ndarray = { version = "0.15", features=["approx"] } From 47515c0e0aee56152cf6609716d66fb37f51a1b9 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Sat, 9 Apr 2022 16:35:50 +0200 Subject: [PATCH 10/15] Renamed python dft struct to HelmholtzEnergyFunctional --- src/dft.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/dft.rs b/src/dft.rs index 39a96388a..976a82ef0 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -131,12 +131,12 @@ impl PairPotential for FunctionalVariant { } } -#[pyclass(name = "Functional", unsendable)] +#[pyclass(name = "HelmholtzEnergyFunctional", unsendable)] #[derive(Clone)] -pub struct PyFunctional(pub Rc>); +pub struct PyFunctionalVariant(pub Rc>); #[pymethods] -impl PyFunctional { +impl PyFunctionalVariant { /// PC-SAFT Helmholtz energy functional. /// /// Parameters @@ -233,17 +233,17 @@ impl PyFunctional { } } -impl_equation_of_state!(PyFunctional); +impl_equation_of_state!(PyFunctionalVariant); -impl_state!(DFT, PyFunctional); -impl_state_molarweight!(DFT, PyFunctional); -impl_phase_equilibrium!(DFT, PyFunctional); +impl_state!(DFT, PyFunctionalVariant); +impl_state_molarweight!(DFT, PyFunctionalVariant); +impl_phase_equilibrium!(DFT, PyFunctionalVariant); impl_planar_interface!(FunctionalVariant); impl_surface_tension_diagram!(FunctionalVariant); -impl_pore!(FunctionalVariant, PyFunctional); -impl_adsorption!(FunctionalVariant, PyFunctional); +impl_pore!(FunctionalVariant, PyFunctionalVariant); +impl_adsorption!(FunctionalVariant, PyFunctionalVariant); impl_pair_correlation!(FunctionalVariant); impl_solvation_profile!(FunctionalVariant); @@ -253,7 +253,7 @@ pub fn dft(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; - m.add_class::()?; + m.add_class::()?; m.add_class::()?; m.add_class::()?; m.add_class::()?; From d4818dc4533a9a431e709a529919f4e404242435 Mon Sep 17 00:00:00 2001 From: Philipp Rehner <69816385+prehner@users.noreply.github.com> Date: Mon, 25 Apr 2022 11:21:40 +0200 Subject: [PATCH 11/15] Add the gc PC-SAFT eos and functional (#12) * Add the gc PC-SAFT eos and functional * update README * update README even more --- Cargo.toml | 9 ++-- README.md | 3 +- src/dft.rs | 135 +++++++++++++++++++++++++++++++++-------------- src/eos.rs | 68 +++++++++++++++++++++--- src/gc_pcsaft.rs | 21 ++++++++ src/lib.rs | 6 +++ 6 files changed, 190 insertions(+), 52 deletions(-) create mode 100644 src/gc_pcsaft.rs diff --git a/Cargo.toml b/Cargo.toml index 7bdd7f9b1..533723993 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,11 +16,12 @@ categories = ["science"] crate-type = ["cdylib"] [dependencies] -quantity = { version = "0.5", features = ["python"] } -feos-core = { git = "https://github.com/feos-org/feos-core", features = ["python"] } -feos-dft = { git = "https://github.com/feos-org/feos-dft", features = ["python"], branch = "v0.2.0" } +quantity = "0.5" +feos-core = "0.2" +feos-dft = "0.2" feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"] } -feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"], branch = "new_dft_struct" } +feos-gc-pcsaft = { version = "0.1", features = ["python"] } +feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"] } numpy = { version = "0.16" } ndarray = { version = "0.15", features=["approx"] } diff --git a/README.md b/README.md index 0ba026512..2d64c8e33 100644 --- a/README.md +++ b/README.md @@ -11,8 +11,9 @@ The following models are currently published as part of the `FeOs` framework |name|description|eos|dft| |-|-|:-:|:-:| |[`feos-pcsaft`](https://github.com/feos-org/feos-pcsaft)|perturbed-chain (polar) statistical associating fluid theory|🗸|🗸| +|[`feos-gc-pcsaft`](https://github.com/feos-org/feos-gc-pcsaft)|(heterosegmented) group contribution PC-SAFT|🗸|🗸| -The list is being expanded continuously. Currently under development are implementations of ePC-SAFT, (heterosegmented) group contribution PC-SAFT and equations of state/Helmholtz energy functionals for model fluids like LJ and Mie fluids. +The list is being expanded continuously. Currently under development are implementations of ePC-SAFT and equations of state/Helmholtz energy functionals for model fluids like LJ and Mie fluids. Other public repositories that implement models within the `FeOs` framework, but are currently not part of the `feos` Python package, are diff --git a/src/dft.rs b/src/dft.rs index 976a82ef0..819c81948 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -5,6 +5,8 @@ use feos_dft::interface::*; use feos_dft::python::*; use feos_dft::solvation::*; use feos_dft::*; +use feos_gc_pcsaft::python::PyGcPcSaftFunctionalParameters; +use feos_gc_pcsaft::{GcPcSaftFunctional, GcPcSaftOptions}; use feos_pcsaft::python::PyPcSaftParameters; use feos_pcsaft::{PcSaftFunctional, PcSaftOptions}; use feos_pets::python::PyPetsParameters; @@ -20,75 +22,79 @@ use std::collections::HashMap; use std::rc::Rc; pub enum FunctionalVariant { - PcSaftFunctional(PcSaftFunctional), - PetsFunctional(PetsFunctional), - FMTFunctional(FMTFunctional), + PcSaft(PcSaftFunctional), + GcPcSaft(GcPcSaftFunctional), + Pets(PetsFunctional), + Fmt(FMTFunctional), } impl From for FunctionalVariant { fn from(f: PcSaftFunctional) -> Self { - Self::PcSaftFunctional(f) + Self::PcSaft(f) + } +} + +impl From for FunctionalVariant { + fn from(f: GcPcSaftFunctional) -> Self { + Self::GcPcSaft(f) } } impl From for FunctionalVariant { fn from(f: PetsFunctional) -> Self { - Self::PetsFunctional(f) + Self::Pets(f) } } impl From for FunctionalVariant { fn from(f: FMTFunctional) -> Self { - Self::FMTFunctional(f) + Self::Fmt(f) } } impl HelmholtzEnergyFunctional for FunctionalVariant { fn subset(&self, component_list: &[usize]) -> DFT { match self { - FunctionalVariant::PcSaftFunctional(functional) => { - functional.subset(component_list).into() - } - FunctionalVariant::PetsFunctional(functional) => { - functional.subset(component_list).into() - } - FunctionalVariant::FMTFunctional(functional) => { - functional.subset(component_list).into() - } + FunctionalVariant::PcSaft(functional) => functional.subset(component_list).into(), + FunctionalVariant::GcPcSaft(functional) => functional.subset(component_list).into(), + FunctionalVariant::Pets(functional) => functional.subset(component_list).into(), + FunctionalVariant::Fmt(functional) => functional.subset(component_list).into(), } } fn molecule_shape(&self) -> MoleculeShape { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.molecule_shape(), - FunctionalVariant::PetsFunctional(functional) => functional.molecule_shape(), - FunctionalVariant::FMTFunctional(functional) => functional.molecule_shape(), + FunctionalVariant::PcSaft(functional) => functional.molecule_shape(), + FunctionalVariant::GcPcSaft(functional) => functional.molecule_shape(), + FunctionalVariant::Pets(functional) => functional.molecule_shape(), + FunctionalVariant::Fmt(functional) => functional.molecule_shape(), } } fn compute_max_density(&self, moles: &Array1) -> f64 { match self { - FunctionalVariant::PcSaftFunctional(functional) => { - functional.compute_max_density(moles) - } - FunctionalVariant::PetsFunctional(functional) => functional.compute_max_density(moles), - FunctionalVariant::FMTFunctional(functional) => functional.compute_max_density(moles), + FunctionalVariant::PcSaft(functional) => functional.compute_max_density(moles), + FunctionalVariant::GcPcSaft(functional) => functional.compute_max_density(moles), + FunctionalVariant::Pets(functional) => functional.compute_max_density(moles), + FunctionalVariant::Fmt(functional) => functional.compute_max_density(moles), } } fn contributions(&self) -> &[Box] { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.contributions(), - FunctionalVariant::PetsFunctional(functional) => functional.contributions(), - FunctionalVariant::FMTFunctional(functional) => functional.contributions(), + FunctionalVariant::PcSaft(functional) => functional.contributions(), + FunctionalVariant::GcPcSaft(functional) => functional.contributions(), + FunctionalVariant::Pets(functional) => functional.contributions(), + FunctionalVariant::Fmt(functional) => functional.contributions(), } } fn ideal_gas(&self) -> &dyn IdealGasContribution { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.ideal_gas(), - FunctionalVariant::PetsFunctional(functional) => functional.ideal_gas(), - FunctionalVariant::FMTFunctional(functional) => functional.ideal_gas(), + FunctionalVariant::PcSaft(functional) => functional.ideal_gas(), + FunctionalVariant::GcPcSaft(functional) => functional.ideal_gas(), + FunctionalVariant::Pets(functional) => functional.ideal_gas(), + FunctionalVariant::Fmt(functional) => functional.ideal_gas(), } } } @@ -96,8 +102,9 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { impl MolarWeight for FunctionalVariant { fn molar_weight(&self) -> SIArray1 { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.molar_weight(), - FunctionalVariant::PetsFunctional(functional) => functional.molar_weight(), + FunctionalVariant::PcSaft(functional) => functional.molar_weight(), + FunctionalVariant::GcPcSaft(functional) => functional.molar_weight(), + FunctionalVariant::Pets(functional) => functional.molar_weight(), _ => unimplemented!(), } } @@ -106,17 +113,19 @@ impl MolarWeight for FunctionalVariant { impl FluidParameters for FunctionalVariant { fn epsilon_k_ff(&self) -> Array1 { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.epsilon_k_ff(), - FunctionalVariant::PetsFunctional(functional) => functional.epsilon_k_ff(), - FunctionalVariant::FMTFunctional(functional) => functional.epsilon_k_ff(), + FunctionalVariant::PcSaft(functional) => functional.epsilon_k_ff(), + FunctionalVariant::GcPcSaft(functional) => functional.epsilon_k_ff(), + FunctionalVariant::Pets(functional) => functional.epsilon_k_ff(), + FunctionalVariant::Fmt(functional) => functional.epsilon_k_ff(), } } fn sigma_ff(&self) -> &Array1 { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.sigma_ff(), - FunctionalVariant::PetsFunctional(functional) => functional.sigma_ff(), - FunctionalVariant::FMTFunctional(functional) => functional.sigma_ff(), + FunctionalVariant::PcSaft(functional) => functional.sigma_ff(), + FunctionalVariant::GcPcSaft(functional) => functional.sigma_ff(), + FunctionalVariant::Pets(functional) => functional.sigma_ff(), + FunctionalVariant::Fmt(functional) => functional.sigma_ff(), } } } @@ -124,9 +133,10 @@ impl FluidParameters for FunctionalVariant { impl PairPotential for FunctionalVariant { fn pair_potential(&self, r: &Array1) -> Array2 { match self { - FunctionalVariant::PcSaftFunctional(functional) => functional.pair_potential(r), - FunctionalVariant::PetsFunctional(functional) => functional.pair_potential(r), - FunctionalVariant::FMTFunctional(functional) => functional.pair_potential(r), + FunctionalVariant::PcSaft(functional) => functional.pair_potential(r), + FunctionalVariant::Pets(functional) => functional.pair_potential(r), + FunctionalVariant::Fmt(functional) => functional.pair_potential(r), + _ => unimplemented!(), } } } @@ -187,6 +197,51 @@ impl PyFunctionalVariant { )) } + /// (heterosegmented) group contribution PC-SAFT Helmholtz energy functional. + /// + /// Parameters + /// ---------- + /// parameters: GcPcSaftFunctionalParameters + /// The set of PC-SAFT parameters. + /// fmt_version: FMTVersion, optional + /// The specific variant of the FMT term. Defaults to FMTVersion.WhiteBear + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// max_iter_cross_assoc : unsigned integer, optional + /// Maximum number of iterations for cross association. Defaults to 50. + /// tol_cross_assoc : float + /// Tolerance for convergence of cross association. Defaults to 1e-10. + /// + /// Returns + /// ------- + /// Functional + #[args( + fmt_version = "FMTVersion::WhiteBear", + max_eta = "0.5", + max_iter_cross_assoc = "50", + tol_cross_assoc = "1e-10" + )] + #[staticmethod] + #[pyo3( + text_signature = "(parameters, fmt_version, max_eta, max_iter_cross_assoc, tol_cross_assoc)" + )] + fn gc_csaft( + parameters: PyGcPcSaftFunctionalParameters, + fmt_version: FMTVersion, + max_eta: f64, + max_iter_cross_assoc: usize, + tol_cross_assoc: f64, + ) -> Self { + let options = GcPcSaftOptions { + max_eta, + max_iter_cross_assoc, + tol_cross_assoc, + }; + Self(Rc::new( + GcPcSaftFunctional::with_options(parameters.0, fmt_version, options).into(), + )) + } + /// PeTS Helmholtz energy functional without simplifications /// for pure components. /// diff --git a/src/eos.rs b/src/eos.rs index 65199f638..4017528f7 100644 --- a/src/eos.rs +++ b/src/eos.rs @@ -2,6 +2,8 @@ use feos_core::cubic::PengRobinson; use feos_core::python::cubic::PyPengRobinsonParameters; use feos_core::python::user_defined::PyEoSObj; use feos_core::*; +use feos_gc_pcsaft::python::PyGcPcSaftEosParameters; +use feos_gc_pcsaft::{GcPcSaft, GcPcSaftOptions}; use feos_pcsaft::python::PyPcSaftParameters; use feos_pcsaft::{PcSaft, PcSaftOptions}; use feos_pets::python::PyPetsParameters; @@ -18,6 +20,7 @@ use std::rc::Rc; pub enum EosVariant { PcSaft(PcSaft), + GcPcSaft(GcPcSaft), PengRobinson(PengRobinson), Python(PyEoSObj), Pets(Pets), @@ -27,6 +30,7 @@ impl EquationOfState for EosVariant { fn components(&self) -> usize { match self { EosVariant::PcSaft(eos) => eos.components(), + EosVariant::GcPcSaft(eos) => eos.components(), EosVariant::PengRobinson(eos) => eos.components(), EosVariant::Python(eos) => eos.components(), EosVariant::Pets(eos) => eos.components(), @@ -36,6 +40,7 @@ impl EquationOfState for EosVariant { fn compute_max_density(&self, moles: &Array1) -> f64 { match self { EosVariant::PcSaft(eos) => eos.compute_max_density(moles), + EosVariant::GcPcSaft(eos) => eos.compute_max_density(moles), EosVariant::PengRobinson(eos) => eos.compute_max_density(moles), EosVariant::Python(eos) => eos.compute_max_density(moles), EosVariant::Pets(eos) => eos.compute_max_density(moles), @@ -45,6 +50,7 @@ impl EquationOfState for EosVariant { fn subset(&self, component_list: &[usize]) -> Self { match self { EosVariant::PcSaft(eos) => Self::PcSaft(eos.subset(component_list)), + EosVariant::GcPcSaft(eos) => Self::GcPcSaft(eos.subset(component_list)), EosVariant::PengRobinson(eos) => Self::PengRobinson(eos.subset(component_list)), EosVariant::Python(eos) => Self::Python(eos.subset(component_list)), EosVariant::Pets(eos) => Self::Pets(eos.subset(component_list)), @@ -54,6 +60,7 @@ impl EquationOfState for EosVariant { fn residual(&self) -> &[Box] { match self { EosVariant::PcSaft(eos) => eos.residual(), + EosVariant::GcPcSaft(eos) => eos.residual(), EosVariant::PengRobinson(eos) => eos.residual(), EosVariant::Python(eos) => eos.residual(), EosVariant::Pets(eos) => eos.residual(), @@ -65,6 +72,7 @@ impl MolarWeight for EosVariant { fn molar_weight(&self) -> SIArray1 { match self { EosVariant::PcSaft(eos) => eos.molar_weight(), + EosVariant::GcPcSaft(eos) => eos.molar_weight(), EosVariant::PengRobinson(eos) => eos.molar_weight(), EosVariant::Python(eos) => eos.molar_weight(), EosVariant::Pets(eos) => eos.molar_weight(), @@ -118,7 +126,9 @@ impl EntropyScaling for EosVariant { moles: &SIArray1, ) -> EosResult { match self { - EosVariant::PcSaft(eos) => eos.thermal_conductivity_reference(temperature, volume, moles), + EosVariant::PcSaft(eos) => { + eos.thermal_conductivity_reference(temperature, volume, moles) + } _ => unimplemented!(), } } @@ -164,7 +174,9 @@ impl PyEosVariant { dq_variant = "\"dq35\"" )] #[staticmethod] - #[pyo3(text_signature = "(parameters, max_eta, max_iter_cross_assoc, tol_cross_assoc, dq_variant)")] + #[pyo3( + text_signature = "(parameters, max_eta, max_iter_cross_assoc, tol_cross_assoc, dq_variant)" + )] pub fn pcsaft( parameters: PyPcSaftParameters, max_eta: f64, @@ -179,7 +191,49 @@ impl PyEosVariant { dq_variant: dq_variant.into(), }; Self(Rc::new(EosVariant::PcSaft(PcSaft::with_options( - parameters.0.clone(), + parameters.0, + options, + )))) + } + + /// Initialize the (heterosegmented) group contribution PC-SAFT equation of state. + /// + /// Parameters + /// ---------- + /// parameters : GcPcSaftEosParameters + /// The parameters of the PC-Saft equation of state to use. + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// max_iter_cross_assoc : unsigned integer, optional + /// Maximum number of iterations for cross association. Defaults to 50. + /// tol_cross_assoc : float + /// Tolerance for convergence of cross association. Defaults to 1e-10. + /// + /// Returns + /// ------- + /// EquationOfState + /// The gc-PC-SAFT equation of state that can be used to compute thermodynamic + /// states. + #[args( + max_eta = "0.5", + max_iter_cross_assoc = "50", + tol_cross_assoc = "1e-10" + )] + #[staticmethod] + #[pyo3(text_signature = "(parameters, max_eta, max_iter_cross_assoc, tol_cross_assoc)")] + pub fn gc_pcsaft( + parameters: PyGcPcSaftEosParameters, + max_eta: f64, + max_iter_cross_assoc: usize, + tol_cross_assoc: f64, + ) -> Self { + let options = GcPcSaftOptions { + max_eta, + max_iter_cross_assoc, + tol_cross_assoc, + }; + Self(Rc::new(EosVariant::GcPcSaft(GcPcSaft::with_options( + parameters.0, options, )))) } @@ -200,18 +254,18 @@ impl PyEosVariant { #[pyo3(text_signature = "(parameters)")] pub fn peng_robinson(parameters: PyPengRobinsonParameters) -> Self { Self(Rc::new(EosVariant::PengRobinson(PengRobinson::new( - parameters.0.clone(), + parameters.0, )))) } /// Equation of state from a Python class. - /// + /// /// Parameters /// ---------- /// obj : Class /// A python class implementing the necessary methods /// to be used as equation of state. - /// + /// /// Returns /// ------- /// EquationOfState @@ -241,7 +295,7 @@ impl PyEosVariant { fn pets(parameters: PyPetsParameters, max_eta: f64) -> Self { let options = PetsOptions { max_eta }; Self(Rc::new(EosVariant::Pets(Pets::with_options( - parameters.0.clone(), + parameters.0, options, )))) } diff --git a/src/gc_pcsaft.rs b/src/gc_pcsaft.rs new file mode 100644 index 000000000..8bfd5cf2b --- /dev/null +++ b/src/gc_pcsaft.rs @@ -0,0 +1,21 @@ +use feos_core::python::joback::PyJobackRecord; +use feos_core::python::parameter::*; +use feos_gc_pcsaft::python::{ + PyGcPcSaftEosParameters, PyGcPcSaftFunctionalParameters, PyGcPcSaftRecord, PySegmentRecord, +}; +use pyo3::prelude::*; + +#[pymodule] +pub fn gc_pcsaft(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +} diff --git a/src/lib.rs b/src/lib.rs index ccbc8eb7f..7eb776247 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,5 @@ +#![warn(clippy::all)] +#![allow(clippy::too_many_arguments)] use pyo3::prelude::*; use pyo3::wrap_pymodule; use quantity::python::__PYO3_PYMODULE_DEF_QUANTITY; @@ -9,6 +11,8 @@ mod cubic; use cubic::__PYO3_PYMODULE_DEF_CUBIC; mod pcsaft; use pcsaft::__PYO3_PYMODULE_DEF_PCSAFT; +mod gc_pcsaft; +use gc_pcsaft::__PYO3_PYMODULE_DEF_GC_PCSAFT; mod pets; use pets::__PYO3_PYMODULE_DEF_PETS; @@ -19,6 +23,7 @@ pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pymodule!(dft))?; m.add_wrapped(wrap_pymodule!(cubic))?; m.add_wrapped(wrap_pymodule!(pcsaft))?; + m.add_wrapped(wrap_pymodule!(gc_pcsaft))?; m.add_wrapped(wrap_pymodule!(pets))?; py.run( "\ @@ -33,6 +38,7 @@ sys.modules['feos.eos'] = eos sys.modules['feos.dft'] = dft sys.modules['feos.cubic'] = cubic sys.modules['feos.pcsaft'] = pcsaft +sys.modules['feos.gc_pcsaft'] = gc_pcsaft sys.modules['feos.pets'] = pets ", None, From 422896212a4609dc37691d3640596d6dad7e060a Mon Sep 17 00:00:00 2001 From: Philipp Rehner Date: Mon, 25 Apr 2022 20:33:45 +0200 Subject: [PATCH 12/15] example for the gc-pcsaft functional including necessary fixes to make it work --- Cargo.lock | 136 +++++++--- Cargo.toml | 5 +- examples/gc_pcsaft_functional.ipynb | 219 ++++++++++++++++ parameters/pcsaft/gc_substances.json | 374 +++++++++++++-------------- src/dft.rs | 10 +- 5 files changed, 523 insertions(+), 221 deletions(-) create mode 100644 examples/gc_pcsaft_functional.ipynb diff --git a/Cargo.lock b/Cargo.lock index 4d7a7bdba..1ee072bb3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -139,18 +139,21 @@ version = "0.1.1" dependencies = [ "feos-core", "feos-dft", + "feos-gc-pcsaft", "feos-pcsaft", "feos-pets", "ndarray", "numpy", + "petgraph", "pyo3", "quantity", ] [[package]] name = "feos-core" -version = "0.1.5" -source = "git+https://github.com/feos-org/feos-core#7c61e48da1ea8db8a106e1e8634c26114df27ab8" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ea697b2f1dc990ed2ab6ef82a00aa22bb527d0fa0c28633e8b8301675e1dce8" dependencies = [ "approx 0.4.0", "either", @@ -168,8 +171,9 @@ dependencies = [ [[package]] name = "feos-dft" -version = "0.1.3" -source = "git+https://github.com/feos-org/feos-dft?branch=v0.2.0#42a8fbec2d4e45545f79e850e2ced2d0d010cf52" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de090412876a95b6c475c70268a38cd054534e1f9a731090d680d3d8e19856fb" dependencies = [ "ang", "feos-core", @@ -188,9 +192,32 @@ dependencies = [ ] [[package]] -name = "feos-pcsaft" +name = "feos-gc-pcsaft" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pcsaft#04ff8f48966889a64b31e60027be7ceb960875d3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a5e6b449c884835df818c858679e48e629ae4fa7c761c5bed16c4812a634755" +dependencies = [ + "feos-core", + "feos-dft", + "indexmap", + "lazy_static", + "ndarray", + "num", + "num-dual", + "numpy", + "petgraph", + "pyo3", + "quantity", + "serde", + "serde_json", + "thiserror", +] + +[[package]] +name = "feos-pcsaft" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e17199ef40b6cf23e26ba83259013c4b70605313fcb1c26d84b8f2ced4061c7a" dependencies = [ "feos-core", "feos-dft", @@ -209,7 +236,7 @@ dependencies = [ [[package]] name = "feos-pets" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pets?branch=new_dft_struct#079a1326cb14d03a5166677cce0fc98895433185" +source = "git+https://github.com/feos-org/feos-pets#e71705b9d855d6ce0f1bc15eac1ec7e2bf3eceda" dependencies = [ "feos-core", "feos-dft", @@ -255,9 +282,9 @@ dependencies = [ [[package]] name = "ghost" -version = "0.1.2" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a5bcf1bbeab73aa4cf2fde60a846858dc036163c7c33bec309f8d17de785479" +checksum = "76c813ffb63e8fd3df6f1ac3cc1ea392c7612ac2de4d0b44dcbfe03e5c4bf94a" dependencies = [ "proc-macro2", "quote", @@ -300,9 +327,9 @@ dependencies = [ [[package]] name = "inventory" -version = "0.2.2" +version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce6b5d8c669bfbad811d95ddd7a1c6cf9cfdbf2777e59928b6f3fa8ff54f72a0" +checksum = "84344c6e0b90a9e2b6f3f9abe5cc74402684e348df7b32adca28747e0cef091a" dependencies = [ "ctor", "ghost", @@ -331,9 +358,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.122" +version = "0.2.124" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec647867e2bf0772e28c8bcde4f0d19a9216916e890543b5a03ed8ef27b8f259" +checksum = "21a41fed9d98f27ab1c6d161da622a4fa35e8a54a8adc24bbf3ddd0ef70b0e50" [[package]] name = "libm" @@ -384,7 +411,7 @@ dependencies = [ "approx 0.4.0", "matrixmultiply", "num-complex 0.3.1", - "num-rational", + "num-rational 0.3.2", "num-traits", "rand", "rand_distr", @@ -432,6 +459,31 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606" +dependencies = [ + "num-bigint", + "num-complex 0.4.0", + "num-integer", + "num-iter", + "num-rational 0.4.0", + "num-traits", +] + +[[package]] +name = "num-bigint" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + [[package]] name = "num-complex" version = "0.3.1" @@ -471,6 +523,17 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-iter" +version = "0.1.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2021c8337a54d21aca0d59a92577a029af9431cb59b909b03252b9c164fad59" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + [[package]] name = "num-rational" version = "0.3.2" @@ -482,6 +545,18 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-rational" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a" +dependencies = [ + "autocfg", + "num-bigint", + "num-integer", + "num-traits", +] + [[package]] name = "num-traits" version = "0.2.14" @@ -586,9 +661,9 @@ dependencies = [ [[package]] name = "pyo3" -version = "0.16.3" +version = "0.16.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b3e99c4c3e790e4fc365b42b70c1f7801f42eadc4ea648fa327e6f5ca29f215" +checksum = "cd86513975ed69bf3fb5d4a286cdcda66dbc56f84bdf4832b6c82b459f4417b2" dependencies = [ "cfg-if", "indoc", @@ -603,9 +678,9 @@ dependencies = [ [[package]] name = "pyo3-build-config" -version = "0.16.3" +version = "0.16.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2486b96281859ff0a3929ba6467b13751627b974f7137362db38e2bed14b2094" +checksum = "450e2e56cbfa67bbe224cef93312b7a76d81c471d4e0c459d24d4bfaf3d75b53" dependencies = [ "once_cell", "target-lexicon", @@ -613,9 +688,9 @@ dependencies = [ [[package]] name = "pyo3-ffi" -version = "0.16.3" +version = "0.16.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd9de1d94557751599f8bd321f10e6c1ef2801067acb58c91138deef2ae83a17" +checksum = "36e653782972eba2fe86e8319ade54b97822c65fb1ccc1e116368372faa6ebc9" dependencies = [ "libc", "pyo3-build-config", @@ -623,9 +698,9 @@ dependencies = [ [[package]] name = "pyo3-macros" -version = "0.16.3" +version = "0.16.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9584049129b1cfb615243391a6345c726690271ae195ffd6aa3766177296aa" +checksum = "317ce641f29f4e10e75765630bf4d28b2008612226fcc80b27f334fee8184d0f" dependencies = [ "proc-macro2", "pyo3-macros-backend", @@ -635,9 +710,9 @@ dependencies = [ [[package]] name = "pyo3-macros-backend" -version = "0.16.3" +version = "0.16.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6c4717e6a55c51a9958eda1f5481ff7f62cccd21f45309c10e4731cb7198dbc" +checksum = "59342fce58a05983688e8d81209d06f67f0fcb1597253ef63b390b2da2417522" dependencies = [ "proc-macro2", "quote", @@ -664,9 +739,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.17" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "632d02bff7f874a36f33ea8bb416cd484b90cc66c1194b1a1110d067a7013f58" +checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1" dependencies = [ "proc-macro2", ] @@ -719,9 +794,9 @@ checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" [[package]] name = "rayon" -version = "1.5.1" +version = "1.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90" +checksum = "fd249e82c21598a9a426a4e00dd7adc1d640b22445ec8545feef801d1a74c221" dependencies = [ "autocfg", "crossbeam-deque", @@ -731,14 +806,13 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.9.1" +version = "1.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e" +checksum = "9f51245e1e62e1f1629cbfec37b5793bbabcaeb90f30e94d2ba03564687353e4" dependencies = [ "crossbeam-channel", "crossbeam-deque", "crossbeam-utils", - "lazy_static", "num_cpus", ] diff --git a/Cargo.toml b/Cargo.toml index 533723993..bc216013e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,11 +19,12 @@ crate-type = ["cdylib"] quantity = "0.5" feos-core = "0.2" feos-dft = "0.2" -feos-pcsaft = { git = "https://github.com/feos-org/feos-pcsaft", features = ["python"] } +feos-pcsaft = { version = "0.2", features = ["python"] } feos-gc-pcsaft = { version = "0.1", features = ["python"] } feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"] } -numpy = { version = "0.16" } +numpy = "0.16" ndarray = { version = "0.15", features=["approx"] } +petgraph = "0.6" [dependencies.pyo3] version = "0.16" diff --git a/examples/gc_pcsaft_functional.ipynb b/examples/gc_pcsaft_functional.ipynb new file mode 100644 index 000000000..c2e38bf50 --- /dev/null +++ b/examples/gc_pcsaft_functional.ipynb @@ -0,0 +1,219 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The (heterosegmented) group contribution PC-SAFT functional\n", + "In segment-based Helmholtz energy functionals like the one corresponding to the heterosegmented gc PC-SAFT equation of state, the spatial distribution of individual segments is calculated." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from feos.si import *\n", + "from feos.dft import *\n", + "from feos.gc_pcsaft import *\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interfaces\n", + "In this example, the vapor-liquid interface of pure 1-pentanol is calculated. From the density profile, it becomes apparent how the polar hydroxy group slightly accumulates on the liquid side of the interface." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "func = HelmholtzEnergyFunctional.gc_pcsaft(GcPcSaftFunctionalParameters.from_json_segments(['1-pentanol'], '../parameters/pcsaft/gc_substances.json', '../parameters/pcsaft/sauer2014_hetero.json'))\n", + "vle = PhaseEquilibrium.pure(func, 300*KELVIN)\n", + "profile = PlanarInterface.from_tanh(vle, 4096, 100*ANGSTROM, 600*KELVIN).solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2.5, 6.0, 0.0, 8.0)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots()\n", + "\n", + "ax.plot(profile.z/(NANO*METER), (profile.density*NAV*(NANO*METER)**3).T)\n", + "ax.legend(['CH$_3$'] + ['CH$_2$']*4 + ['OH'])\n", + "ax.set_xlabel('$z~~/~~\\mathrm{nm}$')\n", + "ax.set_ylabel('$\\\\rho~~/~~\\mathrm{nm}^{-3}$')\n", + "ax.axis([2.5,6,0,8])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Porous media\n", + "The orientation of polar molecules becomes even more apparent in confined media. Shown here, the orientation of 1-pentanol in a non-polar slit pore." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "bulk = State(func, 300*KELVIN, pressure=5*BAR)\n", + "solver = DFTSolver().picard_iteration(tol=1e-5, beta=0.05).anderson_mixing()\n", + "pore = Pore1D(Geometry.Cartesian, 20*ANGSTROM, ExternalPotential.LJ93(3.0, 10.0, 0.08)).initialize(bulk).solve(solver)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 1.2, 0.0, 11.0)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, ax = plt.subplots()\n", + "\n", + "ax.plot(pore.z/(NANO*METER), (pore.density*NAV*(NANO*METER)**3).T)\n", + "ax.legend(['CH$_3$'] + ['CH$_2$']*4 + ['OH'])\n", + "ax.set_xlabel('$z~~/~~\\mathrm{nm}$')\n", + "ax.set_ylabel('$\\\\rho~~/~~\\mathrm{nm}^{-3}$')\n", + "ax.axis([0,1.2,0,11])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Branched molecules\n", + "The heterosegmented DFT method is able to describe branched molecules. Not how the isomers 1-propanol and 2-propanol show significantly different orientations in a slit pore.\n", + "\n", + "Due to the symmetry of the 2-propanol molecules, only 3 distinct density profiles are visible." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_pore(comp):\n", + " func = HelmholtzEnergyFunctional.gc_pcsaft(GcPcSaftFunctionalParameters.from_json_segments([comp], '../parameters/pcsaft/gc_substances.json', '../parameters/pcsaft/sauer2014_hetero.json'))\n", + " bulk = State(func, 300*KELVIN, pressure=5*BAR)\n", + " solver = DFTSolver().picard_iteration(tol=1e-5, beta=0.05).anderson_mixing()\n", + " return Pore1D(Geometry.Cartesian, 20*ANGSTROM, ExternalPotential.LJ93(3.0, 10.0, 0.08)).initialize(bulk).solve(solver)\n", + "\n", + "comps = ['2-propanol', '1-propanol']\n", + "pores = [calc_pore(comp) for comp in comps]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f, axes = plt.subplots(1,2,figsize=(15,5))\n", + "\n", + "for pore,comp,ax in zip(pores,comps,axes):\n", + " ax.plot(pore.z/(NANO*METER), (pore.density*NAV*(NANO*METER)**3).T)\n", + " if comp[0] == '2':\n", + " ax.legend(['CH$_3$', 'CH', 'OH', 'CH$_3$'])\n", + " elif comp[0] == '1':\n", + " ax.legend(['CH$_3$'] + ['CH$_2$']*2 + ['OH'])\n", + " ax.set_xlabel('$z~~/~~\\mathrm{nm}$')\n", + " ax.set_ylabel('$\\\\rho~~/~~\\mathrm{nm}^{-3}$')\n", + " ax.axis([0,1.2,0,15])\n", + " ax.set_title(comp)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "feos", + "language": "python", + "name": "feos" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/parameters/pcsaft/gc_substances.json b/parameters/pcsaft/gc_substances.json index 756c5f4f8..a306a850e 100644 --- a/parameters/pcsaft/gc_substances.json +++ b/parameters/pcsaft/gc_substances.json @@ -177,17 +177,17 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 ], [ - 2, + 1, 3 - ], - [ - 2, - 4 ] ] }, @@ -209,6 +209,10 @@ "OH" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -218,16 +222,12 @@ 3 ], [ - 3, + 2, 4 ], [ - 3, + 2, 5 - ], - [ - 3, - 6 ] ] }, @@ -292,17 +292,17 @@ "NH2" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 ], [ - 2, + 1, 3 - ], - [ - 2, - 4 ] ] }, @@ -325,6 +325,10 @@ "NH2" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -342,16 +346,12 @@ 5 ], [ - 5, - 6 + 0, + 5 ], [ - 1, + 5, 6 - ], - [ - 6, - 7 ] ] }, @@ -823,16 +823,16 @@ ], "bonds": [ [ - 1, - 2 + 0, + 1 ], [ - 1, - 3 + 0, + 2 ], [ - 1, - 4 + 0, + 3 ] ] }, @@ -853,6 +853,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -862,12 +866,8 @@ 3 ], [ - 3, + 1, 4 - ], - [ - 2, - 5 ] ] }, @@ -889,20 +889,20 @@ ], "bonds": [ [ - 1, + 0, + 1 + ], + [ + 0, 2 ], [ - 1, + 0, 3 ], [ - 1, + 0, 4 - ], - [ - 1, - 5 ] ] }, @@ -924,6 +924,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -937,12 +941,8 @@ 4 ], [ - 4, + 1, 5 - ], - [ - 2, - 6 ] ] }, @@ -964,6 +964,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -973,16 +977,12 @@ 3 ], [ - 3, + 1, 4 ], [ - 2, + 1, 5 - ], - [ - 2, - 6 ] ] }, @@ -1004,6 +1004,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1013,16 +1017,12 @@ 3 ], [ - 3, + 1, 4 ], [ 2, 5 - ], - [ - 3, - 6 ] ] }, @@ -1044,6 +1044,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1057,12 +1061,8 @@ 4 ], [ - 4, + 2, 5 - ], - [ - 3, - 6 ] ] }, @@ -1085,6 +1085,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1102,12 +1106,8 @@ 5 ], [ - 5, + 1, 6 - ], - [ - 2, - 7 ] ] }, @@ -1128,6 +1128,10 @@ "CH2_pent" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1142,11 +1146,7 @@ ], [ 4, - 5 - ], - [ - 5, - 1 + 0 ] ] }, @@ -1168,6 +1168,10 @@ "CH2_hex" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1186,11 +1190,7 @@ ], [ 5, - 6 - ], - [ - 6, - 1 + 0 ] ] }, @@ -1212,6 +1212,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1226,15 +1230,11 @@ ], [ 4, - 5 - ], - [ - 5, - 1 + 0 ], [ - 5, - 6 + 4, + 5 ] ] }, @@ -1257,6 +1257,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1275,15 +1279,11 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 - ], - [ - 6, - 7 + 5, + 6 ] ] }, @@ -1306,6 +1306,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1320,19 +1324,15 @@ ], [ 4, - 5 + 0 ], [ - 5, - 1 + 4, + 5 ], [ 5, 6 - ], - [ - 6, - 7 ] ] }, @@ -1356,6 +1356,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1374,19 +1378,15 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 5, + 6 ], [ 6, 7 - ], - [ - 7, - 8 ] ] }, @@ -1507,6 +1507,10 @@ "CH_pent" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1521,11 +1525,7 @@ ], [ 4, - 5 - ], - [ - 5, - 1 + 0 ] ] }, @@ -1547,6 +1547,10 @@ "CH_arom" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1565,11 +1569,7 @@ ], [ 5, - 6 - ], - [ - 6, - 1 + 0 ] ] }, @@ -1592,6 +1592,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1610,15 +1614,11 @@ ], [ 5, - 6 - ], - [ - 6, - 1 + 0 ], [ - 6, - 7 + 5, + 6 ] ] }, @@ -1642,6 +1642,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1660,19 +1664,15 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 5, + 6 ], [ 6, 7 - ], - [ - 7, - 8 ] ] }, @@ -1696,6 +1696,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1714,19 +1718,15 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 1, + 6 ], [ - 2, + 5, 7 - ], - [ - 6, - 8 ] ] }, @@ -1750,6 +1750,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1768,19 +1772,15 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 4, + 6 ], [ 5, 7 - ], - [ - 6, - 8 ] ] }, @@ -1804,6 +1804,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1822,19 +1826,15 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 0, + 6 ], [ - 1, + 3, 7 - ], - [ - 4, - 8 ] ] }, @@ -1859,6 +1859,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1877,11 +1881,11 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 5, + 6 ], [ 6, @@ -1890,10 +1894,6 @@ [ 7, 8 - ], - [ - 8, - 9 ] ] }, @@ -1919,6 +1919,10 @@ "CH2_hex" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -1937,11 +1941,11 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 5, + 6 ], [ 6, @@ -1957,11 +1961,7 @@ ], [ 9, - 10 - ], - [ - 10, - 5 + 4 ] ] }, @@ -1987,6 +1987,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -2005,11 +2009,11 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 5, + 6 ], [ 6, @@ -2022,10 +2026,6 @@ [ 8, 9 - ], - [ - 9, - 10 ] ] }, @@ -2053,6 +2053,10 @@ "CH_arom" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -2071,11 +2075,11 @@ ], [ 5, - 6 + 0 ], [ - 6, - 1 + 5, + 6 ], [ 6, @@ -2099,11 +2103,7 @@ ], [ 11, - 12 - ], - [ - 12, - 7 + 6 ] ] }, @@ -2266,6 +2266,10 @@ "CH3" ], "bonds": [ + [ + 0, + 1 + ], [ 1, 2 @@ -2275,12 +2279,8 @@ 3 ], [ - 3, + 1, 4 - ], - [ - 2, - 5 ] ] }, diff --git a/src/dft.rs b/src/dft.rs index 819c81948..105ad8cbd 100644 --- a/src/dft.rs +++ b/src/dft.rs @@ -14,6 +14,7 @@ use feos_pets::{PetsFunctional, PetsOptions}; use ndarray::{Array1, Array2}; use numpy::convert::ToPyArray; use numpy::{PyArray1, PyArray2, PyArray4}; +use petgraph::graph::{Graph, UnGraph}; use pyo3::exceptions::PyValueError; use pyo3::prelude::*; use quantity::python::*; @@ -97,6 +98,13 @@ impl HelmholtzEnergyFunctional for FunctionalVariant { FunctionalVariant::Fmt(functional) => functional.ideal_gas(), } } + + fn bond_lengths(&self, temperature: f64) -> UnGraph<(), f64> { + match self { + FunctionalVariant::GcPcSaft(functional) => functional.bond_lengths(temperature), + _ => Graph::with_capacity(0, 0), + } + } } impl MolarWeight for FunctionalVariant { @@ -225,7 +233,7 @@ impl PyFunctionalVariant { #[pyo3( text_signature = "(parameters, fmt_version, max_eta, max_iter_cross_assoc, tol_cross_assoc)" )] - fn gc_csaft( + fn gc_pcsaft( parameters: PyGcPcSaftFunctionalParameters, fmt_version: FMTVersion, max_eta: f64, From 1f10901fcde901a8393624626f1c51321399af2f Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Thu, 28 Apr 2022 15:01:22 +0200 Subject: [PATCH 13/15] fixed documentation, added estimator --- Cargo.lock | 13 +++ Cargo.toml | 1 + README.md | 20 +++++ docs/api/dft.md | 69 +++++++++++++++ docs/api/dft/fmt.rst | 38 -------- docs/api/dft/index.md | 13 --- docs/api/eos.md | 35 ++++++++ docs/api/eos/index.md | 15 ---- docs/api/eos/pcsaft.rst | 86 ------------------- docs/api/eos/user_defined.rst | 23 ----- docs/api/gc_pcsaft.md | 29 +++++++ docs/api/index.md | 38 +++----- docs/api/pcsaft.md | 30 +++++++ .../peng_robinson.rst => peng_robinson.md} | 33 ++----- docs/api/pets.md | 21 +++++ docs/api/si.md | 31 +++++++ docs/api/utility/index.md | 12 --- docs/api/utility/si.rst | 18 ---- docs/index.md | 20 +++-- docs/recipes/critical_point.md | 10 +++ docs/recipes/index.md | 29 +++++++ src/estimator.rs | 17 ++++ src/lib.rs | 4 + 23 files changed, 346 insertions(+), 259 deletions(-) create mode 100644 docs/api/dft.md delete mode 100644 docs/api/dft/fmt.rst delete mode 100644 docs/api/dft/index.md create mode 100644 docs/api/eos.md delete mode 100644 docs/api/eos/index.md delete mode 100644 docs/api/eos/pcsaft.rst delete mode 100644 docs/api/eos/user_defined.rst create mode 100644 docs/api/gc_pcsaft.md create mode 100644 docs/api/pcsaft.md rename docs/api/{eos/peng_robinson.rst => peng_robinson.md} (59%) create mode 100644 docs/api/pets.md create mode 100644 docs/api/si.md delete mode 100644 docs/api/utility/index.md delete mode 100644 docs/api/utility/si.rst create mode 100644 docs/recipes/critical_point.md create mode 100644 docs/recipes/index.md create mode 100644 src/estimator.rs diff --git a/Cargo.lock b/Cargo.lock index 1ee072bb3..f80b07d3f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -139,6 +139,7 @@ version = "0.1.1" dependencies = [ "feos-core", "feos-dft", + "feos-estimator", "feos-gc-pcsaft", "feos-pcsaft", "feos-pets", @@ -191,6 +192,18 @@ dependencies = [ "rustfft", ] +[[package]] +name = "feos-estimator" +version = "0.1.0" +dependencies = [ + "feos-core", + "ndarray", + "numpy", + "pyo3", + "quantity", + "thiserror", +] + [[package]] name = "feos-gc-pcsaft" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index bc216013e..4dae7db24 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,6 +22,7 @@ feos-dft = "0.2" feos-pcsaft = { version = "0.2", features = ["python"] } feos-gc-pcsaft = { version = "0.1", features = ["python"] } feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"] } +feos-estimator = { path = "../feos-estimator", features = ["python"] } numpy = "0.16" ndarray = { version = "0.15", features=["approx"] } petgraph = "0.6" diff --git a/README.md b/README.md index 2d64c8e33..68be69998 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,26 @@ The `FeOs` package conveniently provides bindings to the Rust implementations of different equation of state and Helmholtz energy functional models in a single Python package. +```python +from feos.eos import EquationOfState, State +from feos.pcsaft import PcSaftParameters + +# Build an equation of state +parameters = PcSaftParameters.from_json(['methanol'], 'parameters.json') +eos = EquationOfState.pcsaft(parameters) + +# Define thermodynamic conditions +critical_point = State.critical_point(eos) + +# Compute properties +p = critical_point.pressure() +t = critical_point.temperature +print(f'Critical point for methanol: T={t}, p={p}.') +``` +```terminal +Critical point for methanol: T=531.5 K, p=10.7 MPa. +``` + ## Models The following models are currently published as part of the `FeOs` framework diff --git a/docs/api/dft.md b/docs/api/dft.md new file mode 100644 index 000000000..423f46550 --- /dev/null +++ b/docs/api/dft.md @@ -0,0 +1,69 @@ + +# `feos.dft` + +## `HelmholtzEnergyFunctional` + +Implementations of Helmholtz energy functionals for DFT. + +```{eval-rst} +.. currentmodule:: feos.dft + +.. autosummary:: + :toctree: generated/ + + HelmholtzEnergyFunctional + HelmholtzEnergyFunctional.pcsaft + HelmholtzEnergyFunctional.gcpcsaft + HelmholtzEnergyFunctional.pets + HelmholtzEnergyFunctional.fmt +``` + +## Other data types + +```{eval-rst} +.. currentmodule:: feos.dft + +.. autosummary:: + :toctree: generated/ + + State + PhaseEquilibrium + PhaseDiagram + Contributions + Verbosity + FMTVersion +``` + +## Interfaces + +```{eval-rst} +.. autosummary:: + :toctree: generated/ + + PlanarInterface + SurfaceTensionDiagram +``` + +## Adsorption + +```{eval-rst} +.. autosummary:: + :toctree: generated/ + + ExternalPotential + Geometry + Pore1D + Pore3D + Adsorption1D + Adsorption3D +``` + +## Solvation + +```{eval-rst} +.. autosummary:: + :toctree: generated/ + + PairCorrelation + SolvationProfile +``` \ No newline at end of file diff --git a/docs/api/dft/fmt.rst b/docs/api/dft/fmt.rst deleted file mode 100644 index 0118312b0..000000000 --- a/docs/api/dft/fmt.rst +++ /dev/null @@ -1,38 +0,0 @@ -Fundamental Measure Theory --------------------------- - -.. _fmt_api: - -.. currentmodule:: feos.fmt - -Functional -~~~~~~~~~~ - -.. autosummary:: - :toctree: generated/ - - FMTFunctional - DFTSolver - FMTVersion - State - -Adsorption -~~~~~~~~~~ - -.. autosummary:: - :toctree: generated/ - - ExternalPotential - Geometry - Pore1D - Pore3D - Adsorption1D - Adsorption3D - -Solvation -~~~~~~~~~ - -.. autosummary:: - :toctree: generated/ - - PairCorrelation diff --git a/docs/api/dft/index.md b/docs/api/dft/index.md deleted file mode 100644 index e6ba5eb97..000000000 --- a/docs/api/dft/index.md +++ /dev/null @@ -1,13 +0,0 @@ -# Density functional theory - -Implementation of Helmholtz energy functionals. - -```{eval-rst} -.. toctree:: - :maxdepth: 1 - - fmt -``` - - - diff --git a/docs/api/eos.md b/docs/api/eos.md new file mode 100644 index 000000000..33ab9bca2 --- /dev/null +++ b/docs/api/eos.md @@ -0,0 +1,35 @@ +# `feos.eos` + +The `eos` module contains the `EquationOfState` object that contains all implemented equations of state. +The `State` and `PhaseEquilibrium` objects are used to define thermodynamic conditions and -- once created -- can be used to compute properties. + +## `EquationOfState` + +```{eval-rst} +.. currentmodule:: feos.eos + +.. autosummary:: + :toctree: generated/ + + EquationOfState + EquationOfState.pcsaft + EquationOfState.gc_pcsaft + EquationOfState.peng_robinson + EquationOfState.pets + EquationOfState.python +``` + +## Other data types + +```{eval-rst} +.. currentmodule:: feos.eos + +.. autosummary:: + :toctree: generated/ + + Contributions + Verbosity + State + PhaseEquilibrium + PhaseDiagram +``` \ No newline at end of file diff --git a/docs/api/eos/index.md b/docs/api/eos/index.md deleted file mode 100644 index 2e61fa2e9..000000000 --- a/docs/api/eos/index.md +++ /dev/null @@ -1,15 +0,0 @@ -# Equations of state - -Implementations of equations of state and possibly classical density functional theory. - -```{eval-rst} -.. toctree:: - :maxdepth: 1 - - user_defined - peng_robinson - pcsaft -``` - - - diff --git a/docs/api/eos/pcsaft.rst b/docs/api/eos/pcsaft.rst deleted file mode 100644 index 6b08c2227..000000000 --- a/docs/api/eos/pcsaft.rst +++ /dev/null @@ -1,86 +0,0 @@ -PC-SAFT -------- - -Implementation of the PC SAFT equation of state. - -Parameter and utility -~~~~~~~~~~~~~~~~~~~~~ - -.. currentmodule:: feos.pcsaft - -.. autosummary:: - :toctree: generated/ - - Identifier - ChemicalRecord - JobackRecord - PureRecord - SegmentRecord - BinaryRecord - BinarySegmentRecord - PcSaftRecord - PcSaftParameters - Contributions - Verbosity - - -Equation of state -~~~~~~~~~~~~~~~~~ - -.. currentmodule:: feos.pcsaft.eos - -.. autosummary:: - :toctree: generated/ - - PcSaft - State - PhaseEquilibrium - PhaseDiagramPure - PhaseDiagramBinary - PhaseDiagramHetero - -Density functional theory -~~~~~~~~~~~~~~~~~~~~~~~~~ - -.. currentmodule:: feos.pcsaft.dft - -.. autosummary:: - :toctree: generated/ - - PcSaftFunctional - State - PhaseEquilibrium - PhaseDiagramPure - PhaseDiagramBinary - PhaseDiagramHetero - -Interfaces -^^^^^^^^^^ - -.. autosummary:: - :toctree: generated/ - - PlanarInterface - SurfaceTensionDiagram - -Adsorption -^^^^^^^^^^ - -.. autosummary:: - :toctree: generated/ - - ExternalPotential - Geometry - Pore1D - Pore3D - Adsorption1D - Adsorption3D - -Solvation -^^^^^^^^^ - -.. autosummary:: - :toctree: generated/ - - PairCorrelation - SolvationProfile \ No newline at end of file diff --git a/docs/api/eos/user_defined.rst b/docs/api/eos/user_defined.rst deleted file mode 100644 index febbaa3bd..000000000 --- a/docs/api/eos/user_defined.rst +++ /dev/null @@ -1,23 +0,0 @@ -.. _user_defined_api: - - -User defined equation of state ------------------------------- - -A :class:`UserDefinedEos` can be used to implement an equation of state as Python class object. -See :doc:`this example notebook ` to learn more. - -Equation of state -~~~~~~~~~~~~~~~~~ - -.. currentmodule:: feos.user_defined - -.. autosummary:: - :toctree: generated/ - - UserDefinedEos - State - PhaseEquilibrium - PhaseDiagramPure - PhaseDiagramBinary - PhaseDiagramHetero diff --git a/docs/api/gc_pcsaft.md b/docs/api/gc_pcsaft.md new file mode 100644 index 000000000..b8c73e546 --- /dev/null +++ b/docs/api/gc_pcsaft.md @@ -0,0 +1,29 @@ +# `feos.gc_pcsaft` + +Utilities to build `GcPcSaftParameters`. To learn more about ways to build parameters from files or within Python, see [this example](/examples/eos/pcsaft/pcsaft_working_with_parameters). + +## Example + +```python +from feos.gc_pcsaft import GcPcSaftParameters + +``` + +## Data types + +```{eval-rst} +.. currentmodule:: feos.gc_pcsaft + +.. autosummary:: + :toctree: generated/ + + Identifier + ChemicalRecord + JobackRecord + SegmentRecord + BinaryRecord + BinarySegmentRecord + GcPcSaftRecord + GcPcSaftEosParameters + GcPcSaftFunctionalParameters +``` \ No newline at end of file diff --git a/docs/api/index.md b/docs/api/index.md index a69d71b04..6672ddd1f 100644 --- a/docs/api/index.md +++ b/docs/api/index.md @@ -1,38 +1,26 @@ # API -## Utility - -Functionalities that make working with the code easier. +## Modules ```{eval-rst} .. toctree:: - :maxdepth: 2 + :maxdepth: 1 - utility/index + si + eos + dft ``` -## Equations of state +## Model specific modules -Implementations of equations of state and possibly classical density functional theory. +These modules contain the objects to e.g. read parameters from files or build parameters from records in Python. ```{eval-rst} .. toctree:: - :maxdepth: 2 - - eos/index -``` - - - -## Density functional theory - -Implementation of Helmholtz energy functionals. - -```{eval-rst} -.. toctree:: - :maxdepth: 2 - - dft/index -``` - + :maxdepth: 1 + pcsaft + gc_pcsaft + peng_robinson + pets +``` \ No newline at end of file diff --git a/docs/api/pcsaft.md b/docs/api/pcsaft.md new file mode 100644 index 000000000..d71eab90a --- /dev/null +++ b/docs/api/pcsaft.md @@ -0,0 +1,30 @@ +# `feos.pcsaft` + +Utilities to build `PcSaftParameters`. To learn more about ways to build parameters from files or within Python, see [this example](/examples/eos/pcsaft/pcsaft_working_with_parameters). + +## Example + +```python +from feos.pcsaft import PcSaftParameters + +parameters = PcSaftParameters.from_json(['methane', 'ethane'], 'parameters.json') +``` + +## Data types + +```{eval-rst} +.. currentmodule:: feos.pcsaft + +.. autosummary:: + :toctree: generated/ + + Identifier + ChemicalRecord + JobackRecord + PureRecord + SegmentRecord + BinaryRecord + BinarySegmentRecord + PcSaftRecord + PcSaftParameters +``` \ No newline at end of file diff --git a/docs/api/eos/peng_robinson.rst b/docs/api/peng_robinson.md similarity index 59% rename from docs/api/eos/peng_robinson.rst rename to docs/api/peng_robinson.md index 69bafdeab..ed83fcf87 100644 --- a/docs/api/eos/peng_robinson.rst +++ b/docs/api/peng_robinson.md @@ -1,17 +1,16 @@ -.. _peng_robinson_api: - -.. currentmodule:: feos.cubic - -Peng-Robinson -------------- +# `feos.cubic` +```{eval-rst} .. important:: This implementation of the Peng-Robinson equation of state is intended to be used as simple example when considering implementing an equation of state. It is not a sophisticated implementation and should probably not be used to do research. +``` -Parameter and utility -~~~~~~~~~~~~~~~~~~~~~ +## Data types + +```{eval-rst} +.. currentmodule:: feos.cubic .. autosummary:: :toctree: generated/ @@ -19,22 +18,8 @@ Parameter and utility Identifier ChemicalRecord JobackRecord - PengRobinsonRecord PureRecord BinaryRecord + PengRobinsonRecord PengRobinsonParameters - Contributions - Verbosity - -Equation of state -~~~~~~~~~~~~~~~~~ - -.. autosummary:: - :toctree: generated/ - - PengRobinson - State - PhaseEquilibrium - PhaseDiagramPure - PhaseDiagramBinary - PhaseDiagramHetero \ No newline at end of file +``` \ No newline at end of file diff --git a/docs/api/pets.md b/docs/api/pets.md new file mode 100644 index 000000000..033f1c9dd --- /dev/null +++ b/docs/api/pets.md @@ -0,0 +1,21 @@ +# `feos.pets` + +## Example + + +## Data types + +```{eval-rst} +.. currentmodule:: feos.pets + +.. autosummary:: + :toctree: generated/ + + Identifier + ChemicalRecord + JobackRecord + PureRecord + BinaryRecord + PetsRecord + PetsParameters +``` \ No newline at end of file diff --git a/docs/api/si.md b/docs/api/si.md new file mode 100644 index 000000000..fe1a5957f --- /dev/null +++ b/docs/api/si.md @@ -0,0 +1,31 @@ +# `feos.si` + +This module contains data types for dimensioned quantities, i.e. floating point values multiplied with units. +If you want to learn more about this module, take a look at [this notebook](/examples/utility/working_with_units). + +## Example usage + +```python +from feos.si import KELVIN, RGAS, METER, MOL, BAR + +p_ig = 25.0 * MOL / METER**3 * RGAS * 315.5 * KELVIN +print('Ideal gas pressure: {:.2f} bar'.format(p_ig / BAR)) +``` +```terminal +Ideal gas pressure: 0.66 bar +``` + +## Data types + +```{eval-rst} +.. currentmodule:: feos.si + +.. autosummary:: + :toctree: generated/ + + SINumber + SIArray1 + SIArray2 + SIArray3 + SIArray4 +``` \ No newline at end of file diff --git a/docs/api/utility/index.md b/docs/api/utility/index.md deleted file mode 100644 index b97cf133f..000000000 --- a/docs/api/utility/index.md +++ /dev/null @@ -1,12 +0,0 @@ -# Utility - -Functionalities that make working with the code easier. - -```{eval-rst} -.. toctree:: - :maxdepth: 1 - - si -``` - - diff --git a/docs/api/utility/si.rst b/docs/api/utility/si.rst deleted file mode 100644 index d714515d8..000000000 --- a/docs/api/utility/si.rst +++ /dev/null @@ -1,18 +0,0 @@ -.. _si_api: - -.. currentmodule:: feos.si - -SI units --------- - -In `feos` dimensioned quantities are used in various interfaces. -You can learn more about dimensioned quantities :doc:`in this notebook`. - -.. autosummary:: - :toctree: generated/ - - SINumber - SIArray1 - SIArray2 - SIArray3 - SIArray4 \ No newline at end of file diff --git a/docs/index.md b/docs/index.md index 48b7911f3..ba2445a7d 100644 --- a/docs/index.md +++ b/docs/index.md @@ -4,7 +4,7 @@ hide-toc: true # Welcome to {math}`\text{FeO}_\text{s}` -{math}`\text{FeO}_\text{s}` is a **framework** for **thermodynamic equations of state** and **classical functional theory**. +{math}`\text{FeO}_\text{s}` is a **framework** for **thermodynamic equations of state** (EoS) and **classical density functional theory** (DFT). It is written in **Rust** with a **Python** interface. ## Usage @@ -12,13 +12,17 @@ It is written in **Rust** with a **Python** interface. `````{tab-set} ````{tab-item} Python ```python -from feos.si import * -from feos.pcsaft import * -from feos.pcsaft.eos import * +from feos.eos import EquationOfState, State +from feos.pcsaft import PcSaftParameters +# Build an equation of state parameters = PcSaftParameters.from_json(['methanol'], 'parameters.json') -eos = PcSaft(parameters) +eos = EquationOfState.pcsaft(parameters) + +# Define thermodynamic conditions critical_point = State.critical_point(eos) + +# Compute properties p = critical_point.pressure() t = critical_point.temperature print(f'Critical point for methanol: T={t}, p={p}.') @@ -34,9 +38,14 @@ Critical point for methanol: T=531.5 K, p=10.7 MPa. use feos_core::{State, Contributions}; use feos_pcsaft::{PcSaft, PcSaftParameters}; +// Build an equation of state let parameters = PcSaftParameters.from_json(vec!["methanol"], "parameters.json")?; let eos = Rc::new(PcSaft::new(Rc::new(parameters))); + +// Define thermodynamic conditions let critical_point = State::critical_point(&eos, None, None, Default::default())?; + +// Compute properties let p = critical_point.pressure(Contributions::Total); let t = critical_point.temperature; println!("Critical point for methanol: T={}, p={}.", t, p); @@ -104,6 +113,7 @@ help_and_feedback api/index examples/index +recipes/index ``` ```{toctree} diff --git a/docs/recipes/critical_point.md b/docs/recipes/critical_point.md new file mode 100644 index 000000000..544bf6f4f --- /dev/null +++ b/docs/recipes/critical_point.md @@ -0,0 +1,10 @@ +# Critical point of pure substance + +```python +from feos.eos import EquationOfState, State +from feos.pcsaft import PcSaftParameters + +parameters = PcSaftParameters.from_json(['methanol'], 'parameters.json') +eos = EquationOfState.pcsaft(parameters) +critical_point = State.critical_point(eos) +``` \ No newline at end of file diff --git a/docs/recipes/index.md b/docs/recipes/index.md new file mode 100644 index 000000000..122414810 --- /dev/null +++ b/docs/recipes/index.md @@ -0,0 +1,29 @@ +# Recipes + +This section contains short code snippets for specific, commonly used tasks. +If you are looking for examples with explanations, see the [examples](/examples/index). + +## Plots + +```{eval-rst} +.. toctree:: + :maxdepth: 1 + +``` + +## Specifying thermodynamic conditions + +```{eval-rst} +.. toctree:: + :maxdepth: 1 + + critical_point +``` + +## DFT + +```{eval-rst} +.. toctree:: + :maxdepth: 1 + +``` diff --git a/src/estimator.rs b/src/estimator.rs new file mode 100644 index 000000000..b470392e1 --- /dev/null +++ b/src/estimator.rs @@ -0,0 +1,17 @@ +use crate::eos::{EosVariant, PyEosVariant}; +use feos_estimator::*; +use numpy::{PyArray1, ToPyArray}; +use pyo3::prelude::*; +use quantity::python::PySIArray1; +use quantity::si::SIUnit; +use std::collections::HashMap; +use std::rc::Rc; + +impl_estimator!(EosVariant, PyEosVariant); + +#[pymodule] +pub fn estimator(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + m.add_class::() +} diff --git a/src/lib.rs b/src/lib.rs index 7eb776247..4d1209ffa 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,6 +15,8 @@ mod gc_pcsaft; use gc_pcsaft::__PYO3_PYMODULE_DEF_GC_PCSAFT; mod pets; use pets::__PYO3_PYMODULE_DEF_PETS; +mod estimator; +use estimator::__PYO3_PYMODULE_DEF_ESTIMATOR; #[pymodule] pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { @@ -25,6 +27,7 @@ pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pymodule!(pcsaft))?; m.add_wrapped(wrap_pymodule!(gc_pcsaft))?; m.add_wrapped(wrap_pymodule!(pets))?; + m.add_wrapped(wrap_pymodule!(estimator))?; py.run( "\ import sys @@ -40,6 +43,7 @@ sys.modules['feos.cubic'] = cubic sys.modules['feos.pcsaft'] = pcsaft sys.modules['feos.gc_pcsaft'] = gc_pcsaft sys.modules['feos.pets'] = pets +sys.modules['feos.estimator'] = estimator ", None, Some(m.dict()), From 5bffe4b6c70729e465ed795d45c47b736d43e9ed Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Thu, 5 May 2022 11:57:32 +0200 Subject: [PATCH 14/15] add estimator macro call for entropy scaling --- examples/gc_pcsaft_functional.ipynb | 35 +++++++++++++++++------------ examples/pcsaft_state.ipynb | 11 +++++++-- src/estimator.rs | 1 + 3 files changed, 31 insertions(+), 16 deletions(-) diff --git a/examples/gc_pcsaft_functional.ipynb b/examples/gc_pcsaft_functional.ipynb index c2e38bf50..5740528bf 100644 --- a/examples/gc_pcsaft_functional.ipynb +++ b/examples/gc_pcsaft_functional.ipynb @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -51,13 +51,13 @@ "(2.5, 6.0, 0.0, 8.0)" ] }, - "execution_count": 3, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -108,13 +108,13 @@ "(0.0, 1.2, 0.0, 11.0)" ] }, - "execution_count": 5, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -147,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -163,12 +163,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -193,13 +193,20 @@ " ax.axis([0,1.2,0,15])\n", " ax.set_title(comp)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "feos", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "feos" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -211,7 +218,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.10" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/examples/pcsaft_state.ipynb b/examples/pcsaft_state.ipynb index 2d312995a..80af5953d 100644 --- a/examples/pcsaft_state.ipynb +++ b/examples/pcsaft_state.ipynb @@ -761,11 +761,18 @@ "\n", "Hopefully you found this example helpful. If you have comments, critique or feedback, please let us know and consider [opening an issue on github](https://github.com/feos-org/feos/issues)." ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -779,7 +786,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.1" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/src/estimator.rs b/src/estimator.rs index b470392e1..8e99adb7f 100644 --- a/src/estimator.rs +++ b/src/estimator.rs @@ -8,6 +8,7 @@ use std::collections::HashMap; use std::rc::Rc; impl_estimator!(EosVariant, PyEosVariant); +impl_estimator_entropy_scaling!(EosVariant, PyEosVariant); #[pymodule] pub fn estimator(_py: Python<'_>, m: &PyModule) -> PyResult<()> { From 7fe2b92d559cea201ed60934404540ee98ee16b7 Mon Sep 17 00:00:00 2001 From: Gernot Bauer Date: Tue, 10 May 2022 14:09:48 +0200 Subject: [PATCH 15/15] added uv-theory --- Cargo.lock | 23 ++- Cargo.toml | 5 +- examples/uvtheory.ipynb | 390 ++++++++++++++++++++++++++++++++++++++++ src/eos.rs | 37 ++++ src/lib.rs | 4 + src/uvtheory.rs | 19 ++ 6 files changed, 475 insertions(+), 3 deletions(-) create mode 100644 examples/uvtheory.ipynb create mode 100644 src/uvtheory.rs diff --git a/Cargo.lock b/Cargo.lock index f80b07d3f..c89ec2e95 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -143,6 +143,7 @@ dependencies = [ "feos-gc-pcsaft", "feos-pcsaft", "feos-pets", + "feos-uvtheory", "ndarray", "numpy", "petgraph", @@ -195,6 +196,7 @@ dependencies = [ [[package]] name = "feos-estimator" version = "0.1.0" +source = "git+https://github.com/feos-org/feos-estimator?tag=v0.1.0#db0d45050854e9014fbc984667c1fc6a6b54f6bb" dependencies = [ "feos-core", "ndarray", @@ -249,7 +251,8 @@ dependencies = [ [[package]] name = "feos-pets" version = "0.1.0" -source = "git+https://github.com/feos-org/feos-pets#e71705b9d855d6ce0f1bc15eac1ec7e2bf3eceda" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a7b24101875461f33c562687721e254a4b01fe4b9f3ab90eaf86f1fb27d0d10" dependencies = [ "feos-core", "feos-dft", @@ -265,6 +268,24 @@ dependencies = [ "serde_json", ] +[[package]] +name = "feos-uvtheory" +version = "0.1.0" +source = "git+https://github.com/feos-org/feos-uvtheory?tag=v0.1.0#9faa0aec40b9d44d902497437da47d3aef94e0bd" +dependencies = [ + "approx 0.5.1", + "feos-core", + "itertools", + "lazy_static", + "ndarray", + "num-dual", + "numpy", + "pyo3", + "quantity", + "serde", + "serde_json", +] + [[package]] name = "fixedbitset" version = "0.4.1" diff --git a/Cargo.toml b/Cargo.toml index 4dae7db24..224cd9699 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,8 +21,9 @@ feos-core = "0.2" feos-dft = "0.2" feos-pcsaft = { version = "0.2", features = ["python"] } feos-gc-pcsaft = { version = "0.1", features = ["python"] } -feos-pets = { git = "https://github.com/feos-org/feos-pets", features = ["python"] } -feos-estimator = { path = "../feos-estimator", features = ["python"] } +feos-pets = { version = "0.1", features = ["python"] } +feos-uvtheory = { git = "https://github.com/feos-org/feos-uvtheory", features = ["python"], tag = "v0.1.0" } +feos-estimator = { git = "https://github.com/feos-org/feos-estimator", features = ["python"], tag = "v0.1.0" } numpy = "0.16" ndarray = { version = "0.15", features=["approx"] } petgraph = "0.6" diff --git a/examples/uvtheory.ipynb b/examples/uvtheory.ipynb new file mode 100644 index 000000000..80bfcf264 --- /dev/null +++ b/examples/uvtheory.ipynb @@ -0,0 +1,390 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from feos.si import *\n", + "from feos.uvtheory import UVParameters, Perturbation\n", + "from feos.pets import PetsParameters\n", + "from feos.eos import State, PhaseEquilibrium, PhaseDiagram, EquationOfState, Contributions\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters for Thol EoS:\n", + "A = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 2.0,\n", + " 2.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0])\n", + "N = np.array([0.005208073, 2.186252000, -2.161016000, 1.452700000, -2.041792000, 0.186952860, -0.090988445, \n", + " -0.497456100, 0.109014310, -0.800559220, -0.568839000, -0.620862500, -1.466717700, 1.891469000, \n", + " -0.138370100, -0.386964500, 0.126570200, 0.605781000, 1.179189000, -0.477326790, -9.921857500, -0.574793200, 0.003772923])\n", + "T = np.array([1.000, 0.320, 0.505, 0.672, 0.843, 0.898, 1.294, 2.590, 1.786, 2.770, 1.786,\n", + " 1.205, 2.830, 2.548, 4.650, 1.385, 1.460, 1.351, 0.660, 1.496, 1.830, 1.616, 4.970])\n", + "D = np.array([4.0, 1.0, 1.0, 2.0, 2.0, 3.0, 5.0, 2.0, 2.0, 3.0, 1.0,\n", + " 1.0, 1.0, 1.0, 2.0, 3.0, 3.0, 2.0, 1.0, 2.0, 3.0, 1.0, 1.0])\n", + "L = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 1.0, 2.0, 2.0,\n", + " 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])\n", + "ETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2.067, 1.522,\n", + " 8.82, 1.722, 0.679, 1.883, 3.925, 2.461, 28.2, 0.753, 0.82])\n", + "BETA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.625,\n", + " 0.638, 3.91, 0.156, 0.157, 0.153, 1.16, 1.73, 383, 0.112, 0.119])\n", + "GAMMA = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.71,\n", + " 0.86, 1.94, 1.48, 1.49, 1.945, 3.02, 1.11, 1.17, 1.33, 0.24])\n", + "EPSILON = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.2053,\n", + " 0.409, 0.6, 1.203, 1.829, 1.397, 1.39, 0.539, 0.934, 2.369, 2.43])\n", + "\n", + "class Thol:\n", + " def __init__(self):\n", + " self.sigma = 3.7039 * ANGSTROM\n", + " self.eps_k = 150.03 * KELVIN\n", + " self.tc = 1.32 * self.eps_k / KELVIN\n", + " self.rhoc = 0.31 / self.sigma**3 * ANGSTROM**3\n", + " \n", + " def components(self): \n", + " return 1\n", + " \n", + " def subset(self, components):\n", + " return self\n", + " \n", + " def molar_weight(self):\n", + " return np.array([1.0])\n", + " \n", + " def max_density(self, moles):\n", + " return 0.04\n", + " \n", + " def helmholtz_energy(self, state):\n", + " \"\"\"\n", + " state (StateHD):\n", + " temperature in Kelvin als Float, Dual oder HD oder HD3, HDD, HDD3,\n", + " partial_density in # / Angstrom^3\n", + " volume in Angstrom^3\n", + " moles in mol\n", + " \"\"\"\n", + " tau = self.tc / state.temperature\n", + " delta = np.sum(state.partial_density) / self.rhoc\n", + " a = 0.0 #zero(state)\n", + " \n", + " # print(\"v\", state.volume)\n", + " # print(\"n\", state.moles)\n", + " #print(\"partial density\", state.partial_density)\n", + " #print(\"1\")\n", + " # print(\"delta: {}\".format(delta))\n", + " # print(\"tau: {}\".format(tau))\n", + " \n", + " for i in range(6):\n", + " a = a + N[i] * delta**D[i] * tau**T[i]\n", + " \n", + " # print(\"2\")\n", + " for i in range(6, 12):\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", + " # print(\"3\")\n", + " for i in range(12, 23):\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", + " return a * np.sum(state.moles)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sigma = 3.7039\n", + "sigma_a = sigma * ANGSTROM\n", + "eps_k = 150.03\n", + "eps_k_k = eps_k * KELVIN\n", + "\n", + "parameters = UVParameters.from_lists([12.0], [6.0], [sigma], [eps_k])\n", + "uvtheory_wca = EquationOfState.uvtheory(parameters)\n", + "uvtheory_bh = EquationOfState.uvtheory(parameters, perturbation=Perturbation.BarkerHenderson)\n", + "\n", + "parameters = PetsParameters.from_values(sigma, eps_k)\n", + "pets = EquationOfState.pets(parameters)\n", + "\n", + "thol = EquationOfState.python(Thol())\n", + "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "s1 = State(uvtheory_wca, temperature=300*KELVIN, pressure=1*BAR)\n", + "s2 = State(pets, temperature=300*KELVIN, pressure=1*BAR)\n", + "s3 = State(thol, temperature=300*KELVIN, pressure=1*BAR)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0016213224956115704" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s1.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0009407040108813868" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s2.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.0016144150962601586" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "s3.molar_helmholtz_energy(Contributions.ResidualNvt) / (RGAS * 300 * KELVIN)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1.3200003469821506, 1.3097658041494302, 1.3208296613277393)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "State.critical_point(thol).temperature / eps_k_k, State.critical_point(uvtheory_wca).temperature / eps_k_k, State.critical_point(uvtheory_bh).temperature / eps_k_k" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 52.5 ms, sys: 1.45 ms, total: 54 ms\n", + "Wall time: 54.2 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_uv = PhaseDiagram.pure(uvtheory_wca, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vle_uv.liquid" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 49 ms, sys: 1.77 ms, total: 50.7 ms\n", + "Wall time: 52.6 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_uv_bh = PhaseDiagram.pure(uvtheory_bh, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: overflow encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:65: RuntimeWarning: invalid value encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(-1.0 * delta**L[i])\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: overflow encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n", + "/var/folders/3s/t93ws1md04qdbbq5d1jdz8640000gn/T/ipykernel_78968/174117960.py:68: RuntimeWarning: invalid value encountered in exp\n", + " a = a + N[i] * delta**D[i] * tau**T[i] * np.exp(- 1.0 * ETA[i] * (delta - EPSILON[i])**2.0 - 1.0 * BETA[i] * (tau - 1.0 * GAMMA[i])**2.0)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.9 s, sys: 16.4 ms, total: 1.92 s\n", + "Wall time: 1.93 s\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 27 ms, sys: 1.68 ms, total: 28.7 ms\n", + "Wall time: 32.6 ms\n" + ] + } + ], + "source": [ + "%%time\n", + "vle_pets = PhaseDiagram.pure(pets, 150*KELVIN, 500)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "s3 = NAV * sigma_a**3\n", + "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')\n", + "plt.plot(vle_uv.liquid.density * s3, vle_uv.vapor.temperature / eps_k_k, color='black')\n", + "\n", + "plt.plot(vle_uv_bh.vapor.density * s3 , vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", + "plt.plot(vle_uv_bh.liquid.density * s3, vle_uv_bh.vapor.temperature / eps_k_k, color='black', linestyle='dashed')\n", + "\n", + "plt.plot(vle_thol.vapor.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')\n", + "plt.plot(vle_thol.liquid.density * s3, vle_thol.vapor.temperature / eps_k_k, color='red')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vle_thol = PhaseDiagram.pure(thol, 150*KELVIN, 500)\n", + "s3 = NAV * sigma_a**3\n", + "plt.plot(vle_uv.vapor.density * s3 , vle_uv.vapor.temperature / eps_k_k, color='black')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/eos.rs b/src/eos.rs index 4017528f7..01d32e459 100644 --- a/src/eos.rs +++ b/src/eos.rs @@ -8,6 +8,8 @@ use feos_pcsaft::python::PyPcSaftParameters; use feos_pcsaft::{PcSaft, PcSaftOptions}; use feos_pets::python::PyPetsParameters; use feos_pets::{Pets, PetsOptions}; +use feos_uvtheory::python::PyUVParameters; +use feos_uvtheory::{Perturbation, UVTheory, UVTheoryOptions}; use ndarray::Array1; use numpy::convert::ToPyArray; use numpy::{PyArray1, PyArray2}; @@ -24,6 +26,7 @@ pub enum EosVariant { PengRobinson(PengRobinson), Python(PyEoSObj), Pets(Pets), + UVTheory(UVTheory), } impl EquationOfState for EosVariant { @@ -34,6 +37,7 @@ impl EquationOfState for EosVariant { EosVariant::PengRobinson(eos) => eos.components(), EosVariant::Python(eos) => eos.components(), EosVariant::Pets(eos) => eos.components(), + EosVariant::UVTheory(eos) => eos.components(), } } @@ -44,6 +48,7 @@ impl EquationOfState for EosVariant { EosVariant::PengRobinson(eos) => eos.compute_max_density(moles), EosVariant::Python(eos) => eos.compute_max_density(moles), EosVariant::Pets(eos) => eos.compute_max_density(moles), + EosVariant::UVTheory(eos) => eos.compute_max_density(moles), } } @@ -54,6 +59,7 @@ impl EquationOfState for EosVariant { EosVariant::PengRobinson(eos) => Self::PengRobinson(eos.subset(component_list)), EosVariant::Python(eos) => Self::Python(eos.subset(component_list)), EosVariant::Pets(eos) => Self::Pets(eos.subset(component_list)), + EosVariant::UVTheory(eos) => Self::UVTheory(eos.subset(component_list)), } } @@ -64,6 +70,7 @@ impl EquationOfState for EosVariant { EosVariant::PengRobinson(eos) => eos.residual(), EosVariant::Python(eos) => eos.residual(), EosVariant::Pets(eos) => eos.residual(), + EosVariant::UVTheory(eos) => eos.residual(), } } } @@ -76,6 +83,7 @@ impl MolarWeight for EosVariant { EosVariant::PengRobinson(eos) => eos.molar_weight(), EosVariant::Python(eos) => eos.molar_weight(), EosVariant::Pets(eos) => eos.molar_weight(), + _ => unimplemented!(), } } } @@ -299,6 +307,35 @@ impl PyEosVariant { options, )))) } + + /// UV-Theory equation of state. + /// + /// Parameters + /// ---------- + /// parameters : PetsParameters + /// The parameters of the PeTS equation of state to use. + /// max_eta : float, optional + /// Maximum packing fraction. Defaults to 0.5. + /// perturbation : Perturbation, optional + /// + /// Returns + /// ------- + /// EquationOfState + /// The UV-Theory equation of state that can be used to compute thermodynamic + /// states. + #[args(max_eta = "0.5", perturbation = "Perturbation::WeeksChandlerAndersen")] + #[staticmethod] + #[pyo3(text_signature = "(parameters, max_eta, perturbation)")] + fn uvtheory(parameters: PyUVParameters, max_eta: f64, perturbation: Perturbation) -> Self { + let options = UVTheoryOptions { + max_eta, + perturbation, + }; + Self(Rc::new(EosVariant::UVTheory(UVTheory::with_options( + parameters.0, + options, + )))) + } } impl_equation_of_state!(PyEosVariant); diff --git a/src/lib.rs b/src/lib.rs index 4d1209ffa..8114d46ca 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,6 +15,8 @@ mod gc_pcsaft; use gc_pcsaft::__PYO3_PYMODULE_DEF_GC_PCSAFT; mod pets; use pets::__PYO3_PYMODULE_DEF_PETS; +mod uvtheory; +use uvtheory::__PYO3_PYMODULE_DEF_UVTHEORY; mod estimator; use estimator::__PYO3_PYMODULE_DEF_ESTIMATOR; @@ -27,6 +29,7 @@ pub fn feos(py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pymodule!(pcsaft))?; m.add_wrapped(wrap_pymodule!(gc_pcsaft))?; m.add_wrapped(wrap_pymodule!(pets))?; + m.add_wrapped(wrap_pymodule!(uvtheory))?; m.add_wrapped(wrap_pymodule!(estimator))?; py.run( "\ @@ -43,6 +46,7 @@ sys.modules['feos.cubic'] = cubic sys.modules['feos.pcsaft'] = pcsaft sys.modules['feos.gc_pcsaft'] = gc_pcsaft sys.modules['feos.pets'] = pets +sys.modules['feos.uvtheory'] = uvtheory sys.modules['feos.estimator'] = estimator ", None, diff --git a/src/uvtheory.rs b/src/uvtheory.rs new file mode 100644 index 000000000..4be90a0ff --- /dev/null +++ b/src/uvtheory.rs @@ -0,0 +1,19 @@ +use feos_core::python::parameter::*; +use feos_uvtheory::{ + python::{PyPureRecord, PyUVParameters, PyUVRecord}, + Perturbation, +}; +use pyo3::prelude::*; + +#[pymodule] +pub fn uvtheory(_py: Python<'_>, m: &PyModule) -> PyResult<()> { + m.add_class::()?; + m.add_class::()?; + + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + m.add_class::()?; + Ok(()) +}