DatFileWriter.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 "DatFileWriter.H"
 
#include <cctype>
#include <cmath>
#include <fstream>
 
#include "Display.H"
#include "OutputFileCommon.H"
#include "Version.H"
 
bool DatFileWriter::write(
    const std::string& jobName,
    const std::string& inputFile,
    const std::string& solverName,
    const std::string& formatName,
    const BusData& busData,
    const BranchData& branchData,
    const std::vector<std::pair<int, double>>& iterationHistory,
    int totalIterations,
    double finalError,
    double tolerance,
    bool converged,
    double elapsedSec,
    double basemva
) const {
    std::string datFile = jobName + ".dat";
    std::ofstream out(datFile);
    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 << Display::sectionHeader("I N P U T   P R O C E S S I N G");
    out << fmt::format("   Input File           : {}\n", inputFile);
    out << fmt::format("   Input Format         : {}\n", formatName);
 
    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);
 
    std::string solverBanner;
    for (const char &c : solverName) {
        solverBanner += std::toupper(c);
        solverBanner += ' ';
    }
    out << Display::sectionHeader(solverBanner + "   S O L V E R   E X E C U T I O N");
    out << fmt::format("   Method               : {}\n", solverName);
    out << fmt::format("   Max Iterations       : {:>6d}\n", static_cast<int>(iterationHistory.size()) > 0 ?
        static_cast<int>(iterationHistory.back().first) : totalIterations);
    out << fmt::format("   Convergence Tol.     : {:.6e}\n", tolerance);
    out << "\n";
 
    out << fmt::format("   {:>6s}  {:>16s}  {:>12s}  {:>8s}\n",
        "Iter", "Max Mismatch", "Tolerance", "Status");
    out << "   " << std::string(W - 4, '-') << "\n";
 
    for (const auto& [iter, error] : iterationHistory) {
        std::string status;
        if (error < tolerance)
            status = "CONV";
        else
            status = "----";
        out << fmt::format("   {:>6d}  {:>16.6e}  {:>12.6e}  {:>8s}\n",
            iter, error, tolerance, status);
    }
 
    out << "   " << std::string(W - 4, '-') << "\n";
    out << "\n";
 
    if (converged) {
        out << fmt::format("   {} CONVERGED after {} iterations.\n", solverName, totalIterations);
        out << fmt::format("   Final max mismatch = {:.6e}\n", finalError);
    } else {
        out << fmt::format("   *** WARNING: {} DID NOT CONVERGE after {} iterations.\n", solverName, totalIterations);
        out << fmt::format("   Final max mismatch = {:.6e}\n", finalError);
    }
 
    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);
    }
 
    out << "   " << std::string(W - 4, '=') << "\n";
 
    auto totals = OutputFileCommon::computeBusTotals(busData);
 
    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\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");
    if (converged) {
        out << Display::center("THE ANALYSIS HAS BEEN COMPLETED SUCCESSFULLY") << "\n";
    } else {
        out << Display::center("*** THE ANALYSIS HAS NOT CONVERGED ***") << "\n";
    }
    out << "\n";
 
    out.close();
    return true;
}