Thermobench.jl

mutable struct Data
    df::DataFrame
    name::String                # label for plotting
    meta::Dict
end

Data read from thermobench CSV file. You can access the actual data either via d.df (e.g. d.df.ambient) or via a shortcut d.ambient.

Copy existing Data d, but replace the DataFrame with df.

Stores results of processing of one or more thermobench CSV files.

The main data is stored in the result field.

rename!(mf::MultiFit, name)

Rename MultiFit data structure.

The name is often used as graph label so renaming can be used to set descriptive graph labels.

fit(
    time_s::Vector{Float64},
    data::Vector{Float64};
    order::Int64 = 2,
    p0 = nothing,
    tau_bounds = [(1, 60*60)],
    k_bounds = [(-120, 120)],
    T_bounds = (0, 120),
    use_cmpfit::Bool = true,
 )

Fit a thermal model to time series given by time_s and data. The thermal model has the form of

\[T(t) = T_∞ + \sum_{i=1}^{order}k_i⋅e^{-\frac{t}{τ_i}},\]

where T_∞, kᵢ and τᵢ are the coefficients found by this function.

If use_cmpfit is true (the default), use CMPFit.jl package rather than LsqFit.jl. LsqFit doesn't work well in constrained settings.

You can limit the values of fitted parameters with *_bounds parameters. Each bound is a tuple of lower and upper limit. T_bounds limits the T∞ parameter. tau_bounds and k_bounds limit the coefficients of exponential functions $k·e^{-t/τ}$. If you specify less tuples than the order of the model, the last limit will be repeated.

Example

julia> using StatsBase: coef

julia> d = Thermobench.read("test.csv");


julia> f = fit(d.df.time, d.df.CPU_0_temp);


julia> coef(f)
5-element Vector{Float64}:
  53.000281131995216
 -13.124669351494804
 317.6295458318768
  -8.162698170955293
  59.36603736868179

julia> printfit(f)
"53.0 – 8.2⋅e^{−t/59.4} – 13.1⋅e^{−t/317.6}"

interpolate!(d::Data)
interpolate!(df::AbstractDataFrame)

In-place version of interpolate.

interpolate(d::Data)
interpolate(df::AbstractDataFrame)

Replace missing values with results of linear interpolation performed against the first column (time).

julia> x = DataFrame(t=[0.0, 1, 2, 3, 1000, 1001], v=[0.0, missing, missing, missing, 1000.0, missing])
6×2 DataFrame
 Row │ t        v
     │ Float64  Float64?
─────┼────────────────────
   1 │     0.0        0.0
   2 │     1.0  missing
   3 │     2.0  missing
   4 │     3.0  missing
   5 │  1000.0     1000.0
   6 │  1001.0  missing

julia> interpolate(x)
6×2 DataFrame
 Row │ t        v
     │ Float64  Float64?
─────┼────────────────────
   1 │     0.0        0.0
   2 │     1.0        1.0
   3 │     2.0        2.0
   4 │     3.0        3.0
   5 │  1000.0     1000.0
   6 │  1001.0  missing

multi_fit(sources, columns = :CPU_0_temp;
          name = nothing,
          timecol = :time,
          use_measurements = false,
          order::Int64 = 2,
          subtract = nothing,
          kwargs...)::MultiFit

Call fit() for all sources and report the results (coefficients etc.) in DataFrame. When use_measurements is true, report coefficients with their confidence intervals as Measurement objects.

subtract specifies the column (symbol), which is subtracted from data after interpolating its values with interpolate. This intended for subtraction of ambient temperature.

julia> multi_fit("test.csv", [:CPU_0_temp :CPU_1_temp])
Thermobench.MultiFit: test.csv
    2×9 DataFrame
 Row │ name      column      rmse      ops                Tinf     k1        t ⋯
     │ String    Symbol      Float64   Measurem…          Float64  Float64   F ⋯
