ControlElementSolver Class Reference

Solves in the time the control system. Can solve the control system directly from a ControlEditor or from a ControlEditorElement. More...

#include <ControlElementSolver.h>

Collaboration diagram for ControlElementSolver:

Public Member Functions
	ControlElementSolver (ControlEditor *controlEditor, double timeStep=1e-3, double integrationError=1e-3)
	ControlElementSolver (ControlElementContainer *ctrlContainer, double timeStep=1e-3, double integrationError=1e-3, wxWindow *parent=nullptr)
virtual bool	InitializeValues (bool startAllZero)
virtual void	SolveNextStep ()
virtual std::vector< double >	GetSolutions ()
virtual double	GetLastSolution ()
virtual bool	IsOK () const
virtual wxString	GetErrorMessage ()
void	SetSwitchStatus (bool value)
void	SetCurrentTime (double value)
void	SetTerminalVoltage (double value)
void	SetVelocity (double value)
void	SetActivePower (double value)
void	SetReactivePower (double value)
void	SetInitialTerminalVoltage (double value)
void	SetInitialMecPower (double value)
void	SetInitialVelocity (double value)
void	SetDeltaVelocity (double value)
void	SetDeltaActivePower (double value)
double	GetFieldVoltage ()
double	GetMechanicalPower ()
double	GetVelocity ()
double	GetActivePower ()

Protected Member Functions
void	Initialize (wxWindow *parent, double timeStep, double integrationError)
void	FillAllConnectedChildren (ConnectionLine *parent)
ConnectionLine *	SolveNextElement (ConnectionLine *currentLine)

Protected Attributes
ControlElementContainer *	m_ctrlContainer = nullptr
bool	m_ownsCtrlContainer = false
double	m_timeStep = 1e-3
double	m_integrationError = 1e-5
std::vector< double >	m_solutions
bool	m_isOK = false
wxString	m_failMessage = _("Unknown error.")
IOControl *	m_inputControl = nullptr
IOControl *	m_outputControl = nullptr
bool	m_switchStatus = false
double	m_currentTime = 0.0
double	m_terminalVoltage = 0.0
double	m_velocity = 0.0
double	m_activePower = 0.0
double	m_reactivePower = 0.0
double	m_initTerminalVoltage = 0.0
double	m_initMecPower = 0.0
double	m_initVelocity = 0.0
double	m_deltaVelocity = 0.0
double	m_deltaPe = 0.0
double *	m_inputToSolve = nullptr
double	m_fieldVoltage = 0.0
double	m_mecPower = 0.0

Detailed Description

Solves in the time the control system. Can solve the control system directly from a ControlEditor or from a ControlEditorElement.

Author

Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br

Date

05/10/2017

Definition at line 45 of file ControlElementSolver.h.

Constructor & Destructor Documentation

ControlElementSolver() [1/3]

ControlElementSolver::ControlElementSolver ( )

inline

Definition at line 48 of file ControlElementSolver.h.

{}

ControlElementSolver() [2/3]

ControlElementSolver::ControlElementSolver	(	ControlEditor *	controlEditor,
		double	timeStep = 1e-3,
		double	integrationError = 1e-3
	)

Definition at line 34 of file ControlElementSolver.cpp.

{
    m_ctrlContainer = new ControlElementContainer();
    m_ownsCtrlContainer = true;
    m_ctrlContainer->FillContainer(controlEditor);
    Initialize(controlEditor, timeStep, integrationError);
}

ControlElementSolver() [3/3]

ControlElementSolver::ControlElementSolver	(	ControlElementContainer *	ctrlContainer,
		double	timeStep = 1e-3,
		double	integrationError = 1e-3,
		wxWindow *	parent = nullptr
	)

Definition at line 42 of file ControlElementSolver.cpp.

{
    m_ctrlContainer = ctrlContainer;
    m_ownsCtrlContainer = false;
    Initialize(parent, timeStep, integrationError);
}

~ControlElementSolver()

ControlElementSolver::~ControlElementSolver ( )

virtual

Definition at line 52 of file ControlElementSolver.cpp.

