FrgCore.hpp

Go to the documentation of this file.

 
#pragma once
#include <vector>
#include "EffectiveAction.hpp"
#include "Measurement.hpp"
#include "SpinModel.hpp"
#include "SpinParser.hpp"
 
class SpinParser;
 
class FrgCore
{
    friend class SpinParser;
public:
    void takeMeasurements() const
    {
        if (SpinParser::spinParser()->getComputationStatus().statusIdentifier == ComputationStatus::Identifier::Postprocessing)
        {
            //perform deferred measurements
            for (auto m : _measurements)
            {
                if (_flowingFunctional->cutoff <= m->maxCutoff() && _flowingFunctional->cutoff >= m->minCutoff())
                {
                    if (SpinParser::spinParser()->getCommandLineOptions()->deferMeasurements() || m->isDeferred()) m->takeMeasurement(*_flowingFunctional, SpinParser::spinParser()->isMasterRank());
                }
            }
        }
        else
        {
            //perform non-deferred measurements
            for (auto m : _measurements)
            {
                if (_flowingFunctional->cutoff <= m->maxCutoff() && _flowingFunctional->cutoff >= m->minCutoff())
                {
                    if (!SpinParser::spinParser()->getCommandLineOptions()->deferMeasurements() && !m->isDeferred()) m->takeMeasurement(*_flowingFunctional, SpinParser::spinParser()->isMasterRank());
                }
            }
 
            //write vertex output, if deferred measurements are specified
            bool postprocessingRequired = false;
            if (SpinParser::spinParser()->getCommandLineOptions()->deferMeasurements()) postprocessingRequired = true;
            for (auto m : _measurements) if (m->isDeferred()) postprocessingRequired = true;
 
 
            if (postprocessingRequired && SpinParser::spinParser()->isMasterRank()) _flowingFunctional->writeCheckpoint(SpinParser::spinParser()->getFileset().dataFile, true);
        }
    }
 
    virtual void computeStep() = 0;
 
    virtual void finalizeStep(float newCutoff) = 0;
 
    EffectiveAction *flowingFunctional() const
    {
        return _flowingFunctional;
    }
 
    EffectiveAction *flow() const
    {
        return _flow;
    }
 
    std::vector<Measurement *> measurements() const
    {
        return _measurements;
    }
 
protected:
    FrgCore(const std::vector<Measurement *> &measurements) : _flowingFunctional(nullptr), _flow(nullptr), _measurements(measurements) {};
 
    virtual ~FrgCore()
    {
        while (_measurements.size() > 0)
        {
            delete _measurements.back();
            _measurements.pop_back();
        }
    }
 
    EffectiveAction *_flowingFunctional; 
    EffectiveAction *_flow; 
    std::vector<Measurement *> _measurements; 
};