ModelParameters.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2014 by Federico Marulli and Alfonso Veropalumbo  *
 *  federico.marulli3@unibo.it                                      *
 *                                                                  *
 *  This program is free software; you can redistribute it and/or   *
 *  modify it under the terms of the GNU General Public License as  *
 *  published by the Free Software Foundation; either version 2 of  *
 *  the License, or (at your option) any later version.             *
 *                                                                  *
 *  This program is distributed in the hope that it will be useful, *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of  *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   *
 *  GNU General Public License for more details.                    *
 *                                                                  *
 *  You should have received a copy of the GNU General Public       *
 *  License along with this program; if not, write to the Free      *
 *  Software Foundation, Inc.,                                      *
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.       *
 ********************************************************************/
 
#ifndef __MPARAM__
#define __MPARAM__
 
#include "Prior.h"
#include "PriorDistribution.h"
#include "PosteriorDistribution.h"
 
namespace cbl {
 
  namespace statistics {
 
    enum class ParameterType {
 
        _Base_,
 
        _Derived_,
 
        _Correlated_,
    };
 
    inline std::vector<std::string> ParameterTypeNames () { return {"Base", "Derived", "Correlated"}; }
 
    inline ParameterType ParameterTypeCast (const int parameterTypeIndex) { return castFromValue<ParameterType>(parameterTypeIndex); }
 
    inline ParameterType ParameterTypeCast (const std::string parameterTypeName) { return castFromName<ParameterType>(parameterTypeName, ParameterTypeNames()); }
 
    inline std::vector<ParameterType> ParameterTypeCast (const std::vector<int> parameterTypeIndeces) { return castFromValues<ParameterType>(parameterTypeIndeces); } 
 
    inline std::vector<ParameterType> ParameterTypeCast (const std::vector<std::string> parameterTypeNames) { return castFromNames<ParameterType>(parameterTypeNames, ParameterTypeNames()); }
 
 
    class ModelParameters {
 
    protected:
 
      std::vector<ParameterType> m_parameter_type;
 
      std::vector<std::string> m_parameter_name;
 
      size_t m_nparameters = 0;
 
      size_t m_nparameters_base = 0;
 
      size_t m_nparameters_derived = 0;
 
      size_t m_nparameters_correlated = 0;
 
      std::vector<unsigned int> m_base_parameter;
 
      std::vector<unsigned int> m_derived_parameter;
 
      virtual void m_set_parameter_type ();
    
    
    public:
 
 
      ModelParameters () = default;
 
      ModelParameters (const size_t nparameters, std::vector<ParameterType> parameterTypes, std::vector<std::string> parameterNames);
 
      ModelParameters (const size_t nparameters, std::vector<std::string> parameterNames);
 
 
      ~ModelParameters () = default;
 
    
      virtual void reset ()
      { set_parameters(m_nparameters, m_parameter_type, m_parameter_name); } 
 
    
      
      size_t nparameters () const;
 
      size_t nparameters_base () const;
 
      std::vector<unsigned int> base_parameter () const { return m_base_parameter; }
 
      size_t nparameters_derived () const;
 
      size_t nparameters_correlated () const;
      
      std::vector<unsigned int> derived_parameter () const { return m_derived_parameter; }
 
      ParameterType type (const int p) const { return m_parameter_type[p]; }
 
      std::vector<ParameterType> type () const { return m_parameter_type; }
 
      std::string name (const int p) const { return m_parameter_name[p]; }
 
      std::vector<std::string> name () const { return m_parameter_name; }
 
      virtual std::string status (const int p) const
      { (void)p; ErrorCBL("", "status", "ModelParameters.h"); return par::defaultString;}
 
      virtual std::vector<std::string> status () const
      { ErrorCBL("", "status", "ModelParameters.h"); std::vector<std::string> vv; return vv;}
 
      virtual std::vector<double> full_parameter (const std::vector<double> parameter_value) const;
 
      virtual void set_parameters (const size_t nparameters, std::vector<ParameterType> parameterTypes, std::vector<std::string> parameterNames);
      
      virtual void set_parameters (const size_t nparameters, std::vector<std::string> parameterNames);
 
