HelperFunctionsUnitTest.cpp File Reference

#include "Logger.h"
#include "Species/LinearViscoelasticSpecies.h"
#include "Species/LinearPlasticViscoelasticSpecies.h"
#include "Math/ExtendedMath.h"
#include "Math/Helpers.h"
#include "iomanip"

Go to the source code of this file.

Functions
int	main (int argc UNUSED, char *argv[] UNUSED)

Function Documentation

int main	(	int argc	UNUSED,
		char *argv[]	UNUSED
	)

Definition at line 33 of file HelperFunctionsUnitTest.cpp.

References ERROR, helpers::fileExists(), helpers::getEffectiveMass(), helpers::getLineFromStringStream(), helpers::getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep(), mathsFunc::isEqual(), logger, MixedSpecies< NormalForceSpecies, FrictionForceSpecies, AdhesiveForceSpecies >::mixAll(), helpers::openFile(), and helpers::writeToFile().

{
    std::cout << "Running HelperFunctionsUnitTest" << std::endl;

    std::cout << "  Testing getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep" << std::endl;
    unsigned int saveCount = helpers::getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep(21, 10, 0.001);
    if (saveCount != 501)
    {
        logger(ERROR, "save count is %, but should be %", saveCount, 501);
    }

    std::cout << "  Testing getLineFromStringStream" << std::endl;
    std::stringstream is("1.0\n2.000000000000001\n3.0");
    std::stringstream line(std::stringstream::in | std::stringstream::out);
    helpers::getLineFromStringStream(is, line);
    Mdouble value;
    line >> value >> value; //the second value is not reading from the second line
    if (value != 1.0)
    {
        logger(ERROR, "value is %, but should be %", value, 0.0);
    }
    helpers::getLineFromStringStream(is, line);
    line >> value; //reads double precision
    //std::cout << std::setprecision(16) << value << std::endl;
    if (value != 2.000000000000001)
    {
        logger(ERROR, "value is %, but should be %", value, 2.000000000000001);
    }

    std::cout << "  Testing writeToFile, openFile" << std::endl;
    helpers::writeToFile("HelperFunctionsUnitTest.ini",
                         "1 0 0 0 0 1 1 1\n"
                         "0.5 0.5 0  0 0 0.5  0  0 0 0  0 0 0  0\n");
    std::fstream file;
    helpers::openFile(file,"HelperFunctionsUnitTest.ini",std::fstream::in);
    value=0.0;
    file >> value;
    if (value != 1.0)
    {
        logger(ERROR, "value is %, but should be %", value, 1.0);
    }

    std::cout << "  Testing writeToFile, openFile" << std::endl;
    bool fileExists = helpers::fileExists("HelperFunctionsUnitTest.ini");
    if (fileExists != true)
    {
        logger(ERROR, "HelperFunctionsUnitTest.ini exists, but is not detected");
    }
    fileExists = helpers::fileExists("HelperFunctionsUnitTest.out");
    if (fileExists != false)
    {
        logger(ERROR, "HelperFunctionsUnitTest.out does not exist, but is detected");
    }

    std::cout << "  Testing getEffectiveMass" << std::endl;
    Mdouble effectiveMass = helpers::getEffectiveMass(1.0,2.0);
    if (!mathsFunc::isEqual(effectiveMass, 2.0/3.0, 1e-10))
    {
        logger(ERROR, "effective mass is %, but should be %", effectiveMass, 2.0/3.0);
    }

    
    std::cout << "Running LinearViscoelasticSpecies helper functions unit test" << std::endl;
    Mdouble realStiffness = 2e5;
    Mdouble realDissipation = 25.0;
    Mdouble mass = 1.0; //particle mass
    Mdouble radius = 0.5; //particle radius
    Mdouble realCollisionTime = 0.004971179385062563;
    Mdouble realRestitution = 0.883132984295725;
    Mdouble realMaximumVelocity = 316.227766016838;

    LinearViscoelasticSpecies species0;
    species0.setStiffness(realStiffness);
    species0.setDissipation(realDissipation);

    std::cout << "  Testing getMaximumVelocity" << std::endl;
    Mdouble maximumVelocity = species0.getMaximumVelocity(radius, mass);
    //std::cout << std::setprecision(16) << maximumVelocity << std::endl;
    if (!mathsFunc::isEqual(maximumVelocity, realMaximumVelocity, 1e-10))
    {
        logger(ERROR, "maximum velocity is %, but should be %", maximumVelocity, realMaximumVelocity);
    }

    std::cout << "  Testing getCollisionTime, getRestitutionCoefficient" << std::endl;
    Mdouble collisionTime = species0.getCollisionTime(mass);
    Mdouble restitution = species0.getRestitutionCoefficient(mass);
    if (!mathsFunc::isEqual(collisionTime, realCollisionTime, 1e-10))
    {
        logger(ERROR, "collision time is %, but should be %", collisionTime, realCollisionTime);
    }
    if (!mathsFunc::isEqual(restitution, realRestitution, 1e-10))
    {
        logger(ERROR, "restitution coefficient is %, but should be %", restitution, realRestitution);
    }

    std::cout << "  Testing setStiffnessAndRestitutionCoefficient" << std::endl;
    species0.setStiffnessAndRestitutionCoefficient(realStiffness, realRestitution, mass);
    if (!mathsFunc::isEqual(species0.getStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species0.getStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species0.getDissipation(), realDissipation, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species0.getDissipation(), realDissipation);
    }

    std::cout << "  Testing setCollisionTimeAndRestitutionCoefficient" << std::endl;
    species0.setCollisionTimeAndRestitutionCoefficient(realCollisionTime, realRestitution, mass);
    if (!mathsFunc::isEqual(species0.getStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species0.getStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species0.getDissipation(), realDissipation, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species0.getDissipation(), realDissipation);
    }

    std::cout << "  Testing setCollisionTimeAndRestitutionCoefficient for two masses" << std::endl;
    species0.setCollisionTimeAndRestitutionCoefficient(realCollisionTime, realRestitution, mass, mass);
    if (!mathsFunc::isEqual(species0.getStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species0.getStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species0.getDissipation(), realDissipation, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species0.getDissipation(), realDissipation);
    }

    std::cout << "  Testing copy constructor" << std::endl;
    LinearViscoelasticSpecies species1 = species0;
    if (!mathsFunc::isEqual(species1.getStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species1.getStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species1.getDissipation(), realDissipation, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species1.getDissipation(), realDissipation);
    }

    std::cout << "  Testing mix" << std::endl;
    LinearViscoelasticMixedSpecies species2;
    species2.mixAll(&species0, &species1);
    if (!mathsFunc::isEqual(species2.getStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species2.getStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species2.getDissipation(), realDissipation, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species2.getDissipation(), realDissipation);
    }

    std::cout << "Running LinearPlasticViscoelasticSpecies helper functions unit test" << std::endl;
    LinearPlasticViscoelasticSpecies species3;

    std::cout << "  Testing setPlasticParameters" << std::endl;
    species3.setPlasticParameters(realStiffness, 2.0 * realStiffness, 0.5 * realStiffness, 0.5);
    if (!mathsFunc::isEqual(species3.getLoadingStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species3.getLoadingStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species3.getUnloadingStiffnessMax(), 2.0 * realStiffness, 1e-10))
    {
        logger(ERROR, "max. unloading stiffness is %, but should be %", species3.getUnloadingStiffnessMax(), 2.0 * realStiffness);
    }
    if (!mathsFunc::isEqual(species3.getCohesionStiffness(), 0.5 * realStiffness, 1e-10))
    {
        logger(ERROR, "max. unloading stiffness is %, but should be %", species3.getCohesionStiffness(), 0.5 * realStiffness);
    }
    if (!mathsFunc::isEqual(species3.getPenetrationDepthMax(), 0.5, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species3.getPenetrationDepthMax(), 0.5);
    }

    std::cout << "  Testing setCollisionTimeAndRestitutionCoefficient" << std::endl;
    species3.setCollisionTimeAndRestitutionCoefficient(realCollisionTime, realRestitution, mass);
    if (!mathsFunc::isEqual(species3.getLoadingStiffness(), realStiffness, 1e-10))
    {
        logger(ERROR, "stiffness is %, but should be %", species3.getLoadingStiffness(), realStiffness);
    }
    if (!mathsFunc::isEqual(species3.getUnloadingStiffnessMax(), realStiffness, 1e-10))
    {
        logger(ERROR, "max. unloading stiffness is %, but should be %", species3.getUnloadingStiffnessMax(), realStiffness);
    }
    if (!mathsFunc::isEqual(species3.getDissipation(), realDissipation, 1e-10))
    {
        logger(ERROR, "dissipation is %, but should be %", species3.getDissipation(), realDissipation);
    }

    std::cout << "  Testing computeTimeStep" << std::endl;
    Mdouble timeStep = species3.computeTimeStep(mass);
    if (!mathsFunc::isEqual(timeStep, 0.02 * realCollisionTime, 1e-10))
    {
        logger(ERROR, "time step is %, but should be %", timeStep, 0.02 * realCollisionTime);
    }
}