Bus Class Reference

Node for power elements. All others power elements are connected through this. More...

#include <Bus.h>

Inheritance diagram for Bus:

Collaboration diagram for Bus:

Public Member Functions
	Bus ()
	Default constructor.
	Bus (wxPoint2DDouble position)
	Contructor of a new Busbar.
	Bus (wxPoint2DDouble position, wxString name)
	Contructor of a new Busbar.
virtual Element *	GetCopy ()
	Get a the element copy.
virtual bool	AddParent (Element *parent, wxPoint2DDouble position, bool isOpening=false)
	Add a parent element to the Bus.
virtual bool	Contains (wxPoint2DDouble position) const
	Checks if the element contains a position.
virtual bool	Intersects (wxRect2DDouble rect) const
	Check if the element's rect intersects other rect.
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 void	Rotate (bool clockwise=true)
	Rotate the element.
virtual void	AlignToGrid (double gridSize=20.0) override
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 bool	GetContextMenu (wxMenu &menu)
	Get the element contex menu.
virtual wxString	GetTipText () const
	Get the tip text.
virtual wxColour	GetVoltageColour (GUIColour *guiColour=nullptr) const
virtual BusElectricalData	GetElectricalData () const
virtual BusElectricalData &	GetElectricalDataRef ()
virtual void	SetElectricalData (const BusElectricalData &electricalData)
virtual bool	ShowForm (wxWindow *parent, Element *element, wxWindow *workspace=nullptr)
	Show element data form.
virtual bool	GetPlotData (ElementPlotData &plotData, PlotStudy study=PlotStudy::STABILITY)
	Fill the plot data.
virtual rapidxml::xml_node *	SaveElement (rapidxml::xml_document<> &doc, rapidxml::xml_node<> *elementListNode)
virtual bool	OpenElement (rapidxml::xml_node<> *elementNode)
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	UpdateSwitches ()
	Update the switch position.
virtual void	UpdateSwitchesPosition ()
virtual void	UpdatePowerFlowArrowsPosition ()
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	SetNominalVoltage (std::vector< double > nominalVoltage, std::vector< ElectricalUnit > nominalVoltageUnit)
	Set nominal voltage of the element.
virtual void	SetSwitchingData (SwitchingData data)
	Set the switching data of the element.
virtual SwitchingData	GetSwitchingData ()
	Returns the switching data of the element.
virtual void	SetPowerFlowDirection (PowerFlowDirection pfDirection)
	Set the direction of the power flow.
virtual PowerFlowDirection	GetPowerFlowDirection () const
	Return the direction of the power flow.
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	OpenElement (rapidxml::xml_node<> *elementNode, std::vector< Element * > parentList)
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.
virtual void	AddPoint (wxPoint2DDouble point)
	Add point to the list of points that connect the element to the bus.
virtual void	StartMove (wxPoint2DDouble position)
	Update the element attributes related to the movement.
virtual void	Move (wxPoint2DDouble position)
	Move the element other position.
virtual void	MoveNode (Element *parent, wxPoint2DDouble position)
	Move a node. StartMove(wxPoint2DDouble position) before start moving.
virtual bool	NodeContains (wxPoint2DDouble position)
	Check if a node contains a point. If contains, set the attributes related to node movement.
virtual void	UpdateNodes ()
	Update the nodes according to the parents. If a parent is removed, use this method.
void	SetParent (Element *parent, int num)
void	SetChild (Element *child, int num)
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	RemoveParent (Element *parent)
	Remove a parent.
virtual void	ReplaceParent (Element *oldParent, Element *newParent)
	Replace a parent.
virtual void	RotateNode (Element *parent, bool clockwise=true)
	Rotate a node.
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.
void	SaveCADProperties (rapidxml::xml_document<> &doc, rapidxml::xml_node<> *elementNode)
bool	OpenCADProperties (rapidxml::xml_node<> *elementNode)

Protected Attributes
BusElectricalData	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

Node for power elements. All others power elements are connected through this.

Author

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

Date

06/10/2017

Definition at line 86 of file Bus.h.

Constructor & Destructor Documentation

Bus() [1/3]

Bus::Bus

(

)

Default constructor.

Definition at line 23 of file Bus.cpp.

: PowerElement() { m_elementType = TYPE_BUS; }

Here is the caller graph for this function:

Bus() [2/3]

Bus::Bus

(

wxPoint2DDouble

position

)

Contructor of a new Busbar.

Parameters

position

Position to be placed in Workspace.

Definition at line 24 of file Bus.cpp.

                                 : PowerElement()
{
    m_elementType = TYPE_BUS;
    m_width = 100.0;
    m_height = 5.0;
    SetPosition(position);
}

Here is the call graph for this function:

