In rte-antares-rpackage/antaresFlowbased: Run FlowBased Simulations on Antares

knitr::opts_chunk$set(echo = TRUE)

antaresFlowbased allows to model flow-based domains into adequacy studies using the software Antares, with the following main functionalities:

1. Preparation of the input of an Antares study to include a modelling a flow-based in the CWE area

• Projection of flow-based domains on a fix basis so as to be able to describe them in Antares with binding constraints.
• Construction of probabilistic flow-based time series respecting the correlations with other inputs of the study (e.g. load, wind power generation, solar generation).
• Automatic filling of the inputs of the Antares study

2. Post-processing and visualisation of Antares’ results

• Application of the adequacy patch to re-balance the exchanges in the CWE area in case of generation shortages
• Visualisation of the net-positions of the countries of the CWE area along with the limits imposed by the flow-based domains

This vignette describe the first set of functionnalities : the preparation of the inputs for the Antares study.

1 - Summary

#Convert domains from PTDF file, save the output in the directory "model1"
computeFB(PTDF = system.file("/input/ptdf/PTDF.csv", package = "antaresFlowbased"),
          outputName = "D:/model1", verbose = 0, nbFaces = 36)


#Set antares study path
antaresRead::setSimulationPath("D:/exemple_test", 0)

#Create flow-based time series considering their correlations with other inputs of an Antares Study, save the output in the directory "model1"
createFBTS(probabilityMatrix = probabilityMatrix, multiplier = multiplier,
           interSeasonBegin = interSeasonBegin,
           interSeasonEnd = interSeasonEnd, firstDay = firstDay, outputPath = "D:/model1")


#Set setFlowbased directory path
setFlowbasedPath(path = "D:/model1")

#Run shiny application to visualize the results of the convertion
runAppError()

#Initialize the Antares study
initFlowBased(scenario = rep(1:200, times = 5))

2 - Projection of domains

The function computeFB() converts flow-based domains (e.g. historical flow-based domains of some "typical representative days") into an Antares model with fixed PTDF. It uses the main following parameters :

• PTDF : PTDF file path
• outputName : name of output directory
• reports : Boolean indicating whether the function generates html reports or not

PTDF is a csv file with ; field separator, , for decimal points and the following columns :

• Id_day : Id of typical day (integer)
• Period : Hour (integer from 1 to 24), period i corresponds to the hourly time-step [i-1 ; i]
• BE : PTDF for be
• DE : PTDF for de
• FR : PTDF for fr
• NL : PTDF for nl
• RAM : margin

A PTDF file at this format can be automatically generated by using the function writePtdfOfTypicalDays of the package flowBasedClustering. One can also set the following optionnal arguments of the function :

• dayType : subset of typical days to process
• hour : subset of hours to process
• nbFaces : number of binding constraints in the final Antares model (by default : 36).

The function creates a directory with the following files :

• weight.txt : PTDF for the antares model (weight of the binding constraints - constant over time)
• second_member.txt : RAM for the antares model (second member of the binding constraints - variable over the typical days and hours)
• domainesFB.RDS : Information about the modeled domains (points, errors , accuracy of the model,...)
• reports : a directory, created only if reports == TRUE with a html report for each typical day.

3 - Creation of flow-based time series

The previous function - computeFB() - converts the typical flow-based days in a format suited for Antares.

The next step consists in defining, for each day of each Monte-Carlo year, which typical flow-based day will be used to bound the exchanges within the CWE area. The function createFBTS() performs this task. Possible correlations between the flow-based shapes and external variables (e.g. load, wind power generation, solar generation) can be taken into account. Therefore, the function createFBTS() considers other inputs of the Antares study and the way they influence the occurences of the typical days.

The main inputs of this function are :

• probabilityMatrix : the probability matrix carry the information on the correlations between the typical days and external variables. They are calculated with the function getProbability() of the package flowBasedClustering. The names of the columns of the probability matrix must correspond to inputs of the Antares study by respecting the following syntax area@variable (e.g. : fr@load, de@solar, be@wind). If needed, the columns can be easily renamed with the function setNamesProbabilityMatrix().

