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 <string>
#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> fixed_parameters
    );

    ExpData(
        int nytrue, int nztrue, int nmaxevent, std::vector<realtype> ts,
        std::vector<realtype> const& my,
        std::vector<realtype> const& sigma_y,
        std::vector<realtype> const& mz,
        std::vector<realtype> const& sigma_z
    );

    explicit ExpData(Model const& model);

    ExpData(
        ReturnData const& rdata, realtype sigma_y, realtype sigma_z,
        int seed = -1
    );

    ExpData(
        ReturnData const& rdata, std::vector<realtype> sigma_y,
        std::vector<realtype> sigma_z, int seed = -1
    );

    ~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 set_timepoints(std::vector<realtype> const& ts);

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

    realtype get_timepoint(int it) const;

    void set_measurements(std::vector<realtype> const& my);

    void set_measurements(std::vector<realtype> const& my, int iy);

    bool is_set_measurement(int it, int iy) const;

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

    realtype const* get_measurements_ptr(int it) const;

    void set_noise_scales(std::vector<realtype> const& sigma);

    void set_noise_scales(realtype sigma);

    void set_noise_scales(std::vector<realtype> const& sigma, int iy);

    void set_noise_scales(realtype sigma, int iy);

    bool is_set_noise_scale(int it, int iy) const;

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

    realtype const* get_noise_scales_ptr(int it) const;

    void set_event_measurements(std::vector<realtype> const& mz);

    void
    set_event_measurements(std::vector<realtype> const& mz, int iz);

    bool is_set_event_measurement(int ie, int iz) const;

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

    realtype const* get_event_measurements_ptr(int ie) const;

    void set_event_noise_scales(std::vector<realtype> const& sigma);

    void set_event_noise_scales(realtype sigma);

    void set_event_noise_scales(std::vector<realtype> const& sigma, int iz);

    void set_event_noise_scales(realtype sigma, int iz);

    bool is_set_event_noise_scale(int ie, int iz) const;

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

    realtype const* get_event_noise_scales_ptr(int ie) const;

    void clear_observations();

    std::string id;

  protected:
    void apply_dimensions();

    void apply_data_dimension();

    void apply_event_dimension();

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

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

    int nytrue_{0};

    int nztrue_{0};

    int nmaxevent_{0};

    std::vector<realtype> measurements_;

    std::vector<realtype> noise_scales_;

    std::vector<realtype> event_measurements_;

    std::vector<realtype> event_noise_scales_;
};

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.measurements_, rhs.measurements_)
           && is_equal(lhs.noise_scales_, rhs.noise_scales_)
           && is_equal(lhs.event_measurements_, rhs.event_measurements_)
           && is_equal(
               lhs.event_noise_scales_, rhs.event_noise_scales_
           );
}

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

void check_sigma_positivity(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 apply_condition(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_;
    realtype original_tstart_preeq_;
    std::vector<realtype> original_timepoints_;
    std::vector<int> original_parameter_list_;
    std::vector<ParameterScaling> original_scaling_;
    bool original_reinitialize_fixed_parameter_initial_states_;
    std::vector<int> original_reinitialization_state_idxs;
};

} // namespace amici

#endif /* AMICI_EDATA_H */