mcmc_writer.hpp

Go to the documentation of this file.

#ifndef STAN__IO__MCMC__WRITER__HPP
#define STAN__IO__MCMC__WRITER__HPP

#include <ostream>
#include <iomanip>
#include <string>
#include <vector>

#include <stan/mcmc/base_mcmc.hpp>
#include <stan/mcmc/sample.hpp>
#include <stan/model/prob_grad.hpp>

#include <stan/common/recorder/csv.hpp>

namespace stan {
  
  namespace io {
    
    template <class M, 
              class SampleRecorder, class DiagnosticRecorder,
              class MessageRecorder>
    class mcmc_writer {

    private:
      SampleRecorder& sample_recorder_;
      DiagnosticRecorder& diagnostic_recorder_;
      MessageRecorder& message_recorder_;
      
      std::ostream* msg_stream_;
      
    public:
      
      mcmc_writer(SampleRecorder& sample_recorder,
                  DiagnosticRecorder& diagnostic_recorder,
                  MessageRecorder& message_recorder,
                  std::ostream* msg_stream = 0)
        : sample_recorder_(sample_recorder),
          diagnostic_recorder_(diagnostic_recorder),
          message_recorder_(message_recorder),
          msg_stream_(msg_stream) {
      }
      
      void write_sample_names(stan::mcmc::sample& sample,
                              stan::mcmc::base_mcmc* sampler,
                              M& model) {
        std::vector<std::string> names;
        
        sample.get_sample_param_names(names);
        sampler->get_sampler_param_names(names);
        model.constrained_param_names(names, true, true);
        
        sample_recorder_(names);
      }


      template <class RNG>
      void write_sample_params(RNG& rng, 
                               stan::mcmc::sample& sample,
                               stan::mcmc::base_mcmc& sampler,
                               M& model) {
        std::vector<double> values;
        
        sample.get_sample_params(values);
        sampler.get_sampler_params(values);
        
        Eigen::VectorXd model_values;
        
        model.write_array(rng,
                          const_cast<Eigen::VectorXd&>(sample.cont_params()),
                          model_values,
                          true, true,
                          msg_stream_); 
        
        for (int i = 0; i < model_values.size(); ++i)
          values.push_back(model_values(i));

        sample_recorder_(values);
      }
      
      template <class Recorder>
      void write_adapt_finish(stan::mcmc::base_mcmc* sampler, 
                              Recorder& recorder) {
        if (!recorder.is_recording())
          return;
        std::stringstream stream;
        sampler->write_sampler_state(&stream);
        
        recorder("Adaptation terminated\n" + stream.str());
      }
      

      void write_adapt_finish(stan::mcmc::base_mcmc* sampler) {
        write_adapt_finish(sampler, sample_recorder_);
        write_adapt_finish(sampler, diagnostic_recorder_);
      }


      void write_diagnostic_names(stan::mcmc::sample sample,
                                  stan::mcmc::base_mcmc* sampler,
                                  M& model) {
        std::vector<std::string> names;
        
        sample.get_sample_param_names(names);
        sampler->get_sampler_param_names(names);
        
        std::vector<std::string> model_names;
        model.unconstrained_param_names(model_names, false, false);
        
        sampler->get_sampler_diagnostic_names(model_names, names);

        diagnostic_recorder_(names);
      }
      
      void write_diagnostic_params(stan::mcmc::sample& sample,
                                   stan::mcmc::base_mcmc* sampler) {
        std::vector<double> values;
        
        sample.get_sample_params(values);
        sampler->get_sampler_params(values);
        sampler->get_sampler_diagnostics(values);
        
        diagnostic_recorder_(values);
      }


      template <class Recorder>
      void write_timing(double warmDeltaT, double sampleDeltaT, 
                        Recorder& recorder) {
        if (!recorder.is_recording())
          return;

        std::string title(" Elapsed Time: ");
        std::stringstream ss;
        
        
        recorder();
        
        ss.str("");
        ss << title << warmDeltaT << " seconds (Warm-up)";
        recorder(ss.str());

        ss.str("");
        ss << std::string(title.size(), ' ') << sampleDeltaT 
           << " seconds (Sampling)";
        recorder(ss.str());
        
        ss.str("");
        ss << std::string(title.size(), ' ') 
           << warmDeltaT + sampleDeltaT
           << " seconds (Total)";
        recorder(ss.str());
        
        recorder();
      }

      
      void write_timing(double warmDeltaT, double sampleDeltaT) {
        write_timing(warmDeltaT, sampleDeltaT, sample_recorder_);
        write_timing(warmDeltaT, sampleDeltaT, diagnostic_recorder_);
        write_timing(warmDeltaT, sampleDeltaT, message_recorder_);
      }
            
    };
    
  } //io
  
} // stan

#endif