Beispiel #1
0
    def step( self, value ):
        super().step( value )

        self.p_nodes, self.m_dot_pipes, self.m_dot_nodes, gas = \
            pgsim._run_sim( self.net, level = 'BP' )

        for attr in [ '{}/P'.format(k) for k in self.p_nodes.keys() ]:
            self.save_attribute( attr )

        for attr in [ '{}/m_dot'.format(k) for k in self.m_dot_pipes.keys() ]:
            self.save_attribute( attr )
Beispiel #2
0
def test_run_sim(fix_create):
    net = fix_create
    p_nodes, m_dot_pipes, m_dot_nodes, gas = sim._run_sim(net)
    assert round(gas.rho, 3) == 0.017
    assert p_nodes == {'BUS1': 2500.0, 'BUS2': 1962.7, 'BUS3': 1827.8}
    assert m_dot_pipes == {
        'PIPE3': 6.6e-05,
        'PIPE1': 0.000328,
        'PIPE2': 0.000328
    }
    assert m_dot_nodes == {
        'BUS1': -0.000656,
        'BUS2': 0.000262,
        'BUS3': 0.000394
    }
Beispiel #3
0
    def __init__( self ):
        super().__init__()

        connect = PostgreSQLConnectionInfo(
            user = self.init_values[ 'dbuser' ],
            pwd = self.init_values[ 'dbpwd' ],
            host = self.init_values[ 'dbhost' ],
            port = self.init_values[ 'dbport' ],
            dbname = self.init_values[ 'dbname' ]
        )

        pg_reader = PandaNGasModelDBReader( connect )
        
        self.net = pg_reader.get_net( network_id = self.init_values[ 'network_id' ] )
        print(self.net)
        
        self.p_nodes, self.m_dot_pipes, self.m_dot_nodes, gas = \
            pgsim._run_sim( self.net, level = 'BP' )
Beispiel #4
0
def test_sim_utn_gas_pandangas(fix_connect, fix_gas_network_id):

    # Instantiate reader.
    pg_reader = PandaNGasModelDBReader(fix_connect)

    # Create simulation model from database.
    net = pg_reader.get_net(network_id=fix_gas_network_id)

    # Check number of elements in the simulation model.
    assert (len(net.station) == 1)
    assert (len(net.pipe) == 4)
    assert (len(net.feeder) == 1)
    assert (len(net.load) == 2)
    assert (len(net.bus) == 5)

    scaled_loads = gas_sim._scaled_loads_as_dict(net)
    assert (scaled_loads['node-N2'] == 0.000262)
    assert (scaled_loads['node-N3'] == 0.000394)

    p_min_loads = gas_sim._p_min_loads_as_dict(net)
    assert (p_min_loads['node-N2'] == 2200.0)
    assert (p_min_loads['node-N3'] == 2200.0)

    p_nom_feed = gas_sim._p_nom_feed_as_dict(net)
    assert (p_nom_feed['node-NF'] == 90000.0)
    assert (p_nom_feed['node-N1'] == 2500.0)

    #with pytest.warns( PendingDeprecationWarning ) as record:
    p_nodes, m_dot_pipes, m_dot_nodes, gas = gas_sim._run_sim(net)

    #assert( len( record ) == 1 )

    assert (p_nodes['node-N1'] == 2500.0)
    assert (p_nodes['node-N2'] == 1962.7)
    assert (p_nodes['node-N3'] == 1827.8)
    assert (m_dot_pipes['pipe-N1-N2'] == 0.000328)
    assert (m_dot_pipes['pipe-N1-N3'] == 0.000328)
    assert (m_dot_pipes['pipe-N2-N3'] == 6.6e-05)
    assert (m_dot_nodes['node-N1'] == -0.000656)
    assert (m_dot_nodes['node-N2'] == 0.000262)
    assert (m_dot_nodes['node-N3'] == 0.000394)
Beispiel #5
0
def test_run_sim_mp(fix_create):
    net = fix_create_full_mp()
    p_nodes, m_dot_pipes, m_dot_nodes, gas = sim._run_sim(net, level="MP")
    assert round(gas.rho, 3) == 0.683
    assert p_nodes == {
        'BUS1': 89976.5,
        'BUS2': 89957.3,
        'BUS3': 89953.5,
        'BUSF': 90000.0
    }
    assert m_dot_pipes == {
        'PIPE0': 0.001181,
        'PIPE1': 0.000469,
        'PIPE2': 0.00045,
        'PIPE3': 7.5e-05
    }
    assert m_dot_nodes == {
        'BUSF': -0.001181,
        'BUS1': 0.000262,
        'BUS2': 0.000394,
        'BUS3': 0.000525
    }
Beispiel #6
0
def runpp(net, t_grnd=10+273.15):
    sorted_levels = sorted(net.LEVELS.items(), key=operator.itemgetter(1))
    for level, value in sorted_levels:
        if level in net.bus["level"].unique():
            logging.info("Compute level {}".format(level))
            p_nodes, m_dot_pipes, m_dot_nodes, fluid = sim._run_sim(net, level, t_grnd)

            for node, value in p_nodes.items():
                if node in net.bus["name"].unique():
                    idx = get_index(node, net.bus)
                    net.res_bus.loc[idx] = [node, value]

            for pipe, m_dot in m_dot_pipes.items():
                idx = get_index(pipe, net.pipe)
                v = _v_from_m_dot(net, pipe, m_dot, fluid)
                net.res_pipe.loc[idx] = [pipe, m_dot, v, m_dot * net.LHV, 100*v/net.V_MAX]

            for node, m_dot in m_dot_nodes.items():
                if node in net.station["bus_low"].unique():
                    idx_stat = get_index(node, net.station, col="bus_low")
                    stat = net.station.at[idx_stat, "name"]
                    idx = get_index(stat, net.res_station)
                    net.res_station.loc[idx] = [
                        stat,
                        -m_dot,
                        -m_dot * net.LHV,
                        -100*m_dot*net.LHV/net.station.at[idx_stat, "p_lim_kW"]
                    ]

                if node in net.feeder["bus"].unique():
                    idx_feed = get_index(node, net.feeder, col="bus")
                    feed = net.feeder.at[idx_feed, "name"]
                    idx = get_index(feed, net.res_feeder)
                    net.res_feeder.loc[idx] = [
                        feed,
                        m_dot,
                        m_dot * net.LHV,
                        100*m_dot*net.LHV/net.feeder.at[idx_feed, "p_lim_kW"]
                    ]