Ejemplo n.º 1
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=15 * 60)
    hhsim = world.start('HouseholdSim')
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)

    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children
    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE,
                                    grid_name=GRID_NAME).children
    pvs = pvsim.PV.create(20)

    # Connect entities
    connect_buildings_to_grid(world, houses, grid)
    connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')

    # Database
    db = world.start('DB', step_size=60, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5, 'P_from', 'Q_from', 'P_to',
                        'P_from')
Ejemplo n.º 2
0
def create_scenario(world):
    # start simulators
    pypower = world.start('PyPower', step_size = 15*60)
    hhsim = world.start('HouseholdSim')
    pvsim = world.start('CSV', sim_start = START, datafile = PV_DATA)
    
    energy_market = world.start('CSV', sim_start = START, datafile = ENERGY_REQUIREMENTS_FILE)
    vpp_server = world.start('VPPServer')
    pvcontroller = world.start('PVController')
    
    # Instantiate models
    grid = pvcontroller.Grid(gridfile=GRID_FILE).children
    houses = hhsim.ResidentialLoads(sim_start = START, profile_file = PROFILE_FILE, grid_name = GRID_NAME).children
    pvs = pvsim.PV.create(20)
    market = energy_market.Market.create(20)
    vpps = vpp_server.VPPServer(p_peak=PV_PEAK)
    pvcs = pvcontroller.PVController.create(NUMBER_OF_PV_PLANTS)


    #connect entities
    connect_buildings_to_grid(world, house, grid)
    connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')
    
    connect_many_to_one(world, pvs, market, vpps, 'P')
    connect.world(world, vpps, pvcs, 'V')
    
    # Database
    db = world.start('DB', step_size=60, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5,
                        'P_from', 'Q_from', 'P_to', 'P_from')
    #web visualization
      webvis = world.start('WebVis', start_date=START, step_size=60)
Ejemplo n.º 3
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=15 * 60)
    hhsim = world.start('HouseholdSim')
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)

    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children
    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE,
                                    grid_name=GRID_NAME).children
    pvs = pvsim.PV.create(20)

    # Connect entities
    connect_buildings_to_grid(world, houses, grid)
    connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')

    # Database
    db = world.start('DB', step_size=60, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5, 'P_from', 'Q_from', 'P_to',
                        'P_from')

    # Web visualization
    webvis = world.start('WebVis', start_date=START, step_size=60)
    webvis.set_config(
        ignore_types=['Topology', 'ResidentialLoads', 'Grid', 'Database'])
    vis_topo = webvis.Topology()

    connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
    webvis.set_etypes({
        'RefBus': {
            'cls': 'refbus',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 30000,
        },
        'PQBus': {
            'cls': 'pqbus',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 230,
            'min': 0.99 * 230,
            'max': 1.01 * 230,
        },
    })

    connect_many_to_one(world, houses, vis_topo, 'P_out')
    webvis.set_etypes({
        'House': {
            'cls': 'load',
            'attr': 'P_out',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 3000,
        },
    })

    connect_many_to_one(world, pvs, vis_topo, 'P')
    webvis.set_etypes({
        'PV': {
            'cls': 'gen',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -10000,
            'max': 0,
        },
    })
