Sampler.h

Go to the documentation of this file.

#ifndef __OPAL_SAMPLER_H__
#define __OPAL_SAMPLER_H__

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <string>
#include <sstream>
#include <vector>
#include <map>
#include <utility>
#include <fstream>
#include <list>

#include "Comm/types.h"
#include "Util/Types.h"
#include "Util/CmdArguments.h"

#include "Optimizer/Optimizer.h"
#include "Sample/SampleIndividual.h"
#include "Sample/SamplingMethod.h"

#include <boost/smart_ptr.hpp>
#include <boost/chrono.hpp>

#include <memory>

#include <queue>

#include <boost/property_tree/ptree.hpp>


// template<
//       template <class> class SamplingOperator
// >
class Sampler : public Optimizer {

public:

    Sampler(Expressions::Named_t objectives,
            Expressions::Named_t constraints,
            DVarContainer_t dvars,
            size_t dim, Comm::Bundle_t comms,
            CmdArguments_t args,
            std::vector<double> hypervolRef,
            int nrWorkerGroups);


    Sampler(const std::map< std::string,
                            std::shared_ptr<SamplingMethod>
                >& sampleMethods,
            Expressions::Named_t objectives,
            DVarContainer_t dvars,
            Comm::Bundle_t comms,
            CmdArguments_t args);

    virtual void initialize();

    typedef std::vector< SampleIndividual > SolutionState_t;

protected:

    // implementing poller hooks
    bool onMessage(MPI_Status status, size_t length);
    void postPoll();

    void setupPoll() {}
    void prePoll() {}
    void onStop() {}

    // helper sending evaluation requests to the pilot
    void dispatch_forward_solves();

private:

    std::map<std::string,
             std::shared_ptr<SamplingMethod>
        > sampleMethods_m;

    // global index (for job id)
    int gid;

    int my_local_pid_;

    typedef SampleIndividual  Individual_t;

    Comm::Bundle_t comms_;

    std::map<size_t, boost::shared_ptr<Individual_t> > jobmapping_m;

    std::queue<boost::shared_ptr<Individual_t> > individuals_m;

    bounds_t dVarBounds_m;

    DVarContainer_t dvars_m;

    Expressions::Named_t objectives_m;

    int nSamples_m;


    CmdArguments_t args_;

    int act_sample_m;

    int done_sample_m;

    enum State {
        SUBMIT,
        STOP,
        TERMINATE
    };

    State curState_m;

    std::size_t jsonDumpFreq_m;
    std::string jsonFname_m;
    void writeJsonHeader();
    std::list<Individual_t> individualsToDump_m;

    void dumpIndividualsToJSON();
    void addIndividualToJSON(const boost::shared_ptr<Individual_t>& ind);

    void runStateMachine();

    void createNewIndividual();
};

#endif