Program Listing for File multiConditionDataProvider.h

↰ Return to documentation for file (include/parpeamici/multiConditionDataProvider.h)

#ifndef MULTICONDITIONDATAPROVIDER_H
#define MULTICONDITIONDATAPROVIDER_H

#include <parpecommon/hdf5Misc.h>
#include <parpeoptimization/optimizationOptions.h>

#include <amici/amici.h>

#include <gsl/gsl-lite.hpp>

#include <H5Cpp.h>

#include <memory>
#include <string>
#include <vector>

namespace parpe {

class MultiConditionDataProvider
{
  public:
    virtual ~MultiConditionDataProvider() = default;

    virtual int getNumberOfSimulationConditions() const = 0;

    virtual std::vector<int> getSimulationToOptimizationParameterMapping(
      int conditionIdx) const = 0;

    virtual void mapSimulationToOptimizationGradientAddMultiply(
      int conditionIdx,
      gsl::span<double const> simulation,
      gsl::span<double> optimization,
      gsl::span<const double> parameters,
      double coefficient = 1.0) const = 0;

    virtual void mapAndSetOptimizationToSimulationVariables(
      int conditionIdx,
      gsl::span<double const> optimization,
      gsl::span<double> simulation,
      gsl::span<amici::ParameterScaling> optimizationScale,
      gsl::span<amici::ParameterScaling> simulationScale) const = 0;

    virtual amici::ParameterScaling getParameterScaleOpt(
      int parameterIdx) const = 0;

    virtual std::vector<amici::ParameterScaling> getParameterScaleOpt()
      const = 0;

    virtual std::vector<amici::ParameterScaling> getParameterScaleSim(
      int simulationIdx) const = 0;

    virtual amici::ParameterScaling getParameterScaleSim(
      int simulationIdx,
      int modelParameterIdx) const = 0;

    virtual void updateSimulationParametersAndScale(
      int conditionIndex,
      gsl::span<double const> optimizationParams,
      amici::Model& model) const = 0;

    virtual std::unique_ptr<amici::ExpData> getExperimentalDataForCondition(
      int conditionIdx) const = 0;

    virtual std::vector<std::vector<double>> getAllMeasurements() const = 0;
    virtual std::vector<std::vector<double>> getAllSigmas() const = 0;

    virtual int getNumOptimizationParameters() const = 0;

    virtual std::vector<std::string> getProblemParameterIds() const = 0;

    virtual std::unique_ptr<amici::Model> getModel() const = 0;

    virtual std::unique_ptr<amici::Solver> getSolver() const = 0;
};


class MultiConditionDataProviderDefault : public MultiConditionDataProvider
{
  public:
    MultiConditionDataProviderDefault(std::unique_ptr<amici::Model> model,
                                      std::unique_ptr<amici::Solver> solver);

    ~MultiConditionDataProviderDefault() override = default;

    int getNumberOfSimulationConditions() const override;

    std::vector<int> getSimulationToOptimizationParameterMapping(
      int conditionIdx) const override;

    void mapSimulationToOptimizationGradientAddMultiply(
      int conditionIdx,
      gsl::span<double const> simulation,
      gsl::span<double> optimization,
      gsl::span<const double> parameters,
      double coefficient = 1.0) const override;

    void mapAndSetOptimizationToSimulationVariables(
      int conditionIdx,
      gsl::span<double const> optimization,
      gsl::span<double> simulation,
      gsl::span<amici::ParameterScaling> optimizationScale,
      gsl::span<amici::ParameterScaling> simulationScale) const override;

    std::vector<amici::ParameterScaling> getParameterScaleOpt()
      const override;

    amici::ParameterScaling getParameterScaleOpt(
      int optimizationParameterIndex) const override;

    amici::ParameterScaling getParameterScaleSim(
      int simulationIdx,
      int optimizationParameterIndex) const override;

    std::vector<amici::ParameterScaling> getParameterScaleSim(
      int) const override;

    void updateSimulationParametersAndScale(
      int conditionIndex,
      gsl::span<const double> optimizationParams,
      amici::Model& model) const override;

    std::unique_ptr<amici::ExpData> getExperimentalDataForCondition(
      int conditionIdx) const override;

    std::vector<std::vector<double>> getAllMeasurements()
      const override;
    std::vector<std::vector<double>> getAllSigmas() const override;

    int getNumOptimizationParameters() const override;

    std::unique_ptr<amici::Model> getModel() const override;

    std::unique_ptr<amici::Solver> getSolver() const override;

    std::vector<std::string> getProblemParameterIds() const override;

    // TODO private
    std::vector<amici::ExpData> edata_;