Bus() [3/3]

Bus::Bus	(	wxPoint2DDouble	position,
		wxString	name
	)

Contructor of a new Busbar.

Parameters

position	Position to be placed in Workspace.
name	Bus name

Definition at line 32 of file Bus.cpp.

{
    m_elementType = TYPE_BUS;
    m_width = 100.0;
    m_height = 5.0;
    SetPosition(position);
 
    m_electricalData.name = name;
}

Here is the call graph for this function:

~Bus()

Bus::~Bus

(

)

Definition at line 42 of file Bus.cpp.

{}

Member Function Documentation

AddParent()

virtual bool Bus::AddParent ( Element *  parent, wxPoint2DDouble  position, bool  isOpening = false  )

inlinevirtual

Add a parent element to the Bus.

Warning

Since the Bus is always a parent element, it doesn't make sense to add a parent to the bus. Therefore, this method will return true.

Parameters

parent	Parent element.
position	Position of the parent element.

Returns

True.

Reimplemented from Element.

Definition at line 117 of file Bus.h.

{ return true; }

AlignToGrid()

void Bus::AlignToGrid ( double  gridSize = 20.0 )

overridevirtual

Reimplemented from Element.

Definition at line 324 of file Bus.cpp.

{
    if (gridSize <= 0.0) gridSize = 20.0;
    wxPoint2DDouble newPos(std::round(m_position.m_x / gridSize) * gridSize,
                           std::round(m_position.m_y / gridSize) * gridSize);
    m_width = std::round(m_width / gridSize) * gridSize;
    if (m_width < gridSize) m_width = gridSize;
    SetPosition(newPos);
}

Contains()

bool Bus::Contains ( wxPoint2DDouble  position ) const

virtual

Checks if the element contains a position.

Parameters

position

Position to be checked.

Implements Element.

Definition at line 234 of file Bus.cpp.

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

Here is the call graph for this function:

DrawDC() [1/2]

void Bus::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 159 of file Bus.cpp.

{
    //wxPoint2DDouble gcPosition = m_position - wxPoint2DDouble(m_width / 2.0, m_height / 2.0);
    wxPoint2DDouble gcPosition = m_position;
 
    dc.SetPen(*wxTRANSPARENT_PEN);
 
    // Draw selection (layer 1)
    if (m_selected) {
        dc.SetBrush(wxBrush(guiColour->selection));
 
        wxPoint2DDouble pts[4] = { WorldToScreen(translation, scale, -(m_width / 2.0), -(m_height / 2.0)) -
                                      wxPoint2DDouble(m_borderSize, m_borderSize),
                                  WorldToScreen(translation, scale, -(m_width / 2.0), (m_height / 2.0)) -
                                      wxPoint2DDouble(m_borderSize, -m_borderSize),
                                  WorldToScreen(translation, scale, (m_width / 2.0), (m_height / 2.0)) -
                                      wxPoint2DDouble(-m_borderSize, -m_borderSize),
                                  WorldToScreen(translation, scale, (m_width / 2.0), -(m_height / 2.0)) -
                                      wxPoint2DDouble(-m_borderSize, m_borderSize) };
 
        DrawDCRectangle(gcPosition, m_width + 2 * m_borderSize, m_height + 2 * m_borderSize, m_angle, dc);
    }
 
 
    if (!m_electricalData.isConnected)
        dc.SetBrush(wxBrush(guiColour->disable));
    else if (m_dynEvent || m_electricalData.hasFault)
        dc.SetBrush(wxBrush(guiColour->eventElement));
    else
        dc.SetBrush(wxBrush(GetVoltageColour(guiColour)));
 
    DrawDCRectangle(gcPosition, m_width, m_height, m_angle, dc);
 
 
    // Draw faulted bus symbol (layer 4)
    if (m_electricalData.hasFault) {
 
        wxPoint2DDouble center = m_position;
        wxPoint2DDouble fsPosition = center + wxPoint2DDouble(m_width / 2.0, 0.0);
 
        wxColour faultSymbolColour(255, 0, 0, 255);
 
        double localScale = 1.5;
 
        dc.SetBrush(*wxRED_BRUSH);
        dc.SetPen(*wxTRANSPARENT_PEN);
        //gc->SetPen(*wxRED_PEN);
 
        wxPoint points[4];
 
        wxPoint2DDouble p;
 
        // Primeiro polígono
        p = wxPoint2DDouble(fsPosition.m_x + 1 * localScale, fsPosition.m_y + 3 * localScale);
        points[0] = RotateAround(p, center, m_angle);
        p = wxPoint2DDouble(fsPosition.m_x + 1 * localScale, fsPosition.m_y - 3 * localScale);
        points[1] = RotateAround(p, center, m_angle);
        p = wxPoint2DDouble(fsPosition.m_x + 11 * localScale, fsPosition.m_y - 1 * localScale);
        points[2] = RotateAround(p, center, m_angle);
        p = wxPoint2DDouble(fsPosition.m_x + 11 * localScale, fsPosition.m_y + 5 * localScale);
        points[3] = RotateAround(p, center, m_angle);
 
        dc.DrawPolygon(4, points);
 
        p = wxPoint2DDouble(fsPosition.m_x + 7 * localScale, fsPosition.m_y - 5 * localScale);
        points[0] = RotateAround(p, center, m_angle);
        p = wxPoint2DDouble(fsPosition.m_x + 21 * localScale, fsPosition.m_y + 3 * localScale);
        points[1] = RotateAround(p, center, m_angle);
        p = wxPoint2DDouble(fsPosition.m_x + 7 * localScale, fsPosition.m_y + 1 * localScale);
        points[2] = RotateAround(p, center, m_angle);
 
        dc.DrawPolygon(3, points);
    }
}

