OutFileWriter.C

Go to the documentation of this file.

/*
 * Copyright (c) 2024 Saud Zahir
 *
 * This file is part of deltaFlow.
 *
 * deltaFlow is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * deltaFlow is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with deltaFlow.  If not, see
 * <https://www.gnu.org/licenses/>.
 */
 
#include "OutFileWriter.H"
 
#include <cmath>
#include <complex>
 
#include "Display.H"
#include "OutputFileCommon.H"
#include "Version.H"
 
bool OutFileWriter::write(
    const std::string& jobName,
    const std::string& inputFile,
    const std::string& solverName,
    const std::string& formatName,
    const BusData& busData,
    const BranchData& branchData,
    const Eigen::MatrixXcd& Y,
    int iterations,
    double finalError,
    double tolerance,
    double elapsedSec,
    double basemva
) const {
    std::string outFile = jobName + ".out";
    std::ofstream out(outFile);
    if (!out.is_open()) return false;
 
    int nBus = busData.V.size();
    int nBranch = branchData.From.size();
    int W = Display::pageWidth;
 
    out << Display::fileBanner();
 
    out << fmt::format("\n   deltaFlow v{:<32s}Date {:>14s}   Time {:>8s}\n",
        deltaFlow_VERSION, OutputFileCommon::dateStr(), OutputFileCommon::timeStr());
    out << "\n";
 
    out << Display::sectionHeader("S Y S T E M   I N F O R M A T I O N");
    out << fmt::format("   Hostname             : {}\n", OutputFileCommon::hostname());
    out << fmt::format("   CMake Version        : {}\n", CMake_VERSION);
    out << fmt::format("   Compiler Version     : GCC {}\n", gcc_VERSION);
    out << fmt::format("   deltaFlow Version    : {}\n", deltaFlow_VERSION);
    out << "\n";
 
    out << Display::sectionHeader("J O B   P A R A M E T E R S");
    out << fmt::format("   Job Name             : {}\n", jobName);
    out << fmt::format("   Input File           : {}\n", inputFile);
    out << fmt::format("   Input Format         : {}\n", formatName);
    out << fmt::format("   Solver Method        : {}\n", solverName);
    out << fmt::format("   Convergence Tol.     : {:.6e}\n", tolerance);
    out << "\n";
 
    out << Display::sectionHeader("M O D E L   S U M M A R Y");
 
    auto counts = OutputFileCommon::countBusTypes(busData);
 
    out << fmt::format("   Number of Buses      : {:>6d}\n", nBus);
    out << fmt::format("     Slack Buses         : {:>6d}\n", counts.nSlack);
    out << fmt::format("     PV Buses            : {:>6d}\n", counts.nPV);
    out << fmt::format("     PQ Buses            : {:>6d}\n", counts.nPQ);
    out << fmt::format("   Number of Branches   : {:>6d}\n", nBranch);
    out << fmt::format("   Base MVA             : {:>10.1f}\n", basemva);
    out << "\n";
 
    out << Display::sectionHeader("S O L V E R   S U M M A R Y");
    out << fmt::format("   Method               : {}\n", solverName);
    out << fmt::format("   Iterations           : {:>6d}\n", iterations);
    out << fmt::format("   Final Error          : {:.6e}\n", finalError);
    out << fmt::format("   Tolerance            : {:.6e}\n", tolerance);
    out << fmt::format("   Status               : CONVERGED\n");
    out << fmt::format("   Elapsed Time (sec)   : {:.3f}\n", elapsedSec);
    out << "\n";
 
    out << Display::sectionHeader("B U S   D A T A   R E S U L T S");
    out << fmt::format("   {:>4s}  {:>9s}  {:>9s}  {:>10s} {:>10s}  {:>10s} {:>10s}  {:>10s}\n",
        "Bus", "Voltage", "Angle", "Load", "Load", "Gen", "Gen", "Injected");
    out << fmt::format("   {:>4s}  {:>9s}  {:>9s}  {:>10s} {:>10s}  {:>10s} {:>10s}  {:>10s}\n",
        "No.", "Mag.", "Degree", "MW", "Mvar", "MW", "Mvar", "Mvar");
    out << "   " << std::string(W - 4, '=') << "\n";
 
    for (int i = 0; i < nBus; ++i) {
        double injectedMvar = busData.Qg(i) - busData.Ql(i);
        out << fmt::format("   {:>4d}  {:>9.4f}  {:>9.4f}  {:>10.4f} {:>10.4f}  {:>10.4f} {:>10.4f}  {:>10.4f}\n",
            i + 1, busData.V(i), busData.delta(i),
            busData.Pl(i), busData.Ql(i), busData.Pg(i), busData.Qg(i), injectedMvar);
    }
 
    auto totals = OutputFileCommon::computeBusTotals(busData);
 
    out << "   " << std::string(W - 4, '=') << "\n";
    out << fmt::format("   Total{:>27.4f} {:>10.4f}  {:>10.4f} {:>10.4f}  {:>10.4f}\n",
        totals.totalPl, totals.totalQl, totals.totalPg, totals.totalQg, totals.totalInjected);
    out << "\n";
 
    out << Display::sectionHeader("L I N E   F L O W   A N D   L O S S E S");
    out << fmt::format("   {:>4s}  {:>4s}  {:>9s} {:>9s} {:>9s}   {:>9s} {:>9s}  {:>9s}\n",
        "From", "To", "MW", "Mvar", "MVA", "Loss MW", "Loss Mvar", "Tap");
    out << "   " << std::string(W - 4, '=') << "\n";
 
    auto Bc = branchData.B;
    int nLine = nBranch;
 
    Eigen::VectorXcd Vc(nBus);
    Eigen::VectorXcd S(nBus);
    for (int i = 0; i < nBus; ++i) {
        double mag = busData.V(i);
        double ang_rad = busData.delta(i) * M_PI / 180.0;
        Vc(i) = std::polar(mag, ang_rad);
        double P = busData.Pg(i) - busData.Pl(i);
        double Q = busData.Qg(i) - busData.Ql(i);
        S(i) = std::complex<double>(P, Q);
    }
 
    std::complex<double> SLT = 0.0;
 
    for (int n = 1; n <= nBus; ++n) {
        int n_idx = n - 1;
        bool busprt = false;
 
        for (int L = 0; L < nLine; ++L) {
            if (!busprt) {
                double P_inj = busData.Pg(n_idx) - busData.Pl(n_idx);
                double Q_inj = busData.Qg(n_idx) - busData.Ql(n_idx);
                double S_mag = std::abs(S(n_idx)) * basemva;
                out << fmt::format("   {:>4d}        {:>9.3f} {:>9.3f} {:>9.3f}\n",
                    n, P_inj, Q_inj, S_mag);
                busprt = true;
            }
 
            auto writeLineFlow = [&](int from, int to, int L) {
                int f_idx = from - 1;
                int t_idx = to - 1;
                double aL = (branchData.tapRatio(L) == 0.0) ? 1.0 : branchData.tapRatio(L);
 
                std::complex<double> In, Ik;
                if (branchData.From(L) == from) {
                    In = (Vc(f_idx) - aL * Vc(t_idx)) * Y(L) / (aL * aL) + Bc(L) / (aL * aL) * Vc(f_idx);
                    Ik = (Vc(t_idx) - Vc(f_idx) / aL) * Y(L) + Bc(L) * Vc(t_idx);
                } else {
                    In = (Vc(f_idx) - Vc(t_idx) / aL) * Y(L) + Bc(L) * Vc(f_idx);
                    Ik = (Vc(t_idx) - aL * Vc(f_idx)) * Y(L) / (aL * aL) + Bc(L) / (aL * aL) * Vc(t_idx);
                }
                std::complex<double> Snk = Vc(f_idx) * std::conj(In) * basemva;
                std::complex<double> Skn = Vc(t_idx) * std::conj(Ik) * basemva;
                std::complex<double> SL = Snk + Skn;
                SLT += SL;
 
                if (aL != 1.0) {
                    out << fmt::format("         {:>4d}  {:>9.3f} {:>9.3f} {:>9.3f}   {:>9.3f} {:>9.3f}  {:>9.3f}\n",
                        to, std::real(Snk), std::imag(Snk), std::abs(Snk),
                        std::real(SL), std::imag(SL), aL);
                } else {
                    out << fmt::format("         {:>4d}  {:>9.3f} {:>9.3f} {:>9.3f}   {:>9.3f} {:>9.3f}\n",
                        to, std::real(Snk), std::imag(Snk), std::abs(Snk),
                        std::real(SL), std::imag(SL));
                }
            };
 
            if (branchData.From(L) == n) {
                writeLineFlow(n, branchData.To(L), L);
            } else if (branchData.To(L) == n) {
                writeLineFlow(n, branchData.From(L), L);
            }
        }
    }
 
    SLT /= 2.0;
    out << "\n";
    out << fmt::format("   Total loss                        {:>9.3f} {:>9.3f}\n",
        std::real(SLT), std::imag(SLT));
    out << "\n";
 
    out << "\n";
    out << "\n";
    out << "     JOB TIME SUMMARY\n";
    out << fmt::format("       TOTAL CPU TIME (SEC) = {:>12.5f}\n", elapsedSec);
    out << fmt::format("       WALLCLOCK TIME (SEC) = {:>12d}\n", static_cast<int>(std::round(elapsedSec)));
    out << "\n";
 
    out << Display::sectionHeader("A N A L Y S I S   C O M P L E T E");
    out << Display::center("THE ANALYSIS HAS BEEN COMPLETED SUCCESSFULLY") << "\n";
    out << "\n";
 
    out.close();
    return true;
}