Two-winding transformer power element with OLTC support. More...

#include <Transformer.h>

Inheritance diagram for Transformer:

[legend]

Collaboration diagram for Transformer:

[legend]

Public Member Functions
	Transformer (wxString name)

virtual Element *	GetCopy ()
	Get a the element copy.

virtual bool	AddParent (Element *parent, wxPoint2DDouble position, bool isOpening=false)
	Add a parent to the element. This method must be used on power elements that connect to a bus, so the parent must be a bus. The element basic points are calculated in this method, so apply this when the element is being inserted.

virtual bool	Contains (wxPoint2DDouble position) const
	Checks if the element contains a position.

virtual void	DrawDC (GUIColour guiColour, wxPoint2DDouble translation, double scale, wxGraphicsContext gc) const
	Draw the element using GDI+.

virtual void	DrawDC (GUIColour *guiColour, wxPoint2DDouble translation, double scale, wxDC &dc) const
	Draw the element using wxDC.

virtual bool	Intersects (wxRect2DDouble rect) const
	Check if the element's rect intersects other rect.

virtual void	Rotate (bool clockwise=true)
	Rotate the element.

virtual void	Move (wxPoint2DDouble position)
	Move the element other position.

virtual void	AlignToGrid (double gridSize=20.0) override

virtual void	MoveNode (Element *parent, wxPoint2DDouble position)
	Move a node. StartMove(wxPoint2DDouble position) before start moving.

virtual void	StartMove (wxPoint2DDouble position)
	Update the element attributes related to the movement.

virtual bool	GetContextMenu (wxMenu &menu)
	Get the element contex menu.

virtual wxString	GetTipText () const
	Get the tip text.

virtual void	RotateNode (Element *parent, bool clockwise)
	Rotate a node.

virtual bool	SetNodeParent (Element *parent)
	Set a perent to the node. If all conditions are met, a new parent are added to the element and the points related to the nodes will be calculated.

virtual void	SetPowerFlowDirection (PowerFlowDirection pfDirection)
	Set the direction of the power flow.

virtual bool	ShowForm (wxWindow parent, Element element, wxWindow *workspace=nullptr)
	Show element data form.

virtual TransformerElectricalData	GetElectricalData () const

virtual TransformerElectricalData &	GetElectricalDataRef ()

virtual TransformerElectricalData	GetPUElectricalData (double systemBasePower) const

virtual void	SetElectricaData (TransformerElectricalData electricalData)

virtual void	SetNominalVoltage (std::vector< double > nominalVoltage, std::vector< ElectricalUnit > nominalVoltageUnit)
	Set nominal voltage of the element.

virtual void	SetBestPositionAndRotation ()

virtual rapidxml::xml_node *	SaveElement (rapidxml::xml_document<> &doc, rapidxml::xml_node<> *elementListNode)

virtual bool	OpenElement (rapidxml::xml_node<> elementNode, std::vector< Element > parentList)

Public Member Functions inherited from Branch
virtual bool	NodeContains (wxPoint2DDouble position)
	Check if a node contains a point. If contains, set the attributes related to node movement.

virtual void	RemoveParent (Element *parent)
	Remove a parent.

virtual void	UpdateNodes ()
	Update the nodes according to the parents. If a parent is removed, use this method.

virtual wxCursor	GetBestPickboxCursor () const
	Get the best cursor to shown to the user when the mouse is above a pickbox.

virtual void	MovePickbox (wxPoint2DDouble position)
	Move the pickbox.

virtual bool	PickboxContains (wxPoint2DDouble position)
	Check if a pickbox contains a point. If contains the attributes related to pickbox movement will be calculated.

virtual void	AddPoint (wxPoint2DDouble point)
	Add point to the list of points that connect the element to the bus.

virtual void	UpdateSwitchesPosition ()

virtual void	UpdateSwitches ()
	Update the switch position.

Public Member Functions inherited from PowerElement
	PowerElement ()
	Constructor.

virtual	~PowerElement ()
	Destructor.

virtual wxPoint2DDouble	GetSwitchPoint (Element *parent, wxPoint2DDouble parentPoint, wxPoint2DDouble secondPoint) const
	Get the correct switch position.

virtual bool	SwitchesContains (wxPoint2DDouble position) const
	Check if switch contains position.

virtual void	DrawDCSwitches (GUIColour guiColour, wxGraphicsContext gc) const
	Draw switch.

virtual void	DrawDCSwitches (GUIColour *guiColour, wxDC &dc) const

virtual void	CalculatePowerFlowPts (std::vector< wxPoint2DDouble > edges)
	Calculate the points of the power flow arrows.

virtual void	DrawDCPowerFlowPts (GUIColour guiColour, wxGraphicsContext gc) const
	Draw power flow arrows.

virtual void	DrawDCPowerFlowPts (GUIColour *guiColour, wxDC &dc) const

virtual void	SetSwitchingData (SwitchingData data)
	Set the switching data of the element.

virtual SwitchingData	GetSwitchingData ()
	Returns the switching data of the element.

virtual PowerFlowDirection	GetPowerFlowDirection () const
	Return the direction of the power flow.

virtual bool	GetPlotData (ElementPlotData &plotData, PlotStudy study=PlotStudy::STABILITY)
	Fill the plot data.

virtual bool	HaveDynamicEvent () const
	Check if the power element have dynamic event.

virtual void	SetDynamicEvent (bool dynEvent=true)
	Set if the power element have dynamic event.

virtual double	GetValueFromUnit (double value, ElectricalUnit valueUnit) const

virtual void	SaveCADProperties (rapidxml::xml_document<> &doc, rapidxml::xml_node<> *elementNode)

virtual void	SaveSwitchingData (rapidxml::xml_document<> &doc, rapidxml::xml_node<> *electricalNode)

virtual bool	OpenCADProperties (rapidxml::xml_node<> elementNode, std::vector< Element > parentList)

virtual bool	OpenSwitchingData (rapidxml::xml_node<> *electricalNode)

Public Member Functions inherited from Element
	Element ()
	Constructor.

virtual	~Element ()
	Destructor.

void	SetDragging (bool dragging=true)
	Set if the element are being dragged.

void	SetHeight (double height)
	Set element height.

void	SetPosition (const wxPoint2DDouble position)
	Set the element position and update the rectangle.

void	SetSelected (bool selected=true)
	Set element selection.

void	SetWidth (double width)
	Set element width.

void	SetAngle (double angle)
	Set element angle.

void	ShowPickbox (bool showPickbox=true)
	Set if the pickbox is shown.

void	SetBorderSize (double borderSize)
	Set the size of the border (shown in selected elements).

bool	SetOnline (bool online=true)
	Set if the element is online or offline.

virtual void	SetPointList (std::vector< wxPoint2DDouble > pointList)
	Set the list of points that connect the element to the bus.

ElementType	GetElementType ()

wxRect2DDouble	GetRect () const
	Get the element rectangle.

wxPoint2DDouble	GetPosition () const
	Get the element position.

bool	IsDragging () const
	Checks if the element is being dragged.

double	GetHeight () const
	Get the element height.

bool	IsSelected () const
	Checks if the element is selected.

double	GetWidth () const
	Get the element width.

double	GetAngle () const
	Get the element angle.

double	GetRotationAngle () const
	Get the angle of rotation.

bool	IsPickboxShown () const
	Checks if the pickbox is shown.

bool	IsOnline () const
	Checks if the element is online or offline.

virtual std::vector< wxPoint2DDouble >	GetPointList () const
	Get the list of points that connect the element to bus.

virtual std::vector< wxPoint2DDouble > &	GetPointListRef ()

virtual void	AddParent (Element *parent)
	Add a parent to the element.

virtual void	SetID (int id)
	Set the element ID.

virtual int	GetID () const
	Get the element ID.

virtual void	AddChild (Element *child)
	Add a child to the child list.

virtual void	RemoveChild (Element *child)
	Remove a child from the list.

virtual void	ReplaceChild (Element oldChild, Element newChild)
	Replace a child from the list.

void	SetParent (Element *parent, int num)

void	SetChild (Element *child, int num)

virtual void	ReplaceParent (Element oldParent, Element newParent)
	Replace a parent.

virtual void	ResetPickboxes ()
	Remove the pickboxes.

virtual void	ResetNodes ()
	Remove the active nodes.

virtual wxPoint2DDouble	WorldToScreen (wxPoint2DDouble translation, double scale, double offsetX=0.0, double offsetY=0.0) const
	Convert the element position to screen position.

virtual wxPoint2DDouble	WorldToScreen (wxPoint2DDouble position, wxPoint2DDouble translation, double scale, double offsetX=0.0, double offsetY=0.0) const
	Convert a generic position to screen position.

virtual bool	RotatedRectanglesIntersects (wxRect2DDouble rect1, wxRect2DDouble rect2, double angle1, double angle2) const
	Check if two roteted rectangles intersect.

virtual void	DrawDCRectangle (wxPoint2DDouble position, double width, double height, double angle, wxDC &dc) const
	Draw a circle.

virtual void	DrawDCRoundedRectRotated (wxDC &dc, const wxPoint2DDouble &center, double width, double height, double radius, double angleDeg, int arcSegments=8) const

virtual void	DrawDCCircle (wxPoint2DDouble position, double radius, int numSegments, wxGraphicsContext *gc) const
	Draw a circle using device context.

virtual void	DrawDCCircle (wxPoint2DDouble position, double radius, wxDC &dc) const

virtual void	DrawDCArc (wxPoint2DDouble position, double radius, double initAngle, double finalAngle, int numSegments, wxGraphicsContext *gc) const

virtual void	DrawDCArc (wxPoint2DDouble position, double radius, double initAngle, double finalAngle, wxDC &dc) const

virtual void	DrawDCTriangle (std::vector< wxPoint2DDouble > points, wxGraphicsContext *gc) const
	Draw rectangle.

virtual void	DrawDCTriangle (std::vector< wxPoint > points, wxDC &dc) const

virtual void	DrawStabilityEventGC (wxGraphicsContext gc, wxPoint2DDouble translation, double scale, GUIColour guiColour, bool rotateAnchor=false, wxPoint2DDouble iconPosition=wxPoint2DDouble(-1, -1)) const

virtual void	DrawDCPickbox (wxPoint2DDouble position, wxGraphicsContext *gc) const
	Draw a point.

virtual wxPoint2DDouble	RotateAtPosition (wxPoint2DDouble pointToRotate, double angle, bool degrees=true) const
	Rotate a point as element position being the origin.

virtual wxPoint2DDouble	RotateLocal (wxPoint2DDouble local, double angleDeg) const

virtual wxPoint	RotateAround (const wxPoint2DDouble &p, const wxPoint2DDouble &center, double angleDeg) const