Here is the call graph for this function:

DrawDC() [2/2]

void Bus::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 44 of file Bus.cpp.

{
    wxPoint2DDouble gcPosition = m_position - wxPoint2DDouble(m_width / 2.0, m_height / 2.0);
    wxGraphicsMatrix identityMatrix = gc->GetTransform();
    identityMatrix.Set(); // Set to identity
 
    gc->SetPen(*wxTRANSPARENT_PEN);
 
    // Draw selection (layer 1)
    if (m_selected) {
        // If the object is selected, the matrix is reset to remove scale effects applied to it, thus keeping the
        // edges with fixed sizes for all zoom levels.
        gc->PushState();
        gc->SetTransform(identityMatrix);
        // The matrix was reset, so we must use screen coordinates (WorldToScreen).
        wxPoint2DDouble screenPt = WorldToScreen(translation, scale);
        gc->Translate(screenPt.m_x, screenPt.m_y);
        gc->Rotate(wxDegToRad(m_angle));
        gc->Translate(-screenPt.m_x, -screenPt.m_y);
 
        gc->SetBrush(wxBrush(guiColour->selection));
 
        wxPoint2DDouble pts[4] = { WorldToScreen(translation, scale, -(m_width / 2.0), -(m_height / 2.0)) -
                                      wxPoint2DDouble(m_borderSize, m_borderSize),
                                  WorldToScreen(translation, scale, -(m_width / 2.0), (m_height / 2.0)) -
                                      wxPoint2DDouble(m_borderSize, -m_borderSize),
                                  WorldToScreen(translation, scale, (m_width / 2.0), (m_height / 2.0)) -
                                      wxPoint2DDouble(-m_borderSize, -m_borderSize),
                                  WorldToScreen(translation, scale, (m_width / 2.0), -(m_height / 2.0)) -
                                      wxPoint2DDouble(-m_borderSize, m_borderSize) };
        gc->DrawLines(4, pts);
        gc->PopState();
    }
 
    gc->PushState();
    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);
 
 
    if (!m_electricalData.isConnected)
        gc->SetBrush(wxBrush(guiColour->disable));
    //else if (m_dynEvent)
    //  gc->SetBrush(wxBrush(guiColour->eventElement));
    else if (guiColour->useVoltageLevels)
        gc->SetBrush(wxBrush(GetVoltageColour(guiColour)));
    else
        gc->SetBrush(wxBrush(guiColour->bus));
 
    gc->DrawRectangle(gcPosition.m_x, gcPosition.m_y, m_width, m_height);
 
    gc->PopState();
 
    // Draw pickbox (layer 3)
    if (m_showPickbox) {
        gc->PushState();
        gc->SetTransform(identityMatrix);
 
        wxPoint2DDouble screenPt = WorldToScreen(translation, scale);
        gc->Translate(screenPt.m_x, screenPt.m_y);
        gc->Rotate(wxDegToRad(m_angle));
        gc->Translate(-screenPt.m_x, -screenPt.m_y);
 
        wxPoint2DDouble pbPosition[2] = { WorldToScreen(translation, scale, m_width / 2.0) - wxPoint2DDouble(4, 4),
                                         WorldToScreen(translation, scale, -m_width / 2.0) - wxPoint2DDouble(4, 4) };
        DrawDCPickbox(pbPosition[0], gc);
        DrawDCPickbox(pbPosition[1], gc);
 
        gc->PopState();
    }
 
    // Draw faulted bus symbol (layer 4)
    if (m_electricalData.hasFault) {
        gc->PushState();
        gc->SetTransform(identityMatrix);
 
        wxPoint2DDouble screenPt = WorldToScreen(translation, scale);
        gc->Translate(screenPt.m_x, screenPt.m_y);
        gc->Rotate(wxDegToRad(m_angle));
        gc->Translate(-screenPt.m_x, -screenPt.m_y);
 
        wxPoint2DDouble fsPosition = WorldToScreen(translation, scale, m_width / 2.0);
 
        wxColour faultSymbolColour(255, 0, 0, 255);
 
        double scale = 1.5;
 
        gc->SetBrush(*wxRED_BRUSH);
        gc->SetPen(*wxTRANSPARENT_PEN);
        //gc->SetPen(*wxRED_PEN);
 
        wxPoint2DDouble* points = new wxPoint2DDouble[4];
        points[0] = wxPoint2DDouble(fsPosition.m_x + 1 * scale, fsPosition.m_y + 3 * scale);
        points[1] = wxPoint2DDouble(fsPosition.m_x + 1 * scale, fsPosition.m_y - 3 * scale);
        points[2] = wxPoint2DDouble(fsPosition.m_x + 11 * scale, fsPosition.m_y - 1 * scale);
        points[3] = wxPoint2DDouble(fsPosition.m_x + 11 * scale, fsPosition.m_y + 5 * scale);
 
        gc->DrawLines(4, points);
 
        points[0] = wxPoint2DDouble(fsPosition.m_x + 7 * scale, fsPosition.m_y - 5 * scale);
        points[1] = wxPoint2DDouble(fsPosition.m_x + 21 * scale, fsPosition.m_y + 3 * scale);
        points[2] = wxPoint2DDouble(fsPosition.m_x + 7 * scale, fsPosition.m_y + 1 * scale);
 
        gc->DrawLines(3, points);
 
        delete[] points;
 
        gc->PopState();
    }
 
    if (m_dynEvent) {
        DrawStabilityEventGC(gc, translation, scale, guiColour, true);
    }
}

