Being able to have variable flow rates within a section is necessary for modelling some systems. Furthermore, it is a requirement for implementing compressible fluids.

The change from solution_outlet_comp_000 to solution_outlet_port_000_comp_000 has broken compatibility with tools and tutorials for CADET 3.x

Setting /input/return/SPLIT_PORTS_DATA to 0 restores the old name but changes from a vector to a nx1 matrix when only 1 port exists and this still breaks compatibility with tools and tutorials. To deal with this all the tools and tutorials would need to squeeze the matrix and remove the unneeded dimension before using the result.

What I suggest is that when there is only one port in the system that port_000 is dropped from the output to restore compatibility.

Implement system for automatically triggering events when a certain condition is fulfilled (e.g. switch to second column when 10% breakthrough, start gradient when...)

See also #25

Add a new binding model based on Huuk et al. 2017.
The binding model is an extension of the SMA model and adds a pseudo molecule that provides the local pH.

The equations are given by

\frac{\partial q_i}{\partial t} = k_{a,i}(c_p, q, pH) * (Lambda - \sum_j \frac{nu_j(pH) + sigma_j}{f_j} * q_j )^(nu_i(pH)) * c_{p,i} - k_{d,i}(c_p, q, pH) * c_{p,0}^(nu_i(pH)) * q_i
nu_i(pH) = nu_{i,0} + pH * nu_{i,1} + pH^2 * nu_{i,2}
k_{a,i}(c_p, q, pH) = k_{a,i,0} * exp(k_{a,i,1} * pH + k_{a,i,2} * pH^2) * exp(k_{a,i,salt} * c_{p,0} + k_{a,i,prot} * c_{p,i})
k_{d,i}(c_p, q, pH) = k_{d,i,0} * exp(k_{d,i,1} * pH + k_{d,i,2} * pH^2) * exp(k_{d,i,sdlt} * c_{p,0} + k_{d,i,prot} * c_{p,i})

The pH pseudo component will have index 1, since by convention salt already has index 0.
The pH component is non-binding.

When configuring with SUNDIALS_PREFER_OPENMP=ON I get a build error due to the macro below:

#define NVec_SetThreads(x, nThreads) NV_NUM_THREADS_OMP(x) = nThreads

"nThreads is not defined in this scope"

Currently, the last state (as well as its derivative) is only saved for the entire system.
It would be convenient being able to also save the state for each unit operation separately for re-initialization of systems where individual unit operations might be exchanged.

The section dependency of the transport model parameters introduced in commit 543db9d required the type change of ParamID from std::pair to std::tuple.

Apparently, two occurences of ParamID in TimeIntegrator.cpp have been forgotten in the process of changing the type. This leads to the following compile time errors:

cadet/src/libcadet/TimeIntegrator.cpp:441:104: error: no matching function for call to ‘std::tuple<cadet::ParameterName, int, int>::tuple(cadet::ParameterName, int)’
         vpc_it it1 = std::find(_sensModelParams.begin(), _sensModelParams.end(), ParamID(SMA_LAMBDA, -1));  // search for a sensitive SMA_LAMBDA
                                                                                                        ^

cadet/src/libcadet/TimeIntegrator.cpp:442:104: error: no matching function for call to ‘std::tuple<cadet::ParameterName, int, int>::tuple(cadet::ParameterName, int)’
         vpc_it it2 = std::find(_sensModelParams.begin(), _sensModelParams.end(), ParamID(SAI_LAMBDA, -1));  // search for a sensitive SAI_LAMBDA
                                                                                                        ^

A tank with particles with pore diffusion is required e.g. for fluidized bed or batch uptake, where the volume of the unit changes and pore diffusion plays an important role (in contrast to current CSTR implementation)

The newly added flag LINEAR_SOLUTION_MODE seems to be ignored.

A plain C API would decouple the core simulator from the different interfaces.
Also see the discussion in #12.

For calculation of "fast" reactions (e.g. pH), quasi-equilibrium is a valid assumption. This eliminates the need for a "fast time scale" thus reducing the stiffness of the problem.

See also implementation of binding models.

