sn_arvr_state_dependent_balance.h

Go to the documentation of this file.

#pragma once
/**
 * @file sn_arvr_state_dependent_balance.h
 * @brief Arrival rates at stations fed by a JSQ or SQ(d) dispatcher, from flow balance.
 *
 * Port of MATLAB sn_arvr_state_dependent_balance.m. sn_get_arvr_from_tput
 * reads the routing matrix, which for a state-dependent dispatcher holds only
 * the static RAND split: under JSQ it reported ArvR 0.5/0.5 at two stations
 * whose throughputs were 0.57/0.42. At a station a job leaves only by
 * completing service (no finite buffer, no impatience, no retrial) arrivals and
 * departures balance in steady state, so ArvR = Tput there whatever the
 * routing. Residence times derived from the same static visit ratios are
 * rescaled by the same factor. Other stations are left as computed.
 */
 
#include <cmath>
#include <cstddef>
#include <vector>
 
#include "line/lang/qn/network_struct.h"
#include "line/num/number.h"
#include "line/util/matrix.h"
 
namespace line {
namespace sn {
 
template <class T>
void sn_arvr_state_dependent_balance(const qn::NetworkStruct<T>& L, Matrix<T>& AN,
                                     const Matrix<T>& TN, Matrix<T>* WN) {
    const std::size_t I = L.nodes.size();
    const std::size_t K = L.nclasses;
    if (L.rtnodes.rows() < I * K || AN.rows() == 0) return;
    std::vector<std::vector<bool> > fed(L.nstations, std::vector<bool>(K, false));
    bool any = false;
    for (std::size_t ind = 0; ind < I; ++ind)
        for (std::size_t r = 0; r < K && r < L.nodes[ind].routing.size(); ++r) {
            const qn::RoutingStrategy rs = L.nodes[ind].routing[r];
            if (rs != qn::RoutingStrategy::JSQ && rs != qn::RoutingStrategy::SQ) continue;
            for (std::size_t jnd = 0; jnd < I; ++jnd) {
                const std::size_t ist = L.nodes[jnd].station;
                if (ist == 0) continue;
                for (std::size_t s = 0; s < K; ++s)
                    if (num_traits<T>::to_double(L.rtnodes(ind * K + r, jnd * K + s)) > 0.0) {
                        fed[ist - 1][s] = true;
                        any = true;
                    }
            }
        }
    if (!any) return;
    for (std::size_t ist = 0; ist < L.nstations && ist < AN.rows(); ++ist) {
        const qn::Station<T>& st = L.stations[ist];
        for (std::size_t s = 0; s < K && s < AN.cols(); ++s) {
            if (!fed[ist][s]) continue;
            if (std::isfinite(st.cap) || (s < st.classcap.size() && std::isfinite(st.classcap[s])))
                continue;
            if (s < st.impatience.size() && st.impatience[s] != lang::ImpatienceType::NONE) continue;
            const auto rp = L.retrialparam.find(ist + 1);
            if (rp != L.retrialparam.end() && s < rp->second.retrial_proc.size() &&
                !rp->second.retrial_proc[s].disabled)
                continue;
            const double old = num_traits<T>::to_double(AN(ist, s));
            AN(ist, s) = TN(ist, s);
            if (WN != nullptr && old > 0.0 && ist < WN->rows() && s < WN->cols())
                (*WN)(ist, s) = T((*WN)(ist, s) * TN(ist, s) / num_traits<T>::from_double(old));
        }
    }
}
 
}  // namespace sn
}  // namespace line