OneDim.cpp

Go to the documentation of this file.

//! @file OneDim.cpp
 
// This file is part of Cantera. See License.txt in the top-level directory or
// at https://cantera.org/license.txt for license and copyright information.
 
#include "cantera/oneD/OneDim.h"
#include "cantera/numerics/Func1.h"
#include "cantera/oneD/MultiNewton.h"
#include "cantera/base/AnyMap.h"
#include "cantera/numerics/SystemJacobianFactory.h"
 
#include <chrono>
#include <fstream>
 
using namespace std;
 
namespace Cantera
{
 
OneDim::OneDim(span<const shared_ptr<Domain1D>> domains)
{
    for (const auto& dom : domains) {
        addDomain(dom);
    }
    init();
    resize();
}
 
size_t OneDim::domainIndex(const string& name) const
{
    for (size_t n = 0; n < m_dom.size(); n++) {
        if (domain(n).id() == name) {
            return n;
        }
    }
    throw CanteraError("OneDim::domainIndex", "Domain '{}' not found", name);
}
 
std::tuple<string, size_t, string> OneDim::component(size_t i) const {
    if (i >= m_size) {
        throw IndexError("OneDim::component", "components", i, m_size);
    }
    const auto& [n, j, k] = m_componentInfo[i];
    Domain1D& dom = domain(n);
    return make_tuple(dom.id(), j, dom.componentName(k));
}
 
string OneDim::componentName(size_t i) const {
    const auto& [dom, pt, comp] = component(i);
    return fmt::format("domain {}, component {} at point {}", dom, comp, pt);
}
 
pair<string, string> OneDim::componentTableHeader() const
{
    return {"", "Domain   Pt. Component"};
}
 
string OneDim::componentTableLabel(size_t i) const
{
    const auto& [dom, pt, comp] = component(i);
    return fmt::format("{:8s} {:3d} {:<12s}", dom, pt, comp);
}
 
double OneDim::upperBound(size_t i) const
{
    const auto& [n, j, k] = m_componentInfo[i];
    Domain1D& dom = domain(n);
    return dom.upperBound(k);
}
 
double OneDim::lowerBound(size_t i) const
{
    const auto& [n, j, k] = m_componentInfo[i];
    Domain1D& dom = domain(n);
    return dom.lowerBound(k);
}
 
void OneDim::addDomain(shared_ptr<Domain1D> d)
{
    // if 'd' is not the first domain, link it to the last domain
    // added (the rightmost one)
    size_t n = m_dom.size();
    if (n > 0) {
        m_dom.back()->append(d.get());
    }
 
    // every other domain is a connector
    if (n % 2 == 0) {
        m_connect.push_back(d);
    } else {
        m_bulk.push_back(d);
    }
 
    // add it also to the global domain list, and set its container and position
    m_dom.push_back(d);
    d->setData(m_state);
    d->setContainer(this, m_dom.size()-1);
    resize();
}
 
double OneDim::weightedNorm(span<const double> step) const
{
    double sum = 0.0;
    const double* x = m_state->data();
    size_t nd = nDomains();
    for (size_t n = 0; n < nd; n++) {
        Domain1D& dom = domain(n);
        double d_sum = 0.0;
        size_t nv = dom.nComponents();
        size_t np = dom.nPoints();
        size_t dstart = start(n);
 
        for (size_t i = 0; i < nv; i++) {
            double esum = 0.0;
            for (size_t j = 0; j < np; j++) {
                esum += fabs(x[dstart + nv*j + i]);
            }
            double ewt = dom.rtol(i)*esum/np + dom.atol(i);
            for (size_t j = 0; j < np; j++) {
                double f = step[dstart + nv*j + i]/ewt;
                d_sum += f*f;
            }
        }
        sum += d_sum;
    }
    return sqrt(sum / size());
}
 
void OneDim::writeStats(int printTime)
{
    saveStats();
    auto& gridpts = m_stats["grid_points"].asVector<long int>();
    auto& steps = m_stats["steps"].asVector<long int>();
    auto& fevals = m_stats["residual_evals"].asVector<long int>();
    auto& ftime = m_stats["residual_time"].asVector<double>();
    auto& jevals = m_stats["jacobian_evals"].asVector<long int>();
    auto& jtime = m_stats["jacobian_time"].asVector<double>();
    writelog("\nStatistics:\n\n Grid   Timesteps  Functions      Time  Jacobians      Time\n");
    for (size_t i = 0; i < gridpts.size(); i++) {
        if (printTime) {
            writelog("{:5d}       {:5d}     {:6d} {:9.4f}      {:5d} {:9.4f}\n",
                     gridpts[i], steps[i], fevals[i], ftime[i], jevals[i], jtime[i]);
        } else {
            writelog("{:5d}       {:5d}     {:6d}        NA      {:5d}        NA\n",
                     gridpts[i], steps[i], fevals[i], jevals[i]);
        }
    }
}
 
void OneDim::resize()
{
    m_bw = 0;
    m_nvars.clear();
    m_loc.clear();
    m_componentInfo.clear();
    size_t lc = 0;
 
    if (left()) {
        left()->locate();
    }
 
    // save the statistics for the last grid
    saveStats();
    m_pts = 0;
    for (size_t i = 0; i < nDomains(); i++) {
        const auto& d = m_dom[i];
 
        size_t np = d->nPoints();
        size_t nv = d->nComponents();
        for (size_t n = 0; n < np; n++) {
            m_nvars.push_back(nv);
            m_loc.push_back(lc);
            lc += nv;
            m_pts++;
            for (size_t k = 0; k < nv; k++) {
                m_componentInfo.emplace_back(i, n, k);
            }
        }
 
        // update the Jacobian bandwidth
 
        // bandwidth of the local block
        size_t bw1 = d->bandwidth();
        if (bw1 == npos) {
            bw1 = std::max<size_t>(2*d->nComponents(), 1) - 1;
        }
        m_bw = std::max(m_bw, bw1);
 
        // bandwidth of the block coupling the first point of this
        // domain to the last point of the previous domain
        if (i > 0) {
            size_t bw2 = m_dom[i-1]->bandwidth();
            if (bw2 == npos) {
                bw2 = m_dom[i-1]->nComponents();
            }
            bw2 += d->nComponents() - 1;
            m_bw = std::max(m_bw, bw2);
        }
        m_size = d->loc() + d->size();
    }
    if (!m_jac) {
        m_jac = newSystemJacobian("banded-direct");
    }
    SteadyStateSystem::resize();
}
 
Domain1D* OneDim::pointDomain(size_t i)
{
    Domain1D* d = right();
    while (d) {
        if (d->loc() <= i) {
            return d;
        }
        d = d->left();
    }
    return 0;
}
 
void OneDim::eval(size_t j, span<const double> x, span<double> r, double rdt, int count)
{
    auto t0 = std::chrono::steady_clock::now();
    if (m_interrupt) {
        m_interrupt->eval(m_nevals);
    }
    fill(r.begin(), r.end(), 0.0);
    if (j == npos) {
        fill(m_mask.begin(), m_mask.end(), 0);
    }
    if (rdt < 0.0) {
        rdt = m_rdt;
    }
 
    // iterate over the bulk domains first
    for (const auto& d : m_bulk) {
        d->eval(j, x, r, m_mask, rdt);
    }
 
    // then over the connector domains
    for (const auto& d : m_connect) {
        d->eval(j, x, r, m_mask, rdt);
    }
 
    // increment counter and time
    if (count) {
        m_evaltime += std::chrono::duration<double>(
            std::chrono::steady_clock::now() - t0).count();
        m_nevals++;
    }
}
 
void OneDim::evalJacobian(span<const double> x0)
{
    m_jac->reset();
    auto t0 = std::chrono::steady_clock::now();
    m_work1.resize(size());
    m_work2.resize(size());
    eval(npos, x0, m_work1, 0.0, 0);
    // In explicit "analytic" mode, fail fast if analytic evaluation cannot be
    // delivered, before doing a full finite-difference pass. (Base residual
    // eval above leaves each domain's thermo state valid for the capability
    // probe.)
    for (auto& dom : m_dom) {
        dom->checkAnalyticJacobian();
    }
    vector<double> perturbed(x0.begin(), x0.end());
    size_t ipt = 0;
    for (size_t j = 0; j < points(); j++) {
        size_t nv = nVars(j);
        Domain1D* dom = pointDomain(ipt);
        size_t jLocal = j - dom->firstPoint();
        for (size_t n = 0; n < nv; n++) {
            if (dom->hasAnalyticJacobian(jLocal, n)) {
                // skip FD perturbation; analytic fill handled below
                ipt++;
                continue;
            }
            // perturb x(n); preserve sign(x(n))
            double xsave = x0[ipt];
            double dx = fabs(xsave) * m_jacobianRelPerturb + m_jacobianAbsPerturb;
            if (xsave < 0) {
                dx = -dx;
            }
            perturbed[ipt] = xsave + dx;
            double rdx = 1.0 / (perturbed[ipt] - xsave);
 
            // calculate perturbed residual
            eval(j, perturbed, m_work2, 0.0, 0);
 
            // compute nth column of Jacobian
            for (size_t i = j - 1; i != j+2; i++) {
                if (i != npos && i < points()) {
                    size_t mv = nVars(i);
                    size_t iloc = loc(i);
                    for (size_t m = 0; m < mv; m++) {
                        double delta = m_work2[m+iloc] - m_work1[m+iloc];
                        if (std::abs(delta) > m_jacobianThreshold || m+iloc == ipt) {
                            m_jac->setValue(m + iloc, ipt, delta * rdx);
                        }
                    }
                }
            }
            perturbed[ipt] = xsave;
            ipt++;
        }
    }
 
    // analytic contributions for claimed columns
    for (auto& dom : m_dom) {
        dom->evalJacobianAnalytic(x0, *m_jac);
    }
 
    m_jac->updateElapsed(std::chrono::duration<double>(
        std::chrono::steady_clock::now() - t0).count());
    m_jac->incrementEvals();
    m_jac->setAge(0);
}
 
void OneDim::initTimeInteg(double dt, span<const double> x)
{
    SteadyStateSystem::initTimeInteg(dt, x);
    // iterate over all domains, preparing each one to begin time stepping
    Domain1D* d = left();
    while (d) {
        d->initTimeInteg(dt, x);
        d = d->right();
    }
}
 
void OneDim::setSteadyMode()
{
    if (m_rdt == 0) {
        return;
    }
    SteadyStateSystem::setSteadyMode();
    // iterate over all domains, preparing them for steady-state solution
    Domain1D* d = left();
    while (d) {
        d->setSteadyMode();
        d = d->right();
    }
}
 
void OneDim::init()
{
    if (!m_init) {
        Domain1D* d = left();
        while (d) {
            d->init();
            d = d->right();
        }
    }
    m_init = true;
}
 
void OneDim::resetBadValues(span<double> x)
{
    for (auto dom : m_dom) {
        dom->resetBadValues(x);
    }
}
 
}