Ejemplo n.º 4
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=60)
    hhsim = world.start('HouseholdSim')  # Household simulators have by default the step size of 15 minutes. 
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)
    if not GEN_DATA == None:
        gensim = world.start('HouseholdSim')
    rtusim = world.start('RTUSim')


    # Instantiate models
    grid_inf = pypower.Grid(gridfile=GRID_FILE)
    grid = grid_inf.children
    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE, # file with household profiles
                                    grid_name=GRID_NAME).children
    pvs = pvsim.PV.create(5)
    if not GEN_DATA == None:
        gens = gensim.ResidentialLoads(sim_start=START,
                                        profile_file=GEN_DATA,  # file with generators profiles
                                        grid_name=GRID_NAME).children
    rtu_sim = rtusim.RTU(rtu_ref=RTU_FILE)
    rtu=rtu_sim.children

    # Connect entities - this defines the data flow between the simulators 
    # A provides input for B connect(A, B); but B provides "schedule" or control to A
   # world.connect(grid_inf, topology, 'newgrid', async_requests=True)
    connect_buildings_to_grid(world, houses, grid)
    if not GEN_DATA == None:
        connect_buildings_to_grid(world, gens, grid)

    connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')
    #if not GEN_DATA == None:
        #connect_randomly(world, gens, [e for e in grid if 'node' in e.eid], 'P')

    # Database
    db = world.start('DB', step_size=60, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')
    if not GEN_DATA == None:
        connect_many_to_one(world, gens, hdf5, 'P_out')


    logger.warning("Connecting sensors to grid...")
    connect_sensors_to_grid(world, rtu, grid)


    world.connect(grid_inf, rtu_sim, 'switchstates',  async_requests=True)

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')   # connect_many_to_one : (world, source, destibation)

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5,
                        'P_from', 'Q_from', 'P_to', 'Q_to')



    # Web visualization
    webvis = world.start('WebVis', start_date=START, step_size=60)
    webvis.set_config(ignore_types=['Topology', 'ResidentialLoads', 'Grid',
                                    'Database', 'TopologyModel', 'RTU', 'sensor', 'switch'])
    vis_topo = webvis.Topology()

    connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
    webvis.set_etypes({
        'None': {
            'cls': 'none',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 0,
            'min': 0,
            'max': 0,
        },
        'RefBus': {
            'cls': 'refbus',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 10000,
            'min': 0,
            'max': 30000,
        },
        'PQBus': {
            'cls': 'pqbus',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 10000,
            'min': 0.9 * 10000,
            'max': 1.1 * 10000,
        },
    })

    connect_many_to_one(world, houses, vis_topo, 'P_out')
    webvis.set_etypes({
        'House': {
            'cls': 'load',
            'attr': 'P_out',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 3000,
        },
    })

    connect_many_to_one(world, pvs, vis_topo, 'P')
    webvis.set_etypes({
        'PV': {
            'cls': 'pv',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -10000,
            'max': 0,
        },
    })

    if not GEN_DATA == None:
        connect_many_to_one(world, gens, vis_topo, 'P_out')
    webvis.set_etypes({
        'GEN': {
            'cls': 'gen',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -10000,
            'max': 0,
        },
    })
Ejemplo n.º 5
0
def create_scenario(world, parameter):
    # start simulators
    # check the constant and the variable parameters
    if parameter == "adjust_feedin":
        pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)
    else:
        pvsim = world.start('CSV', sim_start=START, datafile=PV_CONST_DATA)

    if parameter == "adjust_market_requirements":
        energy_market = world.start('CSV',
                                    sim_start=START,
                                    datafile=ENERGY_REQUIREMENTS_FILE)
    else:
        energy_market = world.start('CSV',
                                    sim_start=START,
                                    datafile=ENERGY_REQUIREMENTS_CONST_FILE)

    if parameter == "adjust_hh_demand":
        hhsim = world.start('HouseholdSim')
    else:
        hhsim = world.start('HouseholdConstSim')

    pypower = world.start('PyPower', step_size=15 * 60)

    const = world.start('CONST')

    vpp_server = world.start('VPPServer')
    pvcontroller = world.start('PVController')
    cmd = world.start('CMD')
    # Instantiate models
    grid = pvcontroller.Grid(gridfile=GRID_FILE).children
    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE,
                                    grid_name=GRID_NAME).children
    pvs = pvsim.PV.create(20)
    market = energy_market.Market.create(20)
    vpps = vpp_server.VPPServer(p_peak=PV_PEAK)
    pvcs = pvcontroller.PVController.create(NUMBER_OF_PV_PLANTS)
    console = cmd.Console()
    consts = const.Const.create(10,
                                value=1)  # list of ten constants with value 1

    # connect entities
    connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')

    connect_many_to_one(world, pvs, market, vpps, 'P')
    world.connect(world, vpps, pvcs, 'V')

    # Database
    db = world.start('DB', step_size=60, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')
    connect_many_to_one(world, consts, console, 'val')
    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5, 'P_from', 'Q_from', 'P_to',
                        'P_from')