      virtual void set_parameters (const size_t nparameters, const std::vector<std::shared_ptr<PriorDistribution>> priorDistributions, std::vector<ParameterType> parameterTypes, std::vector<std::string> parameterNames)
      { (void)nparameters; (void)priorDistributions; (void)parameterTypes, (void)parameterNames; ErrorCBL("", "set_parameters", "ModelParameters.h"); }
 
 
    
      
      virtual size_t nparameters_free () const 
      { ErrorCBL("", "nparameters_free", "ModelParameters.h"); return 1; }
 
      virtual std::vector<unsigned int> free_parameter () const
      { ErrorCBL("", "free_parameter", "ModelParameters.h"); std::vector<unsigned int> vv; return vv; }
 
      virtual size_t nparameters_fixed () const
      { ErrorCBL("", "nparameters_fixed", "ModelParameters.h"); return 1; }
 
      virtual std::vector<unsigned int> fixed_parameter () const
      { ErrorCBL("", "fixed_parameters", "ModelParameters.h"); std::vector<unsigned int> vv; return vv; }
 
    
    
        
      virtual void free (const int p)
      { (void)p; ErrorCBL("", "free", "ModelParameters.h"); }
 
      virtual void fix (const int p, const double value)
      { (void)p; (void)value; ErrorCBL("", "fix", "ModelParameters.h"); }
 
      virtual void fix_at_bestfit (const int p)
      { (void)p; ErrorCBL("", "fix_at_bestfit", "ModelParameters.h"); }
 
 
    
      virtual double bestfit_value (const int p) const
      { (void)p; ErrorCBL("", "bestfit_value", "ModelParameters.h"); return 0.; }
    
      virtual std::vector<double> bestfit_value () const
      { ErrorCBL("", "bestfit_value", "ModelParameters.h"); std::vector<double> vv; return vv; }
 
      virtual void set_bestfit_values (const std::vector<double> bestfit_value)
      { (void)bestfit_value; ErrorCBL("", "set_bestfit_values", "ModelParameters.h"); }
    
      virtual void set_bestfit_values (const int start, const int thin, const int nbins, const int seed) 
      { (void)start; (void)thin; (void)nbins; (void)seed; ErrorCBL("", "set_bestfit_values", "ModelParameters.h"); }
    
      virtual void write_bestfit_info ()
      { ErrorCBL("", "write_bestfit_info", "ModelParameters.h"); }
 
 
    
    
      virtual void set_prior_distribution (const int p, const std::shared_ptr<PriorDistribution> priorDistribution)
      { (void)p; (void)priorDistribution; ErrorCBL("", "set_prior_distribution", "ModelParameters.h"); }
 
      virtual void set_prior_distribution (const std::vector<std::shared_ptr<PriorDistribution>> priorDistributions)
      { (void)priorDistributions; ErrorCBL("", "set_prior_distribution", "ModelParameters.h"); }
 
      virtual void set_prior_distribution_seed (const std::shared_ptr<random::UniformRandomNumbers_Int> ran_generator)
      { (void)ran_generator; ErrorCBL("", "set_prior_distribution_seed", "ModelParameters.h"); } 
    
      virtual std::shared_ptr<PriorDistribution> prior_distribution (const int p) const
      { (void)p; ErrorCBL("", "prior_distribution", "ModelParameters.h"); return NULL; }
 
      virtual std::vector<std::shared_ptr<PriorDistribution>> prior_distribution () const
      { ErrorCBL("", "prior_distribution", "ModelParameters.h"); std::vector<std::shared_ptr<PriorDistribution>> vv; return vv; }
 
      virtual std::shared_ptr<Prior> prior () const
      { ErrorCBL("", "prior", "ModelParameters.h"); return NULL; }
 
      
      virtual void set_parameter_covariance (const int start=0, const int thin=1)
      { (void)start; (void)thin; ErrorCBL("", "set_parameter_covariance", "ModelParameters.h"); }
 
      virtual double parameter_covariance (const int i, const int j) const
      { (void)i; (void)j; ErrorCBL("", "parameter_covariance", "ModelParameters.h"); return 0.; }
 
      virtual std::vector<std::vector<double>> parameter_covariance () const
      { ErrorCBL("", "parameter_covariance", "ModelParameters.h"); std::vector<std::vector<double>> vv; return vv; }
 
    
 