{
    if (m_inputToSolve) delete[] m_inputToSolve;
    if (m_ownsCtrlContainer && m_ctrlContainer) delete m_ctrlContainer;
}

Member Function Documentation

FillAllConnectedChildren()

void ControlElementSolver::FillAllConnectedChildren ( ConnectionLine *  parent )

protected

Definition at line 321 of file ControlElementSolver.cpp.

{
    auto childList = parent->GetLineChildList();
    for (auto it = childList.begin(), itEnd = childList.end(); it != itEnd; ++it) {
        ConnectionLine* child = *it;
        child->SetValue(parent->GetValue());
        child->SetSolved();
        FillAllConnectedChildren(child);
    }
}

GetActivePower()

double ControlElementSolver::GetActivePower ( )

inline

Definition at line 75 of file ControlElementSolver.h.

{ return m_activePower; }

GetErrorMessage()

virtual wxString ControlElementSolver::GetErrorMessage ( )

inlinevirtual

Definition at line 60 of file ControlElementSolver.h.

{ return m_failMessage; }

GetFieldVoltage()

double ControlElementSolver::GetFieldVoltage ( )

inline

Definition at line 72 of file ControlElementSolver.h.

{ return m_fieldVoltage; }

GetLastSolution()

virtual double ControlElementSolver::GetLastSolution ( )

inlinevirtual

Definition at line 58 of file ControlElementSolver.h.

{ return m_solutions[m_solutions.size() - 1]; }

GetMechanicalPower()

double ControlElementSolver::GetMechanicalPower ( )

inline

Definition at line 73 of file ControlElementSolver.h.

{ return m_mecPower; }

GetSolutions()

virtual std::vector< double > ControlElementSolver::GetSolutions ( )

inlinevirtual

Definition at line 57 of file ControlElementSolver.h.

{ return m_solutions; }

GetVelocity()

double ControlElementSolver::GetVelocity ( )

inline

Definition at line 74 of file ControlElementSolver.h.

{ return m_velocity; }

Initialize()

void ControlElementSolver::Initialize ( wxWindow *  parent, double  timeStep, double  integrationError  )

protected

Definition at line 58 of file ControlElementSolver.cpp.

{
    // Init the input array size
    if (m_inputToSolve) delete[] m_inputToSolve;
    m_inputToSolve = new double[3];
    // Check if the sistem have one input and one output
    bool fail = false;
    auto ioList = m_ctrlContainer->GetIOControlList();
    if (ioList.size() < 2) {
        fail = true;
        m_failMessage = _("The control system must have at least one input and one output.");
    }
    bool haveInput, haveOutput;
    haveInput = haveOutput = false;
    for (auto it = ioList.begin(), itEnd = ioList.end(); it != itEnd; ++it) {
        IOControl* io = *it;
        if (io->GetType() == Node::NodeType::NODE_OUT && !haveInput) {
            m_inputControl = io;
            haveInput = true;
        }
        else if (io->GetType() == Node::NodeType::NODE_IN) {
            m_outputControl = io;
            haveOutput = true;
        }
    }
    if (!fail && !haveInput) {
        fail = true;
        m_failMessage = _("There is no input in the control system.");
    }
    if (!fail && !haveOutput) {
        fail = true;
        m_failMessage = _("There is no output in the control system.");
    }
    if (!fail) {
        if (m_inputControl->GetChildList().size() == 0) {
            fail = true;
            m_failMessage = _("Input not connected.");
        }
    }
 
    m_timeStep = timeStep;
    m_integrationError = integrationError;
    if (!fail) {
        if (!InitializeValues(true)) {
            fail = true;
            m_failMessage = _("It was not possible to initialize the control system.");
        }
    }
 
    if (fail) {
        wxMessageDialog msgDialog(parent, m_failMessage, _("Error"), wxOK | wxCENTRE | wxICON_ERROR);
        msgDialog.ShowModal();
    }
    else {
        m_isOK = true;
    }
}

InitializeValues()

bool ControlElementSolver::InitializeValues ( bool  startAllZero )

virtual

Definition at line 116 of file ControlElementSolver.cpp.

