OutputFileCommon.H

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/>.
 */
 
#ifndef OUTPUT_FILE_COMMON_H
#define OUTPUT_FILE_COMMON_H
 
#include <chrono>
#include <cmath>
#include <complex>
#include <string>
 
#ifdef _WIN32
  #include <windows.h>
#else
  #include <unistd.h>
#endif
 
#include <Eigen/Dense>
#include <fmt/chrono.h>
#include <fmt/core.h>
 
#include "Data.H"
 
namespace OutputFileCommon {
 
    inline std::string hostname() {
    #ifdef _WIN32
        char buf[MAX_COMPUTERNAME_LENGTH + 1];
        DWORD bufLen = sizeof(buf);
        if (GetComputerNameA(buf, &bufLen)) return std::string(buf);
    #else
        char buf[256];
        if (gethostname(buf, sizeof(buf)) == 0) return std::string(buf);
    #endif
        return "unknown";
    }
 
    inline std::string timestamp() {
        auto now = std::time(nullptr);
        return fmt::format("{:%d-%b-%Y  %H:%M:%S}", fmt::localtime(now));
    }
 
    inline std::string dateStr() {
        auto now = std::time(nullptr);
        return fmt::format("{:%d-%b-%Y}", fmt::localtime(now));
    }
 
    inline std::string timeStr() {
        auto now = std::time(nullptr);
        return fmt::format("{:%H:%M:%S}", fmt::localtime(now));
    }
 
    struct BusTypeCounts {
        int nSlack = 0;
        int nPV = 0;
        int nPQ = 0;
    };
 
    inline BusTypeCounts countBusTypes(const BusData& busData) {
        BusTypeCounts counts;
        int nBus = static_cast<int>(busData.Type.size());
        for (int i = 0; i < nBus; ++i) {
            if (busData.Type(i) == 1) counts.nSlack++;
            else if (busData.Type(i) == 2) counts.nPV++;
            else counts.nPQ++;
        }
        return counts;
    }
 
    struct BusTotals {
        double totalPl = 0.0;
        double totalQl = 0.0;
        double totalPg = 0.0;
        double totalQg = 0.0;
        double totalInjected = 0.0;
    };
 
    inline BusTotals computeBusTotals(const BusData& busData) {
        BusTotals t;
        t.totalPl = busData.Pl.sum();
        t.totalQl = busData.Ql.sum();
        t.totalPg = busData.Pg.sum();
        t.totalQg = busData.Qg.sum();
        t.totalInjected = t.totalQg - t.totalQl;
        return t;
    }
 
}
 
#endif