BIE Overview Quick Start Theoretical overview Available methods Parallel chains Computation engine Command Line Interface Graphical User Interface Assigning Output Visualization tool Data handling Software technology Parallel debugging Results to date Recent developments Links User guide Future features Project goals Project Team Copyright and license

/home/weinberg/src/BIE/include/LikelihoodComputation.h // This is really -*- C++ -*- #ifndef LikelihoodComputation_h #define LikelihoodComputation_h #include <iostream> #include <iomanip> #include <fstream> #include <cc++/thread.h> #include "gvariable.h" #include "BIEconfig.h" #include "Simulation.h" #include "BaseDataTree.h" #include "gfunction.h" #include "BIEmpi.h" #include "RecordOutputStream.h" #include "MPIStreamFilter.h" #include "TessToolSender.h" #include "Serializable.h" using namespace ost; namespace BIE { class Model; class TessToolSender; struct thrd_pass_LikeComp { /* Sat Feb 16 16:32:39 EST 2008 -- bchoi * non-intrusive serialization code at the bottom of this file */ void *t; int command; int id; }; struct LikeState { /* Sat Feb 16 22:11:30 EST 2008 -- bchoi * non-intrusive serialization code at the bottom of this file */ double value; bool good; }; //+ CLICLASS LikelihoodComputation class LikelihoodComputation: public Serializable { private: /* Sun Apr 27 03:47:36 EDT 2008 * This variable isn't initialized until this object gets passed * to TemperedSimulation object. (see init() function) * Trying */ Simulation* _simulation; /* Sat Feb 16 16:34:30 EST 2008 -- bchoi * not entirely sure this is the right thing to do.. serialize * semaphore??? */ Semaphore * suspendSem; public: LikelihoodComputation(); virtual ~LikelihoodComputation(); // Must be supplied in derived class. virtual double Likelihood(State &, int indx)=0; // Must be supplied in derived class. virtual double LikelihoodPrevious(State &, int indx)=0; virtual void init(Simulation*_simulation) { this->_simulation = _simulation; } virtual Simulation* GetSimulation() { return _simulation;} virtual Model* GetModel() { return _simulation->_model;} virtual BaseDataTree* GetBaseDataTree() { return _simulation->_dist;} virtual Integration* GetIntegration() { return _simulation->_intgr;} virtual LikelihoodFunction* GetLikeProb() { return _simulation->LP;} virtual void normEvaluateList(Model *model, Tile *tile, const vector<double>& x, const vector<double>& y, SampleDistribution* sampleDistribution, vector<double>& evaluations) = 0; virtual void modelEvaluateList(Model *model, Tile *tile, const vector<double>& x, const vector<double>& y, SampleDistribution* sampleDistribution, vector< vector<double> >& evaluations) = 0; virtual void Granularity(int mpi_type) {}; //+ CLIMETHOD void TileCompare void TileCompare() { DEBUG_LIKE = true; } //+ CLIMETHOD void SetTessTool TessToolSender* void SetTessTool(TessToolSender *ttsender); //+ CLIMETHOD void SampleNext void SampleNext(); //+ CLIMETHOD void SampleNext int void SampleNext(int sessionid); //+ CLIMETHOD void SwitchOnCLI void SwitchOnCLI(); //+ CLIMETHOD void SuspendSimulation void SuspendSimulation(); //+ CLIMETHOD void ResumeSimulation void ResumeSimulation(); //+ CLIMETHOD Semaphore* getLikelihoodSem Semaphore* getLikelihoodSem() {return likelihoodSem;}; //+ CLIMETHOD void setLikelihoodSem Semaphore* void setLikelihoodSem(Semaphore *s) {likelihoodSem = s;}; //+ CLIMETHOD void setCLISem Semaphore* void setCLISem(Semaphore *s) {switchCLISem = s;}; void TessToolSynchronize(); virtual void InitializeTessToolTileDump(); virtual void TessToolTileDump(Tile *t, SampleDistribution *sd, vector<double>& z); virtual void FinalizeTessToolTileDump(); virtual int getNumAndIdsOfTileMasters(int *num, int **idlist); virtual void BuildTessToolTileDumpBaseStream(); virtual RecordOutputStream *GetTessToolTileDumpBaseStream() {return rostrm;}; virtual void SetTessToolTileDumpBaseStream(RecordOutputStream *bstrm) { rostrm = bstrm;}; virtual RecordOutputStream *AttachMPIFilterToTessTool(RecordOutputStream *rostrm); virtual void UpdateTessTool(RecordType *rt, RecordOutputStream *rostrm, MPIStreamFilter *mpifilter); virtual void TessToolTileDumpToBaseStream(Tile *t, SampleDistribution *sd, vector<double>& z); void startThread(); void stopThread(); virtual void enslave_worker(void * arg) {}; virtual void free_workers() {}; virtual bool Serial() = 0; protected: thrd_pass_LikeComp td; pthread_t *t; bool threading_on; int parent_id; Semaphore likelihoodMutex; void thread_fork(int command); bool DEBUG_LIKE; void TileDump(Tile *t, SampleDistribution *sd, vector<double>& z); void SwitchedOnCLI(); void ResumedSimulation(); void SuspendedSimulation(); void DetachTessTool(); int encode_command(int); int decode_command(int); TessToolSender * tesstool; int requestSynchronization; int sampleNext; int switchCliOn; int suspendSimulation; int resumeSimulation; int detachTessTool; bool _builtTTBaseStream; RecordOutputStream * rostrm; int _sessionId; int _nextSessionId; void setPriorFrontier(); void setCurrentFrontier(); Frontier *fd_temp; void StateToBuffer(State&, double*, unsigned int size); void BufferToState(State&, double*, unsigned int size); virtual bool Slaves() { return false; } // AUTO GENERATED BY ../persistence/autopersist.py private: friend class boost::serialization::access; template<class Archive> void serialize(Archive & ar, const unsigned int version) { this->pre_serialize(ar, version); try { ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Serializable); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(_simulation); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(threading_on); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(parent_id); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(DEBUG_LIKE); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(requestSynchronization); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(sampleNext); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(switchCliOn); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(suspendSimulation); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(resumeSimulation); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(detachTessTool); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(_builtTTBaseStream); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(_sessionId); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } try { ar & BOOST_SERIALIZATION_NVP(_nextSessionId); BIE_CATCH_BOOST_SERIALIZATION_EXCEPTION; } this->post_serialize(ar, version); } }; } // namespace BIE namespace boost { namespace serialization { template<class Archive> inline void serialize(Archive& ar, thrd_pass_LikeComp& t, const unsigned int file_version) { LikelihoodComputation* temp = (LikelihoodComputation*)t.t; ar & boost::serialization::make_nvp("pointer", temp); ar & boost::serialization::make_nvp("command", t.command); ar & boost::serialization::make_nvp("id", t.id); } template<class Archive> inline void serialize(Archive& ar, LikeState& ls, const unsigned int file_version) { ar & boost::serialization::make_nvp("value", ls.value); ar & boost::serialization::make_nvp("good", ls.good); } } } BIE_CLASS_EXPORT_KEY(BIE::LikelihoodComputation) #endif