Element to connect ATP-EMTP. More...

#include <EMTElement.h>

Inheritance diagram for EMTElement:

[legend]

Collaboration diagram for EMTElement:

[legend]

Public Member Functions
	EMTElement (wxString name)

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

virtual bool	AddParent (Element *parent, wxPoint2DDouble position)
	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 void	DrawDC (wxPoint2DDouble translation, double scale, wxGraphicsContext *gc) const
	Draw the element using GDI+.

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

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	Rotate (bool clockwise=true)
	Rotate the element.

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

virtual wxString	GetTipText () const
	Get the tip text.

virtual bool	ShowForm (wxWindow parent, Element element)
	Show element data form.

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

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

virtual EMTElementData	GetEMTElementData ()

virtual void	SetEMTElementData (EMTElementData data)

wxArrayString	GetATPNodes (wxArrayString atpFile)

bool	SetATPParameter (wxTextFile &atpFile, const wxString &card, const int &line, const int &initPos, const int &size, const wxString &value)

bool	AddConnectionToNode (wxTextFile &atpFile, const wxString &node)

std::vector< double >	MedianFilter (const std::vector< double > &data)

bool	CalculateCurrent (wxString &errorMsg, const bool &saveFFTData=false)

void	UpdateData (const PropertiesData *properties=nullptr, bool updateVoltageBase=false)

Public Member Functions inherited from Shunt
virtual void	Move (wxPoint2DDouble position)
	Move the element other position.