Here is the call graph for this function:

GetBestPickboxCursor()

wxCursor Bus::GetBestPickboxCursor ( ) const

virtual

Get the best cursor to shown to the user when the mouse is above a pickbox.

Returns

Cursor.

Reimplemented from Element.

Definition at line 271 of file Bus.cpp.

{
    double angle = m_angle;
    while (angle >= 157.5) angle -= 180.0;
 
    if (angle >= -22.5 && angle < 22.5)
        return wxCursor(wxCURSOR_SIZEWE);
    else if (angle >= 22.5 && angle < 67.5)
        return wxCursor(wxCURSOR_SIZENWSE);
    else if (angle >= 67.5 && angle < 112.5)
        return wxCursor(wxCURSOR_SIZENS);
    else if (angle >= 112.5 && angle < 157.5)
        return wxCursor(wxCURSOR_SIZENESW);
 
    return wxCursor(wxCURSOR_ARROW);
}

GetContextMenu()

bool Bus::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 Element.

Definition at line 334 of file Bus.cpp.

{
    menu.Append(ContextMenuID::ID_EDIT_ELEMENT, _("Edit bus"));
 
    wxMenu* textMenu = new wxMenu();
 
    textMenu->Append(ID_TXT_NAME, _("Name"));
    textMenu->Append(ID_TXT_VOLTAGE, _("Voltage"));
    textMenu->Append(ID_TXT_ANGLE, _("Angle"));
    textMenu->Append(ID_TXT_FAULTCURRENT, _("Fault current"));
    textMenu->Append(ID_TXT_FAULTVOLTAGE, _("Fault voltage"));
    textMenu->Append(ID_TXT_SCC, _("Short-circuit power"));
    textMenu->Append(ID_TXT_THD, _("Voltage THD"));
    textMenu->SetClientData(menu.GetClientData());
 
 
    menu.AppendSubMenu(textMenu, _("Add text"));
    GeneralMenuItens(menu);
    return true;
}

Here is the call graph for this function:

GetCopy()

Element * Bus::GetCopy ( )

virtual

Get a the element copy.

Returns

Copy of the element.

Reimplemented from Element.

Definition at line 365 of file Bus.cpp.

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

Here is the call graph for this function:

GetElectricalData()

virtual BusElectricalData Bus::GetElectricalData ( ) const

inlinevirtual

Definition at line 131 of file Bus.h.

{ return m_electricalData; }

GetElectricalDataRef()

virtual BusElectricalData & Bus::GetElectricalDataRef ( )

inlinevirtual

Definition at line 132 of file Bus.h.

{ return m_electricalData; }

GetPlotData()

bool Bus::GetPlotData ( ElementPlotData &  plotData, PlotStudy  study = PlotStudy::STABILITY  )

virtual

Fill the plot data.

Parameters

plotData