─────┼──────────────────────────────────────────────────────────────────────────
   1 │ test.csv  CPU_0_temp  0.308966  3.9364e8±280000.0  53.0003  -8.1627   5 ⋯
   2 │ test.csv  CPU_1_temp  0.288719  3.9364e8±280000.0  54.0527  -7.17072  5
                                                               3 columns omitted

normalize_units!(d::Data)

Normalize units to seconds and °C.

ops_est(d::Data, col_idx = r"work_done")::Measurement

Return sum of operations per second estimations calculated from multiple work_done columns. This is most often used for calculating "performance" of all CPUs together. The result is obtained by combining sample_mean_est and ops_per_sec for all matching columns.

Optional arguments

• drop_inf argument is passed to ops_per_sec function,
• alpha is passed to sample_mean_est.

Example

julia> ops_est(Thermobench.read("test.csv"))
3.9364e8 ± 280000.0

ops_per_sec(d::Data, column = :work_done)::Vector{Float64}

Return a vector of operations per second calculated by combining information from time and work_done-type column identified with column.

Optional arguments

• decimate::Int64 - Use only every n-th "work_done" row (n = decimate). Defaults to 1. Special value 0 means use only first and last value.
• drop_inf - If true, infinity values (if any) are removed from the resulting vector. Defaults to false.

julia> ops_per_sec(Thermobench.read("test.csv"), :CPU0_work_done) |> ops->ops[1:3]
3-element Vector{Float64}:
 5.499226671249357e7
 5.498016096730722e7
 5.4862923057965025e7

Plot various Thermobench data types.

plot(d::Data, columns = :CPU_0_temp; kwargs...)

Plot raw values from Thermobench .csv file stored in d. data.

Arguments

• columns: Column or array of columns to plot (columns are specified as Julia symbols)
• with: Gnuplot's "with" value – chooses how the data is plot. Defaults to "points".
• title: Custom title for all plotted columns. Default title is column title of each plot column.
• enhanced: Use Gnuplot enhanced markup for title. Default is false.
• minutes::Bool=false: chooses between seconds and minutes on the x-axis.

plot(mf::MultiFit; kwargs...)::Vector{Gnuplot.PlotElement}

Plot MultiFit data.

Arguments

• minutes::Bool=true: chooses between seconds and minutes on the x-axis.
• pt_titles::Bool=true whether to include titles of measured data points in separate legend column.
• pt_decim::Int=1 draw only every pt_decim-th measured data point. This can be used to reduce the size of vector image formats.
• pt_size::Real=1 size of measured data points.
• pt_saturation::Real=0.4 intensity of points (0 is white, 1 is saturate)
• stddev::Bool=true whether to include root-mean-square error of the fit in the legend (as (±xxx)).
• models::Bool=true whether show thermal model expressions in the key.

plot_Tinf(mfs::MultiFit...; kwargs...)::Vector{Gnuplot.PlotElement}

Plot $T_∞$ as bargraphs. Multiple data sets can be passed as arguments to compare them. kwargs are passed to Thermobench.plot_bars.

plot_Tinf_and_ops(mf::MultiFit; kwargs...)::Vector{Gnuplot.PlotElement}

Plot $T_∞$ and performance (ops per second from ops_est) as a bargraph.

Arguments

• perf_str: Title to show for the performance legend and y-axis. Default is "Performance".

plot_bars(df::AbstractDataFrame; kwargs...)::Vector{Gnuplot.PlotElement}

Generic helper function to plot bar graphs with Gnuplot.jl.

Arguments

• df: data to plot. The first column should contains text labels, the other columns the plotted values. If the values are of Measurement type, they will be plotted with errorbars style, unless overridden with hist_style.
• box_width=0.8: the width of the boxes. One means that the boxes touch each other.
• gap::Union{Int64,Nothing}=nothing: The gap between bar clusters. If nothing, it is set automatically depending on the number of bars in the cluster; to zero for one bar in the cluster, to 1 for multiple bars.
• hist_style=nothing: histogram style — see Gnuplot documentation.
• fill_style="solid 1 border -1": fill style — see Gnuplot documentation.
• errorbars="": errorbars style — see Gnuplot documentation.
• label_rot=-30: label rotation angle; if > 0, align label to right.
• label_enhanced=false: whether to apply Gnuplot enhanced formatting to labels.
• key_enhanced=false: whether to apply Gnuplot enhanced formatting to data keys.
• y2cols=[]: Columns (specified as symbols) which should be plot against y2 axis.
• linetypes=1:ncol(df)-1: Line types (colors) used for different bars

