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/vector.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;

    ExpData(const ExpData &) = 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(const Model &model);

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

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

    ~ExpData() = default;

    int nytrue() const;

    int nztrue() const;

    int nmaxevent() const;

    int nt() const;

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

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

    realtype getTimepoint(int it) const;

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

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

    bool isSetObservedData(int it, int iy) const;

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

    const realtype *getObservedDataPtr(int it) const;

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

    void setObservedDataStdDev(realtype stdDev);

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

    void setObservedDataStdDev(realtype stdDev, int iy);

    bool isSetObservedDataStdDev(int it, int iy) const;

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

    const realtype *getObservedDataStdDevPtr(int it) const;

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

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

    bool isSetObservedEvents(int ie, int iz) const;

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

    const realtype *getObservedEventsPtr(int ie) const;

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

    void setObservedEventsStdDev(realtype stdDev);

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

    void setObservedEventsStdDev(realtype stdDev, int iz);

    bool isSetObservedEventsStdDev(int ie, int iz) const;

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

    const realtype *getObservedEventsStdDevPtr(int ie) const;

  protected:
    void applyDimensions();

    void applyDataDimension();

    void applyEventDimension();

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

    void checkEventsDimension(std::vector<realtype> const &input,
                              const char *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_;
};

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

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

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

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

    ~ConditionContext();

    void applyCondition(const ExpData *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_;
    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 */