Plot data to be filled.

Returns

true if the plot data was successfully filled, false otherwise.

Reimplemented from PowerElement.

Definition at line 475 of file Bus.cpp.

{
    if (study == PlotStudy::STABILITY) {
        if (!m_electricalData.plotBus) return false;
        plotData.SetName(m_electricalData.name);
        plotData.SetCurveType(ElementPlotData::CurveType::CT_BUS);
 
        std::vector<double> absVoltage, argVoltage;
        for (unsigned int i = 0; i < m_electricalData.stabVoltageVector.size(); ++i) {
            absVoltage.push_back(std::abs(m_electricalData.stabVoltageVector[i]));
            argVoltage.push_back(wxRadToDeg(std::arg(m_electricalData.stabVoltageVector[i])));
        }
        plotData.AddData(absVoltage, _("Voltage"));
        plotData.AddData(argVoltage, _("Angle"));
        plotData.AddData(m_electricalData.stabFreqVector, _("Frequency"));
        return true;
    }
    else if (study == PlotStudy::FREQRESPONSE) {
        if (!m_electricalData.plotPQData) return false;
        plotData.SetName(m_electricalData.name);
        plotData.SetCurveType(ElementPlotData::CurveType::CT_BUS);
        plotData.AddData(m_electricalData.absImpedanceVector, _("Impedance"));
        const auto& z = m_electricalData.complexImpedanceVector;
        std::vector<double> r(z.size());
        std::vector<double> x(z.size());
        for (std::size_t i = 0; i < z.size(); ++i) {
            r[i] = z[i].real();
            x[i] = z[i].imag();
        }
        plotData.AddData(r, _("Resistance"));
        plotData.AddData(x, _("Reactance"));
        return true;
    }
    return false;
}

GetTipText()

wxString Bus::GetTipText ( ) const

virtual

Get the tip text.

Returns

Tip text.

Reimplemented from Element.

Definition at line 432 of file Bus.cpp.

{
    wxString tipText = m_electricalData.name;
    tipText += wxString::Format(" (%d)", m_electricalData.number + 1);
    tipText += "\n";
    tipText += StringFromDouble(m_electricalData.nominalVoltage, 1) +
        (m_electricalData.nominalVoltageUnit == ElectricalUnit::UNIT_V
            ? _(" V")
            : _(" kV"));
    tipText += "\n";
    tipText += _("\nV = ") + wxString::FromDouble(std::abs(m_electricalData.voltage), 5) + _(" p.u.");
    tipText += "\n";
    tipText += wxString(L'\u03B8') + " = " + wxString::FromDouble(wxRadToDeg(std::arg(m_electricalData.voltage)), 5)
        + wxString(L'\u00B0');
 
    tipText += _("\n\nFault info:");
    tipText += _("\nVa = ") + wxString::FromDouble(std::abs(m_electricalData.faultVoltage[0]), 5) + _(" p.u.");
    tipText += _("\nVb = ") + wxString::FromDouble(std::abs(m_electricalData.faultVoltage[1]), 5) + _(" p.u.");
    tipText += _("\nVc = ") + wxString::FromDouble(std::abs(m_electricalData.faultVoltage[2]), 5) + _(" p.u.");
    if (m_electricalData.hasFault) {
        tipText += _("\nIa = ") + wxString::FromDouble(std::abs(m_electricalData.faultCurrent[0]), 5) + _(" p.u.");
        tipText += _("\nIb = ") + wxString::FromDouble(std::abs(m_electricalData.faultCurrent[1]), 5) + _(" p.u.");
        tipText += _("\nIc = ") + wxString::FromDouble(std::abs(m_electricalData.faultCurrent[2]), 5) + _(" p.u.");
    }
 
    tipText += _("\n\nSsc = ") + wxString::FromDouble(std::abs(m_electricalData.scPower), 5) + _(" p.u.");
 
    wxString harmonicsInfo = _("\n\nHarmonics info:");
    bool hasHarmonics = false;
    harmonicsInfo += _("\nTHD = ") + wxString::FromDouble(std::abs(m_electricalData.thd), 5) + wxT("%");
    int i = 0;
    for (auto& hVoltage : m_electricalData.harmonicVoltage) {
        hasHarmonics = true;
        wxString hVoltageStr;
        hVoltageStr.Printf(_("\nVh(%d) = %.5e%s%.2f%s p.u."), m_electricalData.harmonicOrder[i], std::abs(hVoltage), wxString(L'\u2220'), wxRadToDeg(std::arg(hVoltage)), wxString(L'\u00B0'));
        harmonicsInfo += hVoltageStr;
        i++;
    }
    if (hasHarmonics) tipText += harmonicsInfo;
 
    return tipText;
}

