FlexibleModelFittingParameter.h

Go to the documentation of this file.

/*
 * FlexibleModelFittingParameter.h
 *
 *  Created on: Sep 17, 2018
 *      Author: mschefer
 */

#ifndef _SEIMPLEMENTATION_PLUGIN_FLEXIBLEMODELFITTING_FLEXIBLEMODELFITTINGPARAMETER_H_
#define _SEIMPLEMENTATION_PLUGIN_FLEXIBLEMODELFITTING_FLEXIBLEMODELFITTINGPARAMETER_H_

#include <memory>
#include <utility>
#include <functional>
#include <vector>
#include <mutex>
#include "SEFramework/CoordinateSystem/CoordinateSystem.h"

namespace ModelFitting {
  class BasicParameter;
  class EngineParameterManager;
}

namespace SourceXtractor {

class SourceInterface;
class FlexibleModelFittingParameterManager;
class FlexibleModelFittingConverterFactory;

class FlexibleModelFittingParameter : public std::enable_shared_from_this<FlexibleModelFittingParameter>{
public:
  explicit FlexibleModelFittingParameter(int id);
  virtual ~FlexibleModelFittingParameter() = default;

  virtual std::shared_ptr<ModelFitting::BasicParameter> create(
                                  FlexibleModelFittingParameterManager& parameter_manager,
                                  ModelFitting::EngineParameterManager& engine_manager,
                                  const SourceInterface& source) const = 0;
  
  virtual int getId() const final;

  // returns the estimated 1-sigma margin of error for the parameter on a given source, takes the vector of errors
  // for the free parameters from the minimization engine as input
  virtual double getSigma(FlexibleModelFittingParameterManager& parameter_manager, const SourceInterface& source,
      const std::vector<double>& free_parameter_sigmas) const = 0;


private:
  int m_id;
};

class FlexibleModelFittingConstantParameter : public FlexibleModelFittingParameter {
  
public:
  
  using ValueFunc = std::function<double(const SourceInterface&)>;
  
  FlexibleModelFittingConstantParameter(int id, ValueFunc value);

  std::shared_ptr<ModelFitting::BasicParameter> create(
                                  FlexibleModelFittingParameterManager& parameter_manager,
                                  ModelFitting::EngineParameterManager& engine_manager,
                                  const SourceInterface& source) const override;

  double getSigma(FlexibleModelFittingParameterManager&, const SourceInterface&,
      const std::vector<double>&) const override {
    return 0.0;
  }


private:

  ValueFunc m_value;
  
};

class FlexibleModelFittingFreeParameter : public FlexibleModelFittingParameter {
public:
  
  using InitialValueFunc = std::function<double(const SourceInterface&)>;

  FlexibleModelFittingFreeParameter(int id, InitialValueFunc initial_value,
      std::shared_ptr<FlexibleModelFittingConverterFactory> converter_factory)
          : FlexibleModelFittingParameter(id),
            m_initial_value(initial_value),
            m_converter_factory(converter_factory) {}

  std::shared_ptr<ModelFitting::BasicParameter> create(
                                  FlexibleModelFittingParameterManager& parameter_manager,
                                  ModelFitting::EngineParameterManager& engine_manager,
                                  const SourceInterface& source) const override;

  std::shared_ptr<ModelFitting::BasicParameter> create(
                                  FlexibleModelFittingParameterManager& parameter_manager,
                                  ModelFitting::EngineParameterManager& engine_manager,
                                  const SourceInterface& source,
                                  double initial_value) const;

  double getSigma(FlexibleModelFittingParameterManager& parameter_manager, const SourceInterface& source,
      const std::vector<double>& free_parameter_sigmas) const override;

  double getInitialValue(const SourceInterface& source) const;

private:

  InitialValueFunc m_initial_value;
  std::shared_ptr<FlexibleModelFittingConverterFactory> m_converter_factory;
};

class FlexibleModelFittingDependentParameter : public FlexibleModelFittingParameter {
  
public:

  using ValueFunc = std::function<double(const std::shared_ptr<CoordinateSystem>&, const std::vector<double>&)>;
  
  FlexibleModelFittingDependentParameter(int id, ValueFunc value_calculator,
                                         std::vector<std::shared_ptr<FlexibleModelFittingParameter>> parameters)
          : FlexibleModelFittingParameter(id),
            m_value_calculator(value_calculator),
            m_parameters(parameters) { }

  std::shared_ptr<ModelFitting::BasicParameter> create(
                                  FlexibleModelFittingParameterManager& parameter_manager,
                                  ModelFitting::EngineParameterManager& engine_manager,
                                  const SourceInterface& source) const override;

  const std::vector<std::shared_ptr<FlexibleModelFittingParameter>>& getDependees() const {
    return m_parameters;
  }

  double getSigma(FlexibleModelFittingParameterManager& parameter_manager, const SourceInterface& source,
      const std::vector<double>& free_parameter_sigmas) const override;

  std::vector<double> getPartialDerivatives(const SourceInterface& source, const std::vector<double>& param_values) const;

private:

  ValueFunc m_value_calculator;
  std::vector<std::shared_ptr<FlexibleModelFittingParameter>> m_parameters;
  
};

}

#endif /* _SEIMPLEMENTATION_PLUGIN_FLEXIBLEMODELFITTING_FLEXIBLEMODELFITTINGPARAMETER_H_ */