Ejemplo n.º 6
0
def main():

    random.seed(23)
    # Create World
    world = mosaik.World(SIM_CONFIG)

    # Start simulators
    factoryModeles = world.start('SimulateurModels')
    factoryBat = world.start('SimulateurModels')
    factoryDispatcher = world.start('Dispatcher')
    factoryProfileP = world.start('CSV', sim_start=START, datafile=PROFILE_P)
    factoryProfileC = world.start('CSV', sim_start=START, datafile=PROFILE_C)
    webvis = world.start('WebVis', start_date=START, step_size=60)
    webvis.set_config(ignore_types=['Topology', 'ResidentialLoads', 'Grid', 'Database'])
    vis_topo = webvis.Topology()

    # Instantiate models
    print("instanciation Dispatcher")
    entitesDispatcher = factoryDispatcher.ModelDispatcher.create(NB_DISPATCHER)
    connect_many_to_one(world, entitesDispatcher, vis_topo, 'Oequilibre')

    for dispatcher in entitesDispatcher:
        #creation des noeuds
        entiteCA = factoryModeles.ModelCA()
        batterie = factoryBat.Batterie()
        entitePP = factoryProfileP.ModelProfil()  # .create(1)
        entitePC = factoryProfileC.ModelProfil()  # .create(1)
        entiteBC = factoryModeles.ModelBC()
        entiteBP = factoryModeles.ModelBP()
        # Connection des noeuds
        # Un CA est compose d'une batterie, d'un systeme de production et de consommation
        world.connect(entitePP, entiteCA, ('P', 'Iproduction'))
        world.connect(entitePC, entiteCA, ('P', 'Iconsommation'))
        world.connect(batterie, entiteCA, ('Ocharge', 'Icharge'))
        world.connect(entiteCA, batterie, ('Ocharge', 'Icharge'), time_shifted=True, initial_data={'Ocharge': 10})
        # On connecte au dispatcher, un CA, un BP, un BC
        world.connect(entiteCA, dispatcher, ('Oconsommation','Iconsommation'))
        world.connect(dispatcher, entiteCA, ('Oequilibre','Iequilibre'), time_shifted=True, initial_data={'Oequilibre': 0})
        world.connect(entiteBC, dispatcher, ('Oconsommation', 'Iconsommation'))
        world.connect(entiteBP, dispatcher, ('Oproduction', 'Iproduction'))
        # On connecte les noeuds a la visualisation web
        world.connect(entiteBC, vis_topo, 'Oconsommation')
        world.connect(entiteBP, vis_topo, 'Oproduction')
        world.connect(entitePP, vis_topo, 'P')
        world.connect(entitePC, vis_topo, 'P')
        world.connect(batterie, vis_topo, 'Ocharge')
        world.connect(entiteCA, vis_topo, 'Oconsommation')

    webvis.set_etypes({
        'Batterie': {
            'cls': 'load',
            'attr': 'Ocharge',
            'unit': 'Charge',
            'default': 0,
            'min': 0,
            'max': 100,
        }, })
    webvis.set_etypes({
        'ModelProfil': {
            'cls': 'load',
            'attr': 'P',
            'unit': 'P.',
            'default': 0,
            'min': -1000,
            'max': 1000,
        }, })
    webvis.set_etypes({
        'ModelCA': {
            'cls': 'load',
            'attr': 'Oconsommation',
            'unit': 'Conso.',
            'default': 0,
            'min': 0,
            'max': 100,
        }, })
    webvis.set_etypes({
        'ModelBC': {
            'cls': 'load',
            'attr': 'Oconsommation',
            'unit': 'Conso.',
            'default': 0,
            'min': 0,
            'max': 100,
        }, })
    webvis.set_etypes({
        'ModelBP': {
            'cls': 'load',
            'attr': 'Oproduction',
            'unit': 'Prod.',
            'default': 0,
            'min': 0,
            'max': 3000,
        }, })
    webvis.set_etypes({
        'ModelDispatcher': {
            'cls': 'load',
            'attr': 'Oequilibre',
            'unit': 'Equ.',
            'default': 0,
            'min': -3000,
            'max': 3000,
        },})

    webbrowser.open('http://localhost:8000')
    # Run simulation
    world.run(until=END)