  private:
    std::unique_ptr<amici::Model> model_;
    std::unique_ptr<amici::Solver> solver_;
};

// TODO split; separate optimization from simulation
class MultiConditionDataProviderHDF5 : public MultiConditionDataProvider
{
  public:
    MultiConditionDataProviderHDF5() = default;

    MultiConditionDataProviderHDF5(std::unique_ptr<amici::Model> model,
                                   const std::string& hdf5Filename);

    MultiConditionDataProviderHDF5(std::unique_ptr<amici::Model> model,
                                   std::string const& hdf5Filename,
                                   std::string const& rootPath);

    MultiConditionDataProviderHDF5(MultiConditionDataProviderHDF5 const&) =
      delete;

    ~MultiConditionDataProviderHDF5() override;

    int getNumberOfSimulationConditions() const override;

    std::vector<int> getSimulationToOptimizationParameterMapping(
      int conditionIdx) const override;

    void mapSimulationToOptimizationGradientAddMultiply(
      int conditionIdx,
      gsl::span<double const> simulation,
      gsl::span<double> optimization,
      gsl::span<const double> parameters,
      double coefficient = 1.0) const override;

    void mapAndSetOptimizationToSimulationVariables(
      int conditionIdx,
      gsl::span<double const> optimization,
      gsl::span<double> simulation,
      gsl::span<amici::ParameterScaling> optimizationScale,
      gsl::span<amici::ParameterScaling> simulationScale) const override;

    std::vector<amici::ParameterScaling> getParameterScaleOpt()
      const override;

    amici::ParameterScaling getParameterScaleOpt(
      int parameterIdx) const override;

    std::vector<amici::ParameterScaling> getParameterScaleSim(
      int simulationIdx) const override;

    amici::ParameterScaling getParameterScaleSim(
      int simulationIdx,
      int modelParameterIdx) const override;

    virtual void checkDataIntegrity() const;

    // void printInfo() const;

    virtual void readFixedSimulationParameters(int conditionIdx,
                                               gsl::span<double> buffer) const;

    std::unique_ptr<amici::ExpData> getExperimentalDataForCondition(
      int conditionIdx) const override;

    std::vector<std::vector<double>> getAllMeasurements() const override;
    std::vector<std::vector<double>> getAllSigmas() const override;

    std::vector<double> getSigmaForSimulationIndex(int simulationIdx) const;
    std::vector<double> getMeasurementForSimulationIndex(
      int conditionIdx) const;

    virtual void getOptimizationParametersLowerBounds(
      gsl::span<double> buffer) const;

    virtual void getOptimizationParametersUpperBounds(
      gsl::span<double> buffer) const;

    int getNumOptimizationParameters() const override;

    std::unique_ptr<amici::Model> getModel() const override;

    std::unique_ptr<amici::Solver> getSolver() const override;

    void updateSimulationParametersAndScale(
      int simulationIdx,
      gsl::span<const double> optimizationParams,
      amici::Model& model) const override;

    void copyInputData(const H5::H5File& target);

    void getSimAndPreeqConditions(
      const int simulationIdx,
      int& preequilibrationConditionIdx,
      int& simulationConditionIdx
    ) const;

    std::vector<int> getReinitializationIndices(const int simulationIdx) const;

    H5::H5File getHdf5File() const;

    void setModel(std::unique_ptr<amici::Model> model);

    std::vector<std::string> getProblemParameterIds() const override;

  protected:
    void updateFixedSimulationParameters(int conditionIdx,
                                         amici::ExpData& edata) const;


  private:
    std::unique_ptr<amici::Model> model_;

    std::string root_path_ = "/";
    std::string hdf5_measurement_path_;
    std::string hdf5_measurement_sigma_path_;
    std::string hdf5_condition_path_;
    std::string hdf5_reference_condition_path_;
    std::string hdf5_amici_options_path_;
    std::string hdf5_parameter_path_;
    std::string hdf5_parameter_min_path_;
    std::string hdf5_parameter_max_path_;
    std::string hdf5_parameter_scale_simulation_path_;
    std::string hdf5_parameter_scale_optimization_path_;
    std::string hdf5_simulation_to_optimization_parameter_mapping_path_;
    std::string hdf5_parameter_overrides_path;
    std::string hdf5_parameter_ids_path_;
    std::string hdf5_reinitialization_idxs_path_;

    H5::H5File file_;

    std::unique_ptr<OptimizationOptions> optimization_options_;
};

double
applyChainRule(double gradient,
               double parameter,
               amici::ParameterScaling oldScale,
               amici::ParameterScaling newScale);

} // namespace parpe

#endif // MULTICONDITIONDATAPROVIDER_H