Example

julia> using Measurements, Gnuplot

julia> df = DataFrame(names=["very long label", "b", "c"],
                      temp=10:12,
                      speed=collect(4:-1:2) .± 1)
3×3 DataFrame
 Row │ names            temp   speed
     │ String           Int64  Measurem…
─────┼───────────────────────────────────
   1 │ very long label     10    4.0±1.0
   2 │ b                   11    3.0±1.0
   3 │ c                   12    2.0±1.0

julia> @gp Thermobench.plot_bars(df)

plot_fit(sources, columns = :CPU_0_temp;
         timecol = :time,
         kwargs...)

Call fit for all sources and columns and produce a graph using gnuplot.

sources can be a file name (String) or a DataFrame or an array of these.

timecol is the columns with time of measurement.

Setting plotexp to true causes the individual fitted exponentials to be plotted in addition to the compete fitted function.

Other kwargs are passed to fit.

Example

julia> plot_fit("test.csv", [:CPU_0_temp :CPU_1_temp], order=2);

printfit(fit; minutes = false)

Return the fitted function (result of fit) as Gnuplot enhanced string. Time constants (τᵢ) are sorted from smallest to largest.

Example

julia> f = Thermobench.fit(collect(0.0:10:50.0), [0, 6, 6.5, 6.8, 7, 7]);

julia> printfit(f)
"7.1 – 5.0⋅e^{−t/1.0} – 2.1⋅e^{−t/16.1}"

read(source; normalizeunits=true, stripunits=true, name=nothing, kwargs...)::Data

Read thermobech CSV file source and return it as Thermobench.Data.

The source can be a file name or an IO stream. By default units are normalized with normalize_units! and stripped from column names with strip_units!. name is stored in the resulting data structure and often serves as a graph label. If name is not specified it is set (if possible) to the basename of the CSV file. kwargs are stored in the resulting structure as metadata.

Note that future versions of this function may have new arguments that will conflict with your metadata in kwargs. The new arguments will not contain _ in their names so you can use this character in the keywords to ensure forward compatibility.

sample_mean_est(sample; alpha = 0.05)::Measurement

Calculate sample mean estimation and its confidence interval at alpha significance level, e.g. alpha=0.05 for 95% confidence. Return Measurement value.

Example

julia> sample_mean_est([1,2,3])
2.0 ± 4.3

strip_units!(d::Data)

Strip unit names from DataFrame column names.

Example

julia> d = Thermobench.read("test.csv", stripunits=false);


julia> names(d.df)[1:3]
3-element Vector{String}:
 "time_s"
 "CPU_0_temp_°C"
 "CPU_1_temp_°C"

julia> Thermobench.strip_units!(d)


julia> names(d.df)[1:3]
3-element Vector{String}:
 "time"
 "CPU_0_temp"
 "CPU_1_temp"

thermocam_correct!(d::Data)

Estimate correction for thermocamera temperatures and apply it. Return the correction coefficients.

Correction is calculated from CPU_0_temp and cam_cpu columns. This and the names of modified columns are currently hard coded.

write(file, mf::MultiFit)

Write multi_fit() results to a CSV file file.

write(file, d::Data)
d |> write(file)

Write raw thermobench data d to file named file.

julia> const T = Thermobench;

julia> T.read("test.csv") |> interpolate! |> T.write("interpolated.csv");

Construct array of symbols from arguments.

Useful for constructing column names, e.g.,

julia> @symarray Cortex_A57_temp Denver2_temp
2-element Vector{Symbol}:
 :Cortex_A57_temp
 :Denver2_temp