Ejemplo n.º 7
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=STEP)
    hhsim = world.start('HouseholdSim')
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)

    ns3 = world.start('NS3',
                      step_size=STEP,
                      sim_end=END,
                      subserver=STATION_SUBSERVER,
                      protocol=PROTOCOL)

    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children

    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE,
                                    grid_name=GRID_NAME).children

    pvs = pvsim.PV.create(
        NUM_PRODUCERS)  #TODO precisa fazer direto do grid_file ainda

    ns3TopoHelper = ns3Topo.Topo(world, houses,
                                 GRID_FILE)  #TODO arrumar o path desse arquivo
    p2pTopo = ns3TopoHelper.create_p2p_topo()
    ns3TopoHelper.create_file(p2pTopo)

    ns3nodes = ns3.Network(topology_file=TOPO_FILE).children

    # Connect entities
    connect_buildings_to_grid(world, houses, grid)
    connect_producers(world, pvs,
                      grid)  #trocar connect_random por uma configuração
    connect_to_network(world, houses, pvs, grid, ns3nodes)

    # Database
    db = world.start('DB', step_size=STEP, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5, 'P_from', 'Q_from', 'P_to',
                        'P_from')

    # Web visualization
    webvis = world.start('WebVis', start_date=START, step_size=STEP)
    webvis.set_config(
        ignore_types=['Topology', 'ResidentialLoads', 'Grid', 'Database'])
    vis_topo = webvis.Topology()

    connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
    webvis.set_etypes({
        'RefBus': {
            'cls': 'refbus',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 30000,
        },
        'PQBus': {
            'cls': 'pqbus',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 230,
            'min': 0.99 * 230,
            'max': 1.01 * 230,
        },
    })

    connect_many_to_one(world, houses, vis_topo, 'P_out')
    webvis.set_etypes({
        'House': {
            'cls': 'load',
            'attr': 'P_out',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 3000,
        },
    })

    connect_many_to_one(world, pvs, vis_topo, 'P')
    webvis.set_etypes({
        'PV': {
            'cls': 'gen',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -10000,
            'max': 0,
        },
    })
