CombinedPosterior.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2020 by Davide Pelliciari and Sofia Contarini     *
 *  davide.pelliciari@studio.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 __COMBINEDPOSTERIOR__
#define __COMBINEDPOSTERIOR__
 
#include "RandomNumbers.h"
#include "Prior.h"
#include "Likelihood.h"
#include "Posterior.h"
#include "CovarianceMatrix.h"
#include "SuperSampleCovariance.h"
 
 
// ===================================================================================================
 
 
namespace cbl {
 
  namespace statistics {
  
  
    struct STR_DependentProbes_data_model {
      
      std::shared_ptr<data::CovarianceMatrix> covariance;
      
      std::vector<std::shared_ptr<Model>> models;
      
      std::vector<std::shared_ptr<Model>> responses;
      
      std::shared_ptr<cbl::cosmology::SuperSampleCovariance> Sij;
    
      std::vector<std::vector<double>> xx;
    
      std::vector<double> flat_xx;
    
      std::vector<double> flat_data;
    
      std::vector<std::vector<int>> par_indexes;
      
      std::vector<int> cosmoPar_indexes;
 
      STR_DependentProbes_data_model () = default;
    };
 
    class CombinedPosterior : public Posterior {
 
    private:
    
      STR_DependentProbes_data_model m_data_model;
 
      std::vector<std::shared_ptr<Posterior>> m_posteriors;
 
      int m_Nposteriors;
     
      std::vector<std::vector<int>> m_parameter_indexes;
      
      std::vector<std::vector<int>> m_parameter_indexes2;
      
      std::vector<int> m_cosmoPar_indexes;
      
      std::vector<std::vector<std::string>> m_parameter_names;
 
      bool impsampling = false;
 
      std::vector<std::shared_ptr<void>> m_likelihood_inputs;
 
      std::vector<LogLikelihood_function> m_log_likelihood_functions;
 
      std::vector<Likelihood_function> m_likelihood_functions;
 
      std::vector<LogLikelihood_function> m_likelihood_functions_grid;
 
      std::vector<LogLikelihood_function> m_log_likelihood_functions_grid;
 
      std::vector<std::shared_ptr<data::Data>> m_datasets;
 
      std::vector<std::shared_ptr<Model>> m_models;
 
      std::vector<bool> m_use_grid;
 
 
    public:
 
 
      CombinedPosterior () = default;
 
      CombinedPosterior (const std::vector<std::shared_ptr<Posterior>> posteriors, std::vector<std::string> repeated_par={}, const std::vector<std::vector<std::vector<int>>> common_repeated_par={});
      
      CombinedPosterior (const std::vector<std::vector<std::shared_ptr<Posterior>>> posteriors, const std::vector<std::shared_ptr<data::CovarianceMatrix>> covariance, const std::vector<cbl::statistics::LikelihoodType> likelihood_types, const std::vector<std::string> repeated_par={}, const std::vector<std::vector<std::vector<int>>> common_repeated_par={}, const std::vector<std::shared_ptr<cbl::cosmology::SuperSampleCovariance>> SSC={});
 
      ~CombinedPosterior () = default;
 
 
 
      void set_log_posterior(const std::vector<double> logpostA, const std::vector<double> logpostB);
 
      void set_parameters(const std::vector<std::vector<double>> parametersA, const std::vector<std::vector<double>> parametersB);
 
      void set_weight(const std::vector<double> weightsA, const std::vector<double> weightsB);
      
      void m_check_repeated_par (int dummy_Nposteriors, std::vector<std::shared_ptr<Posterior>> posteriors, const std::vector<std::string> repeated_par);
      
      void m_check_common_repeated_par (int dummy_Nposteriors, std::vector<std::shared_ptr<Posterior>> posteriors, std::vector<std::string> repeated_par, std::vector<std::vector<std::vector<int>>> common_repeated_par);
      
      void m_add_prior (bool par_is_repeated, std::vector<std::shared_ptr<Posterior>> posteriors, const int N, const int k, std::vector<std::shared_ptr<cbl::statistics::PriorDistribution>> &prior_distributions);
      
