diagnostic.hpp

Go to the documentation of this file.

#ifndef DIAGNOSTIC_HPP
#define DIAGNOSTIC_HPP

#include "xgc_io.hpp"
#include "space_settings.hpp"
#include "step_trigger.hpp"
#include "host_array.hpp"

/* Base class for diagnostics */
class Diagnostic{
    HostArray<XGC_IO_Stream> stream; // Make this a HostArray so that Diagnostics can be sent to device and not invoke the stream destructor

    protected:

    // These can be set by a derived class
    StepTrigger step_trigger; // Triggers when it is time to call this diagnostic

    public:

    bool is_on;

    /* Returns whether this diagnostic should be executed on this step
     * */
    bool is_triggered(int step){
        return step_trigger.is_triggered(step);
    }

    /* Returns whether or not we have passed the first trigger yet
     * */
    bool has_been_triggered(int step){
        return step_trigger.has_been_triggered(step);
    }

    /* Returns period in steps
     * */
    int get_period() const{
        return step_trigger.get_period();
    }

    // Default constructor for use if diagnostic is not used
    Diagnostic()
      : stream(1),
        is_on(false){}

    // Constructor if used: Set up stream and trigger
    void init(const std::string& name, int period, int first_step=-1){
        stream(0).Init(name);

        is_on = true;
        if(first_step==-1){
            // Use default if no first step provided
            step_trigger = StepTrigger(period);
        }else{
            step_trigger = StepTrigger(period, first_step);
        }
    }

    void open_stream(const std::string& filename, const XGC_IO_Mode& mode){
        stream(0).Open(filename, mode);
    }

#ifdef USE_MPI

    void open_stream(const std::string& filename, const XGC_IO_Mode& mode, const MPI_Comm& comm){
        stream(0).Open(filename, mode, comm);
    }
#endif

    void close_stream(){
        stream(0).Close();
    }

    // Every diagnostic will have its own custom write since they will vary significantly in structure
    void write(const XGC_IO& xgc_io){
        xgc_io.write(stream(0));
    }

    void start_write_step(){
#ifdef ADIOS2
        stream(0).engine->BeginStep();
#endif
    }

    bool is_first_step(){
#ifdef ADIOS2
        return (stream(0).engine->CurrentStep() == 0);
#else
        return true;
#endif
    }

    void end_write_step(){
#ifdef ADIOS2
        stream(0).engine->EndStep();
#endif
    }
};

#endif