virtual std::vector< Element * >	GetParentList () const
	Get the parent list.

virtual std::vector< Element * >	GetChildList () const
	Get the Child list.

virtual wxPoint2DDouble	GetMoveStartPosition () const

virtual wxPoint2DDouble	GetMovePosition () const

virtual void	CalculateBoundaries (wxPoint2DDouble &leftUp, wxPoint2DDouble &rightBottom) const
	Calculate the element boundaries.

virtual void	GeneralMenuItens (wxMenu &menu)
	Insert general itens to context menu.

virtual double	PointToLineDistance (wxPoint2DDouble point, int *segmentNumber=nullptr) const
	Calculate the distance between a line (formed by point list) and a point.

bool	IsInserted () const
	Check if the element is properly inserted in the workspace.

void	SetInserted (bool inserted=true)
	Set if the element is properly inserted in the workspace.

virtual bool	OpenElement (rapidxml::xml_node<> *elementNode)

void	SaveCADProperties (rapidxml::xml_document<> &doc, rapidxml::xml_node<> *elementNode)

bool	OpenCADProperties (rapidxml::xml_node<> *elementNode)

Protected Member Functions
void	UpdatePowerFlowArrowsPosition ()

Protected Attributes
TransformerElectricalData	m_electricalData

Protected Attributes inherited from PowerElement
SwitchingData	m_swData

std::vector< std::vector< wxPoint2DDouble > >	m_powerFlowArrow

PowerFlowDirection	m_pfDirection = PowerFlowDirection::PF_NONE

wxColour	m_busColour

wxColour	m_onlineElementColour

wxColour	m_offlineElementColour

wxColour	m_closedSwitchColour

wxColour	m_openedSwitchColour

wxColour	m_powerFlowArrowColour

wxColour	m_dynamicEventColour

bool	m_dynEvent = false

Protected Attributes inherited from Element
ElementType	m_elementType = ElementType::TYPE_NONE

int	m_elementID = 0

std::vector< Element * >	m_parentList

std::vector< Element * >	m_childList

wxRect2DDouble	m_rect

wxPoint2DDouble	m_position

double	m_width = 0.0

double	m_height = 0.0

double	m_angle = 0.0

double	m_borderSize = 2.0

double	m_rotationAngle = 45.0

double	m_switchSize = 10.0

std::vector< wxRect2DDouble >	m_switchRect

bool	m_selected = false

bool	m_dragging = false

bool	m_showPickbox = false

bool	m_inserted = false

int	m_activePickboxID = ID_PB_NONE

int	m_activeNodeID = 0

std::vector< wxPoint2DDouble >	m_pointList

std::vector< wxPoint2DDouble >	m_movePts

wxPoint2DDouble	m_moveStartPt

wxPoint2DDouble	m_movePos

bool	m_online = true

Additional Inherited Members
Static Public Member Functions inherited from Element
static bool	DoubleFromString (wxWindow *parent, wxString strValue, double &value, wxString errorMsg)
	Get a double value from a string. Show a error message if the conversion fail.

static bool	IntFromString (wxWindow *parent, wxString strValue, int &value, wxString errorMsg)
	Convert a string to int. Show a error message if the conversion fail.

static wxString	StringFromDouble (double value, int minDecimal=1, int maxDecimals=13)
	Convert a double value to string.

Detailed Description

Two-winding transformer power element with OLTC support.

Author: Thales Lima Oliveira thale.nosp@m.s@uf.nosp@m.u.br; Luiz Gonzaga Rocha Junior luizg.nosp@m.rj@g.nosp@m.mail..nosp@m.com

Date: 06/10/2017

Definition at line 95 of file Transformer.h.

Constructor & Destructor Documentation

◆ Transformer() [1/2]

Transformer::Transformer ( )

Definition at line 21 of file Transformer.cpp.

                         : Branch()
{
    m_elementType = TYPE_TRANSFORMER;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) { m_electricalData.faultCurrent[i][j] = std::complex<double>(0.0, 0.0); }
    }
}

◆ Transformer() [2/2]

Transformer::Transformer ( wxString name )

Definition at line 28 of file Transformer.cpp.

                                      : Branch()
{
    m_elementType = TYPE_TRANSFORMER;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) { m_electricalData.faultCurrent[i][j] = std::complex<double>(0.0, 0.0); }
    }
    m_electricalData.name = name;
}

◆ ~Transformer()

Transformer::~Transformer ( )

virtual

Definition at line 36 of file Transformer.cpp.

36{}

Member Function Documentation

◆ AddParent()

bool Transformer::AddParent	(	Element *	parent,
		wxPoint2DDouble	position,
		bool	isOpening = `false`
	)

virtual

Add a parent to the element. This method must be used on power elements that connect to a bus, so the parent must be a bus. The element basic points are calculated in this method, so apply this when the element is being inserted.

Parameters

parent	Element parent.
position	Node position in the parent.

Reimplemented from Element.

Definition at line 38 of file Transformer.cpp.

{
    if (parent) {
        // First bus.
        if (m_parentList.size() == 0) {
            m_position = position;
            m_parentList.push_back(parent);
            parent->AddChild(this);
 
            wxPoint2DDouble parentPt = parent->RotateAtPosition(position, -parent->GetAngle()); // Rotate click to horizontal position
            parentPt.m_y = parent->GetPosition().m_y; // Centralize on bus.
            parentPt = parent->RotateAtPosition(parentPt, parent->GetAngle()); // Rotate back.
 
            m_pointList.push_back(parentPt); // First point
            m_pointList.push_back(GetSwitchPoint(parent, parentPt, m_position));
 
            wxRect2DDouble genRect(0, 0, 0, 0);
            m_switchRect.push_back(genRect);
 
            return false;
        }
 
        // Second bus.
        else if (parent != m_parentList[0]) {
            m_parentList.push_back(parent);
            parent->AddChild(this);
 
            wxPoint2DDouble parentPt = parent->RotateAtPosition(position, -parent->GetAngle()); // Rotate click to horizontal position.
            parentPt.m_y = parent->GetPosition().m_y; // Centralize on bus.
 
            parentPt = parent->RotateAtPosition(parentPt, parent->GetAngle()); // Rotate back.
 
            if (isOpening) {
                m_width = 70.0;
                m_height = 40.0;
 
                m_position = wxPoint2DDouble(
                    (m_pointList[0].m_x + parentPt.m_x) / 2.0,
                    (m_pointList[0].m_y + parentPt.m_y) / 2.0);
 
                SetPosition(m_position);
 
                wxPoint2DDouble term1 =
                    m_position +
                    RotateLocal(wxPoint2DDouble(-40.0, 0.0), m_angle);
 
                wxPoint2DDouble term2 =
                    m_position +
                    RotateLocal(wxPoint2DDouble(40.0, 0.0), m_angle);
 
                m_pointList.push_back(term1);
                m_pointList.push_back(term2);
 
                m_pointList[1] =
                    GetSwitchPoint(
                        m_parentList[0],
                        m_pointList[0],
                        term1);
 
                m_pointList.push_back(
                    GetSwitchPoint(
                        parent,
                        parentPt,
                        term2));
 
                m_pointList.push_back(parentPt);
                m_inserted = true;
 
                wxRect2DDouble genRect(0, 0, 0, 0);
                m_switchRect.push_back(genRect);
 
                UpdateSwitches();
                UpdatePowerFlowArrowsPosition();
 
                return true;
            }
 
            // Normal insertion: determine position and rotation automatically.
            wxPoint2DDouble p1 = m_pointList[0];
            wxPoint2DDouble p2 = parentPt;
 
            double dx = p2.m_x - p1.m_x;
            double dy = p2.m_y - p1.m_y;
 
            // Determine orientation based on bus separation.
            if (std::abs(dy) > std::abs(dx)) {
                m_angle = (dy >= 0.0) ? 90.0 : 270.0;
            }
            else {
                m_angle = (dx >= 0.0) ? 0.0 : 180.0;
            }
 
            // Get the midpoint between the two bus points.
            m_position = wxPoint2DDouble((p1.m_x + p2.m_x) / 2.0, (p1.m_y + p2.m_y) / 2.0);
 
            // Snap position to grid alignment.
            if (std::abs(dx) < 1.0) {
                m_position.m_x = p1.m_x;
                m_position.m_y = std::round(m_position.m_y / 20.0) * 20.0;
            }
            else if (std::abs(dy) < 1.0) {
                m_position.m_y = p1.m_y;
                m_position.m_x = std::round(m_position.m_x / 20.0) * 20.0;
            }
            else {
                m_position.m_x = std::round(m_position.m_x / 20.0) * 20.0;
                m_position.m_y = std::round(m_position.m_y / 20.0) * 20.0;
            }
 
            // Check whether a point belongs to the rotated bus rectangle.
            //
            // The point is first transformed into the local coordinate
            // system of the bus. In that system:
            //   X -> bus width
            //   Y -> bus height
            //
            // This makes the test independent of the bus rotation.
            auto IsPointInsideBus = [](Element* bus, const wxPoint2DDouble& point) -> bool {
                wxPoint2DDouble delta(
                    point.m_x - bus->GetPosition().m_x,
                    point.m_y - bus->GetPosition().m_y);
 
                wxPoint2DDouble local =
                    bus->RotateLocal(delta, -bus->GetAngle());
 
                double halfWidth = bus->GetWidth() / 2.0 + 2.0;
                double halfHeight = bus->GetHeight() / 2.0 + 2.0;
 
                return std::abs(local.m_x) <= halfWidth &&
                    std::abs(local.m_y) <= halfHeight;
                };
 
            if (std::abs(dy) > std::abs(dx)) {
                // Transformer is vertically oriented.
                // Keep the connection points aligned in X.
                wxPoint2DDouble candidate1(m_position.m_x, m_parentList[0]->GetPosition().m_y);
 
                wxPoint2DDouble candidate2(m_position.m_x, parent->GetPosition().m_y);
 
                if (IsPointInsideBus(m_parentList[0], candidate1) && IsPointInsideBus(parent, candidate2)) {
                    m_pointList[0].m_x = m_position.m_x;
                    parentPt.m_x = m_position.m_x;
                }
            }
            else {
                // Transformer is horizontally oriented.
                // Keep the connection points aligned in Y.
                wxPoint2DDouble candidate1(m_parentList[0]->GetPosition().m_x, m_position.m_y);
 
                wxPoint2DDouble candidate2(parent->GetPosition().m_x, m_position.m_y);
 
                if (IsPointInsideBus(m_parentList[0], candidate1) &&
                    IsPointInsideBus(parent, candidate2)) {
 
                    m_pointList[0].m_y = m_position.m_y;
                    parentPt.m_y = m_position.m_y;
                }
            }
 
            // Set the transformer rectangle.
            m_width = 70.0;
            m_height = 40.0;
 
            SetPosition(m_position);  // This method calculates the rectangle properly.
 
            // Set the terminals at 40.0 units offset (2 grid cells),
            // rotated by m_angle.
            wxPoint2DDouble term1 = m_position + RotateLocal(wxPoint2DDouble(-40.0, 0.0), m_angle);
 
            wxPoint2DDouble term2 = m_position + RotateLocal(wxPoint2DDouble(40.0, 0.0), m_angle);
 
            term1.m_x = std::round(term1.m_x);
            term1.m_y = std::round(term1.m_y);
 
            term2.m_x = std::round(term2.m_x);
            term2.m_y = std::round(term2.m_y);
 
            m_pointList.push_back(term1);
            m_pointList.push_back(term2);
 
            // Set first switch point.
            m_pointList[1] = GetSwitchPoint(m_parentList[0], m_pointList[0], term1);
 
            // Set the second switch point.
            m_pointList.push_back(GetSwitchPoint(parent, parentPt, term2));
 
            m_pointList.push_back(parentPt);  // Last point.
            m_inserted = true;
 
            wxRect2DDouble genRect(0, 0, 0, 0);
            m_switchRect.push_back(genRect);
 
            UpdateSwitches();
            UpdatePowerFlowArrowsPosition();
 
            return true;
        }
    }
 
    return false;
}

