Esempio n. 1
0
void Domain1D::
eval(size_t jg, doublereal* xg, doublereal* rg,
     integer* mask, doublereal rdt)
{

    if (jg != npos && (jg + 1 < firstPoint() || jg > lastPoint() + 1)) {
        return;
    }

    // if evaluating a Jacobian, compute the steady-state residual
    if (jg != npos) {
        rdt = 0.0;
    }

    // start of local part of global arrays
    doublereal* x = xg + loc();
    doublereal* rsd = rg + loc();
    integer* diag = mask + loc();

    size_t jmin, jmax, jpt,  j, i;
    jpt = jg - firstPoint();

    if (jg == npos) {      // evaluate all points
        jmin = 0;
        jmax = m_points - 1;
    } else {          // evaluate points for Jacobian
        jmin = std::max<size_t>(jpt, 1) - 1;
        jmax = std::min(jpt+1,m_points-1);
    }

    for (j = jmin; j <= jmax; j++) {
        if (j == 0 || j == m_points - 1) {
            for (i = 0; i < m_nv; i++) {
                rsd[index(i,j)] = residual(x,i,j);
                diag[index(i,j)] = 0;
            }
        } else {
            for (i = 0; i < m_nv; i++) {
                rsd[index(i,j)] = residual(x,i,j)
                                  - timeDerivativeFlag(i)*rdt*(value(x,i,j) - prevSoln(i,j));
                diag[index(i,j)] = timeDerivativeFlag(i);
            }
        }
    }
}
void ReactingSurf1D::eval(size_t jg, doublereal* xg, doublereal* rg,
                          integer* diagg, doublereal rdt)
{
    if (jg != npos && (jg + 2 < firstPoint() || jg > lastPoint() + 2)) {
        return;
    }

    // start of local part of global arrays
    doublereal* x = xg + loc();
    doublereal* r = rg + loc();
    integer* diag = diagg + loc();

    // specified surface temp
    r[0] = x[0] - m_temp;

    // set the coverages
    doublereal sum = 0.0;
    for (size_t k = 0; k < m_nsp; k++) {
        m_work[k] = x[k+1];
        sum += x[k+1];
    }
    m_sphase->setTemperature(x[0]);
    m_sphase->setCoveragesNoNorm(m_work.data());

    // set the left gas state to the adjacent point

    size_t leftloc = 0, rightloc = 0;
    size_t pnt = 0;

    if (m_flow_left) {
        leftloc = m_flow_left->loc();
        pnt = m_flow_left->nPoints() - 1;
        m_flow_left->setGas(xg + leftloc, pnt);
    }

    if (m_flow_right) {
        rightloc = m_flow_right->loc();
        m_flow_right->setGas(xg + rightloc, 0);
    }

    m_kin->getNetProductionRates(m_work.data());
    doublereal rs0 = 1.0/m_sphase->siteDensity();
    size_t ioffset = m_kin->kineticsSpeciesIndex(0, m_surfindex);

    if (m_enabled) {
        doublereal maxx = -1.0;
        for (size_t k = 0; k < m_nsp; k++) {
            r[k+1] = m_work[k + ioffset] * m_sphase->size(k) * rs0;
            r[k+1] -= rdt*(x[k+1] - prevSoln(k+1,0));
            diag[k+1] = 1;
            maxx = std::max(x[k+1], maxx);
        }
        r[1] = 1.0 - sum;
        diag[1] = 0;
    } else {
        for (size_t k = 0; k < m_nsp; k++) {
            r[k+1] = x[k+1] - m_fixed_cov[k];
            diag[k+1] = 0;
        }
    }

    if (m_flow_right) {
        double* rb = r + 1;
        double* xb = x + 1;
        rb[2] = xb[2] - x[0]; // specified T
    }
    if (m_flow_left) {
        size_t nc = m_flow_left->nComponents();
        const vector_fp& mwleft = m_phase_left->molecularWeights();
        double* rb = r - nc;
        double* xb = x - nc;
        rb[2] = xb[2] - x[0]; // specified T
        size_t nSkip = m_flow_left->rightExcessSpecies();
        for (size_t nl = 0; nl < m_left_nsp; nl++) {
            if (nl != nSkip) {
                rb[4+nl] += m_work[nl]*mwleft[nl];
            }
        }
    }
}
Esempio n. 3
0
    void ReactingSurf1D::
    eval(int jg, doublereal* xg, doublereal* rg, 
        integer* diagg, doublereal rdt) {
        if (jg >= 0 && (jg < firstPoint() - 2 || jg > lastPoint() + 2)) return;

        // start of local part of global arrays
        doublereal* x = xg + loc();
        doublereal* r = rg + loc();
        integer* diag = diagg + loc();
        doublereal *xb, *rb;

        // specified surface temp
        r[0] = x[0] - m_temp;

        // set the coverages
        doublereal sum = 0.0;
        int k;
        for (k = 0; k < m_nsp; k++) {
            m_work[k] = x[k+1];
            sum += x[k+1];
        }
        m_sphase->setTemperature(x[0]);
        m_sphase->setCoverages(DATA_PTR(m_work));
        //m_kin->advanceCoverages(1.0);
        //m_sphase->getCoverages(m_fixed_cov.begin());

        // set the left gas state to the adjacent point

        int leftloc = 0, rightloc = 0;
        int pnt = 0;

        if (m_flow_left) {
            leftloc = m_flow_left->loc();
            pnt = m_flow_left->nPoints() - 1;
            m_flow_left->setGas(xg + leftloc, pnt);
        }

        if (m_flow_right) {
            rightloc = m_flow_right->loc();
            m_flow_right->setGas(xg + rightloc, 0);
        }

        m_kin->getNetProductionRates(DATA_PTR(m_work));
        doublereal rs0 = 1.0/m_sphase->siteDensity();
            
        //scale(m_work.begin(), m_work.end(), m_work.begin(), m_mult[0]);
        
        //        bool enabled = true;
        int ioffset = m_kin->kineticsSpeciesIndex(0, m_surfindex);

        if (m_enabled) {
            doublereal maxx = -1.0;
            int imx = -1;
            for (k = 0; k < m_nsp; k++) {
                r[k+1] = m_work[k + ioffset] * m_sphase->size(k) * rs0;
                r[k+1] -= rdt*(x[k+1] - prevSoln(k+1,0));
                diag[k+1] = 1;
                if (x[k+1] > maxx) {
                    maxx = x[k+1];
                    imx = k+1;
                }
            }
            r[1] = 1.0 - sum;
            diag[1] = 0;
        }
        else {
            for (k = 0; k < m_nsp; k++) {
                r[k+1] = x[k+1] - m_fixed_cov[k];
                diag[k+1] = 0;
            }
        }
        
        if (m_flow_right) {
            rb = r + 1;
            xb = x + 1;
            rb[2] = xb[2] - x[0];            // specified T
        }
        int nc;
        if (m_flow_left) {
            nc = m_flow_left->nComponents();
            const doublereal* mwleft = DATA_PTR(m_phase_left->molecularWeights());
            rb =r - nc;
            xb = x - nc;
            rb[2] = xb[2] - x[0];            // specified T
            for (int nl = 1; nl < m_left_nsp; nl++) {
                rb[4+nl] += m_work[nl]*mwleft[nl];
            }
        }
    }