{
    // Reset Elements values
    auto elementList = m_ctrlContainer->GetControlElementsList();
    for (auto it = elementList.begin(), itEnd = elementList.end(); it != itEnd; ++it) {
        if (!(*it)->Initialize()) return false;
    }
    auto connectionLineList = m_ctrlContainer->GetConnectionLineList();
    for (auto it = connectionLineList.begin(), itEnd = connectionLineList.end(); it != itEnd; ++it) {
        if (!(*it)->Initialize()) return false;
    }
    auto tfList = m_ctrlContainer->GetTFList();
    for (auto it = tfList.begin(), itEnd = tfList.end(); it != itEnd; ++it) {
        (*it)->CalculateSpaceState(100, m_integrationError);
    }
 
    if (!startAllZero) {
        double origTimeStep = m_timeStep;
        double minStep = m_timeStep / 10;
        double maxStep = m_timeStep * 10;
        // Calculate the steady-state results according to the input.
        double minError = 1e-7 * m_timeStep;
        int maxIteration = 100 / m_timeStep;
 
        double prevSol = 0.0;
        double currentSol = 1.0;
        double error = 1.0;
        double prevError = 1.0;
        int numIt = 0;
        while (error > minError) {
            prevSol = currentSol;
            prevError = error;
            SolveNextStep();
            currentSol = GetLastSolution();
            numIt++;
            error = std::abs(prevSol - currentSol);
            if (std::abs(error - prevError) < 1e-1) {
                if (m_timeStep < maxStep) { m_timeStep *= 1.5; }
            }
            else if (std::abs(error - prevError) > 10) {
                if (m_timeStep > minStep) { m_timeStep /= 1.5; }
            }
            if (numIt >= maxIteration) {
                m_failMessage = _("It was not possible to initialize the control system.");
                return false;
            }
        }
        m_timeStep = origTimeStep;
        m_solutions.clear();
    }
 
    return true;
}

IsOK()

virtual bool ControlElementSolver::IsOK ( ) const

inlinevirtual

Definition at line 59 of file ControlElementSolver.h.

{ return m_isOK; }

SetActivePower()

void ControlElementSolver::SetActivePower ( double  value )

inline

Definition at line 65 of file ControlElementSolver.h.

{ m_activePower = value; }

SetCurrentTime()

void ControlElementSolver::SetCurrentTime ( double  value )

inline

Definition at line 62 of file ControlElementSolver.h.

{ m_currentTime = value; }

SetDeltaActivePower()

void ControlElementSolver::SetDeltaActivePower ( double  value )

inline

Definition at line 71 of file ControlElementSolver.h.

{ m_deltaPe = value; }

SetDeltaVelocity()

void ControlElementSolver::SetDeltaVelocity ( double  value )

inline

Definition at line 70 of file ControlElementSolver.h.

{ m_deltaVelocity = value; }

SetInitialMecPower()

void ControlElementSolver::SetInitialMecPower ( double  value )

inline

Definition at line 68 of file ControlElementSolver.h.

{ m_initMecPower = value; }

SetInitialTerminalVoltage()

void ControlElementSolver::SetInitialTerminalVoltage ( double  value )

inline

Definition at line 67 of file ControlElementSolver.h.

{ m_initTerminalVoltage = value; }

SetInitialVelocity()

void ControlElementSolver::SetInitialVelocity ( double  value )

inline

Definition at line 69 of file ControlElementSolver.h.

{ m_initVelocity = value; }

SetReactivePower()

void ControlElementSolver::SetReactivePower ( double  value )

inline

Definition at line 66 of file ControlElementSolver.h.

{ m_reactivePower = value; }

SetSwitchStatus()

void ControlElementSolver::SetSwitchStatus ( bool  value )

inline

Definition at line 61 of file ControlElementSolver.h.

{ m_switchStatus = value; }

SetTerminalVoltage()

void ControlElementSolver::SetTerminalVoltage ( double  value )

inline

Definition at line 63 of file ControlElementSolver.h.

{ m_terminalVoltage = value; }

SetVelocity()

void ControlElementSolver::SetVelocity ( double  value )

