#include "CutoffFunction.h"
#include "Log.h"
#include "Stopwatch.h"
#include "utility.h"
#include <iostream>
#include <fstream>

Include dependency graph for nnp-cutoff.cpp:

Functions
void	runTest (bool write)

void	runTest (CutoffFunction::CutoffType cutoffType)

int	main ()

Variables
CutoffFunction	fc

Log	nnplog

ofstream	logFile

Stopwatch	swf

Stopwatch	swdf

Stopwatch	swfdf

size_t	p = 100000000

double	d = 0.99999 / p

double	tbf = 0.0

double	tbdf = 0.0

double	tbfdf = 0.0

double	tlf = 0.0

double	tldf = 0.0

double	tlfdf = 0.0

Function Documentation

◆ runTest() [1/2]

void runTest ( bool write )

Definition at line 42 of file nnp-cutoff.cpp.

{
    swf.reset();
    swf.start();
    for (size_t i = 0; i < p; ++i)
    {
        __asm__ __volatile__("");
    }
    tlf = swf.stop();
    if (write) nnplog << strpr(" %10.2E %6.1f       ", tlf, tlf / tlf);
 
    swdf.reset();
    swdf.start();
    for (size_t i = 0; i < p; ++i)
    {
        __asm__ __volatile__("");
    }
    tldf = swdf.stop();
    if (write) nnplog << strpr(" %10.2E %6.1f       ", tldf, tldf / tldf);
 
    swfdf.reset();
    swfdf.start();
    for (size_t i = 0; i < p; ++i)
    {
        __asm__ __volatile__("");
    }
    tlfdf = swfdf.stop();
    if (write) nnplog << strpr(" %10.2E %6.1f        %10.2E %9.1f\n",
                            tlfdf,
                            tlfdf / tlfdf,
                            tlfdf - (tlf + tldf),
                            100.0 * tlfdf / (tlf + tldf));
}

References nnplog, p, nnp::strpr(), swdf, swf, swfdf, tldf, tlf, and tlfdf.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ runTest() [2/2]

void runTest ( CutoffFunction::CutoffType cutoffType )

Definition at line 76 of file nnp-cutoff.cpp.

{
    fc.setCutoffType(cutoffType);
 
    swf.reset();
    swf.start();
    for (size_t i = 0; i < p; ++i)
    {
        fc.f(i * d);
    }
    double tf = swf.stop();
    if (cutoffType == CutoffFunction::CT_HARD) tbf = tf;
    nnplog << strpr(" %10.2E %6.1f %6.1f", tf, tf / tlf, tf / tbf);
 
    swdf.reset();
    swdf.start();
    for (size_t i = 0; i < p; ++i)
    {
        fc.df(i * d);
    }
    double tdf = swdf.stop();
    if (cutoffType == CutoffFunction::CT_HARD) tbdf = tdf;
    nnplog << strpr(" %10.2E %6.1f %6.1f", tdf, tdf / tldf, tdf / tbdf);
 
    swfdf.reset();
    swfdf.start();
    for (size_t i = 0; i < p; ++i)
    {
        double f;
        double df;
        fc.fdf(i * d, f, df);
    }
    double tfdf = swfdf.stop();
    if (cutoffType == CutoffFunction::CT_HARD) tbfdf = tfdf;
 
    nnplog << strpr(" %10.2E %6.1f %6.1f %10.2E %9.1f\n",
                 tfdf,
                 tfdf / tlfdf,
                 tfdf / tbfdf,
                 tfdf - (tf + tdf),
                 100.0 * tfdf / (tf + tdf));
}

References nnp::CutoffFunction::CT_HARD, d, fc, nnplog, p, nnp::strpr(), swdf, swf, swfdf, tbdf, tbf, tbfdf, tldf, tlf, and tlfdf.

Here is the call graph for this function:

◆ main()

int main ( )

Definition at line 119 of file nnp-cutoff.cpp.

{
    logFile.open("nnp-cutoff.log");
    nnplog.registerStreamPointer(&logFile);
 
    nnplog << "-------------------------------------------------------------------------------------------------------------\n";
    nnplog << "Speed test tool for cutoff functions:\n";
    nnplog << "-------------------------------------------------------------------------------------------------------------\n";
    nnplog << "Column f     : Time for calling f   (no derivatives  ).\n";
    nnplog << "Column df    : Time for calling df  (only derivatives).\n";
    nnplog << "Column fdf   : Time for calling fdf (f and df at once).\n";
    nnplog << "Column compL : Time compared to LOOP ONLY.\n";
    nnplog << "Column compH : Time compared to CT_HARD.\n";
    nnplog << "Column diff  : Time difference between calling f + df (separately) and fdf.\n";
    nnplog << "Column ratio : Ratio time(fdf) / (time(f) + time(df)) in %.\n";
    nnplog << "-------------------------------------------------------------------------------------------------------------\n";
    nnplog << "CutoffType :       f [s]  compL  compH     df [s]  compL  compH     fdf[s]  compL  compH   diff [s] ratio [%]\n";
    nnplog << "-------------------------------------------------------------------------------------------------------------\n";
 
    // Initialize...
    runTest(false);
 
    nnplog << "LOOP ONLY  : ";
    runTest(true);
 
    fc.setCutoffRadius(1.0);
 
    nnplog << "CT_HARD    : ";
    runTest(CutoffFunction::CT_HARD);
 
    nnplog << "CT_COS     : ";
    fc.setCutoffParameter(0.0);
    runTest(CutoffFunction::CT_COS);
 
    nnplog << "CT_TANHU   : ";
    runTest(CutoffFunction::CT_TANHU);
 
    nnplog << "CT_TANH    : ";
    runTest(CutoffFunction::CT_TANH);
 
    nnplog << "CT_EXP     : ";
    fc.setCutoffParameter(0.0);
    runTest(CutoffFunction::CT_EXP);
 
    nnplog << "CT_POLY1   : ";
    fc.setCutoffParameter(0.0);
    runTest(CutoffFunction::CT_POLY1);
 
    nnplog << "CT_POLY2   : ";
    fc.setCutoffParameter(0.0);
    runTest(CutoffFunction::CT_POLY2);
 
    nnplog << "CT_POLY3   : ";
    fc.setCutoffParameter(0.0);
    runTest(CutoffFunction::CT_POLY3);
 
    nnplog << "CT_POLY4   : ";
    fc.setCutoffParameter(0.0);
    runTest(CutoffFunction::CT_POLY4);
 
    logFile.close();
 
    return 0;
}