Here is the call graph for this function:

◆ AlignToGrid()

void Transformer::AlignToGrid ( double gridSize = 20.0 )

overridevirtual

Reimplemented from Element.

Definition at line 540 of file Transformer.cpp.

{
    if (gridSize <= 0.0)
        gridSize = 20.0;
 
    // 1. Snap center position to grid.
    m_position.m_x = std::round(m_position.m_x / gridSize) * gridSize;
    m_position.m_y = std::round(m_position.m_y / gridSize) * gridSize;
 
    SetPosition(m_position);
 
    // 2. Rigidly attach terminals at 40.0 units offset.
    if (m_pointList.size() >= 4) {
        wxPoint2DDouble t1 = m_position + RotateLocal(wxPoint2DDouble(-40.0, 0.0), m_angle);
        wxPoint2DDouble t2 = m_position + RotateLocal(wxPoint2DDouble(40.0, 0.0), m_angle);
        m_pointList[2] = wxPoint2DDouble(std::round(t1.m_x), std::round(t1.m_y));
        m_pointList[3] = wxPoint2DDouble(std::round(t2.m_x), std::round(t2.m_y));
    }
 
    // Transformer orientation.
    bool isVertical = (std::abs(m_angle - 90.0) < 1.0 || std::abs(m_angle - 270.0) < 1.0);
 
    // Check whether a point belongs to the rotated bus rectangle.
    auto IsPointInsideBus =
        [](Element* bus, const wxPoint2DDouble& point) -> bool
        {
            wxPoint2DDouble delta(point.m_x - bus->GetPosition().m_x, point.m_y - bus->GetPosition().m_y);
 
            // Transform the point into the local coordinate
            // system of the bus.
            wxPoint2DDouble local = bus->RotateLocal(delta, -bus->GetAngle());
 
            double halfWidth = bus->GetWidth() / 2.0 + 2.0;
            double halfHeight = bus->GetHeight() / 2.0 + 2.0;
 
            return std::abs(local.m_x) <= halfWidth && std::abs(local.m_y) <= halfHeight;
        };
 
    // 3. Align first bus contact point.
    if (m_parentList.size() > 0 && m_parentList[0] && !m_pointList.empty()) {
 
        Element* bus1 = m_parentList[0];
 
        if (isVertical) {
            // Candidate point obtained by aligning X with the
            // transformer center.
            wxPoint2DDouble candidate(m_position.m_x, bus1->GetPosition().m_y);
 
            if (IsPointInsideBus(bus1, candidate)) {
                m_pointList[0].m_x = m_position.m_x;
            }
 
            // Snap the longitudinal coordinate to the grid.
            m_pointList[0].m_y = std::round(m_pointList[0].m_y / gridSize) * gridSize;
        }
        else {
            // Candidate point obtained by aligning Y with the
            // transformer center.
            wxPoint2DDouble candidate(bus1->GetPosition().m_x, m_position.m_y);
 
            if (IsPointInsideBus(bus1, candidate)) {
                m_pointList[0].m_y = m_position.m_y;
            }
 
            // Snap the longitudinal coordinate to the grid.
            m_pointList[0].m_x = std::round(m_pointList[0].m_x / gridSize) * gridSize;
        }
    }
    else if (!m_pointList.empty()) {
        m_pointList[0].m_x = std::round(m_pointList[0].m_x / gridSize) * gridSize;
 
        m_pointList[0].m_y = std::round(m_pointList[0].m_y / gridSize) * gridSize;
    }
 
    // 4. Align second bus contact point.
    if (m_parentList.size() > 1 &&
        m_parentList[1] &&
        !m_pointList.empty()) {
 
        Element* bus2 = m_parentList[1];
 
        if (isVertical) {
            // Candidate point obtained by aligning X with the
            // transformer center.
            wxPoint2DDouble candidate(m_position.m_x, bus2->GetPosition().m_y);
 
            if (IsPointInsideBus(bus2, candidate)) {
                m_pointList.back().m_x = m_position.m_x;
            }
 
            // Snap the longitudinal coordinate to the grid.
            m_pointList.back().m_y = std::round(m_pointList.back().m_y / gridSize) * gridSize;
        }
        else {
            // Candidate point obtained by aligning Y with the
            // transformer center.
            wxPoint2DDouble candidate(bus2->GetPosition().m_x, m_position.m_y);
 
            if (IsPointInsideBus(bus2, candidate)) {
                m_pointList.back().m_y = m_position.m_y;
            }
 
            // Snap the longitudinal coordinate to the grid.
            m_pointList.back().m_x = std::round(m_pointList.back().m_x / gridSize) * gridSize;
        }
    }
    else if (m_pointList.size() > 1) {
        m_pointList.back().m_x = std::round(m_pointList.back().m_x / gridSize) * gridSize;
 
        m_pointList.back().m_y = std::round(m_pointList.back().m_y / gridSize) * gridSize;
    }
 
    UpdateSwitchesPosition();
    UpdatePowerFlowArrowsPosition();
}

◆ Contains()

bool Transformer::Contains ( wxPoint2DDouble position ) const

virtual

Checks if the element contains a position.

Parameters

position Position to be checked.

Reimplemented from Branch.

Definition at line 240 of file Transformer.cpp.

{
    wxPoint2DDouble ptR = RotateAtPosition(position, -m_angle);
    return m_rect.Contains(ptR);
}

Here is the call graph for this function:

◆ DrawDC() [1/2]

void Transformer::DrawDC	(	GUIColour *	guiColour,
		wxPoint2DDouble	translation,
		double	scale,
		wxDC &	dc
	)		const

virtual

Draw the element using wxDC.

Parameters

guiColour	Colours of the system defined in properties.
translation	Translation of the system.
scale	Scale of the system.
dc	Device context.

Reimplemented from Element.

Definition at line 414 of file Transformer.cpp.

{
    wxColour elementColour;
    if (m_online) {
        if (m_dynEvent)
            elementColour = guiColour->eventElement;
        else
            elementColour = guiColour->enabled;
    }
    else
        elementColour = guiColour->disable;
 
    std::vector<wxPoint> pointList;
    for (auto& pt : m_pointList) { pointList.emplace_back(static_cast<int>(pt.m_x), static_cast<int>(pt.m_y)); }
 
    if (m_inserted) {
        // Draw selection (layer 1).
        if (m_selected) {
            dc.SetPen(wxPen(wxColour(guiColour->selection), 2 + m_borderSize * 2.0));
            dc.SetBrush(*wxTRANSPARENT_BRUSH);
            dc.DrawLines(pointList.size(), &pointList[0]);
 
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(guiColour->selection));
            //DrawDCCircle(m_rect.GetPosition() + wxPoint2DDouble(20.0, 20.0), 20 + (m_borderSize + 1.5) / scale, dc);
            //DrawDCCircle(m_rect.GetPosition() + wxPoint2DDouble(50.0, 20.0), 20 + (m_borderSize + 1.5) / scale, dc);
            DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(15.0, 0.0), m_angle), 20 + (m_borderSize + 1.5) / scale, dc);
            DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(-15.0, 0.0), m_angle), 20 + (m_borderSize + 1.5) / scale, dc);
 
            // Draw nodes selection.
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(guiColour->selection));
            if (pointList.size() > 0) {
                DrawDCCircle(pointList[0], 5.0 + m_borderSize / scale, dc);
                if (m_inserted) { DrawDCCircle(pointList[pointList.size() - 1], 5.0 + m_borderSize / scale, dc); }
            }
        }
 
        // Draw transformer (layer 2).
        // Transformer line
        dc.SetPen(wxPen(elementColour, 2));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawLines(pointList.size(), &pointList[0]);
 
        // Draw nodes.
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(elementColour));
        if (pointList.size() > 0) {
            DrawDCCircle(pointList[0], 5.0, dc);
            if (m_inserted) { DrawDCCircle(pointList[pointList.size() - 1], 5.0, dc); }
        }
 
        DrawDCSwitches(guiColour, dc);
        DrawDCPowerFlowPts(guiColour, dc);
 
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(guiColour->background));
        DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(15.0, 0.0), m_angle), 20, dc);
        DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(-15.0, 0.0), m_angle), 20, dc);
 
        dc.SetPen(wxPen(elementColour, 2));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(15.0, 0.0), m_angle), 20, dc);
        DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(-15.0, 0.0), m_angle), 20, dc);
 
        // Point
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(elementColour));
        DrawDCCircle(m_position + RotateLocal(wxPoint2DDouble(-35, -20), m_angle), 4, dc);
    }
}

Here is the call graph for this function:

◆ DrawDC() [2/2]

void Transformer::DrawDC	(	GUIColour *	guiColour,
		wxPoint2DDouble	translation,
		double	scale,
		wxGraphicsContext *	gc
	)		const

virtual

Draw the element using GDI+.

Parameters

guiColour	Colours of the system defined in properties.
translation	Translation of the system.
scale	Scale of the system.
gc	Graphics context

Reimplemented from Element.

Definition at line 324 of file Transformer.cpp.