Here is the call graph for this function:

GetVoltageColour()

wxColour Bus::GetVoltageColour ( GUIColour *  guiColour = nullptr ) const

virtual

Definition at line 372 of file Bus.cpp.

{
    double v_kV = m_electricalData.nominalVoltage;
    if (m_electricalData.nominalVoltageUnit == ElectricalUnit::UNIT_V) {
        v_kV /= 1000.0;
    }
 
    const std::vector<VoltageLevelColour>* levels = nullptr;
    if (guiColour && !guiColour->voltageLevels.empty()) {
        levels = &guiColour->voltageLevels;
    }
 
    if (levels && !levels->empty()) {
        // 1. Find closest configured level within 15% tolerance
        double minDiff = 1e9;
        int bestIdx = -1;
        for (size_t i = 0; i < levels->size(); ++i) {
            double diff = std::abs(v_kV - (*levels)[i].voltage);
            if (diff < minDiff) {
                minDiff = diff;
                bestIdx = static_cast<int>(i);
            }
        }
 
        if (bestIdx >= 0) {
            double tol = std::max((*levels)[bestIdx].voltage * 0.15, 0.5);
            if (minDiff <= tol) {
                return (*levels)[bestIdx].colour;
            }
            // 2. Range match (assuming ordered descending)
            for (size_t i = 0; i < levels->size(); ++i) {
                if (v_kV >= (*levels)[i].voltage * 0.9) {
                    return (*levels)[i].colour;
                }
            }
            return levels->back().colour;
        }
    }
 
    if (v_kV >= 500.0) {
        return wxColour(0, 90, 220);     // >= 500 kV (ex: 500 kV, 765 kV) - Royal Blue
    } else if (v_kV >= 300.0) {
        return wxColour(160, 82, 45);    // 300 kV - 500 kV (ex: 345 kV, 440 kV) - Brown
    } else if (v_kV >= 200.0) {
        return wxColour(220, 35, 35);    // 200 kV - 300 kV (ex: 230 kV) - Red
    } else if (v_kV >= 100.0) {
        return wxColour(0, 155, 65);     // 100 kV - 200 kV (ex: 138 kV, 161 kV) - Green
    } else if (v_kV >= 50.0) {
        return wxColour(145, 40, 205);   // 50 kV - 100 kV (ex: 69 kV, 88 kV) - Violet / Purple
    } else if (v_kV >= 20.0) {
        return wxColour(215, 35, 135);   // 20 kV - 50 kV (ex: 34.5 kV) - Magenta / Pink
    } else if (v_kV >= 10.0) {
        return wxColour(0, 165, 195);    // 10 kV - 20 kV (ex: 13.8 kV, 18 kV) - Cyan / Teal
    } else if (v_kV >= 1.0) {
        return wxColour(205, 150, 15);   // 1 kV - 10 kV (ex: 2.4 kV, 4.16 kV, 6.9 kV) - Gold / Amber
    } else {
        return wxColour(120, 125, 135);  // < 1 kV (220 V, 380 V, 440 V) - Slate Gray
    }
}

Intersects()

bool Bus::Intersects ( wxRect2DDouble  rect ) const

virtual

Check if the element's rect intersects other rect.

Parameters

rect	Rect to check intersection.

Implements Element.

Definition at line 240 of file Bus.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:

MovePickbox()

void Bus::MovePickbox ( wxPoint2DDouble  position )

virtual

Move the pickbox.

Parameters

position

position that the pickbox will be moved.

Reimplemented from Element.

Definition at line 288 of file Bus.cpp.

{
    if (m_activePickboxID == ID_PB_NONE) return;
 
    wxPoint2DDouble ptR = RotateAtPosition(position, -m_angle);
 
    double dx = 0.0;
    if (m_activePickboxID == ID_PB_RIGHT)
        dx = ptR.m_x - m_position.m_x - m_width / 2.0;
    else if (m_activePickboxID == ID_PB_LEFT)
        dx = m_position.m_x - m_width / 2.0 - ptR.m_x;
 
    if (m_width + dx < 20.0) return;
 
    if (m_activePickboxID == ID_PB_RIGHT) {
        m_position.m_x += (dx / 2.0) * std::cos(wxDegToRad(m_angle));
        m_position.m_y += (dx / 2.0) * std::sin(wxDegToRad(m_angle));
    }
    else if (m_activePickboxID == ID_PB_LEFT) {
        m_position.m_x -= (dx / 2.0) * std::cos(wxDegToRad(m_angle));
        m_position.m_y -= (dx / 2.0) * std::sin(wxDegToRad(m_angle));
    }
    m_width += dx;
 
    SetPosition(m_position);
}

Here is the call graph for this function:

OpenElement()

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