inline

Definition at line 64 of file ControlElementSolver.h.

{ m_velocity = value; }

SolveNextElement()

ConnectionLine * ControlElementSolver::SolveNextElement ( ConnectionLine *  currentLine )

protected

Definition at line 332 of file ControlElementSolver.cpp.

{
    auto parentList = currentLine->GetParentList();
    for (auto it = parentList.begin(), itEnd = parentList.end(); it != itEnd; ++it) {
        ControlElement* element = static_cast<ControlElement*>(*it);
        // Solve the unsolved parent.
        if (!element->IsSolved()) {
            m_inputToSolve[0] = currentLine->GetValue();
            if (!std::isfinite(m_inputToSolve[0])) {
                m_inputToSolve[0] = 0.0;
                m_isOK = false;
                m_failMessage = _("The control system solution is diverging. Try to reduce the time step.");
                return nullptr;
            }
            m_inputToSolve[1] = m_currentTime;
            m_inputToSolve[2] = m_switchStatus;
            if (!element->Solve(m_inputToSolve, m_timeStep)) {
                m_isOK = false;
                if(auto tf = dynamic_cast<TransferFunction*>(element)) {
                    wxString numerator, denominator;
                    tf->GetTFString(numerator, denominator);
                    m_failMessage = wxString::Format(_("Unable to compute the transfer function: (%s)/(%s)"), numerator, denominator);
                }
                return nullptr;
            }
            element->SetSolved();
 
            // Get the output node (must have one or will result nullptr).
            Node* outNode = nullptr;
            auto nodeList = element->GetNodeList();
            for (auto itN = nodeList.begin(), itNEnd = nodeList.end(); itN != itNEnd; ++itN) {
                Node* node = *itN;
                if (node->GetNodeType() == Node::NodeType::NODE_OUT) outNode = node;
            }
            if (!outNode) return nullptr;
 
            // Set connection line value associated with the output node.
            auto childList = element->GetChildList();
            for (auto itC = childList.begin(), itCEnd = childList.end(); itC != itCEnd; ++itC) {
                ConnectionLine* cLine = static_cast<ConnectionLine*>(*itC);
                if (!cLine->IsSolved()) {  // Only check unsolved lines
                    // Check if the connection line have the output node on the list
                    auto lineNodeList = cLine->GetNodeList();
                    for (auto itCN = lineNodeList.begin(), itCNEnd = lineNodeList.end(); itCN != itCNEnd; ++itCN) {
                        Node* childNode = *itCN;
                        if (childNode == outNode) {
                            // Check if the line connect two elements, otherwise return nullptr
                            if (cLine->GetType() != ConnectionLine::ConnectionLineType::ELEMENT_ELEMENT) return nullptr;
 
                            // Set the connection line value and return it.
                            cLine->SetValue(element->GetOutput());
                            cLine->SetSolved();
                            FillAllConnectedChildren(cLine);
                            return cLine;
                        }
                    }
                }
            }
        }
    }
    return nullptr;
}

SolveNextStep()

void ControlElementSolver::SolveNextStep ( )

virtual

Definition at line 170 of file ControlElementSolver.cpp.

