diagnostic.hpp

/*
 * diagnostic.hpp
 *
 * Created on: 23 Oct 2012
 * Author: hschmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_DIAGNOSTIC_HPP_
#define SCHNEK_DIAGNOSTIC_HPP_

#include "../variables/block.hpp"
#include "../util/singleton.hpp"

#include <memory>
#include <fstream>

namespace schnek {

class DiagnosticInterface : public Block
{
  protected:
    std::string fname;
    int append;
  public:
    DiagnosticInterface();
    virtual ~DiagnosticInterface() {}
  protected:
    virtual void open(const std::string &) {}
    virtual void write() {}
    virtual void close() {}

    virtual bool singleOut() { return false; }
    void initParameters(BlockParameters&);

    bool appending();
    std::string parsedFileName(int rank, int timeCounter);
    std::string parsedFileName(int rank, double physicalTime);
};

class IntervalDiagnostic : public DiagnosticInterface
{
  private:
    int interval;
  public:
    IntervalDiagnostic();
    void execute(bool master, int rank, int timeCounter);
    int getInterval();
  protected:
    void initParameters(BlockParameters&);
};

class DeltaTimeDiagnostic : public DiagnosticInterface
{
  private:
    double deltaTime;
    double nextOutput;
    int count;
  public:
    DeltaTimeDiagnostic();
    void execute(bool master, int rank, double physicalTime);
    double getNextOutput();
    double getDeltaTime();
  protected:
    void initParameters(BlockParameters&);
};

typedef std::shared_ptr<DiagnosticInterface> pDiagnosticInterface;
typedef std::list<pDiagnosticInterface> DiagList;

class DiagnosticManager : public Singleton<DiagnosticManager>
{
  private:
    std::list<IntervalDiagnostic*> intervalDiags;
    std::list<DeltaTimeDiagnostic*> deltaTimeDiags;

    int *timecounter;
    double *physicalTime;
    bool usePhysicalTime;
    bool master;
    int rank;

    friend class Singleton<DiagnosticManager>;
    friend class CreateUsingNew<DiagnosticManager>;
  public:
    void addIntervalDiagnostic(IntervalDiagnostic*);
    void addDeltaTimeDiagnostic(DeltaTimeDiagnostic*);
    void execute();

    void setTimeCounter(int *timecounter);
    void setPhysicalTime(double *physicalTime);
    void setMaster(bool master);
    void setRank(int rank);

    double adjustDeltaT(double deltaT);
  private:
    DiagnosticManager();
};

template<class Type, typename PointerType = std::shared_ptr<Type>, class DiagnosticType = IntervalDiagnostic>
class SimpleDiagnostic : public DiagnosticType
{
  private:
    std::string fieldName;
    bool single_out;
  protected:
    PointerType field;
  public:
    SimpleDiagnostic() { single_out=false; }
    virtual ~SimpleDiagnostic();
  protected:
    bool singleOut() { return single_out; }
    void initParameters(BlockParameters&);
    void init();
    std::string getFieldName() { return fieldName; }

    virtual bool isDerived() { return false; }
  public:
    void setSingleOut(bool single_out_) { single_out = single_out_; }
};

template<class Type, typename PointerType = std::shared_ptr<Type>, class DiagnosticType = IntervalDiagnostic >
class SimpleFileDiagnostic : public SimpleDiagnostic<Type, PointerType, DiagnosticType>
{
  private:
    std::ofstream output;
  protected:
    void open(const std::string &);
    void write();
    void close();
};

} // namespace schnek


#include "diagnostic.t"

#endif // SCHNEK_DIAGNOSTIC_HPP_