DistributedCollection.h

Go to the documentation of this file.

#ifndef DISTRIBUTEDCOLLECTION_H_
#define DISTRIBUTEDCOLLECTION_H_
 
#include "MUQ/config.h"
 
#if MUQ_HAS_MPI
 
#if !MUQ_HAS_PARCER
#error
#endif
 
#include <parcer/Communicator.h>
 
#include "MUQ/SamplingAlgorithms/SampleCollection.h"
 
namespace muq {
  namespace SamplingAlgorithms {
    class DistributedCollection : public SampleCollection {
    public:
 
      DistributedCollection(std::shared_ptr<SampleCollection> collection, std::shared_ptr<parcer::Communicator> comm);
 
      virtual ~DistributedCollection() = default;
 
 
      virtual void Add(std::shared_ptr<SamplingState> newSamp) override;
 
 
      std::shared_ptr<SamplingState> LocalAt(unsigned i);
 
 
      const std::shared_ptr<SamplingState> LocalAt(unsigned i) const;
 
 
      std::shared_ptr<SamplingState> GlobalAt(unsigned i);
 
 
      const std::shared_ptr<SamplingState> GlobalAt(unsigned i) const;
 
 
      virtual std::shared_ptr<SamplingState> at(unsigned i) override;
 
 
      virtual const std::shared_ptr<SamplingState> at(unsigned i) const override;
 
 
      unsigned int LocalSize() const;
 
 
      unsigned int GlobalSize() const;
 
 
      virtual unsigned int size() const override;
 
 
      Eigen::VectorXd LocalCentralMoment(unsigned order, int blockDim=-1) const;
 
 
      Eigen::VectorXd GlobalCentralMoment(unsigned order, int blockDim=-1) const;
 
 
      virtual Eigen::VectorXd CentralMoment(unsigned order, int blockDim=-1) const override;
 
 
      Eigen::VectorXd LocalMean(int blockDim=-1) const;
 
 
      Eigen::VectorXd GlobalMean(int blockDim=-1) const;
 
 
      virtual Eigen::VectorXd Mean(int blockDim=-1) const override;
 
 
      Eigen::VectorXd LocalVariance(int blockDim=-1) const;
 
 
      Eigen::VectorXd GlobalVariance(int blockDim=-1) const;
 
 
      virtual Eigen::VectorXd Variance(int blockDim=-1) const override;
 
 
      Eigen::MatrixXd LocalCovariance(int blockDim=-1) const;
 
 
      Eigen::MatrixXd GlobalCovariance(int blockDim=-1) const;
 
 
      virtual Eigen::MatrixXd Covariance(int blockDim=-1) const override;
 
 
      Eigen::VectorXd LocalESS(int blockDim=-1) const;
 
 
      Eigen::VectorXd GlobalESS(int blockDim=-1) const;
 
 
      virtual Eigen::VectorXd ESS(int blockDim=-1) const override;
 
 
      Eigen::MatrixXd AsLocalMatrix(int blockDim=-1) const;
 
 
      Eigen::MatrixXd AsGlobalMatrix(int blockDim=-1) const;
 
 
      virtual Eigen::MatrixXd AsMatrix(int blockDim=-1) const override;
 
 
      Eigen::VectorXd LocalWeights() const;
 
 
      Eigen::VectorXd GlobalWeights() const;
 
 
      virtual Eigen::VectorXd Weights() const override;
 
      virtual void WriteToFile(std::string const& filename, std::string const& dataset = "/") const override;
 
      Eigen::VectorXd GlobalExpectedValue(std::shared_ptr<muq::Modeling::ModPiece> const& f, std::vector<std::string> const& metains = std::vector<std::string>()) const;
 
      Eigen::VectorXd LocalExpectedValue(std::shared_ptr<muq::Modeling::ModPiece> const& f, std::vector<std::string> const& metains = std::vector<std::string>()) const;
 
      virtual Eigen::VectorXd ExpectedValue(std::shared_ptr<muq::Modeling::ModPiece> const& f, std::vector<std::string> const& metains = std::vector<std::string>()) const override;
 
    private:
 
      template <class scalar, int rows, int cols, int options, int maxRows, int maxCols>
        Eigen::Matrix<scalar, rows, cols, options, maxRows, maxCols> GlobalEigenMean(Eigen::Matrix<scalar, rows, cols, options, maxRows, maxCols> const& local) const {
 
            typedef Eigen::Matrix<scalar, rows, cols, options, maxRows, maxCols> MatType;
            MatType global = MatType::Zero(local.rows(), local.cols());
 
            for( unsigned int i=0; i<comm->GetSize(); ++i ) {
              MatType l(local.rows(), local.cols());
              if( comm->GetRank()==i ) { l = local; }
              comm->Bcast(l, i);
 
              global += l/(double)comm->GetSize();
            }
 
            return global;
      }
 
      std::shared_ptr<SampleCollection> collection;
 
      std::shared_ptr<parcer::Communicator> comm;
    };
  } // namespace SamplingAlgorithms
} // namespace muq
 
#endif // end MUQ_HAS_MPI
#endif