Ejemplo n.º 8
0
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5,
                        'P_from', 'Q_from', 'P_to', 'P_from')
    #web visualization
      webvis = world.start('WebVis', start_date=START, step_size=60)
    webvis.set_config(ignore_types=['Topology', 'ResidentialLoads', 'Grid',
                                    'Database'])
    vis_topo = webvis.Topology()

    connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
    webvis.set_etypes({
        'RefBus': {
            'cls': 'refbus',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 30000,
        },
        'PQBus': {
            'cls': 'pqbus',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 230,
            'min': 0.99 * 230,
Ejemplo n.º 9
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=15 * 60)
    hhsim = []
    for i in range(0, RESIDENTIAL_AREA):
        hhsim.append(
            world.start('HouseholdSim',
                        N=NQUBIT,
                        protocol=PROTOCOLS[PROTOCOL_USED],
                        Eve=EVE_SIMULATION,
                        drFreq=DEMAND_FREQUENCY))
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)
    cc = world.start('ControlCenter',
                     step_size=1,
                     N=NQUBIT,
                     protocol=PROTOCOLS[PROTOCOL_USED],
                     Eve=EVE_SIMULATION,
                     simulationNumber=START_REAL_TIME,
                     simulation=SIMULATION_OUTPUT,
                     drFreq=DEMAND_FREQUENCY * 60)

    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children
    houses = []
    for i in range(0, RESIDENTIAL_AREA):
        houses.append(hhsim[i].ResidentialLoads(sim_start=START,
                                                profile_file=PROFILE_FILE,
                                                grid_name=GRID_NAME).children)
    pvs = pvsim.PV.create(12)
    controlCenter = cc.CC()

    # Connect entities
    for i in range(0, RESIDENTIAL_AREA):
        connect_buildings_to_grid(world, houses[i], grid)
    # Connect to the Control Center
    for i in range(0, RESIDENTIAL_AREA):
        connect_many_to_one(world,
                            houses[i],
                            controlCenter, ('hhrequest', 'ccresponse'),
                            async_requests=True)
    connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')

    # Database
    if SIMULATION_OUTPUT == False:
        nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
        branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
        # Web visualization
        webvis = world.start('WebVis', start_date=START, step_size=120)
        webvis.set_config(
            ignore_types=['Topology', 'ResidentialLoads', 'Grid', 'Database'])
        vis_topo = webvis.Topology()

        connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
        webvis.set_etypes({
            'RefBus': {
                'cls': 'refbus',
                'attr': 'P',
                'unit': 'P [W]',
                'default': 0,
                'min': 0,
                'max': 30000,
            },
            'PQBus': {
                'cls': 'pqbus',
                'attr': 'Vm',
                'unit': 'U [V]',
                'default': 230,
                'min': 0.99 * 230,
                'max': 1.01 * 230,
            },
        })
        for i in range(0, RESIDENTIAL_AREA):
            connect_many_to_one(world, houses[i], vis_topo, 'P_out',
                                'hhrequest')
        webvis.set_etypes({
            'House': {
                'cls': 'load',
                'attr': 'P_out',
                'unit': 'P [W]',
                'default': 0,
                'min': 0,
                'max': 3000,
            },
        })

        connect_many_to_one(world, pvs, vis_topo, 'P')
        webvis.set_etypes({
            'PV': {
                'cls': 'gen',
                'attr': 'P',
                'unit': 'P [W]',
                'default': 0,
                'min': -10000,
                'max': 0,
            },
        })

        world.connect(controlCenter, vis_topo, 'ccresponse')
        webvis.set_etypes({
            'CC': {
                'cls': 'cc',
                'attr': 'ccresponse',
                'unit': 'Qubits [S]',
                'default': 0,
                'min': 0,
                'max': 1000,
            },
        })
Ejemplo n.º 10
0
def create_scenario(world):
    # Start simulators
    pypower = world.start("PyPower", step_size=15 * 60)
    hhsim = world.start("HouseholdSim")
    pvsim = world.start("CSV", sim_start=START, datafile=PV_DATA)

    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children
    houses = hhsim.ResidentialLoads(sim_start=START, profile_file=PROFILE_FILE, grid_name=GRID_NAME).children
    pvs = pvsim.PV.create(20)

    # Connect entities
    connect_buildings_to_grid(world, houses, grid)
    connect_randomly(world, pvs, [e for e in grid if "node" in e.eid], "P")

    # Database
    db = world.start("DB", step_size=60, duration=END)
    hdf5 = db.Database(filename="demo.hdf5")
    connect_many_to_one(world, houses, hdf5, "P_out")
    connect_many_to_one(world, pvs, hdf5, "P")

    nodes = [e for e in grid if e.type in ("RefBus, PQBus")]
    connect_many_to_one(world, nodes, hdf5, "P", "Q", "Vl", "Vm", "Va")

    branches = [e for e in grid if e.type in ("Transformer", "Branch")]
    connect_many_to_one(world, branches, hdf5, "P_from", "Q_from", "P_to", "P_from")

    # Web visualization
    webvis = world.start("WebVis", start_date=START, step_size=60)
    webvis.set_config(ignore_types=["Topology", "ResidentialLoads", "Grid", "Database"])
    vis_topo = webvis.Topology()

    connect_many_to_one(world, nodes, vis_topo, "P", "Vm")
    webvis.set_etypes(
        {
            "RefBus": {"cls": "refbus", "attr": "P", "unit": "P [W]", "default": 0, "min": 0, "max": 30000},
            "PQBus": {
                "cls": "pqbus",
                "attr": "Vm",
                "unit": "U [V]",
                "default": 230,
                "min": 0.99 * 230,
                "max": 1.01 * 230,
            },
        }
    )

    connect_many_to_one(world, houses, vis_topo, "P_out")
    webvis.set_etypes({"House": {"cls": "load", "attr": "P_out", "unit": "P [W]", "default": 0, "min": 0, "max": 3000}})

    connect_many_to_one(world, pvs, vis_topo, "P")
    webvis.set_etypes({"PV": {"cls": "gen", "attr": "P", "unit": "P [W]", "default": 0, "min": -10000, "max": 0}})
Ejemplo n.º 11
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=15*60)
    hhsim = world.start('HouseholdSim')
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)

    # =======================================
    # inicializa as classes que irão representar
    # cada um dos agentes dispositivos via
    # comunicação com a plataforma PADE
    # =======================================
    device_agent_sim_dict = dict()
    for i, name in device_agent_sim_names.items():
        device_agent_sim = world.start(name,
                                       eid_prefix='DeviceAgent_',
                                       prosumer_ref=i,
                                       start=START,
                                       step_size=1 * 60) # o step de tempo é dado em segundos
        device_agent_sim_dict[i] = device_agent_sim


    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children
    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE,
                                    grid_name=GRID_NAME).children
    pvs = pvsim.PV.create(PV_QTD)

    device_agents = [i.DeviceAgent.create(1)[0] for i in device_agent_sim_dict.values()]

    # Connect entities
    connect_buildings_to_grid(world, houses, grid)
    # connect_randomly(world, pvs, [e for e in grid if 'node' in e.eid], 'P')
    
    buses = [e for e in grid if 'node' in e.eid]
    buses_indexs = random.sample(range(len(pvs)), len(pvs))
    for pv, i in zip(pvs, buses_indexs):
        world.connect(pv, buses[i], 'P')
        world.connect(pv, device_agents[i], 'P')
        world.connect(device_agents[i], buses[i], 'P')
    
    # connect_buildings_to_agents(world, houses, device_agents)

    # Database
    db = world.start('DB', step_size=60, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5,
                        'P_from', 'Q_from', 'P_to', 'P_from')

    # Web visualization
    webvis = world.start('WebVis', start_date=START, step_size=60)
    webvis.set_config(ignore_types=['Topology', 'ResidentialLoads', 'Grid',
                                    'Database'])
    vis_topo = webvis.Topology()

    connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
    webvis.set_etypes({
        'RefBus': {
            'cls': 'refbus',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 30000,
        },
        'PQBus': {
            'cls': 'pqbus',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 230,
            'min': 0.99 * 230,
            'max': 1.01 * 230,
        },
    })

    connect_many_to_one(world, houses, vis_topo, 'P_out')
    webvis.set_etypes({
        'House': {
            'cls': 'load',
            'attr': 'P_out',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 3000,
        },
    })

    connect_many_to_one(world, pvs, vis_topo, 'P')
    webvis.set_etypes({
        'PV': {
            'cls': 'gen',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -10000,
            'max': 0,
        },
    })

    connect_many_to_one(world, device_agents, vis_topo, 'P')
    webvis.set_etypes({
        'DeviceAgent': {
            'cls': 'storage',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -1000,
            'max': 0,
        },
    })
