BasisGenerator.h

 
// Description: The wrapper class for an SVD algorithm and
//              sampler.  This class controls all aspects of basis
//              vector generation.
 
#ifndef included_BasisGenerator_h
#define included_BasisGenerator_h
 
#include "BasisWriter.h"
#include "BasisReader.h"
#include "Options.h"
#include "svd/SVD.h"
 
#include "mpi.h"
 
#include <cmath>
 
/* Use C++11 built-in shared pointers if available; else fallback to Boost. */
#if __cplusplus >= 201103L
#include <memory>
#else
#include <boost/shared_ptr.hpp>
#endif
 
#include <string.h>
 
namespace CAROM {
 
class BasisWriter;
class BasisReader;
class Matrix;
 
class BasisGenerator
{
public:
    BasisGenerator(
        Options options,
        bool incremental,
        const std::string& basis_file_name = "",
        Database::formats file_format = Database::formats::HDF5);
 
    ~BasisGenerator();
 
    bool
    isNextSample(
        double time);
 
    bool
    updateRightSV()
    {
        return d_update_right_SV;
    }
 
    bool
    takeSample(
        double* u_in,
        bool add_without_increase = false);
 
    void
    endSamples(const std::string& kind = "basis")
    {
        if (d_basis_writer) {
            d_basis_writer->writeBasis(kind);
        }
    }
 
    void
    writeSnapshot()
    {
        if (d_basis_writer) {
            d_basis_writer->writeBasis("snapshot");
        }
    }
 
    void
    loadSampleRange(const std::string& base_file_name,
                    const std::string& kind  = "basis",
                    int col_min = 0,
                    int col_max = 1e9,
                    Database::formats db_format = Database::formats::HDF5);
 
    void
    loadSamples(const std::string& base_file_name,
                const std::string& kind  = "basis",
                int cut_off = 1e9,
                Database::formats db_format = Database::formats::HDF5);
 
    double
    computeNextSampleTime(
        double* u_in,
        double* rhs_in,
        double time);
 
    const Matrix*
    getSpatialBasis()
    {
        return d_svd->getSpatialBasis();
    }
 
    const Matrix*
    getTemporalBasis()
    {
        return d_svd->getTemporalBasis();
    }
 
    const Vector*
    getSingularValues()
    {
        return d_svd->getSingularValues();
    }
 
    const Matrix*
    getSnapshotMatrix()
    {
        return d_svd->getSnapshotMatrix();
    }
 
    int getNumSamples() const
    {
        return d_svd->getNumSamples();
    }
 
    void finalSummary(
        const double energyFractionThreshold,
        int & cutoff,
        const std::string & cutoffOutputPath = "",
        const int first_sv = 0);
 
protected:
    BasisWriter* d_basis_writer;
 
    BasisReader* d_basis_reader;
 
    bool d_write_snapshots;
 
#if __cplusplus >= 201103L
    std::shared_ptr<SVD> d_svd;
#else
    boost::shared_ptr<SVD> d_svd;
#endif
 
private:
    BasisGenerator();
    BasisGenerator(
        const BasisGenerator& other);
 
    BasisGenerator&
    operator = (
        const BasisGenerator& rhs);
 
    void
    resetDt(
        double new_dt);
 
    int
    getDim()
    {
        return d_dim;
    }
 
    bool d_incremental;
 
    bool d_update_right_SV;
 
    double d_tol;
 
    double d_max_time_between_samples;
 
    double d_min_sampling_time_step_scale;
 
    double d_sampling_time_step_scale;
 
    double d_max_sampling_time_step_scale;
 
    double d_dt;
 
    double d_next_sample_time;
 
    int d_num_procs;
 
    const int d_dim;
};
 
}
 
#endif