virtual void	MoveNode (Element *element, 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 void	RotateNode (Element *parent, bool clockwise=true)
	Rotate a node.

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

virtual bool	NodeContains (wxPoint2DDouble position)
	Check if a node contains a point. If contains, set the attributes related to node movement.

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	UpdateNodes ()
	Update the nodes according to the parents. If a parent is removed, use this method.

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	DrawDCSwitches (wxGraphicsContext *gc) const
	Draw switch.

virtual void	DrawDCSwitches (wxDC &dc) const

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

virtual void	DrawDCPowerFlowPts (wxGraphicsContext *gc) const
	Draw power flow arrows.

virtual void	DrawDCPowerFlowPts (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	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)

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 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.

void	SetParent (Element *parent, int num)

void	SetChild (Element *child, int num)

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

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	MovePickbox (wxPoint2DDouble position)
	Move the pickbox.

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

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	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 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
std::vector< double >	DoMedianFilter (double *extension, std::vector< double > &result, const int &n)

Protected Member Functions inherited from Shunt
void	UpdateSwitchesPosition ()

void	UpdatePowerFlowArrowsPosition ()

void	DrawDCGround (wxPoint2DDouble position, wxGraphicsContext *gc) const

void	DrawDCGround (wxPoint2DDouble position, wxDC &dc) const

Protected Attributes
EMTElementData	m_data

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

wxColour	m_selectionColour

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

Element to connect ATP-EMTP.

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

Date: 01/07/2024

Definition at line 64 of file EMTElement.h.

Constructor & Destructor Documentation

◆ EMTElement() [1/2]

EMTElement::EMTElement ( )

Definition at line 15 of file EMTElement.cpp.

16{

17}

◆ EMTElement() [2/2]

EMTElement::EMTElement ( wxString name )

Definition at line 19 of file EMTElement.cpp.

{
    m_data.name = name;
}

◆ ~EMTElement()

EMTElement::~EMTElement ( )

Definition at line 24 of file EMTElement.cpp.

25{

26}

Member Function Documentation

◆ AddConnectionToNode()

bool EMTElement::AddConnectionToNode	(	wxTextFile &	atpFile,
		const wxString &	node
	)

Definition at line 432 of file EMTElement.cpp.

{
    // Get connnected bus data
    bool hasBusData = false;
    BusElectricalData busData;
    if (!m_parentList.empty()) {
        if (m_parentList[0] != nullptr) {
            Bus* bus = static_cast<Bus*>(m_parentList[0]);
            busData = bus->GetElectricalData();
            hasBusData = true;
        }
    }
 
    wxString switchMask = "  PSPNC%c%s%c                                        MEASURING                %d";
    wxString sourceMask = "14PSPNC%c  %s%s%s                           -1.      100.";
    wxString lineStr = "";
    int outCardPos = -1, switchCardPos = -1, sourceCardPos = -1;
    lineStr = atpFile.GetFirstLine();
    while (!atpFile.Eof())
    {
        if (lineStr.IsEmpty()) {
            lineStr = atpFile.GetNextLine();
            continue;
        }
        if (tolower(lineStr[0]) == 'c') {
            lineStr = atpFile.GetNextLine();
            continue; // Skip comments
        }
 
        if (lineStr.Find("/SWITCH") != wxNOT_FOUND)
            switchCardPos = atpFile.GetCurrentLine() + 1;
 
        if (lineStr.Find("/SOURCE") != wxNOT_FOUND)
            sourceCardPos = atpFile.GetCurrentLine() + 1;
 
        if (lineStr.Find("/OUTPUT") != wxNOT_FOUND)
            outCardPos = atpFile.GetCurrentLine();
 
        lineStr = atpFile.GetNextLine();
    }
 
    if (outCardPos < 0) return false;
 
    if (switchCardPos < 0 && outCardPos > 0) {
        atpFile.InsertLine("/SWITCH", outCardPos);
        switchCardPos = outCardPos + 1;
    }
 
    if (sourceCardPos < 0 && outCardPos > 0) {
        atpFile.InsertLine("/SOURCE", outCardPos);
        sourceCardPos = outCardPos + 1;
    }
 
    for (char i = 'A'; i <= 'C'; ++i) {
        lineStr = wxString::Format(switchMask, i, node, i, i == 'A' ? 1 : 0);
        atpFile.InsertLine(lineStr, switchCardPos + (i - 'A'));
    }
    sourceCardPos += 3;
 
    double voltage = std::abs(m_data.puVoltage) * m_data.baseVoltage * (std::sqrt(2) / std::sqrt(3)); // phase-ground, peak value
    wxString ampl = wxString::FromCDouble(voltage, 3); // Amplitude in pu
    wxString freq = wxString::FromCDouble(m_data.frequency, 5); // Frequency in Hz
    // Insert spaces before to complete 10 characters
    while (freq.Length() < 10) freq = " " + freq;
    while (ampl.Length() < 10) ampl = " " + ampl;
 
    int cardPos = sourceCardPos;
    for (char i = 'A'; i <= 'C'; ++i) {
        wxString angle = wxString::FromCDouble(std::arg(m_data.puVoltage) * 180.0 / M_PI - 120.0 * (i - 'A'), 5); // Angle in degrees
 
        // Insert spaces before to complete 10 characters
        while (angle.Length() < 10) angle = " " + angle;
 
        lineStr = wxString::Format(sourceMask, i, ampl, freq, angle);
        atpFile.InsertLine(lineStr, cardPos);
        cardPos++;
 
        if (hasBusData) {
            // Insert harmonic voltage
            for (size_t j = 0; j < busData.harmonicOrder.size(); ++j) {
                int order = busData.harmonicOrder[j];
                if (order == 1) continue; // Skip fundamental
 
                std::complex<double> harmVoltage = busData.harmonicVoltage[j];
 
                voltage = std::abs(busData.harmonicVoltage[j]) * m_data.baseVoltage * (std::sqrt(2) / std::sqrt(3));
                wxString amplH = wxString::FromCDouble(voltage, 3);
                while (amplH.Length() < 10) amplH = " " + amplH;
 
                wxString freqH = wxString::FromCDouble(m_data.frequency * static_cast<double>(order), 5);
                while (freqH.Length() < 10) freqH = " " + freqH;
 
                double angleValue = std::arg(harmVoltage) * 180.0 / M_PI;
                if (order % 3 == 1) { // Positive sequence
                    angleValue += -120.0 * (i - 'A');
                }
                else if (order % 3 == 2) { // Negative sequence
                    angleValue += 120.0 * (i - 'A');
                }
                // Zero sequence doesn't change the angle because it's the same for all phases
 
                wxString angleH = wxString::FromCDouble(angleValue, 5);
                while (angleH.Length() < 10) angleH = " " + angleH;
 
                lineStr = wxString::Format(sourceMask, i, amplH, freqH, angleH);
                atpFile.InsertLine(lineStr, cardPos);
                cardPos++;
            }
        }
    }
 
    return true;
}

◆ AddParent()

bool EMTElement::AddParent	(	Element *	parent,
		wxPoint2DDouble	position
	)

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 35 of file EMTElement.cpp.

{
    if (parent) {
        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_position = parentPt + wxPoint2DDouble(0.0, 100.0);  // Shifts the position to the down of the bus.
        m_width = 50;
        m_height = 50;
        m_rect = wxRect2DDouble(m_position.m_x - m_width / 2.0, m_position.m_y - m_height / 2.0, m_width, m_height);
 
        m_pointList.push_back(parentPt);
        m_pointList.push_back(GetSwitchPoint(parent, parentPt, m_position));
        m_pointList.push_back(m_position + wxPoint2DDouble(0.0, -m_height / 2.0 - 10.0));
        m_pointList.push_back(m_position + wxPoint2DDouble(0.0, -m_height / 2.0));
 
        m_inserted = true;
 
        wxRect2DDouble genRect(0, 0, 0, 0);
        m_switchRect.push_back(genRect);  // Push a general rectangle.
        UpdateSwitches();
 
        // Base data
        auto data = static_cast<Bus*>(parent)->GetElectricalData();
        m_data.puVoltage = data.voltage;
        m_data.baseVoltage = GetValueFromUnit(data.nominalVoltage, data.nominalVoltageUnit);
        m_data.frequency = data.stabFreq;
 
        return true;
    }
    return false;
}

Here is the call graph for this function:

◆ CalculateCurrent()

bool EMTElement::CalculateCurrent	(	wxString &	errorMsg,
		const bool &	saveFFTData = `false`
	)

Definition at line 582 of file EMTElement.cpp.

{
    wxFileName fileName(m_data.atpFile);
    if (!fileName.IsOk()) {
        errorMsg = wxString::Format(_("Invalid ATP file path for the electromagnetic element \"%s\"."), m_data.name);
        return false;
    }
 
    //double fundFreq = properties.GetSimulationPropertiesData().stabilityFrequency;
    double fundFreq = m_data.frequency;
    double timeSim = (1.0 / fundFreq) * static_cast<double>(m_data.cyclesToSS);
 
    //wxString atpFolder = properties.GetGeneralPropertiesData().atpPath.GetPath();
    wxString atpFolder = m_data.atpPath.GetPath();
    // Set fundamental frequency to EMT element
    //m_data.frequency = fundFreq;
 
    wxExecuteEnv env;
    env.cwd = atpFolder;
 
    // Save the ATP file in ATP work folder
    wxTextFile origFile(m_data.atpFile.GetFullPath());
    //fileName.SetPath(properties.GetGeneralPropertiesData().atpWorkFolder);
    fileName.SetPath(m_data.atpWorkFolder);
    wxString name = fileName.GetFullPath();
    wxTextFile copyFile(fileName.GetFullPath());
    if (origFile.Open()) {
        copyFile.Create();
        for (size_t i = 0; i < origFile.GetLineCount(); i++) {
            copyFile.AddLine(origFile.GetLine(i));
        }
        origFile.Close();
 
        wxString stepSizeStr = wxString::Format("%.2E", m_data.stepSize);
        stepSizeStr.Replace(wxT(","), wxT("."));
        wxString timeStr = wxString::Format("%.6f", timeSim);
        timeStr.Replace(wxT(","), wxT("."));
        SetATPParameter(copyFile, wxT("BEGIN NEW DATA CASE"), 1, 0, 8, stepSizeStr);
        SetATPParameter(copyFile, wxT("BEGIN NEW DATA CASE"), 1, 8, 8, timeStr);
        SetATPParameter(copyFile, wxT("BEGIN NEW DATA CASE"), 2, 0, 8, wxT("99999999"));
        SetATPParameter(copyFile, wxT("BEGIN NEW DATA CASE"), 2, 8, 8, wxString::Format("%8d", m_data.recordFrequency));
 
        // Add source and switch to selectec node
        AddConnectionToNode(copyFile, m_data.atpNodeName);
 
        copyFile.Write();
    }
    else {
        errorMsg = wxString::Format(_("Fail to open ATP file of the electromagnetic element \"%s\"."), m_data.name);
        return false;
    }
 
    //wxString cmd = properties.GetGeneralPropertiesData().atpPath.GetFullPath() + wxT(" both ") + fileName.GetFullPath() + wxT(" s -R");
    wxString cmd = m_data.atpPath.GetFullPath() + wxT(" both ") + fileName.GetFullPath() + wxT(" s -R");
    wxExecute(cmd, wxEXEC_SYNC | wxEXEC_HIDE_CONSOLE | wxEXEC_NODISABLE, nullptr, &env);
 
    // Delete all .tmp files
    wxDir dir(atpFolder);
    if (dir.IsOpened()) {
        wxString file;
        bool cont = dir.GetFirst(&file, wxT("*.tmp"), wxDIR_FILES);
        while (cont) {
            wxRemoveFile(atpFolder + wxT("/") + file);
            cont = dir.GetNext(&file);
        }
    }
 
    fileName.SetFullName(fileName.GetName() + wxT(".pl4"));
    wxFileInputStream pl4File(fileName.GetFullPath());
    // https://github.com/ldemattos/readPL4/wiki/PISA's-PL4-Format---Time-domain
    if (pl4File.IsOk() && pl4File.GetSize() > 0) {
        wxDataInputStream store(pl4File);
        store.UseBasicPrecisions();
        float* buffer = new float[2];
        std::vector<double> timeVec;
        std::vector<double> valueVec;
        double oldTime = 0.0;
        int read16Bytes = 0;
        while (!pl4File.Eof()) {
            store.ReadFloat(buffer, 2);
            if (read16Bytes > 11 && (buffer[0] >= oldTime)) {
                oldTime = buffer[0];
                timeVec.emplace_back(buffer[0]);
                valueVec.emplace_back(buffer[1]);
            }
            read16Bytes++;
        }
        delete[] buffer;
 
        if (m_data.useMedianFilter)
            valueVec = MedianFilter(valueVec);
 
        // FFT
        double dataStepSize = timeVec[1] - timeVec[0]; // Real sampling time from data
        bool useRemainder = false;
        size_t n = ceil(1.0 / (dataStepSize * fundFreq)); // Number of samples
        // Due to ATP logic, the number of samples can be greater than the number of samples in the PL4 file
        // In this case, I choose to follow the remainder approach
        if (n > valueVec.size()) {
            n = valueVec.size();
            useRemainder = true;
        }
 
        double fs = 1.0 / dataStepSize; // Sampling frequency
        double df = fs / static_cast<double>(n); // Frequency resolution
 
        if (useRemainder) {
            double rmder = abs(remainder(fundFreq, df));
            int minRmderN = n;
            while (rmder > 1e-3) {
                n--;
                df = fs / static_cast<double>(n);
 
                if (abs(remainder(fundFreq, df)) < rmder) minRmderN = n;
 
                rmder = abs(remainder(fundFreq, df));
 
                if (n <= 0) {
                    n = minRmderN;
                    df = fs / static_cast<double>(n);
                    break;
                }
            }
        }
 
        double dtWindow = timeVec[timeVec.size() - 1] - timeVec[timeVec.size() - n];
 
        fftw_complex* out;
        double* in;
        fftw_plan p;
        out = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * (n / 2 + 1));
        in = (double*)fftw_malloc(sizeof(double) * n);
        // Populate input array
        for (size_t i = (valueVec.size() - n); i < valueVec.size(); ++i) {
            size_t index = i - (valueVec.size() - n);
            in[index] = valueVec[i];
        }
 
        p = fftw_plan_dft_r2c_1d(n, in, out, FFTW_ESTIMATE);
        fftw_execute(p); /* repeat as needed */
        fftw_destroy_plan(p);
 
        double ampCorrection = 2.0 / static_cast<double>(n);
 
        // Identify fundamental frequency
        int fundIndex = -1;
        double fundMagnitude = 0.0;
        for (size_t i = 0; i < (n / 2 + 1); i++) {
            double freq = static_cast<double>(i) * df;
            if (remainder(freq, fundFreq)) {
                fundIndex = i;
                fundMagnitude = sqrt(out[i][0] * out[i][0] + out[i][1] * out[i][1]) * ampCorrection;
                break;
            }
        }
        if (fundIndex < 0) {
            errorMsg = wxString::Format(_("Fail to identify the fundamental frequency of the electromagnetic element \"%s\"."), m_data.name);
            return false;
        }
 
        // Fundamental and harmonics
        m_data.currHarmonics.clear();
        //m_data.currHarmonicsOrder.clear();
        for (size_t i = 0; i < (n / 2 + 1); i++) {
            double freq = static_cast<double>(i) * df;
            int order = static_cast<int>(round(freq / fundFreq));
 
            if (order > m_data.numMaxHarmonics) break; // Stop if the order is greater than the maximum number of harmonics
 
            double magnitude = sqrt(out[i][0] * out[i][0] + out[i][1] * out[i][1]) * ampCorrection;
            if ((magnitude / fundMagnitude) > (m_data.harmonicsThreshold / 100.0)) {
                //m_data.currHarmonics.emplace_back(std::complex<double>(out[i][0], out[i][1]) * ampCorrection);
                //m_data.currHarmonicsOrder.emplace_back(order);
                m_data.currHarmonics[order] = std::complex<double>(out[i][0], out[i][1]) * ampCorrection / sqrt(2.0); // RMS value
            }
        }
 
        if (saveFFTData) {
            m_data.atpData.clear();
            m_data.inFFTData.clear();
            m_data.outFFTData.clear();
            for (size_t i = 0; i < valueVec.size(); i++) {
                m_data.atpData.emplace_back(std::make_pair(timeVec[i], valueVec[i]));
            }
            for (size_t i = 0; i < n; i++) {
                m_data.inFFTData.emplace_back(std::make_pair(timeVec[i + timeVec.size() - n], in[i]));
            }
            for (size_t i = 0; i < (n / 2 + 1); i++) {
                std::complex<double> value(out[i][0] * ampCorrection, out[i][1] * ampCorrection);
                double freq = static_cast<double>(i) * df;
                m_data.outFFTData.emplace_back(std::make_pair(freq, value));
            }
        }
 
        fftw_free(in);
        fftw_free(out);
 
    }
    else {
        wxString atpErrorMsg = _("No error found.");
 
        fileName.SetFullName(fileName.GetName() + wxT(".lis"));
        wxTextFile lisFile(fileName.GetFullPath());
 
        if (!lisFile.Exists()) {
            errorMsg = wxString::Format(_("Fail to run ATP file of the electromagnetic element \"%s\".\nThe ATP program did not return any error messages."), m_data.name);
            return false;
        }
        if (lisFile.Open()) {
            wxString line = lisFile.GetFirstLine() + "\n";
            bool foundError = false;
            int lineCount = -1;
            atpErrorMsg.Clear();
            while (!lisFile.Eof())
            {
                if (line.Find(wxT("KILL ")) != wxNOT_FOUND) {
                    foundError = true;
                    lineCount++;
                }
                if (line.Find(wxT("----------")) != wxNOT_FOUND) {
                    foundError = false;
                }
                if (foundError && lineCount == 1)
                    atpErrorMsg += line + " ";
                line = lisFile.GetNextLine();
            }
            lisFile.Close();
        }
        else
        {
            errorMsg = wxString::Format(_("Fail to run ATP file of the electromagnetic element \"%s\".\nThe ATP program did not return any error messages."), m_data.name);
            return false;
        }
 
        errorMsg = wxString::Format(_("Fail to run ATP file of the electromagnetic element \"%s\".\nThe ATP returned the following error message:\n\"%s\""), m_data.name, atpErrorMsg);
        return false;
    }
    return true;
}