      virtual void set_posterior_distribution (const int start, const int thin, const int nbins, const int seed=34121, const std::vector<double> weight={})
      { (void)start; (void)thin; (void)nbins; (void)seed; (void)weight; ErrorCBL("", "set_posterior_distribution", "ModelParameters.h"); }
 
      virtual std::shared_ptr<PosteriorDistribution> posterior_distribution (const int par) const 
      { (void)par; ErrorCBL("", "posterior_distribution", "ModelParameters.h"); return NULL; }
 
    
 
      virtual void show_results (const int start, const int thin, const int nbins, const int seed=34121, const bool show_mode=false, const int ns=-1, const int nb=-1, const std::vector<double> weight={})
      { (void)start; (void)thin; (void)nbins; (void)seed; (void)show_mode; (void)ns; (void)nb; (void)weight; ErrorCBL("", "show_results", "ModelParameters.h"); }
 
      virtual void write_results (const std::string dir, const std::string file, const int start, const int thin, const int nbins, const int seed=34121, const bool compute_mode=false, const int ns=-1, const int nb=-1, const std::vector<double> weight={})
      { (void)dir; (void)file; (void)start; (void)thin; (void)nbins; (void)seed; (void)compute_mode; (void)ns; (void)nb; (void)weight; ErrorCBL("", "write_results", "ModelParameters.h"); }
 
      virtual size_t chain_size () const
      { ErrorCBL("", "chain_size", "ModelParameters.h"); return 0; }
 
      virtual size_t chain_nwalkers () const
      { ErrorCBL("", "chain_nwalkers", "ModelParameters.h"); return 0; }
 
      virtual void set_chain (const size_t size, const size_t nwalkers)
      { (void)size; (void)nwalkers; ErrorCBL("", "set_chain", "ModelParameters.h"); }
 
      virtual void reset_chain ()
      { ErrorCBL("", "reset_chain", "ModelParameters.h"); }
 
      virtual void expand_chain (const int append)
      { (void)append; ErrorCBL("", "expand_chain", "ModelParameters.h"); }
 
      virtual double chain_value (const int param, const int pos, const int ww) const
      { (void)param; (void)pos; (void)ww; ErrorCBL("", "chain_value", "ModelParameters.h"); return 0.; }
 
      virtual std::vector<double> chain_value_parameters (const int pos, const int ww) const
      { (void)pos; (void)ww; ErrorCBL("", "chain_value_parameters", "ModelParameters.h"); std::vector<double> vv; return vv; }
 
      virtual std::vector<double> parameter_chain_values (const int par, const int start=0, const int thin = 1) const
      { (void)par; (void)start; (void)thin; ErrorCBL("", "parameter_chain_values", "ModelParameters.h");  std::vector<double> vv; return vv; }
 
      virtual void set_chain_value (const int param, const int pos, const int ww, const double value) 
      { (void)param; (void)pos; (void)ww; (void)value; ErrorCBL("", "set_chain_value", "ModelParameters.h"); }
 
      virtual void set_chain_values (const std::vector<std::vector<double>> values, const int nwalkers)
      { (void)values; (void)nwalkers; ErrorCBL("", "set_chain_values", "ModelParameters.h"); }
 
      virtual void set_chain_values (const std::vector<std::vector<std::vector<double>>> values)
      { (void)values;  ErrorCBL("", "set_chain_values", "ModelParameters.h"); }
 
      virtual void initialize_chain (const std::vector<std::vector<double>> values)
      { (void)values;  ErrorCBL("", "initialize_chain", "ModelParameters.h"); }
 
      virtual void initialize_chain_from_prior ()
      { ErrorCBL("", "initialize_chain_from_prior", "ModelParameters.h"); }
 
      virtual void initialize_chain_ball (const std::vector<double> center, const double radius, const double seed)
      { (void)center; (void)radius; (void)seed; ErrorCBL("", "initialize_chain_ball", "ModelParameters.h"); }
 
      virtual void initialize_chain_ball_bestfit (const double radius, const double seed)
      { (void)radius; (void)seed;  ErrorCBL("", "initialize_chain_ball_bestfit", "ModelParameters.h"); }
 
    };
  }
}
 
#endif