Homec4science
Diffusion SpecMiCP / ReactMiCP (fixpoint) Browse

specmicp/src/specmicp/reduced_system.cpp
f42f76860daffixpoint

Last Change
Raw File

reduced_system.cpp
View Options

/*-------------------------------------------------------
- Module : specmicp
- File : specmicp.cpp
- Author : Fabien Georget
Copyright (c) 2014, Fabien Georget <fabieng@princeton.edu>, Princeton University
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the Princeton University nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------*/
#include <iostream>
#include "reduced_system.hpp"
#include "utils/log.hpp"
#include "equilibrium_data.hpp"
#include "physics/constants.hpp"
#include "physics/laws.hpp"
namespace specmicp {
inline double pow10(double x)
{
return std::pow(10.0, x);
}
ReducedSystem::ReducedSystem(
RawDatabasePtr ptrdata,
const Vector &totconc,
bool conservation_water
):
m_data(ptrdata),
m_tot_conc(totconc),
m_secondary_conc(ptrdata->nb_aqueous),
m_loggamma(ptrdata->nb_component+ptrdata->nb_aqueous)
{
if (not m_simulbox.is_fixed_temperature() or m_simulbox.get_temperature() != units::celsius(25))
{
throw std::runtime_error("Only a fixed temperature of 25°C is supported");
}
number_eq(conservation_water);
m_secondary_conc.setZero();
m_loggamma.setZero();
}
ReducedSystem::ReducedSystem(
RawDatabasePtr ptrdata,
const Vector &totconc,
const SimulationBox &simul_box,
bool conservation_water
):
m_simulbox(simul_box),
m_data(ptrdata),
m_tot_conc(totconc),
m_secondary_conc(ptrdata->nb_aqueous),
m_loggamma(ptrdata->nb_component+ptrdata->nb_aqueous)
{
if (not m_simulbox.is_fixed_temperature() or m_simulbox.get_temperature() != units::celsius(25))
{
throw std::runtime_error("Only a fixed temperature of 25°C is supported");
}
number_eq(conservation_water);
m_secondary_conc.setZero();
m_loggamma.setZero();
}
ReducedSystem::ReducedSystem(
RawDatabasePtr ptrdata,
const Vector& totconc,
const SimulationBox& simul_box,
const EquilibriumState& previous_solution,
bool conservation_water
):
m_simulbox(simul_box),
m_data(ptrdata),
m_tot_conc(totconc),
m_secondary_conc(previous_solution.molality_secondary()),
m_loggamma(previous_solution.activity_coefficient())
{
if (not m_simulbox.is_fixed_temperature() or m_simulbox.get_temperature() != units::celsius(25))
{
throw std::runtime_error("Only a fixed temperature of 25°C is supported");
}
number_eq(conservation_water);
}
void ReducedSystem::number_eq(bool water_equation)
{
index_t neq = 0;
m_ideq.reserve(m_data->nb_component+m_data->nb_mineral);
if (water_equation)
{
m_ideq.push_back(neq);
++neq;
} else {
m_ideq.push_back(no_equation);
}
for (index_t i: m_data->range_aqueous_component())
{
// Remove components that does not exist
if (m_tot_conc(i) == 0 and i!= 1)
{
INFO << "Component " << m_data->labels_basis[i]
<< "has total concentration equal to zero, we desactivate it" << std::endl;
m_nonactive_component.push_back(i);
m_ideq.push_back(no_equation);
continue;
}
else
{
m_ideq.push_back(neq);
++neq;
}
}
m_nb_free_vars = neq;
for (index_t m: m_data->range_mineral())
{
bool can_precipitate = true;
// Remove minerals that cannot precipitate
for (auto it=m_nonactive_component.begin(); it!=m_nonactive_component.end(); ++it)
{
if (m_data->nu_mineral(m, *it) != 0)
{
can_precipitate = false;
break; // this is not a mineral that can precipitate
}
}
if (can_precipitate)
{
m_ideq.push_back(neq);
++neq;
}
else
{
m_ideq.push_back(no_equation);
}
}
m_nb_tot_vars = neq;
m_nb_compl_vars = m_nb_tot_vars - m_nb_free_vars;
// aqueous species
m_active_aqueous.reserve(m_data->nb_aqueous);
for (index_t j: m_data->range_aqueous())
{
bool can_exist = true;
for (auto it=m_nonactive_component.begin(); it!=m_nonactive_component.end(); ++it)
{
if (m_data->nu_aqueous(j,*it) != 0)
{
can_exist = false;
}
}
m_active_aqueous.push_back(can_exist);
}
}
scalar_t ReducedSystem::residual_water(const Vector& x) const
{
scalar_t res = m_tot_conc(0) - mass_water(x)/m_data->molar_mass_basis_si(0);
for (index_t j: m_data->range_aqueous())
{
if (m_data->nu_aqueous(j, 0) == 0) continue;
res -= mass_water(x)*m_data->nu_aqueous(j, 0)*m_secondary_conc(j);
}
for (index_t m: m_data->range_mineral())
{
if (ideq_min(m) == no_equation or m_data->nu_mineral(m, 0) == 0) continue;
res -= m_data->nu_mineral(m, 0)*x(ideq_min(m));
}
return res;
}
double ReducedSystem::residual_component(const Vector &x, index_t i) const
{
const index_t idp = ideq_paq(i);
scalar_t res = m_tot_conc(i) - mass_water(x)*pow10(x(idp));
for (index_t j: m_data->range_aqueous())
{
if (not m_active_aqueous[j]) continue;
res -= mass_water(x)*m_data->nu_aqueous(j, i)*m_secondary_conc(j);
}
for (index_t m: m_data->range_mineral())
{
if (ideq_min(m) == no_equation) continue;
res -= m_data->nu_mineral(m, i)*x(ideq_min(m));
}
return res;
}
double ReducedSystem::residual_mineral(const Vector& x, index_t m) const
{
scalar_t res = m_data->logk_mineral(m);
for (index_t i: m_data->range_aqueous_component())
{
if (m_data->nu_mineral(m, i) != 0)
res -= m_data->nu_mineral(m, i)*(x(ideq_paq(i)) + m_loggamma(i));
}
return res;
}
void ReducedSystem::get_residuals(const Vector& x, Vector& residual)
{
set_secondary_concentration(x);
if (ideq_w() != no_equation) residual(ideq_w()) = residual_water(x);
for (index_t i: m_data->range_aqueous_component())
{
if (ideq_paq(i) != no_equation) residual(ideq_paq(i)) = residual_component(x, i);
}
for (index_t m: m_data->range_mineral())
{
if (ideq_min(m) != no_equation) residual(ideq_min(m)) = residual_mineral(x, m);
}
}
//non-optimized Finite difference, for test only
//void ReducedSystem::get_jacobian(Eigen::VectorXd& x,
// Eigen::MatrixXd& jacobian)
//{
// const int neq = total_variables();
// Eigen::VectorXd res(total_variables());
// Eigen::VectorXd perturbed_res(total_variables());
// get_residuals(x, res);
// for (int j=0; j<neq; ++j)
// {
// double h = 1e-8*std::abs(x(j));
// //h = std::copysign(h, x(j));
// if (h==0) h = 1e-8;
// double tmp = x(j);
// x(j) += h;
// h = x(j) - tmp;
// get_residuals(x, perturbed_res);
// for (int i=0; i<neq; ++i)
// {
// jacobian(i, j) = (perturbed_res(i) - res(i))/h;
// }
// x(j) = tmp;
// }
// std::cout << jacobian << std::endl;
// return;
//}
void ReducedSystem::get_jacobian(Vector& x, Matrix& jacobian)
{
const scalar_t log10 = std::log(10.0);
jacobian.resize(total_variables(), total_variables());
jacobian.setZero();
// water
if (ideq_w() != no_equation)
{
scalar_t tmp = -1/m_data->molar_mass_basis_si(0);
for (index_t j: m_data->range_aqueous())
{
if ( m_data->nu_aqueous(j, 0) == 0 ) continue;
tmp -= m_data->nu_aqueous(j, 0)*m_secondary_conc(j);
}
jacobian(0, 0) = tmp;
for (index_t k: m_data->range_aqueous_component())
{
if (ideq_paq(k) == no_equation) continue;
scalar_t tmp = 0;
for (index_t j: m_data->range_aqueous())
{
tmp -= m_data->nu_aqueous(j,0)*m_data->nu_aqueous(j,k)*m_secondary_conc(j);
}
jacobian(0, ideq_paq(k)) = x(ideq_w())*log10 * tmp;
}
for (index_t m: m_data->range_mineral())
{
if (ideq_min(m) == no_equation) continue;
jacobian(0, ideq_min(m)) = -m_data->nu_mineral(m, 0);
}
}
// aqueous component
for (index_t i: m_data->range_aqueous_component())
{
const index_t idp = ideq_paq(i);
if (idp == no_equation) continue;
// aqueous components
for (index_t k: m_data->range_aqueous_component())
{
if (ideq_paq(k) == no_equation) continue;
scalar_t tmp_iip = 0;
if (k == i) tmp_iip -= pow10(x(ideq_paq(i)))*log10;
for (index_t j: m_data->range_aqueous())
{
tmp_iip -= log10*m_data->nu_aqueous(j, i)*m_data->nu_aqueous(j, k)*m_secondary_conc(j);
}
jacobian(idp, ideq_paq(k)) = mass_water(x)*tmp_iip;
}
// minerals
for (index_t m: m_data->range_mineral())
{
if (ideq_min(m) == no_equation) continue;
jacobian(idp, ideq_min(m)) = - m_data->nu_mineral(m, i);
}
if (ideq_w() != no_equation) // Water
{
scalar_t tmp_iw = -std::pow(10.0, x(idp));
for (index_t j: m_data->range_aqueous())
{
if ( m_data->nu_aqueous(j, i) == 0 ) continue;
tmp_iw -= m_data->nu_aqueous(j, i)*m_secondary_conc(j);
}
jacobian(idp, ideq_w()) = tmp_iw;
}
}
// mineral equilibrium
for (index_t m: m_data->range_mineral())
{
const index_t idm = ideq_min(m);
if (idm == no_equation) continue;
for (index_t i: m_data->range_aqueous_component())
{
if (ideq_paq(i) == no_equation) continue;
jacobian(idm, ideq_paq(i)) = -m_data->nu_mineral(m, i);
}
}
}
void ReducedSystem::set_secondary_concentration(const Vector& x)
{
for (index_t j: m_data->range_aqueous())
{
if (m_active_aqueous[j] == false)
{
m_secondary_conc(j) = 0;
continue;
}
scalar_t conc = -m_data->logk_aqueous(j) - m_loggamma(j+m_data->nb_component);
for (index_t k: m_data->range_aqueous_component())
{
if (m_data->nu_aqueous(j, k) == 0) continue;
conc += m_data->nu_aqueous(j, k)*(x(ideq_paq(k)) + m_loggamma(k));
}
m_secondary_conc(j) = pow10(conc);
}
}
void ReducedSystem::set_ionic_strength(const Vector& x)
{
scalar_t ionic = 0;
for (index_t i: m_data->range_aqueous_component())
{
if (ideq_paq(i) == no_equation or m_data->charge_component(i) == 0) continue;
ionic += pow10(x(ideq_paq(i)))*std::pow(m_data->charge_component(i),2);
}
for (index_t j: m_data->range_aqueous())
{
if (not m_active_aqueous[j] or m_data->charge_aqueous(j) == 0) continue;
ionic += m_secondary_conc(j)*std::pow(m_data->charge_aqueous(j),2);
}
m_ionic_strength = ionic/2;
}
void ReducedSystem::compute_log_gamma(const Vector& x)
{
set_ionic_strength(x);
const scalar_t sqrti = std::sqrt(m_ionic_strength);
for (index_t i: m_data->range_aqueous_component())
{
if (ideq_paq(i) == no_equation)
{
m_loggamma(i) = 0;
continue;
}
m_loggamma(i) = laws::extended_debye_huckel(m_ionic_strength, sqrti,
m_data->charge_component(i),
m_data->a_debye_component(i),
m_data->b_debye_component(i));
}
for (index_t j: m_data->range_aqueous())
{
if (not m_active_aqueous[j])
{
m_loggamma(m_data->nb_component + j) = 0;
continue;
}
m_loggamma(m_data->nb_component + j) = laws::extended_debye_huckel(
m_ionic_strength, sqrti,
m_data->charge_aqueous(j),
m_data->a_debye_aqueous(j),
m_data->b_debye_aqueous(j));
}
}
bool ReducedSystem::hook_start_iteration(const Vector& x, scalar_t norm_residual)
{
not_in_linesearch = true;
scalar_t previous_norm = m_loggamma.norm();
bool may_have_converged = false;
if (norm_residual < nb_free_variables())
{
// Use fix point iterations for non-ideality
for (int i=0; i<6; ++i)
{
set_secondary_concentration(x);
compute_log_gamma(x);
if (std::abs(previous_norm - m_loggamma.norm()) < 1e-6) {may_have_converged = true; break;}
previous_norm = m_loggamma.norm();
}
}
return may_have_converged;
}
double ReducedSystem::max_lambda(const Vector& x, const Vector& update)
{
if (ideq_w() != no_equation)
{
return 1.0/std::max(1.0, -update(0)/(0.9*x(0)));
}
else
{
return 1.0;
}
}
void ReducedSystem::reasonable_starting_guess(Vector &x, bool for_min)
{
x.resize(m_data->nb_component+ m_data->nb_mineral);
x(0) = 2*m_tot_conc(0)*m_data->molar_mass_basis_si(0);
for (index_t i: m_data->range_aqueous_component())
{
x(i) = -4.0;
}
if (for_min)
x.block(m_data->nb_component, 0, m_data->nb_mineral, 1).setZero();
else
x.block(m_data->nb_component, 0, m_data->nb_mineral, 1).setZero();
m_loggamma.setZero();
m_secondary_conc.setZero();
}
void ReducedSystem::reasonable_restarting_guess(Vector& x)
{
x(0) = m_tot_conc(0)*m_data->molar_mass_basis_si(0);
for (index_t i=m_data->nb_component; i<m_data->nb_component+m_data->nb_mineral; ++i)
{
x(i) = 0.0;
}
m_loggamma.setZero();
m_secondary_conc.setZero();
}
EquilibriumState ReducedSystem::get_solution(const Vector& xtot, const Vector& x)
{
double previous_norm = m_loggamma.norm();
set_secondary_concentration(x);
compute_log_gamma(x);
if (std::abs(previous_norm - m_loggamma.norm()) > 1e-6)
{
WARNING << "Activity coefficient have not converged !" << std::endl
<< "output can not be trusted\n Difference "+std::to_string(std::abs(previous_norm - m_loggamma.norm()));
}
return EquilibriumState(xtot, m_secondary_conc,
m_loggamma, m_ionic_strength,
m_data);
}
void ReducedSystem::reduce_mineral_problem(Vector& true_var)
{
for (index_t mineral: m_data->range_mineral())
{
if (ideq_min(mineral) == no_equation) continue;
if (m_data->stability_mineral(mineral) == database::MineralStabilityClass::cannot_dissolve)
{
if (true_var(ideq_min(mineral)) == 0.0) continue;
for (index_t component: m_data->range_component())
{
if (m_data->nu_mineral(mineral, component) == 0.0) continue;
m_tot_conc(component) -= m_data->nu_mineral(mineral, component)*true_var(ideq_min(mineral));
}
true_var(ideq_min(mineral)) = 0.0;
}
}
}
void ReducedSystem::reset_mineral_system(Vector& true_var, Vector& output_var)
{
for (index_t mineral: m_data->range_mineral())
{
if (ideq_min(mineral) == no_equation) continue;
if (m_data->stability_mineral(mineral) == database::MineralStabilityClass::cannot_dissolve)
{
output_var(mineral) += true_var(ideq_min(mineral));
}
}
}
} // end namespace specmicp
c4science · Help