{
    // Set all elements as not solved
    auto elementList = m_ctrlContainer->GetControlElementsList();
    for (auto& element : elementList) {
        element->SetSolved(false);
    }
    auto connectionLineList = m_ctrlContainer->GetConnectionLineList();
    for (auto& cLine : connectionLineList) {
        cLine->SetSolved(false);
    }
 
    // Get first node connection
    ConnectionLine* firstConn = static_cast<ConnectionLine*>(m_inputControl->GetChildList()[0]);
 
    // Set value to the connected lines in constants
    auto constantList = m_ctrlContainer->GetConstantList();
    for (auto it = constantList.begin(), itEnd = constantList.end(); it != itEnd; ++it) {
        Constant* constant = *it;
        if (constant->GetChildList().size() == 1) {
            constant->SetSolved();
            ConnectionLine* child = static_cast<ConnectionLine*>(constant->GetChildList()[0]);
            child->SetValue(constant->GetValue());
            child->SetSolved();
            FillAllConnectedChildren(child);
        }
    }
 
    // Solve math expression without inputs (but connected)
    auto mathExprList = m_ctrlContainer->GetMathExprList();
    for (auto it = mathExprList.begin(), itEnd = mathExprList.end(); it != itEnd; ++it) {
        MathExpression* mathExpr = *it;
        if (mathExpr->GetVariables().size() == 0) {  // No variables, no inputs.
            m_inputToSolve[0] = 0.0;
            m_inputToSolve[1] = m_currentTime;
            m_inputToSolve[2] = m_switchStatus;
            mathExpr->Solve(m_inputToSolve, m_timeStep);
            mathExpr->SetSolved();
            ConnectionLine* child = static_cast<ConnectionLine*>(mathExpr->GetChildList()[0]);
            child->SetValue(mathExpr->GetOutput());
            child->SetSolved();
            FillAllConnectedChildren(child);
        }
    }
 
    // Set value to the connected lines in inputs
    auto ioList = m_ctrlContainer->GetIOControlList();
    for (auto it = ioList.begin(), itEnd = ioList.end(); it != itEnd; ++it) {
        IOControl* io = *it;
        if (io->GetChildList().size() == 1) {
            io->SetSolved();
            ConnectionLine* child = static_cast<ConnectionLine*>(io->GetChildList()[0]);
            if (m_inputControl == io) firstConn = child;
            bool inputType = true;
            io->SetSolved();
            switch (io->GetValue()) {
            case IOControl::IN_TERMINAL_VOLTAGE: {
                child->SetValue(m_terminalVoltage);
            } break;
            case IOControl::IN_VELOCITY: {
                child->SetValue(m_velocity);
            } break;
            case IOControl::IN_ACTIVE_POWER: {
                child->SetValue(m_activePower);
            } break;
            case IOControl::IN_REACTIVE_POWER: {
                child->SetValue(m_reactivePower);
            } break;
            case IOControl::IN_INITIAL_TERMINAL_VOLTAGE: {
                child->SetValue(m_initTerminalVoltage);
            } break;
            case IOControl::IN_INITIAL_MEC_POWER: {
                child->SetValue(m_initMecPower);
            } break;
            case IOControl::IN_INITIAL_VELOCITY: {
                child->SetValue(m_initVelocity);
            } break;
            case IOControl::IN_DELTA_VELOCITY: {
                child->SetValue(m_deltaVelocity);
            } break;
            case IOControl::IN_DELTA_ACTIVE_POWER: {
                child->SetValue(m_deltaPe);
            } break;
            case IOControl::IN_TEST: {
                child->SetValue(io->GetTestValue());
            } break;
            default: {
                inputType = false;
                io->SetSolved(false);
            } break;
            }
            if (inputType) {
                child->SetSolved();
                FillAllConnectedChildren(child);
            }
        }
    }
 
    ConnectionLine* currentLine = firstConn;
    while (currentLine) {
        currentLine = SolveNextElement(currentLine);
        if (!m_isOK) return;
    }
 
    bool haveUnsolvedElement = true;
    while (haveUnsolvedElement) {
        haveUnsolvedElement = false;
        // Get the solved line connected with unsolved element (elements not connected in the main branch).
        for (auto& cLine : connectionLineList) {
            if (cLine->IsSolved()) {
                auto parentList = cLine->GetParentList();
                for (auto itP = parentList.begin(), itPEnd = parentList.end(); itP != itPEnd; ++itP) {
                    ControlElement* parent = static_cast<ControlElement*>(*itP);
                    if (!parent->IsSolved()) {
                        haveUnsolvedElement = true;
                        // Solve secondary branch.
                        currentLine = cLine.get();
                        while (currentLine) {
                            currentLine = SolveNextElement(currentLine);
                            if (!m_isOK) return;
                        }
                        break;
                    }
                }
            }
            if (haveUnsolvedElement) break;
        }
    }
 
    // Set the control system output.
    for (auto it = ioList.begin(), itEnd = ioList.end(); it != itEnd; ++it) {
        IOControl* io = *it;
        if (io->GetChildList().size() == 1) {
            io->SetSolved();
            ConnectionLine* child = static_cast<ConnectionLine*>(io->GetChildList()[0]);
            switch (io->GetValue()) {
            case IOControl::OUT_MEC_POWER: {
                m_mecPower = child->GetValue();
                m_solutions.push_back(m_mecPower);
            } break;
            case IOControl::OUT_FIELD_VOLTAGE: {
                m_fieldVoltage = child->GetValue();
                m_solutions.push_back(m_fieldVoltage);
            } break;
            default:
                break;
            }
        }
    }
}