virtual

Reimplemented from Element.

Definition at line 567 of file Bus.cpp.

{
    if (!Element::OpenCADProperties(elementNode)) return false;
 
    auto electricalProp = elementNode->first_node("ElectricalProperties");
    if (!electricalProp) return false;
 
    m_electricalData.name = electricalProp->first_node("Name")->value();
    m_electricalData.nominalVoltage = XMLParser::GetNodeValueDouble(electricalProp, "NominalVoltage");
    m_electricalData.nominalVoltageUnit =
        (ElectricalUnit)XMLParser::GetAttributeValueInt(electricalProp, "NominalVoltage", "UnitID");
    m_electricalData.isVoltageControlled = XMLParser::GetNodeValueInt(electricalProp, "IsVoltageControlled");
    m_electricalData.controlledVoltage = XMLParser::GetNodeValueDouble(electricalProp, "ControlledVoltage");
    m_electricalData.controlledVoltageUnitChoice =
        XMLParser::GetAttributeValueInt(electricalProp, "ControlledVoltage", "Choice");
    m_electricalData.slackBus = XMLParser::GetNodeValueInt(electricalProp, "SlackBus");
    auto fault = electricalProp->first_node("Fault");
    m_electricalData.hasFault = XMLParser::GetNodeValueInt(fault, "HasFault");
    m_electricalData.faultType = (FaultData)XMLParser::GetNodeValueInt(fault, "Type");
    m_electricalData.faultLocation = (FaultData)XMLParser::GetNodeValueInt(fault, "Location");
    m_electricalData.faultResistance = XMLParser::GetNodeValueDouble(fault, "Resistance");
    m_electricalData.faultReactance = XMLParser::GetNodeValueDouble(fault, "Reactance");
    auto stability = electricalProp->first_node("Stability");
    m_electricalData.plotBus = XMLParser::GetNodeValueInt(stability, "Plot");
    m_electricalData.stabHasFault = XMLParser::GetNodeValueInt(stability, "HasFault");
    m_electricalData.stabFaultTime = XMLParser::GetNodeValueDouble(stability, "FaultTime");
    m_electricalData.stabFaultLength = XMLParser::GetNodeValueDouble(stability, "FaultLength");
    m_electricalData.stabFaultResistance = XMLParser::GetNodeValueDouble(stability, "FaultResistance");
    m_electricalData.stabFaultReactance = XMLParser::GetNodeValueDouble(stability, "FaultReactance");
 
    auto powerQuality = electricalProp->first_node("PowerQuality");
    if (powerQuality) m_electricalData.plotPQData = XMLParser::GetNodeValueInt(powerQuality, "Plot");
 
    if (m_electricalData.stabHasFault) SetDynamicEvent(true);
    SetInserted();
    return true;
}

PickboxContains()

bool Bus::PickboxContains ( wxPoint2DDouble  position )

virtual

Check if a pickbox contains a point. If contains the attributes related to pickbox movement will be calculated.

Parameters

position

Position to be checked.

Returns

True if the element constains the pickbox, false otherwise.

Reimplemented from Element.

Definition at line 247 of file Bus.cpp.

{
    m_activePickboxID = ID_PB_NONE;
 
    wxPoint2DDouble ptR = RotateAtPosition(position, -m_angle);
 
    wxPoint2DDouble center(m_position.m_x + m_width / 2.0, m_position.m_y);
    wxRect2DDouble rectRight(center.m_x - 5.0, center.m_y - 5.0, 10.0, 10.0);
 
    center = wxPoint2DDouble(m_position.m_x - m_width / 2.0, m_position.m_y);
    wxRect2DDouble rectLeft(center.m_x - 5.0, center.m_y - 5.0, 10.0, 10.0);
 
    if (rectRight.Contains(ptR)) {
        m_activePickboxID = ID_PB_RIGHT;
        return true;
    }
    if (rectLeft.Contains(ptR)) {
        m_activePickboxID = ID_PB_LEFT;
        return true;
    }
 
    return false;
}

Here is the call graph for this function:

Rotate()

void Bus::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 315 of file Bus.cpp.

{
    double rotAngle = m_rotationAngle;
    if (!clockwise) rotAngle = -m_rotationAngle;
 
    m_angle += rotAngle;
    if (m_angle >= 360 || m_angle <= -360) m_angle = 0.0;
}

SaveElement()

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

virtual

Reimplemented from Element.

Definition at line 511 of file Bus.cpp.

