AMR1d.h

#ifndef gridripper_main_AMR1d_h
#define gridripper_main_AMR1d_h

#include <gridripper/util/THMSSLogFile.h>
#include <gridripper/util/GrrProperties.h>
#include <gridripper/amr1d/Grid.h>
#include <gridripper/amr1d/PDE.h>
#include <gridripper/amr1d/InitCond.h>
#include <gridripper/amr1d/AutoAMRCore.h>
#include <gridripper/amr1d/ParameterParser.h>
#include <gridripper/io/IOException.h>
#include <string>

namespace gridripper { namespace main {

using namespace std;
using namespace gridripper::io;
using namespace gridripper::amr1d;

class AMR1d
{
private:
    string inputFileName;

    AutoAMRCore* autoAMRCore;

private:
    bool writeIntq;

    string intqHeaderFormat;

    string intqFormat;

    bool writeMarker;

    string markerHeaderFormat;

    string markerFormat;

    string logTimeFormat;

    string initCondMessage;

public:
    class AMRLogger
    {
    private:
        const AMR1d* parent;
        THMSSLogFile flog;

    public:
        AMRLogger(const AMR1d* p, const string& f, bool append)
            throw(IOException&);

        void writeComment(const string& s) throw(IOException&);

        void close() throw(IOException&);

        void log(const Grid& g, double error) throw(IOException&);
    };

public:
    AMR1d(const string& f, bool enable) throw(InitCond::Exception&,
            IOException&, IllegalArgumentException&,
            AutoAMRCore::OutFileExistsException&);

    ~AMR1d();

    void play() throw(IOException&, IllegalArgumentException&);

    const AMRCore& getAMRCore() const;

protected:
    string getDataFileName(const ParameterParser& p) const;

    string getLogFilename() const;

    string getIntegratedQuantitiesFilename() const;

    string getMarkerQuantitiesFilename() const;

private:
    void init(istream& is, const string& streamname, bool enable)
        throw(InitCond::Exception&, IOException&, IllegalArgumentException&,
              AutoAMRCore::OutFileExistsException&);

    void printIntqHeader(ostream& fintq, const PDE& pde,
                         tvalarray<PDE::PhysicalQuantity*>& q);

    void printIntq(ostream& fintq, const PDE& pde,
                   tvalarray<PDE::PhysicalQuantity*>& q,
                   GReal_t t, const tvalarray<GReal_t>& qv);

    void printMarkerHeader(ostream& fmarker,
                         tvalarray<PDE::MarkerQuantity*>& mq);

    void printMarker(ostream& fmarker, GReal_t t, const tvalarray<GReal_t>& mqv);

    AutoAMRCore* createAMRCore(const GrrProperties& props, bool enable)
            throw(InitCond::Exception&, IOException&,
                  IllegalArgumentException&,
                  AutoAMRCore::OutFileExistsException&);

    void output(AMRLogger& logger, ostream& fintq, ostream& fmarker,
                AutoAMRCore& ai, const Grid& baseg,
                PDE::PhysicalQuantityArray& q, tvalarray<GReal_t>& qv,
                PDE::MarkerQuantityArray& mq, tvalarray<GReal_t>& mqv)
        throw(IOException&);
};

} } // namespace gridripper::main

#endif /* gridripper_main_AMR1d_h */