{
    wxColour elementColour;
    if (m_online) {
        //if (m_dynEvent)
        //  elementColour = guiColour->eventElement;
        //else
        elementColour = guiColour->enabled;
    }
    else
        elementColour = guiColour->disable;
 
    if (m_inserted) {
        // Draw selection (layer 1).
        if (m_selected) {
            gc->SetPen(wxPen(guiColour->selection, 2 + m_borderSize * 2.0));
            gc->SetBrush(*wxTRANSPARENT_BRUSH);
            gc->StrokeLines(m_pointList.size(), &m_pointList[0]);
 
            // Push the current matrix on stack.
            gc->PushState();
            // Rotate the matrix around the object position.
            gc->Translate(m_position.m_x, m_position.m_y);
            gc->Rotate(wxDegToRad(m_angle));
            gc->Translate(-m_position.m_x, -m_position.m_y);
 
            gc->SetPen(*wxTRANSPARENT_PEN);
            gc->SetBrush(wxBrush(guiColour->selection));
            DrawDCCircle(m_position + wxPoint2DDouble(-15.0, 0.0), 20 + (m_borderSize + 1.5) / scale, 20, gc);
            DrawDCCircle(m_position + wxPoint2DDouble(15.0, 0.0), 20 + (m_borderSize + 1.5) / scale, 20, gc);
 
            gc->PopState();
 
            // Draw nodes selection.
            gc->SetPen(*wxTRANSPARENT_PEN);
            gc->SetBrush(wxBrush(guiColour->selection));
            if (m_pointList.size() > 0) {
                DrawDCCircle(m_pointList[0], 5.0 + m_borderSize / scale, 10, gc);
                if (m_inserted) { DrawDCCircle(m_pointList[m_pointList.size() - 1], 5.0 + m_borderSize / scale, 10, gc); }
            }
        }
 
        // Draw transformer (layer 2).
        // Transformer line
        gc->SetPen(wxPen(elementColour, 2));
        gc->SetBrush(*wxTRANSPARENT_BRUSH);
        gc->StrokeLines(m_pointList.size(), &m_pointList[0]);
 
        // Draw nodes.
        gc->SetPen(*wxTRANSPARENT_PEN);
        gc->SetBrush(wxBrush(elementColour));
        if (m_pointList.size() > 0) {
            DrawDCCircle(m_pointList[0], 5.0, 10, gc);
            if (m_inserted) { DrawDCCircle(m_pointList[m_pointList.size() - 1], 5.0, 10, gc); }
        }
 
        DrawDCSwitches(guiColour, gc);
        DrawDCPowerFlowPts(guiColour, gc);
 
        // Push the current matrix on stack.
        gc->PushState();
        // Rotate the matrix around the object position.
        gc->Translate(m_position.m_x, m_position.m_y);
        gc->Rotate(wxDegToRad(m_angle));
        gc->Translate(-m_position.m_x, -m_position.m_y);
 
        //glColor4d(1.0, 1.0, 1.0, 1.0);
        gc->SetPen(*wxTRANSPARENT_PEN);
        gc->SetBrush(wxBrush(guiColour->background));
        DrawDCCircle(m_position + wxPoint2DDouble(-15.0, 0.0), 20, 20, gc);
        DrawDCCircle(m_position + wxPoint2DDouble(15.0, 0.0), 20, 20, gc);
 
        gc->SetPen(wxPen(elementColour, 2));
        gc->SetBrush(*wxTRANSPARENT_BRUSH);
        DrawDCCircle(m_position + wxPoint2DDouble(-15.0, 0.0), 20, 20, gc);
        DrawDCCircle(m_position + wxPoint2DDouble(15.0, 0.0), 20, 20, gc);
 
        // Point
        gc->SetPen(*wxTRANSPARENT_PEN);
        gc->SetBrush(wxBrush(elementColour));
        DrawDCCircle(m_rect.GetPosition(), 4, 10, gc);
 
        gc->PopState();
 
        if (m_dynEvent) {
            DrawStabilityEventGC(gc, translation, scale, guiColour);
        }
    }
}

Here is the call graph for this function:

◆ GetContextMenu()

bool Transformer::GetContextMenu ( wxMenu & menu )

virtual

Get the element contex menu.

Parameters

menu	menu that will be inserted the element itens.

Returns: True if was possible to build the menu, false otherwise.

Reimplemented from Branch.

Definition at line 699 of file Transformer.cpp.

{
    menu.Append(ID_EDIT_ELEMENT, _("Edit tranformer"));
 
    wxString busName[2] = { "?", "?" };
    if (m_parentList.size() == 2) {
        int i = 0;
        for (Element* element : m_parentList) {
            if (element) {
                Bus* bus = static_cast<Bus*>(element);
                busName[i] = bus->GetElectricalData().name;
            }
            i++;
        }
    }
 
    wxMenu* textMenu = new wxMenu();
 
    textMenu->Append(ID_TXT_NAME, _("Name"));
    textMenu->Append(ID_TXT_BRANCH_ACTIVE_POWER_1_2, _("Active power (") + busName[0] + _(" to ") + busName[1] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_ACTIVE_POWER_2_1, _("Active power (") + busName[1] + _(" to ") + busName[0] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_REACTIVE_POWER_1_2, _("Reactive power (") + busName[0] + _(" to ") + busName[1] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_REACTIVE_POWER_2_1, _("Reactive power (") + busName[1] + _(" to ") + busName[0] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_LOSSES, _("Losses"));
    textMenu->Append(ID_TXT_BRANCH_CURRENT_1_2, _("Current (") + busName[0] + _(" to ") + busName[1] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_CURRENT_2_1, _("Current (") + busName[1] + _(" to ") + busName[0] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_FAULT_CURRENT_1_2, _("Fault current (") + busName[0] + _(" to ") + busName[1] + wxT(")"));
    textMenu->Append(ID_TXT_BRANCH_FAULT_CURRENT_2_1, _("Fault current (") + busName[1] + _(" to ") + busName[0] + wxT(")"));
    textMenu->Append(ID_TXT_TAP, _("Tap"));
    textMenu->SetClientData(menu.GetClientData());
    menu.AppendSubMenu(textMenu, _("Add text"));
 
    GeneralMenuItens(menu);
    return true;
}

Here is the call graph for this function:

◆ GetCopy()

Element * Transformer::GetCopy ( )

virtual

Get a the element copy.

Returns: Copy of the element.

Reimplemented from Element.

Definition at line 864 of file Transformer.cpp.

{
    Transformer* copy = new Transformer();
    *copy = *this;
    return copy;
}

◆ GetElectricalData()

virtual TransformerElectricalData Transformer::GetElectricalData ( ) const

inlinevirtual

Definition at line 120 of file Transformer.h.

120{ return m_electricalData; }

◆ GetElectricalDataRef()

virtual TransformerElectricalData & Transformer::GetElectricalDataRef ( )

inlinevirtual

Definition at line 121 of file Transformer.h.

121{ return m_electricalData; }

◆ GetPUElectricalData()

TransformerElectricalData Transformer::GetPUElectricalData ( double systemBasePower ) const

virtual

Definition at line 940 of file Transformer.cpp.

{
    TransformerElectricalData data;
 
    data.name = m_electricalData.name;
 
    data.nominalPower = m_electricalData.nominalPower;
    data.nominalPowerUnit = m_electricalData.nominalPowerUnit;
 
    data.primaryNominalVoltage = m_electricalData.primaryNominalVoltage;
    data.primaryNominalVoltageUnit = m_electricalData.primaryNominalVoltageUnit;
 
    data.secondaryNominalVoltage = m_electricalData.secondaryNominalVoltage;
    data.secondaryNominalVoltageUnit = m_electricalData.secondaryNominalVoltageUnit;
 
    data.useTransformerPower = m_electricalData.useTransformerPower;
 
    data.baseVoltage = m_electricalData.baseVoltage;
 
    data.resistance = m_electricalData.resistance;
    data.resistanceUnit = m_electricalData.resistanceUnit;
 
    data.indReactance = m_electricalData.indReactance;
    data.indReactanceUnit = m_electricalData.indReactanceUnit;
 
    data.connection = m_electricalData.connection;
    data.turnsRatio = m_electricalData.turnsRatio;
    data.phaseShift = m_electricalData.phaseShift;
 
    data.hasTapChanger = m_electricalData.hasTapChanger;
    data.nominalTurnsRatio = m_electricalData.nominalTurnsRatio;
    data.oltcControlledBus = m_electricalData.oltcControlledBus;
    data.oltcTargetVoltage = m_electricalData.oltcTargetVoltage;
    data.oltcVoltageDeadband = m_electricalData.oltcVoltageDeadband;
    data.oltcMinTap = m_electricalData.oltcMinTap;
    data.oltcMaxTap = m_electricalData.oltcMaxTap;
    data.oltcTapStep = m_electricalData.oltcTapStep;
    data.oltcIsDiscrete = m_electricalData.oltcIsDiscrete;
 
    data.zeroResistance = m_electricalData.zeroResistance;
    data.zeroIndReactance = m_electricalData.zeroIndReactance;
 
    data.primaryGrndResistance = m_electricalData.primaryGrndResistance;
    data.primaryGrndReactance = m_electricalData.primaryGrndReactance;
 
    data.secondaryGrndResistance = m_electricalData.secondaryGrndResistance;
    data.secondaryGrndReactance = m_electricalData.secondaryGrndReactance;
 
    data.powerFlow[0] = m_electricalData.powerFlow[0];
    data.powerFlow[1] = m_electricalData.powerFlow[1];
 
    data.faultCurrent[0][0] = m_electricalData.faultCurrent[0][0];
    data.faultCurrent[0][1] = m_electricalData.faultCurrent[0][1];
    data.faultCurrent[0][2] = m_electricalData.faultCurrent[0][2];
    data.faultCurrent[1][0] = m_electricalData.faultCurrent[1][0];
    data.faultCurrent[1][1] = m_electricalData.faultCurrent[1][1];
    data.faultCurrent[1][2] = m_electricalData.faultCurrent[1][2];
 
 
    data.harmonicOrder = m_electricalData.harmonicOrder;
    data.harmonicCurrent[0] = m_electricalData.harmonicCurrent[0];
    data.harmonicCurrent[1] = m_electricalData.harmonicCurrent[1];
 
    double transformerBasePower = GetValueFromUnit(data.nominalPower, data.nominalPowerUnit);
    double baseVoltage = 0.0;
    if (data.baseVoltage == 0) {
        baseVoltage = GetValueFromUnit(data.primaryNominalVoltage, data.primaryNominalVoltageUnit);
    }
    else {
        baseVoltage = GetValueFromUnit(data.secondaryNominalVoltage, data.secondaryNominalVoltageUnit);
    }
    double systemBaseImpedance = (baseVoltage * baseVoltage) / systemBasePower;
    double transformerBaseImpedance = (baseVoltage * baseVoltage) / transformerBasePower;
 
    // Resistance
    double r = data.resistance;
    if (data.resistanceUnit == ElectricalUnit::UNIT_PU) {
        if (data.useTransformerPower) data.resistance = (r * transformerBaseImpedance) / systemBaseImpedance;
    }
    else {
        data.resistance = r / systemBaseImpedance;
    }
    data.resistanceUnit = ElectricalUnit::UNIT_PU;
 
    // Indutive reactance
    double x = data.indReactance;
    if (data.indReactanceUnit == ElectricalUnit::UNIT_PU) {
        if (data.useTransformerPower) data.indReactance = (x * transformerBaseImpedance) / systemBaseImpedance;
    }
    else {
        data.indReactance = x / systemBaseImpedance;
    }
    data.indReactanceUnit = ElectricalUnit::UNIT_PU;
 
    // Fault
 
    // Zero seq. resistance
    double r0 = data.zeroResistance;
    if (data.useTransformerPower) data.zeroResistance = (r0 * transformerBaseImpedance) / systemBaseImpedance;
 
    // Zero seq. ind. reactance
    double x0 = data.zeroIndReactance;
    if (data.useTransformerPower) data.zeroIndReactance = (x0 * transformerBaseImpedance) / systemBaseImpedance;
 
    // Primary ground resistance
    double rgp = data.primaryGrndResistance;
    if (data.useTransformerPower) data.primaryGrndResistance = (rgp * transformerBaseImpedance) / systemBaseImpedance;
 
    // Primary ground ind reactance
    double xgp = data.primaryGrndReactance;
    if (data.useTransformerPower) data.primaryGrndReactance = (xgp * transformerBaseImpedance) / systemBaseImpedance;
 
    // Secondary ground resistance
    double rgs = data.secondaryGrndResistance;
    if (data.useTransformerPower) data.secondaryGrndResistance = (rgs * transformerBaseImpedance) / systemBaseImpedance;
 
    // Secondary ground ind reactance
    double xgs = data.secondaryGrndReactance;
    if (data.useTransformerPower) data.secondaryGrndReactance = (xgs * transformerBaseImpedance) / systemBaseImpedance;
 
    if (!m_online) {
        data.powerFlow[0] = std::complex<double>(0, 0);
        data.powerFlow[1] = std::complex<double>(0, 0);
        data.faultCurrent[0][0] = std::complex<double>(0, 0);
        data.faultCurrent[0][1] = std::complex<double>(0, 0);
        data.faultCurrent[0][2] = std::complex<double>(0, 0);
        data.faultCurrent[1][0] = std::complex<double>(0, 0);
        data.faultCurrent[1][1] = std::complex<double>(0, 0);
        data.faultCurrent[1][2] = std::complex<double>(0, 0);
    }
 
    return data;
}