{
    m_electricalData.number = m_elementID;
 
    auto elementNode = XMLParser::AppendNode(doc, elementListNode, "Bus");
    XMLParser::SetNodeAttribute(doc, elementNode, "ID", m_elementID);
 
    Element::SaveCADProperties(doc, elementNode);
 
    auto electricalProp = XMLParser::AppendNode(doc, elementNode, "ElectricalProperties");
    auto name = XMLParser::AppendNode(doc, electricalProp, "Name");
    XMLParser::SetNodeValue(doc, name, m_electricalData.name);
    auto nominalVoltage = XMLParser::AppendNode(doc, electricalProp, "NominalVoltage");
    XMLParser::SetNodeValue(doc, nominalVoltage, m_electricalData.nominalVoltage);
    XMLParser::SetNodeAttribute(doc, nominalVoltage, "UnitID", static_cast<int>(m_electricalData.nominalVoltageUnit));
    auto isVoltageControlled = XMLParser::AppendNode(doc, electricalProp, "IsVoltageControlled");
    XMLParser::SetNodeValue(doc, isVoltageControlled, m_electricalData.isVoltageControlled);
    auto controlledVoltage = XMLParser::AppendNode(doc, electricalProp, "ControlledVoltage");
    XMLParser::SetNodeValue(doc, controlledVoltage, m_electricalData.controlledVoltage);
    XMLParser::SetNodeAttribute(doc, controlledVoltage, "Choice", m_electricalData.controlledVoltageUnitChoice);
    auto slackBus = XMLParser::AppendNode(doc, electricalProp, "SlackBus");
    XMLParser::SetNodeValue(doc, slackBus, m_electricalData.slackBus);
 
    auto fault = XMLParser::AppendNode(doc, electricalProp, "Fault");
    auto hasFault = XMLParser::AppendNode(doc, fault, "HasFault");
    XMLParser::SetNodeValue(doc, hasFault, m_electricalData.hasFault);
    auto faultType = XMLParser::AppendNode(doc, fault, "Type");
    XMLParser::SetNodeValue(doc, faultType, static_cast<int>(m_electricalData.faultType));
    auto faultLocation = XMLParser::AppendNode(doc, fault, "Location");
    XMLParser::SetNodeValue(doc, faultLocation, static_cast<int>(m_electricalData.faultLocation));
    auto faultResistance = XMLParser::AppendNode(doc, fault, "Resistance");
    XMLParser::SetNodeValue(doc, faultResistance, m_electricalData.faultResistance);
    auto faultReactance = XMLParser::AppendNode(doc, fault, "Reactance");
    XMLParser::SetNodeValue(doc, faultReactance, m_electricalData.faultReactance);
 
    auto stability = XMLParser::AppendNode(doc, electricalProp, "Stability");
    auto plotBus = XMLParser::AppendNode(doc, stability, "Plot");
    XMLParser::SetNodeValue(doc, plotBus, m_electricalData.plotBus);
    auto stabHasFault = XMLParser::AppendNode(doc, stability, "HasFault");
    XMLParser::SetNodeValue(doc, stabHasFault, m_electricalData.stabHasFault);
    auto stabFaultTime = XMLParser::AppendNode(doc, stability, "FaultTime");
    XMLParser::SetNodeValue(doc, stabFaultTime, m_electricalData.stabFaultTime);
    auto stabFaultLength = XMLParser::AppendNode(doc, stability, "FaultLength");
    XMLParser::SetNodeValue(doc, stabFaultLength, m_electricalData.stabFaultLength);
    auto stabFaultResistance = XMLParser::AppendNode(doc, stability, "FaultResistance");
    XMLParser::SetNodeValue(doc, stabFaultResistance, m_electricalData.stabFaultResistance);
    auto stabFaultReactance = XMLParser::AppendNode(doc, stability, "FaultReactance");
    XMLParser::SetNodeValue(doc, stabFaultReactance, m_electricalData.stabFaultReactance);
 
    auto powerQuality = XMLParser::AppendNode(doc, electricalProp, "PowerQuality");
    auto plotPQData = XMLParser::AppendNode(doc, powerQuality, "Plot");
    XMLParser::SetNodeValue(doc, plotPQData, m_electricalData.plotPQData);
 
    return elementNode;
}

SetElectricalData()

virtual void Bus::SetElectricalData ( const BusElectricalData &  electricalData )

inlinevirtual

Definition at line 133 of file Bus.h.

{ m_electricalData = electricalData; }

ShowForm()

bool Bus::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 355 of file Bus.cpp.

{
    BusForm busForm(parent, this);
    busForm.CentreOnParent();
    if (busForm.ShowModal() == wxID_OK) {
        return true;
    }
    return false;
}

Member Data Documentation

m_electricalData

BusElectricalData Bus::m_electricalData

protected

Definition at line 141 of file Bus.h.

---

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

• Project/elements/powerElement/Bus.h
• Project/elements/powerElement/Bus.cpp