bench.cpp

/* Copyright (C) 2005-2015 Massachusetts Institute of Technology  
%
%  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 2, 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, write to the Free Software Foundation,
%  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#include <stdio.h>
#include <stdlib.h>

#include <meep.hpp>
using namespace meep;
using namespace std;

double one(const vec &) { return 1.0; }
static double width = 20.0;
double bump(const vec &pt) { return (fabs(pt.z()-50.0) > width)?1.0:12.0; }

struct bench {
  double time; // In seconds.
  double gridsteps;
};

bench bench_periodic(const double rmax, const double zmax,
                     double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = (zmax==0.0)?a*rmax:a*a*rmax*zmax;
  const double ttot = 5.0 + 1e5/gridpts;
  const int m = 0;

  grid_volume gv = volcyl(rmax,zmax,a);
  structure s(gv, eps);
  fields f(&s, m);
  f.use_bloch(0.0);
  f.add_point_source(Ep, 0.7, 2.5, 0.0, 4.0, veccyl(0.5, 0.4), 1.0);
  f.add_point_source(Ez, 0.8, 0.6, 0.0, 4.0, veccyl(0.401, 0.301), 1.0);

  double start = wall_time();
  while (f.time() < ttot) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

bench bench_flux_1d(const double zmax,
                    double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*zmax;
  const double ttot = 10.0 + 1e5/zmax;

  grid_volume gv = volone(zmax,a);
  structure s(gv, eps, pml(zmax/6));

  fields f(&s);
  f.use_real_fields();
  f.add_point_source(Ex, 0.7, 2.5, 0.0, 3.0, vec(zmax/2+0.3), 1.0);
  flux_vol *left = f.add_flux_plane(vec(zmax/3.0), vec(zmax/3.0));
  flux_vol *right = f.add_flux_plane(vec(zmax*2.0/3.0), vec(zmax*2.0/3.0));

  while (f.time() <= f.last_source_time()) f.step();

  grid_volume mid = volone(zmax/3,a);
  mid.set_origin(vec(zmax/3));
  double flux_energy=0.0;
  double start = wall_time();
  while (f.time() < ttot) {
    f.step();
    flux_energy += f.dt*(right->flux() - left->flux());
  }
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

bench bench_2d(const double xmax, const double ymax,
               double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*xmax*ymax;
  const double ttot = 5.0 + 1e5/gridpts;

  grid_volume gv = voltwo(xmax,ymax,a);
  structure s(gv, eps);
  fields f(&s);
  f.add_point_source(Ez, 0.8, 0.6, 0.0, 4.0, vec(0.401, 0.301));
  f.add_point_source(Hz, 0.8, 0.7, 0.0, 4.0, vec(0.431, 0.2));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

const double te_tm_2d_time = 2e5;

bench bench_2d_tm_nonlinear(const double xmax, const double ymax,
                            double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*xmax*ymax;
  const double ttot = 5.0 + te_tm_2d_time/gridpts;

  grid_volume gv = voltwo(xmax,ymax,a);
  structure s(gv, eps);
  s.set_chi3(eps);
  fields f(&s);
  f.add_point_source(Ez, 0.8, 0.6, 0.0, 4.0, vec(0.401, 0.301));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

bench bench_2d_tm(const double xmax, const double ymax,
               double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*xmax*ymax;
  const double ttot = 5.0 + te_tm_2d_time/gridpts;

  grid_volume gv = voltwo(xmax,ymax,a);
  structure s(gv, eps);
  fields f(&s);
  f.add_point_source(Ez, 0.8, 0.6, 0.0, 4.0, vec(0.401, 0.301));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

bench bench_2d_te(const double xmax, const double ymax,
               double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*xmax*ymax;
  const double ttot = 5.0 + te_tm_2d_time/gridpts;

  grid_volume gv = voltwo(xmax,ymax,a);
  structure s(gv, eps);
  fields f(&s);
  f.add_point_source(Ex, 0.8, 0.6, 0.0, 4.0, vec(0.401, 0.301));
  f.add_point_source(Hz, 0.6, 0.6, 0.0, 4.0, vec(0.7, 0.5));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

bench bench_2d_te_nonlinear(const double xmax, const double ymax,
                            double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*xmax*ymax;
  const double ttot = 5.0 + te_tm_2d_time/gridpts;

  grid_volume gv = voltwo(xmax,ymax,a);
  structure s(gv, eps);
  s.set_chi3(eps);
  fields f(&s);
  f.add_point_source(Ex, 0.8, 0.6, 0.0, 4.0, vec(0.401, 0.301));
  f.add_point_source(Hz, 0.6, 0.6, 0.0, 4.0, vec(0.7, 0.5));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

#define showbench(name, bb) { \
    bench b = bb; \
    master_printf("bench:, %s, %g, %g\n", \
                  name, b.time, b.time*1e6/b.gridsteps); \
  }

// 3D benchmarks:

inline double max(double a, double b) { return (a>b)?a:b; }

bench bench_3d_periodic(const double xmax, const double ymax, const double zmax,
                        double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*a*max(xmax,1/a)*max(ymax,1/a)*max(zmax,1/a);
  const double ttot = 5.0 + 1e5/gridpts;

  grid_volume gv = vol3d(xmax,ymax,zmax,a);
  structure s(gv, eps);
  fields f(&s);
  if (xmax==0) f.use_bloch(X,0.0);
  if (ymax==0) f.use_bloch(Y,0.0);
  if (ymax==0) f.use_bloch(Z,0.0);
  f.add_point_source(Ez, 0.8, 0.6, 0.0, 4.0, vec(xmax*.5, ymax*.5, zmax*.5));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

bench bench_3d(const double xmax, const double ymax, const double zmax,
               double eps(const vec &)) {
  const double a = 10.0;
  const double gridpts = a*a*a*xmax*ymax*zmax;
  const double ttot = 5.0 + 1e5/gridpts;

  grid_volume gv = vol3d(xmax,ymax,zmax,a);
  structure s(gv, eps);
  fields f(&s);
  f.add_point_source(Ez, 0.8, 0.6, 0.0, 4.0, vec(xmax*.5, ymax*.5, zmax*.5));

  while (f.time() < f.last_source_time()) f.step();
  const double tend = f.time() + ttot;
  double start = wall_time();
  while (f.time() < tend) f.step();
  bench b;
  b.time = (wall_time() - start);
  b.gridsteps = ttot*a*2*gridpts;
  //f.print_times();
  return b;
}

int main(int argc, char **argv) {
  initialize mpi(argc, argv);
  quiet = true;
  master_printf("Benchmarking with %d processor%s...\n",
		count_processors(), count_processors() > 1 ? "s" : "");

  master_printf("bench:, test, total time (s), normalized time (s/Mgs)\n");

  showbench("Periodic 6x4 ", bench_periodic(6.0, 4.0, one));
  showbench("Periodic 12x1", bench_periodic(12.0, 1.0, one));
  showbench("Periodic 1x12", bench_periodic(1.0, 12.0, one));
  showbench("Periodic 12x0", bench_periodic(12.0, 0.0, one));
  showbench("Periodic 12x12", bench_periodic(12.0, 12.0, one));

  width = 20.0;
  showbench("Flux 1D 100", bench_flux_1d(100.0, bump));
  width = 10.0;
  showbench("Flux 1D 100", bench_flux_1d(100.0, bump));
  width = 300.0;
  showbench("Flux 1D 100", bench_flux_1d(100.0, bump));

  showbench("3D 1x1x10", bench_3d(1.0, 1.0, 10.0, one));
  showbench("3D 10x1x1", bench_3d(10.0, 1.0, 1.0, one));
  showbench("3D 1x1x1 ", bench_3d(1.0, 1.0, 1.0, one));
  showbench("3D 3x3x3 ", bench_3d(3.0, 3.0, 3.0, one));
  showbench("3D 10x3x0", bench_3d_periodic(10.0, 3.0, 0.0, one));
  showbench("3D 0x3x10", bench_3d_periodic(0.0, 3.0, 10.0, one));

  showbench("2D 6x4 ", bench_2d(6.0, 4.0, one));
  showbench("2D 12x12 ", bench_2d(12.0, 12.0, one));
  showbench("2D 12x12 ", bench_2d(12.0, 12.0, one));

  showbench("2D TM 6x4 nonlinear ", bench_2d_tm_nonlinear(6.0, 4.0, one));
  showbench("2D TM 6x4 ", bench_2d_tm(6.0, 4.0, one));
  showbench("2D TM 12x12 ", bench_2d_tm(12.0, 12.0, one));

  showbench("2D TE 2x2 nonlinear ", bench_2d_te_nonlinear(2.0, 2.0, one));
  showbench("2D TE 2x2 ", bench_2d_te(2.0, 2.0, one));
  showbench("2D TE 10x11 nonlinear ", bench_2d_te_nonlinear(10.0, 11.0, one));
  showbench("2D TE 10x11 ", bench_2d_te(10.0, 11.0, one));

  master_printf("\nnote: 1 Mgs = 1 million grid point time steps\n");

  return 0;
}