Let the transport related parameters depend on the current section, i.e., allow the user to give values for each section.

Relevant parameters are:

• VELOCITY
• COL_DISPERSION
• PAR_DIFFUSION
• FILM_DIFFUSION
• PAR_SURFDIFFUSION

Currently, all sections are global, however, for advanced systems, it is advantageous to only define events per unit operation.

E.g. it is difficult to design processes that simultaneously use gradients, non-constant input profiles, and have complicated switching procedures in the system. This is especially true for optimization because the "parameter path" can change if the order of events switches.

Currently the compilation of the LaTeX documentation is failing due to a the missing file /doc/tex/all.gitinfo.

The file used to contain the git commit hash of the repository at which the documentation was compiled. Maybe this could be included dynamically when building CADET from source.

The StirredTankModel in the Matlab interface does not accept an empty bindingModel. This was possible up to (including) version 3.1.2.

Using a NoneBinding object for bindingModel does not work either since it complains about missing bound states (even if nBoundStates = 0). Adding a bound state crashes the simulation (since NoneBinding, which maps to DummyBinding in C++, does not add equations for the bound states).

The Matlab interface should allow empty bindingModel, which is also set in the constructor of StirredTankModel by default.

For downwards compatibility, create converter that translates older parameter naming conventions to later versions of CADET which otherwise would lead to breaking changes.

Before running a simulation, parameters could be checked for sanity (e.g. correct sizes and plausible values).

Furthermore, after the simulation, simulation results could be checked (e.g., mass balance checks out).

Tools like this could be implemented in CADET-core or in higher level tools like CADET-Process

List of known issues:

• CSTR: length of FLOWRATE_FILTER
• Section continuity (See also: https://forum.cadet-web.de/t/error-in-dextrane-puls-simulation/903)
• Conistency between the last entries in the root.input.solver.sections.section_times and root.input.solver.user_solution_times

The OutletModel fills both SOLUTION_INLET_XYZ and SOLUTION_OUTLET_XYZ, although it doesn't have an outlet. This behavior is convenint for users since they only think of it as a system outlet ("I'm interested in the outlet concentration, why should I query the inlet concentration of the outlet unit?").

The InletModel does not behave the same. It only exposes the solution as SOLUTION_OUTLET_XYZ. But the behavior of both units should be the same.

In all of CADET documentation, the following nomenclature is used:
cf: fluid phase concentration
cp: pore concentration
cs: solid phase concentration

In the code, however, mostly q is still used.

When solving a single column, the column’s solve() function is called at least twice. This is unnecessary for simple setups that don’t recycle. We could detect that, break the DAG (which otherwise is only a directed graph) up into parallel chunks and solve them from inlets to outlets.

In case of unconnected unit operations, the sequential solution mode for the linear systems in ModelSystem does not work correctly.

In CADET-Process, flow rates are only specified for Sources and CSTRs. The value of the flow rate for other units is automatically calculated using output state variables that specify the distribution of flow to units following downstream (basically acting as a valve).

For the setup of more complex systems of unit operations, especially those with internal recycles (e.g. SMB), a unit without an actual model would be helpful which just mixes the inputs and distributes the output streams. This could be achieved by setting a CSTR's volume to zero, however, this currently raises a timeout error.

If this is not consistent with the design philosophy of CSTRs, it would also be possible to create a new unit operation (e.g. a Mixer/Splitter/Valve unit).

If the main directory of the MATLAB interface is read-only, the current strsplit workaround fails.

At the moment the installCADET.m script checks whether a native strsplit function is available. If this is not the case, the strsplit_workaround.m file gets renamed to strsplit.m, which is only possible when the current user has write-access to the main directory of the MATLAB interface.

The fallback file-based backend does not work. When instantiating a new object of the Simulator MATLAB class the getVersion() function reports an error:

Error using textscan
First input can not be empty.

Error in splitstring (line 13)
    splitted = textscan(str,'%s','delimiter',delim);

Error in Simulator/getVersion (line 621)
                parts = splitstring(parts{5}, ' ');

Ultrafiltration is commonly used in downstream processing.

see also https://doi.org/10.1016/j.cesx.2019.100025

For process optimization (e.g. finding the optimum times for switching valves), the sensitivity of section times is useful.

See also #25

Add a logging output for MATLAB MEX via mexPrintf function.
At the moment, logging is disabled in the MEX interface since the default logging destination (stdout) is ignored by MATLAB.

Add support for vcpkg.
This will allow bootstrapping a complete development environment in a single command.

However, CADET currently depends on a specific version of SUNDIALS. This constraint is not easily achieved using vcpkg.

For systems like true moving bed (TMB), the solid phases moves in counter current with respect to the fluid.

Using a plain C interface (see #16), the Matlab interface can be removed from the core simulator. It will be put in its own repository in order to decouple language interfaces (Python, Matlab etc.) from the core simulator. It also simplifies the build process.

̶s̶e̶e̶ ̶p̶a̶g̶e̶ ̶3̶9̶ ̶i̶n̶ ̶L̶i̶u̶ ̶d̶i̶s̶s̶e̶r̶t̶a̶t̶i̶o̶n̶

Currently, particles are implemented as spheres, however, in monolithic columns or membrane chromatography, other geometries might occur, e.g. plane sheets or cylinders. (see https://doi.org/10.1016/B978-0-12-415807-8.00002-X or https://doi.org/10.1023/A:1008913301145)

Implementing binding models (isotherms) in CADET currently requires an advanced level of knowledge in C++ and some understanding of the architecture of CADET. A domain specific language (DSL) can provide a simpler interface for implementing model equations in some simpler form which are then translated to something CADET can understand.

Possible implementations include include:

• Plugins (would not require re-compiling all of CADET)
• Interpreter
• JIT
• ...

Works by Kristian Meyer have shown speed improvements in the order of 10^2 using Discontinuous Galerkin method (standard nodal DG-method). This could be implemented for CADET.

Compiling CADET on MS Visual Studio 2013 Pro produces errors because of unknown identifiers min and max.

Suspect name clashes with macros defined in Windows headers.

The Matlab MEX interface returns the matrices and tensors in the ordering created by CADET (row-major). Since Matlab originates from Fortran, it uses column-major ordering. This is fine when using HDF5 as Matlab transposes / reorders the arrays upon read regardless of the saved ordering, which cannot be detected. To comply with Matlab's ordering, the MEX interface has to reorder the data from row-major to column-major.

If i try to compile cadet with Sundials 4.1.0 (haven`t tried older version, but it works as anaconda package with shared anaconda libs), the file VersionInfo.cpp (in /build/) seems to miss a quotation mark " after SUNDIALS=:

namespace cadet
{
	const char GIT_COMMIT_HASH[] = "GITDIR-NOTFOUND";
	const char GIT_BRANCH[] = "GITDIR-NOTFOUND";
	const char LIBCADET_VERSION[] = "3.1.2";
	const char DEPENDENCY_VERSIONS[] = "HDF5=1.10.5;TBB=2017.0;MATLAB=NOTFOUND;SUNDIALS=/* ----------------------------------------------------------------- 
 * Programmer(s): Aaron Collier and Radu Serban @ LLNL
 * -----------------------------------------------------------------
 * LLNS/SMU Copyright Start
 * Copyright (c) 2002-2018, Southern Methodist University and
 * Lawrence Livermore National Security
 *
 * This work was performed under the auspices of the U.S. Department
 * of Energy by Southern Methodist University and Lawrence Livermore
 * National Laboratory under Contract DE-AC52-07NA27344.
 * Produced at Southern Methodist University and the Lawrence
 * Livermore National Laboratory.
 *
 * All rights reserved.
 * For details, see the LICENSE file.
 * LLNS/SMU Copyright End
 * -----------------------------------------------------------------
 * SUNDIALS configuration header file
 * -----------------------------------------------------------------*/```

Currently, only first order derivatives are provided using Forward Mode Algorithmic Differentiation.
If implemented, the efficiency for first order would be much higher and second order would be possible with reasonable effort.

Although the equilibrium model can be simulated using the LumpedRateModelWithoutPores and setting the axial dispersion to zero, it requires a lot of cells to achieve acceptable accuracy due to the very steep waves in the system.
The model is still used a lot in academia and should be implemented to enable comparisons with the many publications that used it.

For modelling gas adsorption, heat of adsorption has to be considered.

CADET already provides a MATLAB interface via MEX-functions. A similar in-memory interface can be done in Python. Such an interface reduces the overhead of reading input files, allocating memory, configuring and initializing the simulation. This is especially interesting when doing optimization or repeated simulations (e.g., parameter studies).

There are basically two approaches to build an in-memory interface:

• Intrusive: Expose C++ API via boost::python, Cython, CPython and directly interact with Python objects
• Nonintrusive: Expose a generic C API that is used from the Python side via ctypes and use callback functions when necessary

Generally, the file format should be recreated on the Python side using nested dictionaries.

Attention: Due to the handling of AD directions, whose active number is reset when starting time integration, running simulations concurrently in the same (Python) process / libcadet instance might produce wrong sensitivities or results (when using AD for Jacobians) under specific circumstances. This is the case when the simulations use a different number of active AD directions and the one with less directions is started last. The global active-AD-directions-variable is then reset to the lower number, which causes the other simulation to use the same number of directions.

Intrusive approach

• Write a ParameterProvider that reads nested Python dict structures to get the parameters into CADET.
• Implement a writer class that turns arrays into numpy arrays (replacing HDF5Writer, for example).
• Expose a reasonable set of commands in a Python object (maybe the same methods as in Matlab MEX).

Pros / cons:

• Specific to Python, requires additional dependencies
• Maybe faster to implement

Nonintrusive approach

• Plain C wrapper for C++ objects or at least most used functions (cf. MATLAB interface)
• Pass model setup as hardcoded nested C structs or use a callback-based ParameterProvider
• Memory is managed by CADET and will need to be released explicitly (by calling C functions)
• Python object that handles everyting and takes care of communication (maybe called Simulator)

Pros / cons:

• Rather general, might be used for interfacing with other languages (e.g., Julia)
• Does not require additional dependencies
• C structs are one more point in code to update when changing stuff
• Callback-based ParameterProvider is probably slow (Python -> C -> C++ -> Python roundtrip)
• Separation between CADET library and Python client via callback "protocol".
• Can be directly built into libcadet without introducing another binary / CMake target.

Proposal: Nonintrusive approach using callbacks

A minimal working setup:

• Implement callback-based ParameterProvider: Takes ctype function pointers to callbacks that return values or arrays (including their size).
• Create an exported C function that simply creates a Driver, configures it and runs the simulation.
• Create an exported C function that cleans up (delete Driver, release memory).
• Specify a model in Python via nested dicts containing mostly numpy objects (even for scalars?).
• Plot the results by wrapping a numpy.array around the returned array pointer.

Details on the callback-based ParameterProvider:

• Two possible query styles: readDouble(string fullPathToItem) or pushGroup(string groupName), readDouble(string itemInCurrentGroup), popGroup().
• Depending on the query style, tracking of the current group / scope is handled in C++ or in Python, respectively.
• It is easily possible to have both styles implemented and switchable at runtime.
• Function pointers need to be passed from the Python side upon construction of the ParameterProvider (or maybe later). Those function pointers could be collected in a C struct since this is fixed and unlikely to change.
• Signature of the callbacks could be bool readXYZ(string itemOrPath, xyz* out) for scalars and bool readXYZ(string itemOrPath, xyz* out, int* size) for arrays. The bool return value signals whether the key has been accessed successfully.

Estimated timeframe for a working prototype: 1.5 months.

I am running 64-bit MATLAB on a 64-bit Windows 10 Enterprise Virtual Desktop. When I try to install CADET 4.0.1 or 4.0.0, I run into an issue when I run the installCADET.m function. The output looks similar to the one in the step-by-step tutorial:

installCADET
Adding C:\Users\JohnDoe\Documents\cadet to MATLAB PATH
Adding C:\Users\JohnDoe\Documents\cadet\bindings to MATLAB PATH
Adding C:\Users\JohnDoe\Documents\cadet\bin to MATLAB PATH
... and so on for the 'units', 'reactions', and 'extfuns' folders in the 'cadet' folder

But then, immediately after the 'extfuns' folder is added, I receive a statement saying:

"Unfortunately, no working CADET interface could be found."
"Please check the error messages for the different interfaces or consult the manual or wiki."

I do not receive any other error messages besides for that one, and the troubleshooting link in the step-by-step tutorial does not work.

Would anyone be able to explain what is causing this issue and how I might go about fixing it? Thanks.

Negative parameters are currently not allowed in the external steric mass action binding model.

CADET is currently based on the SI unit system and this should always be the deafult standard. However, it might be convenient for many users to be able to specify different units for each individual parameter, e.g. from the CGS system.

This could be implemented by adding an additonal field to the HDF5 file that specifies the unit and converting the corresponding values upon read/ write. If the unit field is missing, SI units are used.

Moving the parameter NBOUND from the discretization group (where it is needed in the code) to the unit_operation parameters group makes more sense in the user interface.

See also #18

Currently, IDAS from SUNDIALS is used, however, LIMEX (linear implicit extrapolation) is a very flexible and stable one step method (variable order and step size is easy). It can be parallelized to some extent (at the cost of memory). It only requires solution of linear systems (BDF requires solution of a nonlinear system, which is done by variants of Newton’s method). In addition, one step methods are better for input signals with lots of discontinuities (e.g. piecewise constant feeds generated by closed / open loop optimal control etc.) since we have to restart the multi-step BDF at each discontinuity (then it needs some small steps to reach its maximum order).

For processes in gas phase, the compressibility of fluids has to be considered.

Add a linear binding model to the library.

I've been experiencing some problems building CADET on Ubuntu (both with 18.04 and 20.04).

Found Matlab: FALSE

If Matlab is not found on the system, cmake should automatically set ENABLE_CADET_MEX to false. Otherwise, it will result in the following error message. I don't know if this is specific to Ubuntu or if this is also the case for other platforms. Would be convenient, though, if this was done automatically (or mentioned in the build instructions).

CMake Error: The following variables are used in this project, but they are set to NOTFOUND.
Please set them or make sure they are set and tested correctly in the CMake files:
~/cadet/CADET/src/cadet-mex/Matlab_INCLUDE_DIRS
   used as include directory in directory ~/cadet/CADET/src/cadet-mex
Matlab_MEX_LIBRARY
    linked by target "cadet-mex" in directory ~/cadet/CADET/src/cadet-mex
Matlab_MX_LIBRARY
    linked by target "cadet-mex" in directory ~/cadet/CADET/src/cadet-mex

Error can be avoided by passing -DENABLE_CADET_MEX=FALSE.

Build errors

I have not been able to compile CADET since f010551 (see output message below). Help would be appreciated.

Scanning dependencies of target createLWE
Scanning dependencies of target createMCLin
Scanning dependencies of target convertFile
Scanning dependencies of target createSCLang
Scanning dependencies of target createConvBenchmark
Scanning dependencies of target libcadet_nonlinalg_static
Scanning dependencies of target templateCodeGen
Scanning dependencies of target createSCLin
Scanning dependencies of target createSCLinStep
Scanning dependencies of target testLogging
[  1%] Building CXX object src/tools/CMakeFiles/createLWE.dir/createLWE.cpp.o
[  2%] Building CXX object src/tools/CMakeFiles/createMCLin.dir/createMCLin.cpp.o
[  2%] Building CXX object src/tools/CMakeFiles/createSCLang.dir/createSCLang.cpp.o
[  3%] Building CXX object test/CMakeFiles/testLogging.dir/testLogging.cpp.o
[  4%] Building CXX object src/tools/CMakeFiles/createConvBenchmark.dir/createConvBenchmark.cpp.o
[  5%] Building CXX object src/build-tools/CMakeFiles/templateCodeGen.dir/templateCodeGen.cpp.o
[  6%] Building CXX object src/tools/CMakeFiles/createSCLin.dir/createSCLin.cpp.o
[  7%] Building CXX object src/tools/CMakeFiles/createSCLinStep.dir/createSCLinStep.cpp.o
[  8%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/BandMatrix.cpp.o
[  9%] Building CXX object src/tools/CMakeFiles/convertFile.dir/convertFile.cpp.o
[ 10%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/CompressedSparseMatrix.cpp.o
[ 11%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/SparseMatrix.cpp.o
[ 11%] Building CXX object src/tools/CMakeFiles/convertFile.dir/__/io/FileIO.cpp.o
[ 11%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/DenseMatrix.cpp.o
[ 12%] Building CXX object src/tools/CMakeFiles/convertFile.dir/FormatConverter.cpp.o
[ 13%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/Gmres.cpp.o
[ 13%] Building CXX object src/tools/CMakeFiles/convertFile.dir/__/__/ThirdParty/pugixml/pugixml.cpp.o
[ 14%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/nonlin/AdaptiveTrustRegionNewton.cpp.o
[ 15%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/nonlin/LevenbergMarquardt.cpp.o
[ 16%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/nonlin/CompositeSolver.cpp.o
[ 16%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/nonlin/Solver.cpp.o
[ 18%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/SuperLUSparseMatrix.cpp.o
[ 18%] Building CXX object src/libcadet/CMakeFiles/libcadet_nonlinalg_static.dir/linalg/UMFPackSparseMatrix.cpp.o
[ 18%] Linking CXX executable testLogging
[ 18%] Linking CXX static library libcadet_nonlinalg_static.a
[ 18%] Built target libcadet_nonlinalg_static
Scanning dependencies of target testAdaptiveTRNewton
Scanning dependencies of target testSMANonlinearSolve
make[2]: *** No rule to make target '-Wl,--start-group', needed by 'test/testAdaptiveTRNewton'.  Stop.
make[2]: *** Waiting for unfinished jobs....
[ 18%] Built target testLogging
[ 18%] Building CXX object test/CMakeFiles/testAdaptiveTRNewton.dir/testAdaptiveTRNewton.cpp.o
make[2]: *** No rule to make target '-Wl,--start-group', needed by 'test/testSMANonlinearSolve'.  Stop.
make[2]: *** Waiting for unfinished jobs....
[ 19%] Building CXX object test/CMakeFiles/testSMANonlinearSolve.dir/testSMANonlinearSolve.cpp.o
[ 20%] Linking CXX executable createMCLin
[ 21%] Linking CXX executable createConvBenchmark
[ 22%] Linking CXX executable createSCLang
[ 23%] Linking CXX executable createSCLinStep
[ 23%] Linking CXX executable createLWE
[ 23%] Linking CXX executable createSCLin
make[1]: *** [CMakeFiles/Makefile2:639: test/CMakeFiles/testAdaptiveTRNewton.dir/all] Error 2
make[1]: *** Waiting for unfinished jobs....
make[1]: *** [CMakeFiles/Makefile2:612: test/CMakeFiles/testSMANonlinearSolve.dir/all] Error 2
[ 23%] Linking CXX executable convertFile
[ 23%] Built target createSCLinStep
[ 23%] Built target createMCLin
[ 23%] Built target createConvBenchmark
[ 23%] Built target createSCLin
[ 23%] Built target createSCLang
[ 23%] Built target createLWE
[ 24%] Linking CXX executable templateCodeGen
[ 24%] Built target templateCodeGen
[ 24%] Built target convertFile
make: *** [Makefile:130: all] Error 2

Libraries used:

• intel-mkl: Version 2020.0.166-1
• TBB: Version 2020.1 (Interface 11101)
• SUNDIALS: Version 3.2.1
• SuperLU: Version 5.2.1
• UMFPACK: Version 5.7.8
• HDF5: Version 1.10.4
• cmake: Version 3.16.3
• gcc: Version 9.3.0

All libraries were installed from the ubuntu repositories, except for SUNDIALS which was installed using version 3.2.1, as specified here.