Program Listing for File edata.h

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

#ifndef AMICI_EDATA_H
#define AMICI_EDATA_H

#include "amici/defines.h"
#include "amici/misc.h"
#include "amici/simulation_parameters.h"

#include <vector>

namespace amici {

class Model;
class ReturnData;

class ExpData : public SimulationParameters {

  public:
    ExpData() = default;

    // needs to be declared to be wrapped by SWIG
    ExpData(ExpData const&) = default;

    ExpData(int nytrue, int nztrue, int nmaxevent);

    ExpData(int nytrue, int nztrue, int nmaxevent, std::vector<realtype> ts);

    ExpData(
        int nytrue, int nztrue, int nmaxevent, std::vector<realtype> ts,
        std::vector<realtype> fixedParameters
    );

    ExpData(
        int nytrue, int nztrue, int nmaxevent, std::vector<realtype> ts,
        std::vector<realtype> const& observedData,
        std::vector<realtype> const& observedDataStdDev,
        std::vector<realtype> const& observedEvents,
        std::vector<realtype> const& observedEventsStdDev
    );

    explicit ExpData(Model const& model);

    ExpData(ReturnData const& rdata, realtype sigma_y, realtype sigma_z);

    ExpData(
        ReturnData const& rdata, std::vector<realtype> sigma_y,
        std::vector<realtype> sigma_z
    );

    ~ExpData() = default;

    friend inline bool operator==(ExpData const& lhs, ExpData const& rhs);

    int nytrue() const;

    int nztrue() const;

    int nmaxevent() const;

    int nt() const;

    void setTimepoints(std::vector<realtype> const& ts);

    std::vector<realtype> const& getTimepoints() const;

    realtype getTimepoint(int it) const;

    void setObservedData(std::vector<realtype> const& observedData);

    void setObservedData(std::vector<realtype> const& observedData, int iy);

    bool isSetObservedData(int it, int iy) const;

    std::vector<realtype> const& getObservedData() const;

    realtype const* getObservedDataPtr(int it) const;

    void setObservedDataStdDev(std::vector<realtype> const& observedDataStdDev);

    void setObservedDataStdDev(realtype stdDev);

    void setObservedDataStdDev(
        std::vector<realtype> const& observedDataStdDev, int iy
    );

    void setObservedDataStdDev(realtype stdDev, int iy);

    bool isSetObservedDataStdDev(int it, int iy) const;

    std::vector<realtype> const& getObservedDataStdDev() const;

    realtype const* getObservedDataStdDevPtr(int it) const;

    void setObservedEvents(std::vector<realtype> const& observedEvents);

    void setObservedEvents(std::vector<realtype> const& observedEvents, int iz);

    bool isSetObservedEvents(int ie, int iz) const;

    std::vector<realtype> const& getObservedEvents() const;

    realtype const* getObservedEventsPtr(int ie) const;

    void
    setObservedEventsStdDev(std::vector<realtype> const& observedEventsStdDev);

    void setObservedEventsStdDev(realtype stdDev);

    void setObservedEventsStdDev(
        std::vector<realtype> const& observedEventsStdDev, int iz
    );

    void setObservedEventsStdDev(realtype stdDev, int iz);

    bool isSetObservedEventsStdDev(int ie, int iz) const;

    std::vector<realtype> const& getObservedEventsStdDev() const;

    realtype const* getObservedEventsStdDevPtr(int ie) const;

    void clear_observations();

    std::string id;

  protected:
    void applyDimensions();

    void applyDataDimension();

    void applyEventDimension();

    void checkDataDimension(
        std::vector<realtype> const& input, char const* fieldname
    ) const;

    void checkEventsDimension(
        std::vector<realtype> const& input, char const* fieldname
    ) const;

    int nytrue_{0};

    int nztrue_{0};

    int nmaxevent_{0};

    std::vector<realtype> observed_data_;

    std::vector<realtype> observed_data_std_dev_;

    std::vector<realtype> observed_events_;

    std::vector<realtype> observed_events_std_dev_;
};

inline bool operator==(ExpData const& lhs, ExpData const& rhs) {
    return *dynamic_cast<SimulationParameters const*>(&lhs)
               == *dynamic_cast<SimulationParameters const*>(&rhs)
           && lhs.id == rhs.id && lhs.nytrue_ == rhs.nytrue_
           && lhs.nztrue_ == rhs.nztrue_ && lhs.nmaxevent_ == rhs.nmaxevent_
           && is_equal(lhs.observed_data_, rhs.observed_data_)
           && is_equal(lhs.observed_data_std_dev_, rhs.observed_data_std_dev_)
           && is_equal(lhs.observed_events_, rhs.observed_events_)
           && is_equal(
               lhs.observed_events_std_dev_, rhs.observed_events_std_dev_
           );
};

void checkSigmaPositivity(
    std::vector<realtype> const& sigmaVector, char const* vectorName
);

void checkSigmaPositivity(realtype sigma, char const* sigmaName);

class ConditionContext : public ContextManager {
  public:
    explicit ConditionContext(
        Model* model, ExpData const* edata = nullptr,
        FixedParameterContext fpc = FixedParameterContext::simulation
    );

    ConditionContext& operator=(ConditionContext const& other) = delete;

    ~ConditionContext();

    void applyCondition(ExpData const* edata, FixedParameterContext fpc);

    void restore();

  private:
    Model* model_ = nullptr;
    std::vector<realtype> original_x0_;
    std::vector<realtype> original_sx0_;
    std::vector<realtype> original_parameters_;
    std::vector<realtype> original_fixed_parameters_;
    realtype original_tstart_;
    std::vector<realtype> original_timepoints_;
    std::vector<int> original_parameter_list_;
    std::vector<amici::ParameterScaling> original_scaling_;
    bool original_reinitialize_fixed_parameter_initial_states_;
    std::vector<int> original_reinitialization_state_idxs;
};

} // namespace amici

#endif /* AMICI_EDATA_H */