Program Listing for File model_dimensions.h

↰ Return to documentation for file (include/amici/model_dimensions.h)

#ifndef AMICI_MODEL_DIMENSIONS_H
#define AMICI_MODEL_DIMENSIONS_H

#include <gsl/gsl-lite.hpp>
#include <vector>

namespace amici {

struct ModelDimensions {
    ModelDimensions() = default;

    ModelDimensions(
        int const nx_rdata, int const nxtrue_rdata, int const nx_solver,
        int const nxtrue_solver, int const nx_solver_reinit, int const np,
        int const nk, int const ny, int const nytrue, int const nz,
        int const nztrue, int const ne, int const ne_solver, int const nspl,
        int const nJ, int const nw, int const ndwdx, int const ndwdp,
        int const ndwdw, int const ndxdotdw, std::vector<int> ndJydy,
        int const ndxrdatadxsolver, int const ndxrdatadtcl,
        int const ndtotal_cldx_rdata, int const nnz, int const ubw,
        int const lbw
    )
        : nx_rdata(nx_rdata)
        , nxtrue_rdata(nxtrue_rdata)
        , nx_solver(nx_solver)
        , nxtrue_solver(nxtrue_solver)
        , nx_solver_reinit(nx_solver_reinit)
        , np(np)
        , nk(nk)
        , ny(ny)
        , nytrue(nytrue)
        , nz(nz)
        , nztrue(nztrue)
        , ne(ne)
        , ne_solver(ne_solver)
        , nspl(nspl)
        , nw(nw)
        , ndwdx(ndwdx)
        , ndwdp(ndwdp)
        , ndwdw(ndwdw)
        , ndxdotdw(ndxdotdw)
        , ndJydy(std::move(ndJydy))
        , ndxrdatadxsolver(ndxrdatadxsolver)
        , ndxrdatadtcl(ndxrdatadtcl)
        , ndtotal_cldx_rdata(ndtotal_cldx_rdata)
        , nnz(nnz)
        , nJ(nJ)
        , ubw(ubw)
        , lbw(lbw) {
        Expects(nxtrue_rdata >= 0);
        Expects(nxtrue_rdata <= nx_rdata);
        Expects(nxtrue_solver >= 0);
        Expects(nx_solver <= nx_rdata);
        Expects(nxtrue_solver <= nx_solver);
        Expects(nx_solver_reinit >= 0);
        Expects(nx_solver_reinit <= nx_solver);
        Expects(np >= 0);
        Expects(nk >= 0);
        Expects(nytrue <= ny);
        Expects(nytrue >= 0);
        Expects(nztrue >= 0);
        Expects(nztrue <= nz);
        Expects(ne >= 0);
        Expects(ne_solver >= 0);
        Expects(ne >= ne_solver);
        Expects(nspl >= 0);
        Expects(nw >= 0);
        Expects(ndwdx >= 0);
        Expects(ndwdx <= nw * nx_solver);
        Expects(ndwdp >= 0);
        Expects(ndwdp <= nw * np);
        Expects(ndwdw >= 0);
        Expects(ndwdw <= nw * nw);
        Expects(ndxdotdw >= 0);
        Expects(ndxrdatadxsolver >= 0);
        Expects(ndxrdatadxsolver <= nx_rdata * nx_solver);
        Expects(ndxrdatadtcl >= 0);
        Expects(ndxrdatadtcl <= nx_rdata * (nx_rdata - nx_solver));
        Expects(ndtotal_cldx_rdata >= 0);
        Expects(ndtotal_cldx_rdata <= (nx_rdata - nx_solver) * nx_rdata);
        Expects(nnz >= 0);
        Expects(nJ >= 0);
        Expects(ubw >= 0);
        Expects(lbw >= 0);
    }

    int nx_rdata{0};

    int nxtrue_rdata{0};

    int nx_solver{0};

    int nxtrue_solver{0};

    int nx_solver_reinit{0};

    int np{0};

    int nk{0};

    int ny{0};

    int nytrue{0};

    int nz{0};

    int nztrue{0};

    int ne{0};

    int ne_solver{0};

    int nspl{0};

    int nw{0};

    int ndwdx{0};

    int ndwdp{0};

    int ndwdw{0};

    int ndxdotdw{0};

    std::vector<int> ndJydy;

    int ndxrdatadxsolver{0};

    int ndxrdatadtcl{0};

    int ndtotal_cldx_rdata{0};

    int nnz{0};

    int nJ{0};

    int ubw{0};

    int lbw{0};
};

} // namespace amici

#endif // AMICI_MODEL_DIMENSIONS_H