◆ GetTipText()

wxString Transformer::GetTipText ( ) const

virtual

Get the tip text.

Returns: Tip text.

Reimplemented from Element.

Definition at line 871 of file Transformer.cpp.

{
    wxString tipText = m_electricalData.name;
    wxString primVoltage = StringFromDouble(m_electricalData.primaryNominalVoltage);
    switch (m_electricalData.primaryNominalVoltageUnit) {
    case ElectricalUnit::UNIT_V: {
        primVoltage += _(" V");
    } break;
    case ElectricalUnit::UNIT_kV: {
        primVoltage += _(" kV");
    } break;
    default:
        break;
    }
    wxString secVoltage = StringFromDouble(m_electricalData.secondaryNominalVoltage);
    switch (m_electricalData.secondaryNominalVoltageUnit) {
    case ElectricalUnit::UNIT_V: {
        secVoltage += _(" V");
    } break;
    case ElectricalUnit::UNIT_kV: {
        secVoltage += _(" kV");
    } break;
    default:
        break;
    }
 
    tipText += "\n" + primVoltage + " / " + secVoltage;
 
    if (m_online) {
        tipText += "\n";
        int busNumber[2];
        busNumber[0] = static_cast<Bus*>(m_parentList[0])->GetElectricalData().number + 1;
        busNumber[1] = static_cast<Bus*>(m_parentList[1])->GetElectricalData().number + 1;
 
        tipText += _("\nP") + wxString::Format("(%d-%d) = ", busNumber[0], busNumber[1]) +
            wxString::FromDouble(m_electricalData.powerFlow[0].real(), 5) + _(" p.u.");
        tipText += _("\nQ") + wxString::Format("(%d-%d) = ", busNumber[0], busNumber[1]) +
            wxString::FromDouble(m_electricalData.powerFlow[0].imag(), 5) + _(" p.u.");
        tipText += _("\nP") + wxString::Format("(%d-%d) = ", busNumber[1], busNumber[0]) +
            wxString::FromDouble(m_electricalData.powerFlow[1].real(), 5) + _(" p.u.");
        tipText += _("\nQ") + wxString::Format("(%d-%d) = ", busNumber[1], busNumber[0]) +
            wxString::FromDouble(m_electricalData.powerFlow[1].imag(), 5) + _(" p.u.");
 
        if (m_electricalData.hasTapChanger) {
            tipText += _("\nOLTC: Enabled (Vset = ") +
                wxString::FromDouble(m_electricalData.oltcTargetVoltage, 3) +
                _(" p.u., Tap = ") +
                wxString::FromDouble(m_electricalData.turnsRatio, 4) +
                _(" p.u.)");
        }
 
        if (!m_electricalData.harmonicOrder.empty()) {
            tipText += _("\n\nHarmonic currents:");
            int i = 0;
            for (auto& hCurrent1 : m_electricalData.harmonicCurrent[0]) {
                auto& hCurrent2 = m_electricalData.harmonicCurrent[1][i];
                wxString i1, i2;
                i1.Printf(_("\nIh(%d)(%d-%d) = %.5e%s%.2f%s p.u."), m_electricalData.harmonicOrder[i], busNumber[0], busNumber[1], std::abs(hCurrent1), wxString(L'\u2220'), wxRadToDeg(std::arg(hCurrent1)), wxString(L'\u00B0'));
                i2.Printf(_("\nIh(%d)(%d-%d) = %.5e%s%.2f%s p.u."), m_electricalData.harmonicOrder[i], busNumber[1], busNumber[0], std::abs(hCurrent2), wxString(L'\u2220'), wxRadToDeg(std::arg(hCurrent2)), wxString(L'\u00B0'));
 
                tipText += i1 + i2;
                i++;
            }
        }
    }
 
    return tipText;
}

Here is the call graph for this function:

◆ Intersects()

bool Transformer::Intersects ( wxRect2DDouble rect ) const

virtual

Check if the element's rect intersects other rect.

Parameters

rect	Rect to check intersection.

Reimplemented from Branch.

Definition at line 486 of file Transformer.cpp.

{
    if (m_angle == 0.0 || m_angle == 180.0) return m_rect.Intersects(rect);
    return RotatedRectanglesIntersects(m_rect, rect, m_angle, 0.0);
}

Here is the call graph for this function:

◆ Move()

void Transformer::Move ( wxPoint2DDouble position )

virtual

Move the element other position.

Parameters

position Position that the element will be moved. Use StartMove(wxPoint2DDouble position) before start moving.

Reimplemented from Branch.

Definition at line 519 of file Transformer.cpp.

{
    SetPosition(m_movePos + position - m_moveStartPt);
 
    // Update terminals rigidly attached to transformer body at 40.0 units offset
    if (m_pointList.size() >= 4) {
        wxPoint2DDouble t1 = m_position + RotateLocal(wxPoint2DDouble(-40.0, 0.0), m_angle);
        wxPoint2DDouble t2 = m_position + RotateLocal(wxPoint2DDouble(40.0, 0.0), m_angle);
        m_pointList[2] = wxPoint2DDouble(std::round(t1.m_x), std::round(t1.m_y));
        m_pointList[3] = wxPoint2DDouble(std::round(t2.m_x), std::round(t2.m_y));
    }
 
    if (!m_parentList[0]) { m_pointList[0] = m_movePts[0] + position - m_moveStartPt; }
    if (!m_parentList[1]) {
        m_pointList[m_pointList.size() - 1] = m_movePts[m_pointList.size() - 1] + position - m_moveStartPt;
    }
 
    UpdateSwitchesPosition();
    UpdatePowerFlowArrowsPosition();
}

Here is the call graph for this function:

◆ MoveNode()

void Transformer::MoveNode	(	Element *	parent,
		wxPoint2DDouble	position
	)

virtual

Move a node. StartMove(wxPoint2DDouble position) before start moving.

Parameters

parent	Node's parent.
position	New node position.

Reimplemented from Branch.

Definition at line 656 of file Transformer.cpp.

{
    if (parent) {
        // First bus.
        if (parent == m_parentList[0]) {
            m_pointList[0] = m_movePts[0] + position - m_moveStartPt;
        }
        // Second bus.
        else if (parent == m_parentList[1]) {
            m_pointList[m_pointList.size() - 1] = m_movePts[m_pointList.size() - 1] + position - m_moveStartPt;
        }
    }
    else {
        if (m_activeNodeID == 1) {
            m_pointList[0] = m_movePts[0] + position - m_moveStartPt;
            if (m_parentList[0]) {
                m_parentList[0]->RemoveChild(this);
                m_parentList[0] = nullptr;
                m_online = false;
            }
        }
        else if (m_activeNodeID == 2) {
            m_pointList[m_pointList.size() - 1] = m_movePts[m_pointList.size() - 1] + position - m_moveStartPt;
            if (m_parentList[1]) {
                m_parentList[1]->RemoveChild(this);
                m_parentList[1] = nullptr;
                m_online = false;
            }
        }
    }
 
    // Recalculate switches positions
    UpdateSwitchesPosition();
    UpdatePowerFlowArrowsPosition();
}

◆ OpenElement()

bool Transformer::OpenElement	(	rapidxml::xml_node<> *	elementNode,
		std::vector< Element * >	parentList
	)

virtual

Reimplemented from PowerElement.

Definition at line 1183 of file Transformer.cpp.