◆ Contains()

virtual bool EMTElement::Contains ( wxPoint2DDouble position ) const

inlinevirtual

Checks if the element contains a position.

Parameters

position Position to be checked.

Reimplemented from Shunt.

Definition at line 75 of file EMTElement.h.

75{ return m_rect.Contains(position); }

◆ DoMedianFilter()

std::vector< double > EMTElement::DoMedianFilter	(	double *	extension,
		std::vector< double > &	result,
		const int &	n
	)

protected

Definition at line 844 of file EMTElement.cpp.

{
    //   Move window through all elements of the signal
    for (int i = 2; i < n - 2; ++i)
    {
        //   Pick up window elements
        double window[5];
        for (int j = 0; j < 5; ++j)
            window[j] = extension[i - 2 + j];
        //   Order elements (only half of them)
        for (int j = 0; j < 3; ++j)
        {
            //   Find position of minimum element
            int min = j;
            for (int k = j + 1; k < 5; ++k)
                if (window[k] < window[min])
                    min = k;
            //   Put found minimum element in its place
            const double temp = window[j];
            window[j] = window[min];
            window[min] = temp;
        }
        //   Get result - the middle element
        result[i - 2] = window[2];
    }
    return result;
}

◆ DrawDC() [1/2]

void EMTElement::DrawDC	(	wxPoint2DDouble	translation,
		double	scale,
		wxDC &	dc
	)		const

