SweepStudy.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstCore/Command.hpp"
#include "AstScript/Expr.hpp"
#include <memory>
 
AST_NAMESPACE_BEGIN
 
class Interpreter;
 
class AST_ANALYZER_API SweepVariable : public ObjectNamed
{
public:
    AST_OBJECT(SweepVariable)
 
    double startValue() const { return startValue_; }
    void setStartValue(double value) { startValue_ = value; }
 
    double endValue() const { return endValue_; }
    void setEndValue(double value) { endValue_ = value; }
    
    double stepSize() const { return stepSize_; }
    void setStepSize(double value) { stepSize_ = value; }
 
    Expr* expr() const { return expr_.get(); }
    void setExpr(Expr* expr) { expr_ = expr; }
 
    errc_t getValue(double& value) const;
    errc_t setValue(double value);
 
    std::vector<double>& values() { return values_; }
    const std::vector<double>& values() const { return values_; }
private:
    double startValue_{0.0};        
    double endValue_{0.0};          
    double stepSize_{0.0};          
    SharedPtr<Expr> expr_;          
    std::vector<double> values_;    
};
 
 
class AST_ANALYZER_API SweepOutput : public ObjectNamed
{
public:
    AST_OBJECT(SweepOutput)
 
    errc_t getValue(double& value) const;
    
    Expr* expr() const { return expr_.get(); }
    void setExpr(Expr* expr) { expr_ = expr; }
 
    std::vector<double>& values() {return values_;}
    const std::vector<double>& values() const {return values_;}
 
private:
    SharedPtr<Expr> expr_;          
    std::vector<double> values_;    
};
 
 
 
 
class AST_ANALYZER_API SweepStudy : public Command
{
public:
    AST_OBJECT(SweepStudy)
public:
    SweepStudy();
    ~SweepStudy() override;
 
    using VariableType = SweepVariable;
    using OutputType = SweepOutput;
 
    using VariableList = std::vector<SharedPtr<VariableType>>;
    using OutputList = std::vector<SharedPtr<OutputType>>;
 
    errc_t execute() override;
 
    VariableList& variables() { return variables_; }
    const VariableList& variables() const { return variables_; }
 
    OutputList& outputs() { return outputs_; }
    const OutputList& outputs() const { return outputs_; }
 
    void addVariable(VariableType* variable);
 
    void removeVariable(VariableType* variable);
 
    void addOutput(OutputType* output);
 
    void removeOutput(OutputType* output);
 
    Command* relatedCommand() const { return relatedCommand_.get(); }
 
    void setRelatedCommand(Command* command) { relatedCommand_ = command; }
 
    int totalRuns() const;
 
    errc_t executeStep(int stepIndex);
 
private:
    void generateValueLists();
 
    void stepIndexToVarIndices(int stepIndex, std::vector<int>& indices) const;
 
    VariableList variables_;                            
    OutputList outputs_;                                
    mutable WeakPtr<Command> relatedCommand_;           
};
 
AST_NAMESPACE_END