{
    auto cadPropNode = elementNode->first_node("CADProperties");
    if (!cadPropNode) return false;
 
    auto position = cadPropNode->first_node("Position");
    double posX = XMLParser::GetNodeValueDouble(position, "X");
    double posY = XMLParser::GetNodeValueDouble(position, "Y");
    auto size = cadPropNode->first_node("Size");
    m_width = XMLParser::GetNodeValueDouble(size, "Width");
    m_height = XMLParser::GetNodeValueDouble(size, "Height");
    m_angle = XMLParser::GetNodeValueDouble(cadPropNode, "Angle");
 
    // Get nodes points
    std::vector<wxPoint2DDouble> ptsList;
    auto nodePosList = cadPropNode->first_node("NodeList");
    if (!nodePosList) return false;
    auto nodePos = nodePosList->first_node("Node");
    while (nodePos) {
        double nodePosX = XMLParser::GetNodeValueDouble(nodePos, "X");
        double nodePosY = XMLParser::GetNodeValueDouble(nodePos, "Y");
        ptsList.push_back(wxPoint2DDouble(nodePosX, nodePosY));
        nodePos = nodePos->next_sibling("Node");
    }
 
    // Get parents IDs
    auto parentIDList = cadPropNode->first_node("ParentIDList");
    if (!parentIDList) return false;
    auto parentNode = parentIDList->first_node("ParentID");
    long parentID[2] = { -1, -1 };
    while (parentNode) {
        long index = 0;
        wxString(parentNode->first_attribute("ID")->value()).ToLong(&index);
        wxString(parentNode->value()).ToCLong(&parentID[index]);
        parentNode = parentNode->next_sibling("ParentID");
    }
 
    std::vector<wxPoint2DDouble> nodePtsList;            // List of node points
    nodePtsList.push_back(ptsList[0]);                   // First point on the list
    nodePtsList.push_back(ptsList[ptsList.size() - 1]);  // Last point on the list
 
    // List of dummy buses to set not connected nodes properly
    std::vector<Bus*> dummyBusList;
    // Set parents (if have)
    for (unsigned int i = 0; i < 2; ++i) {
        if (parentID[i] == -1)  // No parent connected
        {
            Bus* dummyBus = new Bus(nodePtsList[i]);
            dummyBusList.push_back(dummyBus);
            AddParent(dummyBus, nodePtsList[i], true);
        }
        else {  // Parent connected (necessarily a bus, get from bus list)
            AddParent(parentList[parentID[i]], nodePtsList[i], true);
        }
    }
 
    StartMove(m_position);
    Move(wxPoint2DDouble(posX, posY));
 
    // Remove dummy buses
    for (auto it = dummyBusList.begin(), itEnd = dummyBusList.end(); it != itEnd; ++it) {
        RemoveParent(*it);
        delete* it;
    }
    dummyBusList.clear();
 
    // Set rotation properly.
    //int numRot = angle / GetRotationAngle();
    //bool clockwise = true;
    //if (numRot < 0) {
    //  numRot = std::abs(numRot);
    //  clockwise = false;
    //}
    //for (int i = 0; i < numRot; i++) Rotate(clockwise);
 
    auto electricalProp = elementNode->first_node("ElectricalProperties");
    if (!electricalProp) return false;
 
    SetOnline(XMLParser::GetNodeValueInt(electricalProp, "IsOnline"));
    m_electricalData.name = electricalProp->first_node("Name")->value();
    m_electricalData.primaryNominalVoltage = XMLParser::GetNodeValueDouble(electricalProp, "PrimaryNominalVoltage");
    m_electricalData.primaryNominalVoltageUnit =
        static_cast<ElectricalUnit>(XMLParser::GetAttributeValueInt(electricalProp, "PrimaryNominalVoltage", "UnitID"));
    m_electricalData.secondaryNominalVoltage = XMLParser::GetNodeValueDouble(electricalProp, "SecondaryNominalVoltage");
    m_electricalData.secondaryNominalVoltageUnit = static_cast<ElectricalUnit>(
        XMLParser::GetAttributeValueInt(electricalProp, "SecondaryNominalVoltage", "UnitID"));
    m_electricalData.nominalPower = XMLParser::GetNodeValueDouble(electricalProp, "NominalPower");
    m_electricalData.nominalPowerUnit =
        static_cast<ElectricalUnit>(XMLParser::GetAttributeValueInt(electricalProp, "NominalPower", "UnitID"));
    m_electricalData.resistance = XMLParser::GetNodeValueDouble(electricalProp, "Resistance");
    m_electricalData.resistanceUnit =
        static_cast<ElectricalUnit>(XMLParser::GetAttributeValueInt(electricalProp, "Resistance", "UnitID"));
    m_electricalData.indReactance = XMLParser::GetNodeValueDouble(electricalProp, "IndReactance");
    m_electricalData.indReactanceUnit =
        static_cast<ElectricalUnit>(XMLParser::GetAttributeValueInt(electricalProp, "IndReactance", "UnitID"));
    m_electricalData.connection = (TransformerConnection)XMLParser::GetNodeValueInt(electricalProp, "Connection");
    m_electricalData.turnsRatio = XMLParser::GetNodeValueDouble(electricalProp, "TurnsRatio");
    m_electricalData.phaseShift = XMLParser::GetNodeValueDouble(electricalProp, "PhaseShift");
    m_electricalData.useTransformerPower = XMLParser::GetNodeValueInt(electricalProp, "UseTransfomerPower");
 
    auto oltcNode = electricalProp->first_node("TapChanger");
    if (oltcNode) {
        m_electricalData.hasTapChanger = XMLParser::GetNodeValueInt(oltcNode, "Enabled") == 1;
        auto nomNode = oltcNode->first_node("NominalTurnsRatio");
        if (nomNode) wxString(nomNode->value()).ToCDouble(&m_electricalData.nominalTurnsRatio);
        else m_electricalData.nominalTurnsRatio = m_electricalData.turnsRatio;
        auto ctrlBusNode = oltcNode->first_node("ControlledBus");
        if (ctrlBusNode) {
            long cb = 1;
            wxString(ctrlBusNode->value()).ToCLong(&cb);
            m_electricalData.oltcControlledBus = (int)cb;
        }
        auto targetVNode = oltcNode->first_node("TargetVoltage");
        if (targetVNode) wxString(targetVNode->value()).ToCDouble(&m_electricalData.oltcTargetVoltage);
        auto deadbandNode = oltcNode->first_node("VoltageDeadband");
        if (deadbandNode) wxString(deadbandNode->value()).ToCDouble(&m_electricalData.oltcVoltageDeadband);
        auto minTapNode = oltcNode->first_node("MinTap");
        if (minTapNode) wxString(minTapNode->value()).ToCDouble(&m_electricalData.oltcMinTap);
        auto maxTapNode = oltcNode->first_node("MaxTap");
        if (maxTapNode) wxString(maxTapNode->value()).ToCDouble(&m_electricalData.oltcMaxTap);
        auto tapStepNode = oltcNode->first_node("TapStep");
        if (tapStepNode) wxString(tapStepNode->value()).ToCDouble(&m_electricalData.oltcTapStep);
        m_electricalData.oltcIsDiscrete = XMLParser::GetNodeValueInt(oltcNode, "IsDiscrete") == 1;
    }
    else {
        m_electricalData.hasTapChanger = false;
        m_electricalData.nominalTurnsRatio = m_electricalData.turnsRatio;
        m_electricalData.oltcControlledBus = 1;
        m_electricalData.oltcTargetVoltage = 1.0;
        m_electricalData.oltcVoltageDeadband = 0.005;
        m_electricalData.oltcMinTap = 0.90;
        m_electricalData.oltcMaxTap = 1.10;
        m_electricalData.oltcTapStep = 0.00625;
        m_electricalData.oltcIsDiscrete = false;
    }
 
    auto fault = electricalProp->first_node("Fault");
    m_electricalData.zeroResistance = XMLParser::GetNodeValueDouble(fault, "ZeroResistance");
    m_electricalData.zeroIndReactance = XMLParser::GetNodeValueDouble(fault, "ZeroIndReactance");
    m_electricalData.primaryGrndResistance = XMLParser::GetNodeValueDouble(fault, "PrimaryGrndResistance");
    m_electricalData.primaryGrndReactance = XMLParser::GetNodeValueDouble(fault, "PrimaryGrndReactance");
    m_electricalData.secondaryGrndResistance = XMLParser::GetNodeValueDouble(fault, "SecondaryGrndResistance");
    m_electricalData.secondaryGrndReactance = XMLParser::GetNodeValueDouble(fault, "SecondaryGrndReactance");
 
    if (!OpenSwitchingData(electricalProp)) return false;
    if (m_swData.swTime.size() != 0) SetDynamicEvent(true);
 
    return true;
}

◆ Rotate()

void Transformer::Rotate ( bool clockwise = true )

virtual

Rotate the element.

Parameters

clockwise True to rotate clockwise, false to rotate counter-clockwise.

Reimplemented from Element.

Definition at line 492 of file Transformer.cpp.

{
    double rotAngle = m_rotationAngle;
    if (!clockwise) rotAngle = -m_rotationAngle;
 
    m_angle += rotAngle;
    while (m_angle >= 360.0) m_angle -= 360.0;
    while (m_angle < 0.0) m_angle += 360.0;
 
    // Clean up floating point precision for cardinal angles
    if (std::abs(m_angle - 90.0) < 1e-4) m_angle = 90.0;
    else if (std::abs(m_angle - 180.0) < 1e-4) m_angle = 180.0;
    else if (std::abs(m_angle - 270.0) < 1e-4) m_angle = 270.0;
    else if (std::abs(m_angle - 0.0) < 1e-4 || std::abs(m_angle - 360.0) < 1e-4) m_angle = 0.0;
 
    // Update terminals rigidly attached to transformer body at 40.0 units offset
    if (m_pointList.size() >= 4) {
        wxPoint2DDouble t1 = m_position + RotateLocal(wxPoint2DDouble(-40.0, 0.0), m_angle);
        wxPoint2DDouble t2 = m_position + RotateLocal(wxPoint2DDouble(40.0, 0.0), m_angle);
        m_pointList[2] = wxPoint2DDouble(std::round(t1.m_x), std::round(t1.m_y));
        m_pointList[3] = wxPoint2DDouble(std::round(t2.m_x), std::round(t2.m_y));
    }
 
    UpdateSwitchesPosition();
    UpdatePowerFlowArrowsPosition();
}

◆ RotateNode()

void Transformer::RotateNode	(	Element *	parent,
		bool	clockwise
	)

virtual

Rotate a node.

Parameters

parent	Node's parent.
clockwise	True to rotate clockwise, false to rotate counter-clockwise.

Reimplemented from Branch.

Definition at line 778 of file Transformer.cpp.

{
    double rotAngle = m_rotationAngle;
    if (!clockwise) rotAngle = -m_rotationAngle;
 
    if (parent == m_parentList[0]) {
        m_pointList[0] = parent->RotateAtPosition(m_pointList[0], rotAngle);
    }
    else if (parent == m_parentList[1]) {
        m_pointList[m_pointList.size() - 1] = parent->RotateAtPosition(m_pointList[m_pointList.size() - 1], rotAngle);
    }
    UpdateSwitchesPosition();
    UpdatePowerFlowArrowsPosition();
}