      void m_set_common_repeated_par (std::vector<std::shared_ptr<Posterior>> posteriors, const bool is_in_parnames, const int N, const int k, const std::vector<std::string> repeated_par, const std::vector<std::vector<std::vector<int>>> common_repeated_par, std::vector<std::shared_ptr<cbl::statistics::PriorDistribution>> &prior_distributions, std::vector<std::string> &parameter_names, std::vector<std::string> &original_names, std::vector<ParameterType> &parameter_types);
      
      void m_set_repeated_par (std::vector<std::shared_ptr<Posterior>> posteriors, const bool is_in_parnames, const int N, const int k, const std::vector<std::string> repeated_par, const std::vector<std::vector<std::vector<int>>> common_repeated_par, std::vector<std::shared_ptr<cbl::statistics::PriorDistribution>> &prior_distributions, std::vector<std::string> &parameter_names, std::vector<std::string> &original_names, std::vector<ParameterType> &parameter_types);
      
      void m_set_parameters_priors (std::vector<std::shared_ptr<Posterior>> posteriors, std::vector<std::string> repeated_par={}, const std::vector<std::vector<std::vector<int>>> common_repeated_par={});
      
      
      void m_set_independent_probes ();
      
 
      void importance_sampling(const int distNum, const double cell_size, const double rMAX, const double cut_sigma=-1);
 
      void importance_sampling(const std::string output_path, const std::string model_nameA, const std::string model_nameB, const std::vector<double> start, const int chain_size, const int nwalkers, const int burn_in, const int thin);
 
      void initialize_chains (const int chain_size, const int n_walkers, const double radius, const std::vector<double> start, const unsigned int max_iter=10000, const double tol=1.e-6, const double epsilon=1.e-3);
 
 
      void initialize_chains (const int chain_size, const int n_walkers);
      
      void initialize_chains (const int chain_size, const int n_walkers, const std::string input_dir, const std::string input_file, const int seed);
 
      void sample_stretch_move (const double aa=2, const bool parallel=true, const std::string outputFile=par::defaultString, const int start=0, const int thin=1, const int nbins=50);
 
 
      double operator () (std::vector<double> &pp) const;
 
      double log (std::vector<double> &pp) const;
 
      void maximize (const std::vector<double> start, const std::vector<std::vector<double>> parameter_limits, const unsigned int max_iter=10000, const double tol=1.e-6, const double epsilon=1.e-3)
      { (void)start; (void)parameter_limits; (void)max_iter; (void)tol; (void)epsilon; ErrorCBL("the method is used without parameter_ranges!", "maximize", "Posterior.h"); }
 
      void maximize (const std::vector<double> start, const unsigned int max_iter=10000, const double tol=1.e-6, const double epsilon=1.e-4);
 
      void write_results (const std::string output_dir, const std::string root_file, const int start=0, const int thin=1, const int nbins=50, const bool fits=false, const bool compute_mode=false, const int ns=-1, const int nb=-1);
 
      void show_results (const int start, const int thin, const int nbins=50, const bool show_mode=false, const int ns=-1, const int nb=-1);
      void write_chain (const std::string output_dir, const std::string output_file, const int start=0, const int thin=1, const bool is_FITS_format=false, const int prec=5, const int ww=14);
 
      void write_chain_ascii (const std::string output_dir, const std::string output_file, const int start=0, const int thin=1, const int prec=5, const int ww=14);
 
      void write_chain_fits (const std::string output_dir, const std::string output_file, const int start=0, const int thin=1);
 
      void write_model_from_chain (const std::string output_dir, const std::string output_file, const int start, const int thin, const std::vector<double> xx={}, const std::vector<double> yy={});
 
      void write_maximization_results (const std::string dir_output, const std::string file);
 
      std::vector<std::vector<double>> read (const std::string path, const std::string filename);
 
 
    };
    
 
    double LogLikelihood_Gaussian_combined (std::vector<double> &likelihood_parameter, const std::shared_ptr<void> input);
    
    double LogLikelihood_Poissonian_combined (std::vector<double> &likelihood_parameter, const std::shared_ptr<void> input);
    
    double LogLikelihood_Poissonian_SSC_combined (std::vector<double> &likelihood_parameter, const std::shared_ptr<void> input);
    
        
  }
}
 
#endif