log2tab

#!/usr/bin/perl
################################################################################
# This file is part of a collection of embedded Runge-Kutta solvers.           #
# Copyright (C) 2009-2021, Matthias Korch, University of Bayreuth, Germany.    #
#                                                                              #
# This program is free software: you can redistribute it and/or modify         #
# it under the terms of the GNU General Public License as published by         #
# the Free Software Foundation, either version 3 of the License, or            #
# (at your option) any later version.                                          #
#                                                                              #
# This program is distributed in the hope that it will be useful,              #
# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
# GNU General Public License for more details.                                 #
#                                                                              #
# You should have received a copy of the GNU General Public License            #
# along with this program.  If not, see <https://www.gnu.org/licenses/>.       #
################################################################################

use strict;
use warnings;

use File::Basename;
use Getopt::Long;

my $want_head = 0;
my $want_pmd  = 0;
my $want_help = 0;
my $sep       = ',';

GetOptions(
  'separator=s' => \$sep,
  'head'        => \$want_head,
  'pmd'         => sub { $want_pmd = 1; $sep = "\t"; },
  'help|?'      => \$want_help,
);

if ($want_help)
{
  print STDERR "Usage: ", basename($0),
    " [--head] [--pmd] [< logfile] [> tabfile]\n";
  exit(1);
}

my @cols = qw( problem n alpha t0 te iv_0 iv_nm1 iv_min iv_max tol lock pad
  partype impl cores method ord s h0 steps accepted rejected
  kt tps tpcs tt res_0 res_nm1 res_min res_max );

my $p_int   = '\d+';
my $p_float = '\d+(\.\d+)?e[+-]\d+';
my $p_word  = '\S+';

my $col        = 0;
my $num_cols   = scalar @cols;
my $state      = 0;
my $linenumber = 0;
my $parallel;
my $ode;
my $n;
my $tps;

if ($want_head)
{
  if ($want_pmd)
  {
    print "# cols=", $num_cols, "\n";
    print "# ", join($sep, @cols), "\n";
  }
  else
  {
    print join($sep, @cols), "\n";
  }
}

while (<STDIN>)
{
  $linenumber++;

  if (/^ODE: ($p_word)/)
  {
    $ode = $1;
    if ($state != 0)
    {
      print "\@$sep" x ($num_cols - $col - 1);
      print "\@\n";
    }
    print "$ode$sep";
    $col   = 1;
    $state = 1;
  }

  if ($state == 1)
  {
    if ($ode eq "BRUSS2D-MIX")
    {
      if (/^Grid size: ($p_int)/)
      {
        $n = 2 * $1 * $1;
        print "$n$sep";
        $col++;
        $state = 2;
      }
    }
    else
    {
      if (/^(Problem|System) size: ($p_int)/)
      {
        $n = $2;
        print "$n${sep}0.0${sep}";
        $col += 2;
        $state = 3;
      }
    }
  }
  elsif ($state == 2)
  {
    if (/^Alpha: ($p_float)/)
    {
      print "$1$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 3)
  {
    if (/^Integration interval: \[($p_float),($p_float)\]/)
    {
      print "$1$sep$3$sep";
      $col += 2;
      $state = 4;
    }
  }
  elsif ($state == 4)
  {
    my $p =
        "^Initial value: y0\[0\] = ($p_float), \.\.\., y0\[\d+\] = ($p_float); "
      . "min = ($p_float), max = ($p_float)";
    if (/$p/)
    {
      print "$1$sep$3$sep$5$sep$7$sep";
      $col += 4;
      $state++;
    }
  }
  elsif ($state == 5)
  {
    if (/^Tolerance: ($p_float)/)
    {
      print "$1$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 6)
  {
    if (/^Lock type: ($p_word)/)
    {
      print "$1$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 7)
  {
    if (/^Pad size: ($p_int)/)
    {
      print "$1$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 8)
  {
    my $p = "^Solver type: ($p_word) embedded Runge-Kutta method"
      . "( for ($p_word) address space)?";
    if (/$p/)
    {
      if ("$1" eq "parallel")
      {
        $parallel = 1;
        if ("$3" eq "shared")
        {
          print "pth$sep";
          $col++;
        }
        else
        {
          print "mpi$sep";
          $col++;
        }
      }
      else
      {
        $parallel = 0;
        print "seq$sep";
        $col++;
      }
      $state++;
    }
  }
  elsif ($state == 9)
  {
    if (/^Implementation variant: ($p_word)/)
    {
      print "$1$sep";
      $col++;
      if ($parallel)
      {
        $state++;
      }
      else
      {
        print "1$sep";
        $col++;
        $state += 2;
      }
    }
  }
  elsif ($state == 10)
  {
    if (/^Number of (threads|MPI processes): ($p_int)/)
    {
      print "$2$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 11)
  {
    if (/^Method: (\S+) (\d)\((\d)\) \(order ($p_int), ($p_int) stages\)/)
    {
      my $m = lc($1) . $2 . $3;
      print "$m$sep$4$sep$5$sep";
      $col += 3;
      $state++;
    }
    elsif (/^Method: (\S+) \(order ($p_int), ($p_int) stages\)/)
    {
      my $m = lc($1);
      print "$m$sep$2$sep$3$sep";
      $col += 3;
      $state++;
    }
  }
  elsif ($state == 12)
  {
    if (/^Initial step size: ($p_float)/)
    {
      print "$1$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 13)
  {
    if (/^Number of steps: ($p_int) \(($p_int) accepted, ($p_int) rejected\)/)
    {
      print "$1$sep$2$sep$3$sep";
      $col += 3;
      $state++;
    }
  }
  elsif ($state == 14)
  {
    if (/^Kernel time: ($p_float) s \(($p_float) s per step\)/)
    {
      $tps = $3;
      my $tpcs = $3 / $n;
      print "$1$sep$tps$sep$tpcs$sep";
      $col += 3;
      $state++;
    }
  }
  elsif ($state == 15)
  {
    if (/^Total time:\s+($p_float) s/)
    {
      print "$1$sep";
      $col++;
      $state++;
    }
  }
  elsif ($state == 16)
  {
    my $p = "^Result: y\[0\] = ($p_float), \.\.\., y\[\d+\] = ($p_float);"
      . " min = ($p_float), max = ($p_float)";
    if (/$p/)
    {
      print "$1$sep$3$sep$5$sep$7\n";
      $col   = 0;
      $state = 0;
    }
  }
}