• multiplier : The probability matrix levels are usually computed on normalized data (e.g. load factor for RES generation). They can be rescale to the time series of the Antares study by using a multiplier.

• interSeasonBegin, interSeasonEnd and firstDay : defines the calendar, i.e. the the boundaries between the different seasons (winter, summer, interseason) and the week-end days. the firstDay can be automatically identified with the function identifyFirstDays() which will look for patterns in the load time series to identify which days are saturdays and sundays.

• opts : a link toward an antares study, as returned by the function setSimulationPath() from the package antaresRead.

• outputPath : directory where the file ts.txt, containing the time series of typical flow-based days, will be written.

An example of the use of createFBTS() is given below.

# build probabilityMatrix with the function getProbability() from the package flowBasedClustering
# select an antaresStudy with the function setSimulationPath() from the package antaresRead

# rename columns of the probability matrix

matProb <- setNamesProbabilityMatrix(probabilityMatrix, c("FR_load", "DE_wind", "DE_solar"),
                                   c("fr@load", "de@wind", "de@solar"))

# set multipliers

multiplier <- data.frame(variable = c("fr@load", "de@wind", "de@solar"),
                         coef = c(1, 35000, 40000))

# set Calendar
firstDay <- identifyFirstDay(opts = antaresStudy)
interSeasonBegin <- as.Date(c("2017-09-03", "2018-02-02"))
interSeasonEnd <- as.Date(c("2020-10-04", "2018-05-02"))

# create ts.txt in D:/model1
ts <- createFBTS(opts = antaresStudy, probabilityMatrix = probabilityMatrix, multiplier = multiplier,
                 interSeasonBegin = interSeasonBegin,
                 interSeasonEnd = interSeasonEnd, firstDay = firstDay, outputPath = "D:/model1")

4 - Set the flow-based model

Once the modeled flow-based domains have been created with computeFB() and createFBTS(), they can be loaded using the following function :

• setFlowbasedPath() : set the model directory (directory in which the output of computeFB() have been saved)

# Specify a repository
setFlowbasedPath(path = "C:/PATH/TO/INPUT")

The directory must contain :

• weight.txt : PTDF for the antares model (weight of the binding constraints - constant over time)
• second_member.txt : RAM for the antares model (second member of the binding constraints - variable over the typical days and hours)
• domainesFB.RDS : Information about domains (points, errors ,...)
• ts.txt : flow-based time series

5 - Visualization & reports

One can visualize the modeled flow-based domains, download the associated data or create a summary of the model accuracy in a html document using a shiny application with the function runAppError().

runAppError()

plotFB() can also be used to plot one or more domains directly in R :

library(antaresFlowbased)
setFlowbasedPath(model = "model2017")

# multiple countries and hour
plotFB(hour = 5:6, dayType = 1, country1 = c("FR", "DE"), country2 = c("DE", "NL"))

Reports in html format can also be generated within the shiny application. This solution can be use to facilitate the transmission and communication of the results.

6 - Study initialization

This last step allows to prepare the inputs of an Antares study so as to include flow-based domains to bound CWE exchanges.

It is first necessary to select an antares study using setSimulationPath() function of the package antaresRead, and the flow-based model which will be set on this study must be specified with setFlowbasedPath().

The initialization of the study is then done with the function initFlowBased(). This function creates the inputs of the Antares study related to the flow-based modelling, with the appropriate binding constraints and virtual thermal plants.

The time-series of flow-based domains used for each Monte-Carlo years are desribed with the parameter scenarios. For instance, with scenario = rep(1:200, times = 5) (default value), up to 1000 Monte-Carlo years can be simulated with 5 blocks of, successively, time series 1 to 200. This "scenario building mode" is written in the file user/flowbased/scenario.txt of the Antares Study.

antaresRead::setSimulationPath("D:/exemple_test", 0)

# initialisation of flow-based study
initFlowBased(scenario = rep(1:200, times = 5))

7 - Run simulations

Once all these steps have been performed, the Antares study can be run as usual, for instance using the run simulation button of the software interface.

rte-antares-rpackage/antaresFlowbased documentation built on Oct. 19, 2020, 11:23 a.m.