Ejemplo n.º 12
0
def create_scenario(world):
    # Start simulators
    pypower = world.start('PyPower', step_size=STEP)
    hhsim = world.start('HouseholdSim')
    pvsim = world.start('CSV', sim_start=START, datafile=PV_DATA)
    
    ns3 = world.start('NS3',step_size=STEP,sim_end=END,subserver=STATION_SUBSERVER,protocol=PROTOCOL);

    # Instantiate models
    grid = pypower.Grid(gridfile=GRID_FILE).children
    
    houses = hhsim.ResidentialLoads(sim_start=START,
                                    profile_file=PROFILE_FILE,
                                    grid_name=GRID_NAME).children

    pvs = pvsim.PV.create(NUM_PRODUCERS) #TODO precisa fazer direto do grid_file ainda
    
    ns3TopoHelper = ns3Topo.Topo(world,houses,GRID_FILE) #TODO arrumar o path desse arquivo
    p2pTopo = ns3TopoHelper.create_p2p_topo()
    ns3TopoHelper.create_file(p2pTopo)
    
    ns3nodes = ns3.Network(topology_file=TOPO_FILE).children

    # Connect entities
    connect_buildings_to_grid(world, houses, grid)
    connect_producers(world, pvs, grid)#trocar connect_random por uma configuração
    connect_to_network(world,houses,pvs,grid,ns3nodes)

    # Database
    db = world.start('DB', step_size=STEP, duration=END)
    hdf5 = db.Database(filename='demo.hdf5')
    connect_many_to_one(world, houses, hdf5, 'P_out')
    connect_many_to_one(world, pvs, hdf5, 'P')

    nodes = [e for e in grid if e.type in ('RefBus, PQBus')]
    connect_many_to_one(world, nodes, hdf5, 'P', 'Q', 'Vl', 'Vm', 'Va')

    branches = [e for e in grid if e.type in ('Transformer', 'Branch')]
    connect_many_to_one(world, branches, hdf5,
                        'P_from', 'Q_from', 'P_to', 'P_from')

    # Web visualization
    webvis = world.start('WebVis', start_date=START, step_size=STEP)
    webvis.set_config(ignore_types=['Topology', 'ResidentialLoads', 'Grid',
                                    'Database'])
    vis_topo = webvis.Topology()
    
    connect_many_to_one(world, nodes, vis_topo, 'P', 'Vm')
    webvis.set_etypes({
        'RefBus': {
            'cls': 'refbus',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 30000,
        },
        'PQBus': {
            'cls': 'pqbus',
            'attr': 'Vm',
            'unit': 'U [V]',
            'default': 230,
            'min': 0.99 * 230,
            'max': 1.01 * 230,
        },
    })

    connect_many_to_one(world, houses, vis_topo, 'P_out')
    webvis.set_etypes({
        'House': {
            'cls': 'load',
            'attr': 'P_out',
            'unit': 'P [W]',
            'default': 0,
            'min': 0,
            'max': 3000,
        },
    })

    connect_many_to_one(world, pvs, vis_topo, 'P')
    webvis.set_etypes({
        'PV': {
            'cls': 'gen',
            'attr': 'P',
            'unit': 'P [W]',
            'default': 0,
            'min': -10000,
            'max': 0,
        },
    })