Here is the call graph for this function:

◆ SaveElement()

rapidxml::xml_node * Transformer::SaveElement	(	rapidxml::xml_document<> &	doc,
		rapidxml::xml_node<> *	elementListNode
	)

virtual

Reimplemented from Element.

Definition at line 1074 of file Transformer.cpp.

{
    auto elementNode = XMLParser::AppendNode(doc, elementListNode, "Transfomer");
    XMLParser::SetNodeAttribute(doc, elementNode, "ID", m_elementID);
    auto cadProp = XMLParser::AppendNode(doc, elementNode, "CADProperties");
    auto position = XMLParser::AppendNode(doc, cadProp, "Position");
    auto posX = XMLParser::AppendNode(doc, position, "X");
    XMLParser::SetNodeValue(doc, posX, m_position.m_x);
    auto posY = XMLParser::AppendNode(doc, position, "Y");
    XMLParser::SetNodeValue(doc, posY, m_position.m_y);
    auto size = XMLParser::AppendNode(doc, cadProp, "Size");
    auto width = XMLParser::AppendNode(doc, size, "Width");
    XMLParser::SetNodeValue(doc, width, m_width);
    auto height = XMLParser::AppendNode(doc, size, "Height");
    XMLParser::SetNodeValue(doc, height, m_height);
    auto angle = XMLParser::AppendNode(doc, cadProp, "Angle");
    XMLParser::SetNodeValue(doc, angle, m_angle);
    auto nodeList = XMLParser::AppendNode(doc, cadProp, "NodeList");
    auto nodePos1 = XMLParser::AppendNode(doc, nodeList, "Node");
    XMLParser::SetNodeAttribute(doc, nodePos1, "ID", 0);
    auto nodePosX1 = XMLParser::AppendNode(doc, nodePos1, "X");
    XMLParser::SetNodeValue(doc, nodePosX1, m_pointList[0].m_x);
    auto nodePosY1 = XMLParser::AppendNode(doc, nodePos1, "Y");
    XMLParser::SetNodeValue(doc, nodePosY1, m_pointList[0].m_y);
    auto nodePos2 = XMLParser::AppendNode(doc, nodeList, "Node");
    XMLParser::SetNodeAttribute(doc, nodePos2, "ID", 1);
    auto nodePosX2 = XMLParser::AppendNode(doc, nodePos2, "X");
    XMLParser::SetNodeValue(doc, nodePosX2, m_pointList[m_pointList.size() - 1].m_x);
    auto nodePosY2 = XMLParser::AppendNode(doc, nodePos2, "Y");
    XMLParser::SetNodeValue(doc, nodePosY2, m_pointList[m_pointList.size() - 1].m_y);
 
    auto parentIDList = XMLParser::AppendNode(doc, cadProp, "ParentIDList");
    for (unsigned int i = 0; i < m_parentList.size(); i++) {
        Element* parent = m_parentList[i];
        if (parent) {
            auto parentID = XMLParser::AppendNode(doc, parentIDList, "ParentID");
            XMLParser::SetNodeAttribute(doc, parentID, "ID", static_cast<int>(i));
            XMLParser::SetNodeValue(doc, parentID, parent->GetID());
        }
    }
 
    auto electricalProp = XMLParser::AppendNode(doc, elementNode, "ElectricalProperties");
    auto isOnline = XMLParser::AppendNode(doc, electricalProp, "IsOnline");
    XMLParser::SetNodeValue(doc, isOnline, m_online);
    auto name = XMLParser::AppendNode(doc, electricalProp, "Name");
    XMLParser::SetNodeValue(doc, name, m_electricalData.name);
    auto primaryNominalVoltage = XMLParser::AppendNode(doc, electricalProp, "PrimaryNominalVoltage");
    XMLParser::SetNodeValue(doc, primaryNominalVoltage, m_electricalData.primaryNominalVoltage);
    XMLParser::SetNodeAttribute(doc, primaryNominalVoltage, "UnitID", static_cast<int>(m_electricalData.primaryNominalVoltageUnit));
    auto secondaryNominalVoltage = XMLParser::AppendNode(doc, electricalProp, "SecondaryNominalVoltage");
    XMLParser::SetNodeValue(doc, secondaryNominalVoltage, m_electricalData.secondaryNominalVoltage);
    XMLParser::SetNodeAttribute(doc, secondaryNominalVoltage, "UnitID", static_cast<int>(m_electricalData.secondaryNominalVoltageUnit));
    auto nominalPower = XMLParser::AppendNode(doc, electricalProp, "NominalPower");
    XMLParser::SetNodeValue(doc, nominalPower, m_electricalData.nominalPower);
    XMLParser::SetNodeAttribute(doc, nominalPower, "UnitID", static_cast<int>(m_electricalData.nominalPowerUnit));
    auto resistance = XMLParser::AppendNode(doc, electricalProp, "Resistance");
    XMLParser::SetNodeValue(doc, resistance, m_electricalData.resistance);
    XMLParser::SetNodeAttribute(doc, resistance, "UnitID", static_cast<int>(m_electricalData.resistanceUnit));
    auto indReactance = XMLParser::AppendNode(doc, electricalProp, "IndReactance");
    XMLParser::SetNodeValue(doc, indReactance, m_electricalData.indReactance);
    XMLParser::SetNodeAttribute(doc, indReactance, "UnitID", static_cast<int>(m_electricalData.indReactanceUnit));
    auto connection = XMLParser::AppendNode(doc, electricalProp, "Connection");
    XMLParser::SetNodeValue(doc, connection, m_electricalData.connection);
    auto turnsRatio = XMLParser::AppendNode(doc, electricalProp, "TurnsRatio");
    XMLParser::SetNodeValue(doc, turnsRatio, m_electricalData.turnsRatio);
    auto phaseShift = XMLParser::AppendNode(doc, electricalProp, "PhaseShift");
    XMLParser::SetNodeValue(doc, phaseShift, m_electricalData.phaseShift);
    auto useTransformerPower = XMLParser::AppendNode(doc, electricalProp, "UseTransfomerPower");
    XMLParser::SetNodeValue(doc, useTransformerPower, m_electricalData.useTransformerPower);
 
    auto oltcNode = XMLParser::AppendNode(doc, electricalProp, "TapChanger");
    auto hasTapChanger = XMLParser::AppendNode(doc, oltcNode, "Enabled");
    XMLParser::SetNodeValue(doc, hasTapChanger, m_electricalData.hasTapChanger ? 1 : 0);
    auto nominalTurnsRatio = XMLParser::AppendNode(doc, oltcNode, "NominalTurnsRatio");
    XMLParser::SetNodeValue(doc, nominalTurnsRatio, m_electricalData.nominalTurnsRatio);
    auto oltcControlledBus = XMLParser::AppendNode(doc, oltcNode, "ControlledBus");
    XMLParser::SetNodeValue(doc, oltcControlledBus, m_electricalData.oltcControlledBus);
    auto oltcTargetVoltage = XMLParser::AppendNode(doc, oltcNode, "TargetVoltage");
    XMLParser::SetNodeValue(doc, oltcTargetVoltage, m_electricalData.oltcTargetVoltage);
    auto oltcVoltageDeadband = XMLParser::AppendNode(doc, oltcNode, "VoltageDeadband");
    XMLParser::SetNodeValue(doc, oltcVoltageDeadband, m_electricalData.oltcVoltageDeadband);
    auto oltcMinTap = XMLParser::AppendNode(doc, oltcNode, "MinTap");
    XMLParser::SetNodeValue(doc, oltcMinTap, m_electricalData.oltcMinTap);
    auto oltcMaxTap = XMLParser::AppendNode(doc, oltcNode, "MaxTap");
    XMLParser::SetNodeValue(doc, oltcMaxTap, m_electricalData.oltcMaxTap);
    auto oltcTapStep = XMLParser::AppendNode(doc, oltcNode, "TapStep");
    XMLParser::SetNodeValue(doc, oltcTapStep, m_electricalData.oltcTapStep);
    auto oltcIsDiscrete = XMLParser::AppendNode(doc, oltcNode, "IsDiscrete");
    XMLParser::SetNodeValue(doc, oltcIsDiscrete, m_electricalData.oltcIsDiscrete ? 1 : 0);
 
    auto fault = XMLParser::AppendNode(doc, electricalProp, "Fault");
    auto zeroResistance = XMLParser::AppendNode(doc, fault, "ZeroResistance");
    XMLParser::SetNodeValue(doc, zeroResistance, m_electricalData.zeroResistance);
    auto zeroIndReactance = XMLParser::AppendNode(doc, fault, "ZeroIndReactance");
    XMLParser::SetNodeValue(doc, zeroIndReactance, m_electricalData.zeroIndReactance);
    auto primaryGrndResistance = XMLParser::AppendNode(doc, fault, "PrimaryGrndResistance");
    XMLParser::SetNodeValue(doc, primaryGrndResistance, m_electricalData.primaryGrndResistance);
    auto primaryGrndReactance = XMLParser::AppendNode(doc, fault, "PrimaryGrndReactance");
    XMLParser::SetNodeValue(doc, primaryGrndReactance, m_electricalData.primaryGrndReactance);
    auto secondaryGrndResistance = XMLParser::AppendNode(doc, fault, "SecondaryGrndResistance");
    XMLParser::SetNodeValue(doc, secondaryGrndResistance, m_electricalData.secondaryGrndResistance);
    auto secondaryGrndReactance = XMLParser::AppendNode(doc, fault, "SecondaryGrndReactance");
    XMLParser::SetNodeValue(doc, secondaryGrndReactance, m_electricalData.secondaryGrndReactance);
 
    SaveSwitchingData(doc, electricalProp);
 
    return elementNode;
}

◆ SetBestPositionAndRotation()

void Transformer::SetBestPositionAndRotation ( )

virtual

Definition at line 1333 of file Transformer.cpp.

