nnp-cutoff.cpp File Reference

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

Include dependency graph for nnp-cutoff.cpp:

Go to the source code of this file.

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::Stopwatch::reset(), nnp::Stopwatch::start(), nnp::Stopwatch::stop(), 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 d, nnp::CutoffFunction::df(), nnp::CutoffFunction::f(), fc, nnp::CutoffFunction::fdf(), nnplog, p, nnp::Stopwatch::reset(), nnp::CutoffFunction::setCutoffType(), nnp::Stopwatch::start(), nnp::Stopwatch::stop(), 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;
}

References fc, logFile, nnplog, nnp::Log::registerStreamPointer(), runTest(), nnp::CutoffFunction::setCutoffParameter(), and nnp::CutoffFunction::setCutoffRadius().

Here is the call graph for this function:

Variable Documentation

fc

CutoffFunction fc

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

Referenced by nnp::ModeCabana< t_device >::compute_cutoff(), nnp::CutoffFunction::fdf(), nnp::CutoffFunction::fdfCORE(), nnp::CutoffFunction::fdfCOS(), nnp::CoreFunction::fdfEXP(), nnp::CutoffFunction::fdfHARD(), nnp::CutoffFunction::fdfTANH(), nnp::CutoffFunction::fdfTANHU(), main(), and runTest().

nnplog

Log nnplog

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

Referenced by main(), and runTest().

logFile

ofstream logFile

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

Referenced by main().

swf

Stopwatch swf

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

Referenced by runTest().

swdf

Stopwatch swdf

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

Referenced by runTest().

swfdf

Stopwatch swfdf

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

Referenced by runTest().

p

size_t p = 100000000

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

Referenced by nnp::SymFncBaseExpAng::calculateRadialPart(), nnp::SymFncExpAngnWeighted::calculateRadialPart(), nnp::InterfaceLammps::extractEWBuffer(), nnp::InterfaceLammps::fillEWBuffer(), nnp::SymGrpCompAngn::getMembers(), nnp::SymGrpCompAngnWeighted::getMembers(), nnp::SymGrpCompAngw::getMembers(), nnp::SymGrpCompAngwWeighted::getMembers(), nnp::SymGrpExpAngn::getMembers(), nnp::SymGrpExpAngw::getMembers(), nnp::Dataset::prepareNumericForces(), nnp::Dataset::recvStructure(), runTest(), and nnp::Dataset::sendStructure().

d

double d = 0.99999 / p

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

Referenced by nnp::Training::calculateErrorEpoch(), nnp::InterfaceLammps::extractEWBuffer(), nnp::SymFncStatistics::getExtrapolationWarningLines(), nnp::Atom::Neighbor::info(), nnp::Atom::Neighbor::operator<(), nnp::Atom::Neighbor::operator==(), runTest(), and nnp::Settings::sanityCheck().

tbf

double tbf = 0.0

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

Referenced by runTest().

tbdf

double tbdf = 0.0

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

Referenced by runTest().

tbfdf

double tbfdf = 0.0

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

Referenced by runTest().

tlf

double tlf = 0.0

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

Referenced by runTest().

tldf

double tldf = 0.0

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

Referenced by runTest().

tlfdf

double tlfdf = 0.0

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

Referenced by runTest().