sampler.h

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#ifndef SAMPLER_H
#define SAMPLER_H


#include <config.h>

#include <iostream>
#include <sstream>
#include <list>

#include <inttypes.h>

#include <jwsc/matblock/matblock.h>

#include <jwsc++/base/exception.h>

#include "imaging_model.h"
#include "psf_model.h"
#include "alternaria_model.h"


class Sampler_move_parameters
{
    public:

        Sampler_move_parameters
        (
            Alternaria_model*       alternaria,
            PSF_model*              psf,
            Imaging_model*          imaging,
            const jwsc::Matblock_f* data
        )
        throw (jwscxx::base::Arg_error);


        virtual ~Sampler_move_parameters();


        void init_proposals();


        Alternaria_model* alternaria;

        PSF_model* psf;

        Imaging_model* imaging;

        double ll;

        Alternaria_model* alternaria_proposal;

        PSF_model* psf_proposal;

        Imaging_model* imaging_proposal;

        double ll_proposal;

        const jwsc::Matblock_f* data;

        float data_avg;
};


class Sampler_move
{
    public:

        virtual ~Sampler_move() { }


        virtual bool run(Sampler_move_parameters* params)
            throw (jwscxx::base::Exception) = 0;


        const char* get_name() const { return name; }


        virtual const std::ostringstream& get_info
        (
            Sampler_move_parameters* params
        ) = 0;


        virtual const std::ostringstream& get_proposal_info
        (
            Sampler_move_parameters* params
        ) = 0;


        virtual double get_prob() const = 0;


        virtual void set_prob(double prob) throw (jwscxx::base::Arg_error) = 0;


    protected:

        const char* name;

        std::ostringstream info;

        std::ostringstream proposal_info;
};


class Sampler_diffusion_move : public Sampler_move
{
    public:

        Sampler_diffusion_move(const char* name, double prob) 
            throw (jwscxx::base::Arg_error);


        virtual ~Sampler_diffusion_move() { }


        double get_prob() const { return prob; }


        void set_prob(double prob) throw (jwscxx::base::Arg_error);



    protected:

        uint32_t num_accepted;

        uint32_t num_attempts;

        double prob;
};


class Sampler_jump_move : public Sampler_move
{
    public:

        Sampler_jump_move
        (
            const char* name_1, 
            const char* name_2,
            double      prob_1, 
            double      prob_2
        )
        throw (jwscxx::base::Arg_error);


        virtual ~Sampler_jump_move() { }


        bool run(Sampler_move_parameters* params) 
            throw (jwscxx::base::Exception);


        virtual bool run_1(Sampler_move_parameters* params)
            throw (jwscxx::base::Exception) = 0;


        virtual bool run_2(Sampler_move_parameters* params)
            throw (jwscxx::base::Exception) = 0;


        virtual const std::ostringstream& get_info
        (
            Sampler_move_parameters* params
        );


        virtual const std::ostringstream& get_proposal_info
        (
            Sampler_move_parameters* params
        );


        double get_prob() const { return prob_1+prob_2; }


        void set_prob(double prob) throw (jwscxx::base::Arg_error);


        double get_prob_1() const { return prob_1; }


        const char* get_name_1() const { return name_1; }


        void set_prob_1(double prob_1) throw (jwscxx::base::Arg_error);


        double get_prob_2() const { return prob_2; }


        const char* get_name_2() const { return name_2; }


        void set_prob_2(double prob_2) throw (jwscxx::base::Arg_error);


    protected:

        uint32_t num_accepted_1;

        uint32_t num_attempts_1;

        double prob_1;

        const char* name_1;

        uint32_t num_accepted_2;

        uint32_t num_attempts_2;

        double prob_2;

        const char* name_2;
};


class Sampler
{
    public:

        virtual ~Sampler();


        void add_move(Sampler_move* move);


        void normalize_move_probs() throw (jwscxx::base::Arg_error);


        void run
        (
            Alternaria_model**       best_alt,
            PSF_model**              best_psf,
            Imaging_model**          best_imaging,
            Sampler_move_parameters* params,
            uint32_t                 iterations,
            const char*              move_fname,
            const char*              best_fname,
            const char*              alt_pro_fmt
        )
        throw (jwscxx::base::Exception);


        void run
        (
            Alternaria_model**       best_alt,
            PSF_model**              best_psf,
            Imaging_model**          best_imaging,
            Sampler_move_parameters* params,
            uint32_t                 iterations,
            std::ostream&            move_out,
            std::ostream&            best_out,
            const char*              alt_pro_fmt
        )
        throw (jwscxx::base::Exception);


    protected:

        std::list<Sampler_move*> moves;
};


#endif