{
    wxPoint2DDouble p1 = m_pointList[0];
    wxPoint2DDouble p2 = m_pointList[m_pointList.size() - 1];
    double dx = p2.m_x - p1.m_x;
    double dy = p2.m_y - p1.m_y;
 
    if (std::abs(dy) > std::abs(dx)) {
        m_angle = (dy >= 0.0) ? 90.0 : 270.0;
    }
    else {
        m_angle = (dx >= 0.0) ? 0.0 : 180.0;
    }
 
    wxPoint2DDouble mid = (p1 + p2) / 2.0;
    if (std::abs(dx) < 1.0) {
        mid.m_x = p1.m_x;
        mid.m_y = std::round(mid.m_y / 20.0) * 20.0;
    }
    else if (std::abs(dy) < 1.0) {
        mid.m_y = p1.m_y;
        mid.m_x = std::round(mid.m_x / 20.0) * 20.0;
    }
    else {
        mid.m_x = std::round(mid.m_x / 20.0) * 20.0;
        mid.m_y = std::round(mid.m_y / 20.0) * 20.0;
    }
 
    SetPosition(mid);
 
    if (m_parentList.size() > 0 && m_parentList[0] && m_parentList.size() > 1 && m_parentList[1]) {
        Element* bus1 = m_parentList[0];
        Element* bus2 = m_parentList[1];
        if (std::abs(dy) > std::abs(dx)) {
            wxPoint2DDouble loc1 = bus1->RotateAtPosition(wxPoint2DDouble(m_position.m_x, bus1->GetPosition().m_y), -bus1->GetAngle());
            wxPoint2DDouble loc2 = bus2->RotateAtPosition(wxPoint2DDouble(m_position.m_x, bus2->GetPosition().m_y), -bus2->GetAngle());
            double halfW1 = bus1->GetWidth() / 2.0 + 2.0;
            double halfW2 = bus2->GetWidth() / 2.0 + 2.0;
            if (std::abs(loc1.m_x - bus1->GetPosition().m_x) <= halfW1 &&
                std::abs(loc2.m_x - bus2->GetPosition().m_x) <= halfW2) {
                m_pointList[0].m_x = m_position.m_x;
                m_pointList.back().m_x = m_position.m_x;
            }
        }
        else {
            wxPoint2DDouble loc1 = bus1->RotateAtPosition(wxPoint2DDouble(bus1->GetPosition().m_x, m_position.m_y), -bus1->GetAngle());
            wxPoint2DDouble loc2 = bus2->RotateAtPosition(wxPoint2DDouble(bus2->GetPosition().m_x, m_position.m_y), -bus2->GetAngle());
            double halfW1 = bus1->GetWidth() / 2.0 + 2.0;
            double halfW2 = bus2->GetWidth() / 2.0 + 2.0;
            if (std::abs(loc1.m_x - bus1->GetPosition().m_x) <= halfW1 &&
                std::abs(loc2.m_x - bus2->GetPosition().m_x) <= halfW2) {
                m_pointList[0].m_y = m_position.m_y;
                m_pointList.back().m_y = m_position.m_y;
            }
        }
    }
 
    if (m_pointList.size() >= 4) {
        wxPoint2DDouble t1 = m_position + RotateLocal(wxPoint2DDouble(-40.0, 0.0), m_angle);
        wxPoint2DDouble t2 = m_position + RotateLocal(wxPoint2DDouble(40.0, 0.0), m_angle);
        m_pointList[2] = wxPoint2DDouble(std::round(t1.m_x), std::round(t1.m_y));
        m_pointList[3] = wxPoint2DDouble(std::round(t2.m_x), std::round(t2.m_y));
    }
    UpdateSwitchesPosition();
    UpdatePowerFlowArrowsPosition();
}

◆ SetElectricaData()

virtual void Transformer::SetElectricaData ( TransformerElectricalData electricalData )

inlinevirtual

Definition at line 123 of file Transformer.h.

123{ m_electricalData = electricalData; }

◆ SetNodeParent()

bool Transformer::SetNodeParent ( Element * parent )

virtual

Set a perent to the node. If all conditions are met, a new parent are added to the element and the points related to the nodes will be calculated.

Parameters

parent Node parent.

Returns: True if was possible to set the parent.

Reimplemented from Branch.

Definition at line 793 of file Transformer.cpp.

{
    if (m_activeNodeID == 1 && parent == m_parentList[0]) return false;
    if (m_activeNodeID == 2 && parent == m_parentList[1]) return false;
 
    if (parent && m_activeNodeID != 0) {
        wxRect2DDouble nodeRect(0, 0, 0, 0);
        if (m_activeNodeID == 1) {
            nodeRect = wxRect2DDouble(m_pointList[0].m_x - 5.0 - m_borderSize, m_pointList[0].m_y - 5.0 - m_borderSize,
                10 + 2.0 * m_borderSize, 10 + 2.0 * m_borderSize);
        }
        if (m_activeNodeID == 2) {
            nodeRect = wxRect2DDouble(m_pointList[m_pointList.size() - 1].m_x - 5.0 - m_borderSize,
                m_pointList[m_pointList.size() - 1].m_y - 5.0 - m_borderSize,
                10 + 2.0 * m_borderSize, 10 + 2.0 * m_borderSize);
        }
 
        if (parent->Intersects(nodeRect)) {
            if (m_activeNodeID == 1) {
                // Check if the user is trying to connect the same bus.
                if (m_parentList[1] == parent) {
                    m_activeNodeID = 0;
                    return false;
                }
 
                m_parentList[0] = parent;
 
                // Centralize the node on bus.
                wxPoint2DDouble parentPt = parent->RotateAtPosition(
                    m_pointList[0], -parent->GetAngle());  // Rotate click to horizontal position.
                parentPt.m_y = parent->GetPosition().m_y;  // Centralize on bus.
                parentPt = parent->RotateAtPosition(parentPt, parent->GetAngle());
                m_pointList[0] = parentPt;
 
                UpdateSwitchesPosition();
                UpdatePowerFlowArrowsPosition();
                return true;
            }
            if (m_activeNodeID == 2) {
                if (m_parentList[0] == parent) {
                    m_activeNodeID = 0;
                    return false;
                }
 
                m_parentList[1] = parent;
 
                wxPoint2DDouble parentPt =
                    parent->RotateAtPosition(m_pointList[m_pointList.size() - 1], -parent->GetAngle());
                parentPt.m_y = parent->GetPosition().m_y;
                parentPt = parent->RotateAtPosition(parentPt, parent->GetAngle());
                m_pointList[m_pointList.size() - 1] = parentPt;
 
                UpdateSwitchesPosition();
                UpdatePowerFlowArrowsPosition();
                return true;
            }
        }
        else {
            if (m_activeNodeID == 1) m_parentList[0] = nullptr;
            if (m_activeNodeID == 2) m_parentList[1] = nullptr;
        }
    }
    return false;
}

Here is the call graph for this function:

◆ SetNominalVoltage()

void Transformer::SetNominalVoltage	(	std::vector< double >	nominalVoltage,
		std::vector< ElectricalUnit >	nominalVoltageUnit
	)

virtual

Set nominal voltage of the element.

Parameters

nominalVoltage	Value of the nominal voltage.
nominalVoltageUnit	Unit of the nominal voltage.

Reimplemented from PowerElement.

Definition at line 745 of file Transformer.cpp.

{
    if (nominalVoltage.size() == 1) {
        m_electricalData.primaryNominalVoltage = nominalVoltage[0];
        m_electricalData.primaryNominalVoltageUnit = nominalVoltageUnit[0];
    }
    else if (nominalVoltage.size() == 2) {
        m_electricalData.primaryNominalVoltage = nominalVoltage[0];
        m_electricalData.primaryNominalVoltageUnit = nominalVoltageUnit[0];
        m_electricalData.secondaryNominalVoltage = nominalVoltage[1];
        m_electricalData.secondaryNominalVoltageUnit = nominalVoltageUnit[1];
    }
}

◆ SetPowerFlowDirection()

void Transformer::SetPowerFlowDirection ( PowerFlowDirection pfDirection )

virtual

Set the direction of the power flow.

Parameters

pfDirection Power flow direction.

Reimplemented from PowerElement.

Definition at line 858 of file Transformer.cpp.

{
    m_pfDirection = pfDirection;
    UpdatePowerFlowArrowsPosition();
}

Here is the caller graph for this function:

◆ ShowForm()

bool Transformer::ShowForm	(	wxWindow *	parent,
		Element *	element,
		wxWindow *	workspace = `nullptr`
	)

virtual

Show element data form.

Parameters

parent	Form parent
element	Element that will be edited.

Returns: True if the form is shown, false otherwise.

Reimplemented from Element.

Definition at line 735 of file Transformer.cpp.

{
    TransformerForm transfForm(parent, this);
    transfForm.CenterOnParent();
    if (transfForm.ShowModal() == wxID_OK) {
        return true;
    }
    return false;
}

◆ StartMove()

void Transformer::StartMove ( wxPoint2DDouble position )

virtual

Update the element attributes related to the movement.

Parameters

position Start move position.

Reimplemented from Branch.

Definition at line 692 of file Transformer.cpp.

{
    m_moveStartPt = position;
    m_movePts = m_pointList;
    m_movePos = m_position;
}

◆ UpdatePowerFlowArrowsPosition()

void Transformer::UpdatePowerFlowArrowsPosition ( )

protectedvirtual

Reimplemented from PowerElement.

Definition at line 759 of file Transformer.cpp.

{
    std::vector<wxPoint2DDouble> edges;
    switch (m_pfDirection) {
    case PowerFlowDirection::PF_NONE: {
        m_powerFlowArrow.clear();
    } break;
    case PowerFlowDirection::PF_BUS1_TO_BUS2: {
        for (int i = 1; i < (int)m_pointList.size() - 1; i++) { edges.push_back(m_pointList[i]); }
    } break;
    case PowerFlowDirection::PF_BUS2_TO_BUS1: {
        for (int i = (int)m_pointList.size() - 2; i > 0; i--) { edges.push_back(m_pointList[i]); }
    } break;
    default:
        break;
    }
    CalculatePowerFlowPts(edges);
}

Member Data Documentation

◆ m_electricalData

TransformerElectricalData Transformer::m_electricalData

protected

Definition at line 132 of file Transformer.h.

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

Project/elements/powerElement/Transformer.h
Project/elements/powerElement/Transformer.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Transformer() [1/2]

◆ Transformer() [2/2]

◆ ~Transformer()

Member Function Documentation

◆ AddParent()

◆ AlignToGrid()

◆ Contains()

◆ DrawDC() [1/2]

◆ DrawDC() [2/2]

◆ GetContextMenu()

◆ GetCopy()

◆ GetElectricalData()

◆ GetElectricalDataRef()

◆ GetPUElectricalData()

◆ GetTipText()

◆ Intersects()

◆ Move()

◆ MoveNode()

◆ OpenElement()

◆ Rotate()

◆ RotateNode()

◆ SaveElement()

◆ SetBestPositionAndRotation()

◆ SetElectricaData()

◆ SetNodeParent()

◆ SetNominalVoltage()

◆ SetPowerFlowDirection()

◆ ShowForm()

◆ StartMove()

◆ UpdatePowerFlowArrowsPosition()

Member Data Documentation

◆ m_electricalData