virtual

Draw the element using wxDC.

Parameters

translation	Translation of the system.
scale	Scale of the system.
dc	Device context.

Reimplemented from Element.

Definition at line 156 of file EMTElement.cpp.

{
    wxColour elementColour;
    if (m_online) {
        if (m_dynEvent)
            elementColour = m_dynamicEventColour;
        else
            elementColour = m_onlineElementColour;
    }
    else
        elementColour = m_offlineElementColour;
 
    std::vector<wxPoint> pointListInt;
    for (auto& pt : m_pointList) {
        pointListInt.emplace_back(static_cast<int>(pt.m_x), static_cast<int>(pt.m_y));
    }
 
    if (m_inserted) {
 
        if (m_selected) {
            dc.SetPen(wxPen(wxColour(m_selectionColour), 2 + m_borderSize * 2.0));
            dc.SetBrush(*wxTRANSPARENT_BRUSH);
 
            dc.DrawLines(pointListInt.size(), &pointListInt[0]);
 
            DrawDCRoundedRectRotated(dc, m_position, m_width, m_height, 10.0, m_angle);
 
            // Draw node selection.
            dc.SetPen(*wxTRANSPARENT_PEN);
            dc.SetBrush(wxBrush(wxColour(m_selectionColour)));
            DrawDCCircle(m_pointList[0], 5.0 + m_borderSize / scale, dc);
        }
        // Draw EMTElement (layer 2).
        // Draw node.
        dc.SetPen(*wxTRANSPARENT_PEN);
        dc.SetBrush(wxBrush(wxColour(elementColour)));
        DrawDCCircle(pointListInt[0], 5.0, dc);
 
        dc.SetPen(wxPen(wxColour(elementColour), 2));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawLines(pointListInt.size(), &pointListInt[0]);
 
        DrawDCSwitches(dc);
 
        dc.SetPen(wxPen(wxColour(elementColour), 2));
        dc.SetBrush(*wxWHITE_BRUSH);
        DrawDCRoundedRectRotated(dc, m_position, m_width, m_height, 10.0, m_angle);
 
        wxFont font;
        font.SetFaceName(wxT("CMU Serif"));
        font.SetPointSize(10);
        font.MakeBold();
        GCText gcText;
        gcText.SetFont(font);
        gcText.SetText(_("EMT"));
        wxPoint pt = RotateAround(m_position + wxPoint2DDouble(0.0, 20.0), m_position, m_angle);
        gcText.Draw(pt, gcText.GetWidth(), gcText.GetHeight(), dc, m_angle, m_online ? wxColour(255, 60, 0) : m_offlineElementColour);
        //dc.SetFont(font);
        //dc.SetTextForeground(m_online ? wxColour(255, 60, 0) : m_offlineElementColour);
        //int textWidth, textHeight;
        //dc.GetTextExtent(_("EMT"), &textWidth, &textHeight);
        //wxPoint pt = RotateAround(wxPoint2DDouble(m_position.m_x, m_position.m_y - m_height / 2.0 + 20.0), m_position, m_angle);
        //dc.DrawRotatedText(_("EMT"), pt.x, pt.y, -m_angle);
 
        //wxGCDC* gcdc = new wxGCDC(gc);
        dc.SetPen(wxPen(m_online ? wxColour(0, 60, 255) : m_offlineElementColour, 2));
        std::vector<wxPoint> ptList;
        for (double x = m_position.m_x - m_width / 2.0 + 2; x < (m_position.m_x + m_width / 2.0); x += (m_width - 4.0) / 6.0) {
            wxPoint pt = RotateAround(wxPoint2DDouble(x, m_position.m_y + std::sin((x - (m_position.m_x - m_width / 2.0 + 2)) / m_width * 6 * M_PI) * 20.0), m_position, m_angle);
            ptList.emplace_back(pt);
        }
        dc.DrawSpline(ptList.size(), ptList.data());
    }
}