Member Data Documentation

m_activePower

double ControlElementSolver::m_activePower = 0.0

protected

Definition at line 96 of file ControlElementSolver.h.

m_ctrlContainer

ControlElementContainer* ControlElementSolver::m_ctrlContainer = nullptr

protected

Definition at line 81 of file ControlElementSolver.h.

m_currentTime

double ControlElementSolver::m_currentTime = 0.0

protected

Definition at line 93 of file ControlElementSolver.h.

m_deltaPe

double ControlElementSolver::m_deltaPe = 0.0

protected

Definition at line 102 of file ControlElementSolver.h.

m_deltaVelocity

double ControlElementSolver::m_deltaVelocity = 0.0

protected

Definition at line 101 of file ControlElementSolver.h.

m_failMessage

wxString ControlElementSolver::m_failMessage = _("Unknown error.")

protected

Definition at line 87 of file ControlElementSolver.h.

m_fieldVoltage

double ControlElementSolver::m_fieldVoltage = 0.0

protected

Definition at line 111 of file ControlElementSolver.h.

m_initMecPower

double ControlElementSolver::m_initMecPower = 0.0

protected

Definition at line 99 of file ControlElementSolver.h.

m_initTerminalVoltage

double ControlElementSolver::m_initTerminalVoltage = 0.0

protected

Definition at line 98 of file ControlElementSolver.h.

m_initVelocity

double ControlElementSolver::m_initVelocity = 0.0

protected

Definition at line 100 of file ControlElementSolver.h.

m_inputControl

IOControl* ControlElementSolver::m_inputControl = nullptr

protected

First input control to be solved

Definition at line 89 of file ControlElementSolver.h.

m_inputToSolve

double* ControlElementSolver::m_inputToSolve = nullptr

protected

Definition at line 109 of file ControlElementSolver.h.

m_integrationError

double ControlElementSolver::m_integrationError = 1e-5

protected

Definition at line 84 of file ControlElementSolver.h.

m_isOK

bool ControlElementSolver::m_isOK = false

protected

Definition at line 86 of file ControlElementSolver.h.

m_mecPower

double ControlElementSolver::m_mecPower = 0.0

protected

Definition at line 112 of file ControlElementSolver.h.

m_outputControl

IOControl* ControlElementSolver::m_outputControl = nullptr

protected

Definition at line 90 of file ControlElementSolver.h.

m_ownsCtrlContainer

bool ControlElementSolver::m_ownsCtrlContainer = false

protected

Definition at line 82 of file ControlElementSolver.h.

m_reactivePower

double ControlElementSolver::m_reactivePower = 0.0

protected

Definition at line 97 of file ControlElementSolver.h.

m_solutions

std::vector<double> ControlElementSolver::m_solutions

protected

Definition at line 85 of file ControlElementSolver.h.

m_switchStatus

bool ControlElementSolver::m_switchStatus = false

protected

Definition at line 92 of file ControlElementSolver.h.

m_terminalVoltage

double ControlElementSolver::m_terminalVoltage = 0.0

protected

Definition at line 94 of file ControlElementSolver.h.

m_timeStep

double ControlElementSolver::m_timeStep = 1e-3

protected

Definition at line 83 of file ControlElementSolver.h.

m_velocity

double ControlElementSolver::m_velocity = 0.0

protected

Definition at line 95 of file ControlElementSolver.h.

---

The documentation for this class was generated from the following files:

• Project/elements/controlElement/ControlElementSolver.h
• Project/elements/controlElement/ControlElementSolver.cpp