Here is the call graph for this function:

◆ DrawDC() [2/2]

void EMTElement::DrawDC	(	wxPoint2DDouble	translation,
		double	scale,
		wxGraphicsContext *	gc
	)		const

virtual

Draw the element using GDI+.

Parameters

translation	Translation of the system.
scale	Scale of the system.
gc	Graphics context

Reimplemented from Element.

Definition at line 72 of file EMTElement.cpp.

{
    wxColour elementColour;
    if (m_online) {
        if (m_dynEvent)
            elementColour = m_dynamicEventColour;
        else
            elementColour = m_onlineElementColour;
    }
    else
        elementColour = m_offlineElementColour;
 
    if (m_inserted) {
 
        if (m_selected) {
            gc->SetPen(wxPen(wxColour(m_selectionColour), 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->DrawRectangle(m_position.m_x - m_width / 2.0, m_position.m_y - m_height / 2.0, m_width, m_height);
            gc->DrawRoundedRectangle(m_position.m_x - m_width / 2.0, m_position.m_y - m_height / 2.0, m_width, m_height, 10.0);
 
            gc->PopState();
 
            // Draw node selection.
            gc->SetPen(*wxTRANSPARENT_PEN);
            gc->SetBrush(wxBrush(wxColour(m_selectionColour)));
            DrawDCCircle(m_pointList[0], 5.0 + m_borderSize / scale, 10, gc);
        }
        // Draw EMTElement (layer 2).
        // Draw node.
        gc->SetPen(*wxTRANSPARENT_PEN);
        gc->SetBrush(wxBrush(wxColour(elementColour)));
        DrawDCCircle(m_pointList[0], 5.0, 10, gc);
 
        gc->SetPen(wxPen(wxColour(elementColour), 2));
        gc->SetBrush(*wxTRANSPARENT_BRUSH);
        gc->StrokeLines(m_pointList.size(), &m_pointList[0]);
 
        DrawDCSwitches(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);
 
        gc->SetPen(wxPen(wxColour(elementColour), 2));
        gc->SetBrush(*wxWHITE_BRUSH);
        //gc->DrawRectangle(m_position.m_x - m_width / 2.0, m_position.m_y - m_height / 2.0, m_width, m_height);
        gc->DrawRoundedRectangle(m_position.m_x - m_width / 2.0, m_position.m_y - m_height / 2.0, m_width, m_height, 10.0);
 
        //gc->SetPen(*wxBLACK_PEN);
        //wxFont font(10, wxFONTFAMILY_ROMAN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
        wxFont font;
        font.SetFaceName(wxT("CMU Serif"));
        font.SetPointSize(10);
        font.MakeBold();
        gc->SetFont(font, m_online ? wxColour(255, 60, 0) : m_offlineElementColour);
        double textWidth, textHeight;
        gc->GetTextExtent(_("EMT"), &textWidth, &textHeight);
        gc->DrawText(_("EMT"), m_position.m_x - textWidth / 2.0, m_position.m_y - textHeight / 2.0 + 20.0);
 
        wxGCDC* gcdc = new wxGCDC(gc);
        gcdc->SetPen(wxPen(m_online ? wxColour(0, 60, 255) : m_offlineElementColour, 2));
        std::vector<wxPoint> ptList;
        for (double x = m_position.m_x - m_width / 2.0 + 2; x < (m_position.m_x + m_width / 2.0); x += (m_width - 4.0) / 6.0) {
            ptList.emplace_back(x, m_position.m_y + std::sin((x - (m_position.m_x - m_width / 2.0 + 2)) / m_width * 6 * M_PI) * 20.0);
        }
        gcdc->DrawSpline(ptList.size(), ptList.data());
 
        gc->PopState();
    }
}

Here is the call graph for this function:

◆ GetATPNodes()

wxArrayString EMTElement::GetATPNodes ( wxArrayString atpFile )

Definition at line 336 of file EMTElement.cpp.

{
    wxArrayString nodeList;
    uint32_t mode = 0;
    std::vector<wxString> mode0Cards{ "/OUTPUT", "BLANK", "TACS", "INCLUDE", "TRANSFORMER" };
    std::vector<wxString> mode1Cards{ "/SOURCE" };
    std::vector<wxString> mode2Cards{ "/BRANCH", "/SWITCH", };
    wxString ground = "000000";
    for (wxString line : atpFile) {
        if (line.IsEmpty()) continue;
        if (tolower(line[0]) == 'c') continue; // Skip comments
 
        bool cardHeader = false;
        for (wxString card : mode0Cards) {
            if (line.Find(card) != wxNOT_FOUND) {
                mode = 0;
                cardHeader = true;
                break;
            }
        }
        for (wxString card : mode1Cards) {
            if (line.Find(card) != wxNOT_FOUND) {
                mode = 1;
                cardHeader = true;
                break;
            }
        }
        for (wxString card : mode2Cards) {
            if (line.Find(card) != wxNOT_FOUND) {
                mode = 2;
                cardHeader = true;
                break;
            }
        }
        if (cardHeader) continue;
 
 
        wxString node = "";
        switch (mode)
        {
        case 1: {
            node = line(2, 6).Trim();
            node.Replace(" ", "0");
            if (node != ground && node[5] >= 'A') { // Ignore ground and monophasic nodes
                if (nodeList.Index(node(0, 5)) == wxNOT_FOUND)
                    nodeList.Add(node(0, 5));
            }
        } break;
        case 2: {
            node = line(2, 6);
            if (node != ground && node[5] >= 'A') { // Ignore ground and monophasic nodes
                if (nodeList.Index(node(0, 5)) == wxNOT_FOUND)
                    nodeList.Add(node(0, 5));
            }
            node = line(8, 6);
            if (node != ground && node[5] >= 'A') { // Ignore ground and monophasic nodes
                if (nodeList.Index(node(0, 5)) == wxNOT_FOUND)
                    nodeList.Add(node(0, 5));
            }
        } break;
        }
    }
    return nodeList;
}

◆ GetContextMenu()

bool EMTElement::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 243 of file EMTElement.cpp.

{
    menu.Append(ID_EDIT_ELEMENT, _("Edit Electromagnetic Transient"));
    GeneralMenuItens(menu);
    return true;
}

Here is the call graph for this function:

◆ GetCopy()

Element * EMTElement::GetCopy ( )

virtual

Get a the element copy.

Returns: Copy of the element.

Reimplemented from Element.

Definition at line 28 of file EMTElement.cpp.

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

◆ GetEMTElementData()

virtual EMTElementData EMTElement::GetEMTElementData ( )

inlinevirtual

Definition at line 85 of file EMTElement.h.

85{ return m_data; }

◆ GetTipText()

wxString EMTElement::GetTipText ( ) const

virtual

Get the tip text.

Returns: Tip text.

Reimplemented from Element.

Definition at line 250 of file EMTElement.cpp.

{
    wxString tipText = m_data.name;
    tipText += wxT("\n");
 
    tipText += wxString::Format(_("\nP = %.5f p.u."), m_data.power.real());
    tipText += wxString::Format(_("\nQ = %.5f p.u."), m_data.power.imag());
    if (auto itCurrrent = m_data.currHarmonics.find(1); itCurrrent != m_data.currHarmonics.end())
        tipText += wxString::Format(_("\nI = %.5f A"), std::abs(itCurrrent->second));
 
    wxString harmonicsInfo = _("\n\nHarmonics info:");
    bool hasHarmonics = false;
    for (auto& [order, current] : m_data.currHarmonics) {
        if (order != 1) {
            hasHarmonics = true;
            harmonicsInfo += wxString::Format(_("\nIh(%d): %.5f%s%.2f%s A"), order, std::abs(current), wxString(L'\u2220'), wxRadToDeg(std::arg(current)), wxString(L'\u00B0'));
        }
    }
 
    if (hasHarmonics) tipText += harmonicsInfo;
 
    return tipText;
}

◆ Intersects()

virtual bool EMTElement::Intersects ( wxRect2DDouble rect ) const

inlinevirtual

Check if the element's rect intersects other rect.

Parameters

rect	Rect to check intersection.

Reimplemented from Shunt.

Definition at line 76 of file EMTElement.h.

76{ return m_rect.Intersects(rect); }

◆ MedianFilter()

std::vector< double > EMTElement::MedianFilter ( const std::vector< double > & data )

Definition at line 546 of file EMTElement.cpp.

{
    // Based on: http://www.librow.com/articles/article-1
 
    size_t n = data.size();
    std::vector<double> result(data);
 
    //   Check arguments
    if (data.empty() || n < 1)
        return result;
    //   Treat special case N = 1
    if (n == 1)
    {
        result[0] = data[0];
        return result;
    }
    //   Allocate memory for signal extension
    double* extension = new double[n + 4];
    //   Check memory allocation
    //if (!extension)
    //  return;
    //   Create signal extension
    memcpy(extension + 2, data.data(), n * sizeof(double));
    for (int i = 0; i < 2; ++i)
    {
        extension[i] = data[1 - i];
        extension[n + 2 + i] = data[n - 1 - i];
    }
    //   Call median filter implementation
    result = DoMedianFilter(extension, result, n + 4);
    //   Free memory
    delete[] extension;
 
    return result;
}

◆ OpenElement()

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

virtual

Reimplemented from PowerElement.

Definition at line 315 of file EMTElement.cpp.

{
    if (!OpenCADProperties(elementNode, parentList)) return false;
 
    auto electricalProp = elementNode->first_node("ElectricalProperties");
    if (!electricalProp) return false;
 
    SetOnline(XMLParser::GetNodeValueInt(electricalProp, "IsOnline"));
    m_data.name = electricalProp->first_node("Name")->value();
    m_data.atpFile = wxFileName(electricalProp->first_node("ATPFilePath")->value());
    m_data.atpNodeName = electricalProp->first_node("ATPNodeName")->value();
    m_data.stepSize = XMLParser::GetNodeValueDouble(electricalProp, "StepSize");
    m_data.cyclesToSS = XMLParser::GetNodeValueInt(electricalProp, "CyclesToSS");
    m_data.recordFrequency = XMLParser::GetNodeValueInt(electricalProp, "RecordFrequency");
    m_data.useMedianFilter = XMLParser::GetNodeValueInt(electricalProp, "UseMedianFilter");
    m_data.numMaxHarmonics = XMLParser::GetNodeValueInt(electricalProp, "NumMaxHarmonics");
 
    m_inserted = true;
    return true;
}

◆ Rotate()

void EMTElement::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 231 of file EMTElement.cpp.

{
    double rotAngle = m_rotationAngle;
    if (!clockwise) rotAngle = -m_rotationAngle;
 
    m_angle += rotAngle;
    if (m_angle >= 360 || m_angle <= -360) m_angle = 0.0;
    m_pointList[2] = RotateAtPosition(m_pointList[2], rotAngle);
    m_pointList[3] = RotateAtPosition(m_pointList[3], rotAngle);
    UpdateSwitchesPosition();
}

Here is the call graph for this function:

◆ SaveElement()

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

virtual

Reimplemented from Element.

Definition at line 285 of file EMTElement.cpp.

{
    auto elementNode = XMLParser::AppendNode(doc, elementListNode, "EMTElement");
    XMLParser::SetNodeAttribute(doc, elementNode, "ID", m_elementID);
 
    SaveCADProperties(doc, elementNode);
 
    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_data.name);
    auto atpFilePath = XMLParser::AppendNode(doc, electricalProp, "ATPFilePath");
    XMLParser::SetNodeValue(doc, atpFilePath, m_data.atpFile.GetFullPath());
    auto atpNodeName = XMLParser::AppendNode(doc, electricalProp, "ATPNodeName");
    XMLParser::SetNodeValue(doc, atpNodeName, m_data.atpNodeName);
    auto stepSize = XMLParser::AppendNode(doc, electricalProp, "StepSize");
    XMLParser::SetNodeValue(doc, stepSize, m_data.stepSize);
    auto cyclesToSS = XMLParser::AppendNode(doc, electricalProp, "CyclesToSS");
    XMLParser::SetNodeValue(doc, cyclesToSS, m_data.cyclesToSS);
    auto recordFrequency = XMLParser::AppendNode(doc, electricalProp, "RecordFrequency");
    XMLParser::SetNodeValue(doc, recordFrequency, m_data.recordFrequency);
    auto useMedianFilter = XMLParser::AppendNode(doc, electricalProp, "UseMedianFilter");
    XMLParser::SetNodeValue(doc, useMedianFilter, m_data.useMedianFilter);
    auto numMaxHarmonics = XMLParser::AppendNode(doc, electricalProp, "NumMaxHarmonics");
    XMLParser::SetNodeValue(doc, numMaxHarmonics, m_data.numMaxHarmonics);
 
    return elementNode;
}

◆ SetATPParameter()

bool EMTElement::SetATPParameter	(	wxTextFile &	atpFile,
		const wxString &	card,
		const int &	line,
		const int &	initPos,
		const int &	size,
		const wxString &	value
	)

Definition at line 401 of file EMTElement.cpp.

{
    bool foundCard = false;
    int currLine = -1;
    wxString lineStr = "";
    lineStr = atpFile.GetFirstLine();
    while (!atpFile.Eof())
    {
        if (tolower(lineStr[0]) == 'c') {
            lineStr = atpFile.GetNextLine();
            continue; // Skip comments
        }
        if (lineStr.Find(card) != wxNOT_FOUND) {
            foundCard = true;
            currLine = -1;
        }
        if (foundCard) currLine++;
        if (foundCard && currLine == line) {
            for (int i = initPos; i < initPos + size; i++) {
                lineStr[i] = value[i - initPos];
            }
            atpFile.RemoveLine(atpFile.GetCurrentLine());
            atpFile.InsertLine(lineStr, atpFile.GetCurrentLine());
            return true;
        }
 
        lineStr = atpFile.GetNextLine();
    }
    return false;
}

◆ SetEMTElementData()

virtual void EMTElement::SetEMTElementData ( EMTElementData data )

inlinevirtual

Definition at line 86 of file EMTElement.h.

86{ m_data = data; }

◆ ShowForm()

bool EMTElement::ShowForm	(	wxWindow *	parent,
		Element *	element
	)

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 274 of file EMTElement.cpp.

{
    EMTElementForm emtForm(parent, this);
    emtForm.SetTitle(_("Electromagnetic Transient"));
    emtForm.CenterOnParent();
    if (emtForm.ShowModal() == wxID_OK) {
        return true;
    }
    return false;
}

◆ UpdateData()

void EMTElement::UpdateData	(	const PropertiesData *	properties = `nullptr`,
		bool	updateVoltageBase = `false`
	)

Definition at line 822 of file EMTElement.cpp.

{
    if (properties != nullptr) {
        m_data.frequency = properties->GetSimulationPropertiesData().stabilityFrequency;
        m_data.atpPath = properties->GetGeneralPropertiesData().atpPath;
        m_data.atpWorkFolder = properties->GetGeneralPropertiesData().atpWorkFolder;
    }
    if (!m_parentList.empty()) {
        Bus* bus = static_cast<Bus*>(m_parentList[0]);
        if (bus != nullptr) {
            auto busData = bus->GetElectricalData();
            std::complex<double> voltage = std::complex<double>(1.0, 0.0);
            if (abs(busData.voltage) > 1e-3)
                m_data.puVoltage = busData.voltage;
            if (updateVoltageBase) {
                m_data.baseVoltage = GetValueFromUnit(busData.nominalVoltage, busData.nominalVoltageUnit);
            }
        }
    }
 
}

Member Data Documentation

◆ m_data

EMTElementData EMTElement::m_data

protected

Definition at line 97 of file EMTElement.h.

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

Project/elements/powerElement/EMTElement.h
Project/elements/powerElement/EMTElement.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ EMTElement() [1/2]

◆ EMTElement() [2/2]

◆ ~EMTElement()

Member Function Documentation

◆ AddConnectionToNode()

◆ AddParent()

◆ CalculateCurrent()

◆ Contains()

◆ DoMedianFilter()

◆ DrawDC() [1/2]

◆ DrawDC() [2/2]

◆ GetATPNodes()

◆ GetContextMenu()

◆ GetCopy()

◆ GetEMTElementData()

◆ GetTipText()

◆ Intersects()

◆ MedianFilter()

◆ OpenElement()

◆ Rotate()

◆ SaveElement()

◆ SetATPParameter()

◆ SetEMTElementData()

◆ ShowForm()

◆ UpdateData()

Member Data Documentation

◆ m_data