helpers Namespace Reference

Classes
class	KAndDisp
	return type specifically for fuctions returning k and disp at once More...
class	KAndDispAndKtAndDispt
	return type specifically for fuctions returning k, disp, kt, dispt at once More...

Functions
MERCURY_DEPRECATED KAndDisp	computeKAndDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass (Mdouble tc, Mdouble r, Mdouble mass)
	Set disp and k such that is matches a given collision time tc and restitution coefficient r for a collision of effective/reduced mass m. More...
MERCURY_DEPRECATED Mdouble	computeCollisionTimeFromKAndDispAndEffectiveMass (Mdouble k, Mdouble disp, Mdouble mass)
	Calculates the collision time for a given stiffness, dissipation, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeRestitutionCoefficientFromKAndDispAndEffectiveMass (Mdouble k, Mdouble disp, Mdouble mass)
	Calculates the restitution coefficient time for a given stiffness, dissipation, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeDispFromKAndRestitutionCoefficientAndEffectiveMass (Mdouble k, Mdouble r, Mdouble mass)
	Calculates the dissipation for a given stiffness, restitution coefficient, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeCollisionTimeFromKAndRestitutionCoefficientAndEffectiveMass (Mdouble k, Mdouble r, Mdouble mass)
	Calculates the collision time for a given stiffness, restitution coefficient, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeDispFromKAndCollisionTimeAndEffectiveMass (Mdouble k, Mdouble tc, Mdouble mass)
	Calculates the dissipation for a given stiffness, collision time, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeRestitutionCoefficientFromKAndCollisionTimeAndEffectiveMass (Mdouble k, Mdouble tc, Mdouble mass)
	Calculates the restitution coefficient for a given stiffness, collision time, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass (Mdouble tc, Mdouble r, Mdouble mass)
	Calculates the dissipation for a given collision time, restitution coefficient, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass (Mdouble tc, Mdouble r, Mdouble mass)
	Calculates the stiffness for a given collision time, restitution coefficient, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeKFromCollisionTimeAndDispAndEffectiveMass (Mdouble tc, Mdouble disp, Mdouble mass)
	Calculates the stiffness for a given collision time, dissipation, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeRestitutionCoefficientFromCollisionTimeAndDispAndEffectiveMass (Mdouble tc, Mdouble disp, Mdouble mass)
	Calculates the resitution coefficient for a given collision time, dissipation, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeKFromDispAndRestitutionCoefficientAndEffectiveMass (Mdouble disp, Mdouble r, Mdouble mass)
	Calculates the stiffness for a given dissipation, restitution coefficient, and effective mass. More...
MERCURY_DEPRECATED Mdouble	computeCollisionTimeFromDispAndRestitutionCoefficientAndEffectiveMass (Mdouble disp, Mdouble r, Mdouble mass)
	Calculates the collision time for a given dissipation, restitution coefficient, and effective mass. More...
MERCURY_DEPRECATED KAndDispAndKtAndDispt	computeDisptFromCollisionTimeAndRestitutionCoefficientAndTangentialRestitutionCoefficientAndEffectiveMass (Mdouble tc, Mdouble r, Mdouble beta, Mdouble mass)
	Set disp, k, dispt and kt such that is matches a given collision time tc and a normal andtangential restitution coefficient r, beta for a collision of effective/reduced mass m. From Deen...Kuipers2006, eq. 43 and 30. More...
MERCURY_DEPRECATED Mdouble	getMaximumVelocity (Mdouble k, Mdouble disp, Mdouble radius, Mdouble mass)
	Calculates the maximum relative velocity allowed for a normal collision of two particles of radius r and particle mass m (for higher velocities particles could pass through each other) More...
unsigned int	getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep (unsigned int numberOfSaves, Mdouble timeMax, Mdouble timestep)
	Returns the correct saveCount if the total number of saves, the final time and the time step is known. More...
void	getLineFromStringStream (std::istream &in, std::stringstream &out)
	Reads a line from one stringstream into another, and prepares the latter for reading in. More...
bool	writeToFile (std::string filename, std::string filecontent)
	Writes a string to a file. More...
bool	fileExists (std::string strFilename)
	Function to check if a file exists, is used to check if a run has already need done. More...
bool	openFile (std::fstream &file, std::string filename, std::fstream::openmode mode)
	Provides a simple interface for opening a file. More...
Mdouble	getEffectiveMass (Mdouble mass0, Mdouble mass1)
	Calculates the effective mass of a particle pair, i.e. half the harmonic mean of two particle masses. More...

Function Documentation

Mdouble helpers::computeCollisionTimeFromDispAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	disp,
		Mdouble	r,
		Mdouble	mass
	)

Calculates the collision time for a given dissipation, restitution coefficient, and effective mass.

Deprecated:

use species->computeCollisionTime(2.0*effectiveMass) instead

Definition at line 281 of file Helpers.cc.

{
    if (disp <= 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromDispAndRestitutionCoefficientAndEffectiveMass(Mdouble disp, Mdouble r, Mdouble mass) dissipation is not set or has an unexpected value, (dissipation time=" << disp << ")" << std::endl;
        exit(-1);
    }
    if (r < 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromDispAndRestitutionCoefficientAndEffectiveMass(Mdouble disp, Mdouble r, Mdouble mass) restitution coefficient not set or has an unexpected value, (restitution coefficient=" << r << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromDispAndRestitutionCoefficientAndEffectiveMass(Mdouble disp, Mdouble r, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return -2.0 * mass * std::log(r) / disp;
}

Mdouble helpers::computeCollisionTimeFromKAndDispAndEffectiveMass	(	Mdouble	k,
		Mdouble	disp,
		Mdouble	mass
	)

Calculates the collision time for a given stiffness, dissipation, and effective mass.

Deprecated:

use species->computeCollisionTime(2.0*effectiveMass) instead

Todo:

This does not result in the same value as the given alternative.

Definition at line 41 of file Helpers.cc.

References constants::pi, and mathsFunc::square().

Referenced by ChuteBottom::makeRoughBottom().

{
    if (k <= 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) stiffness is not set or has an unexpected value, (stiffness=" << k << ")" << std::endl;
        exit(-1);
    }
    if (disp < 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) dissipation is not set or has an unexpected value, (dissipation=" << disp << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    if (4.0 * k / mass - mathsFunc::square(disp / mass) < 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) values for stiffness, dissipation and mass lead to an overdamped system (stiffness=" << k << " dissipation=" << disp << " mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return 2.0 * constants::pi / std::sqrt(4.0 * k / mass - mathsFunc::square(disp / mass));
}

Mdouble helpers::computeCollisionTimeFromKAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	k,
		Mdouble	r,
		Mdouble	mass
	)

Calculates the collision time for a given stiffness, restitution coefficient, and effective mass.

Deprecated:

use species->computeCollisionTime(2.0*effectiveMass) instead

Definition at line 111 of file Helpers.cc.

References constants::sqr_pi, and mathsFunc::square().

{
    if (k <= 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKAndRestitutionCoefficientAndEffectiveMass(Mdouble k, Mdouble r, Mdouble mass) stiffness is not set or has an unexpected value, (stiffness=" << k << ")" << std::endl;
        exit(-1);
    }
    if (r < 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKAndRestitutionCoefficientAndEffectiveMass(Mdouble k, Mdouble r, Mdouble mass) restitution coefficient is not set or has an unexpected value, (restitution coefficient=" << r << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeCollisionTimeFromKAndRestitutionCoefficientAndEffectiveMass(Mdouble k, Mdouble r, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return sqrt(mass / k * (constants::sqr_pi + mathsFunc::square(std::log(r))));
}

Mdouble helpers::computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	tc,
		Mdouble	r,
		Mdouble	mass
	)

Calculates the dissipation for a given collision time, restitution coefficient, and effective mass.

Deprecated:

use species->setCollisionTimeAndRestitutionCoefficient(2.0*effectiveMass) instead

Definition at line 181 of file Helpers.cc.

Referenced by computeKAndDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass().

{
    if (tc <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(Mdouble tc, Mdouble r, Mdouble mass) collision time is not set or has an unexpected value, (collision time=" << tc << ")" << std::endl;
        exit(-1);
    }
    if (r < 0)
    {
        std::cerr << "Error in helpers::computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(Mdouble tc, Mdouble r, Mdouble mass) restitution coefficient not set or has an unexpected value, (restitution coefficient=" << r << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(Mdouble tc, Mdouble r, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return -2.0 * mass * std::log(r) / tc;
}

Mdouble helpers::computeDispFromKAndCollisionTimeAndEffectiveMass	(	Mdouble	k,
		Mdouble	tc,
		Mdouble	mass
	)

Calculates the dissipation for a given stiffness, collision time, and effective mass.

Deprecated:

use species->setStiffnessAndRestitutionCoefficient(2.0*effectiveMass) instead

Definition at line 131 of file Helpers.cc.

References constants::sqr_pi, and mathsFunc::square().

{
    if (k <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble tc, Mdouble mass) stiffness is not set or has an unexpected value, (stiffness=" << k << ")" << std::endl;
        exit(-1);
    }
    if (tc <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble tc, Mdouble mass) collision time is not set or has an unexpected value, (collision time=" << tc << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble tc, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    if (mass * k - constants::sqr_pi * mathsFunc::square(mass / tc) < 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) values for stiffness, collision time and mass lead to an overdamped system (stiffness=" << k << " collision time=" << tc << " mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return 2.0 * std::sqrt(mass * k - constants::sqr_pi * mathsFunc::square(mass / tc));
}

Mdouble helpers::computeDispFromKAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	k,
		Mdouble	r,
		Mdouble	mass
	)

Calculates the dissipation for a given stiffness, restitution coefficient, and effective mass.

Definition at line 91 of file Helpers.cc.

References constants::sqr_pi, and mathsFunc::square().

{
    if (k <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndRestitutionCoefficientAndEffectiveMass(Mdouble k, Mdouble r, Mdouble mass) stiffness is not set or has an unexpected value, (stiffness=" << k << ")" << std::endl;
        exit(-1);
    }
    if (r < 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndRestitutionCoefficientAndEffectiveMass(Mdouble k, Mdouble r, Mdouble mass) restitution coefficient is not set or has an unexpected value, (restitution coefficient=" << r << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeDispFromKAndRestitutionCoefficientAndEffectiveMass(Mdouble k, Mdouble r, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return -2.0 * sqrt(mass * k / (constants::sqr_pi + mathsFunc::square(std::log(r)))) * std::log(r);
}

helpers::KAndDispAndKtAndDispt helpers::computeDisptFromCollisionTimeAndRestitutionCoefficientAndTangentialRestitutionCoefficientAndEffectiveMass	(	Mdouble	tc,
		Mdouble	r,
		Mdouble	beta,
		Mdouble	mass
	)

Set disp, k, dispt and kt such that is matches a given collision time tc and a normal andtangential restitution coefficient r, beta for a collision of effective/reduced mass m. From Deen...Kuipers2006, eq. 43 and 30.

from Deen...Kuipers2006, eq. 43 and 30

Definition at line 302 of file Helpers.cc.

References helpers::KAndDispAndKtAndDispt::disp, helpers::KAndDispAndKtAndDispt::dispt, helpers::KAndDispAndKtAndDispt::k, helpers::KAndDispAndKtAndDispt::kt, constants::pi, and mathsFunc::square().

{
    helpers::KAndDispAndKtAndDispt ans;
    ans.disp = -2.0 * mass * log(r) / tc;
    ans.k = mass * (mathsFunc::square(constants::pi / tc) + mathsFunc::square(ans.disp / (2.0 * mass)));
    ans.kt = 2.0 / 7.0 * ans.k * (mathsFunc::square(constants::pi) + mathsFunc::square(log(beta))) / (mathsFunc::square(constants::pi) + mathsFunc::square(log(r)));
    if (beta != 0.0)
        ans.dispt = -2 * log(beta) * sqrt(1.0 / 7.0 * mass * ans.kt / (mathsFunc::square(constants::pi) + mathsFunc::square(log(beta))));
    else
        ans.dispt = 2. * sqrt(1.0 / 7.0 * mass * ans.kt);
    return ans;
}

helpers::KAndDisp helpers::computeKAndDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	tc,
		Mdouble	r,
		Mdouble	mass
	)

Set disp and k such that is matches a given collision time tc and restitution coefficient r for a collision of effective/reduced mass m.

Deprecated:

use species->setCollisionTimeAndRestitutionCoefficient(collisionTime, restitutionCoefficient, 2.0*effectiveMass); instead

Definition at line 33 of file Helpers.cc.

References computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(), computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(), helpers::KAndDisp::disp, and helpers::KAndDisp::k.

{
    helpers::KAndDisp ans;
    ans.k = computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(tc, r, mass);
    ans.disp = computeDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(tc, r, mass);
    return ans;
}

Mdouble helpers::computeKFromCollisionTimeAndDispAndEffectiveMass	(	Mdouble	tc,
		Mdouble	disp,
		Mdouble	mass
	)

Calculates the stiffness for a given collision time, dissipation, and effective mass.

Definition at line 221 of file Helpers.cc.

References constants::sqr_pi, and mathsFunc::square().

{
    if (tc <= 0)
    {
        std::cerr << "Error in helpers::computeKFromCollisionTimeAndDispAndEffectiveMass(Mdouble tc, Mdouble disp, Mdouble mass) collision time is not set or has an unexpected value, (collision time=" << tc << ")" << std::endl;
        exit(-1);
    }
    if (disp < 0)
    {
        std::cerr << "Error in helpers::computeKFromCollisionTimeAndDispAndEffectiveMass(Mdouble tc, Mdouble disp, Mdouble mass) dissipation not set or has an unexpected value, (dissipation=" << disp << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeKFromCollisionTimeAndDispAndEffectiveMass(Mdouble tc, Mdouble disp, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return 0.25 * mathsFunc::square(disp) / mass + constants::sqr_pi * mass / mathsFunc::square(tc);
}

Mdouble helpers::computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	tc,
		Mdouble	r,
		Mdouble	mass
	)

Calculates the stiffness for a given collision time, restitution coefficient, and effective mass.

Deprecated:

use species->setCollisionTimeAndRestitutionCoefficient(2.0*effectiveMass) instead

Definition at line 201 of file Helpers.cc.

References constants::pi, and mathsFunc::square().

Referenced by computeKAndDispFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass().

{
    if (tc <= 0)
    {
        std::cerr << "Error in helpers::computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(Mdouble tc, Mdouble r, Mdouble mass) collision time is not set or has an unexpected value, (collision time=" << tc << ")" << std::endl;
        exit(-1);
    }
    if (r < 0)
    {
        std::cerr << "Error in helpers::computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(Mdouble tc, Mdouble r, Mdouble mass) restitution coefficient not set or has an unexpected value, (restitution coefficient=" << r << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeKFromCollisionTimeAndRestitutionCoefficientAndEffectiveMass(Mdouble tc, Mdouble r, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return mass * (mathsFunc::square(constants::pi / tc) + mathsFunc::square(-std::log(r) / tc));
}

Mdouble helpers::computeKFromDispAndRestitutionCoefficientAndEffectiveMass	(	Mdouble	disp,
		Mdouble	r,
		Mdouble	mass
	)

Calculates the stiffness for a given dissipation, restitution coefficient, and effective mass.

Definition at line 261 of file Helpers.cc.

References constants::sqr_pi, and mathsFunc::square().

{
    if (disp <= 0)
    {
        std::cerr << "Error in helpers::computeKFromDispAndRestitutionCoefficientAndEffectiveMass(Mdouble disp, Mdouble r, Mdouble mass) dissipation is not set or has an unexpected value, (dissipation time=" << disp << ")" << std::endl;
        exit(-1);
    }
    if (r < 0)
    {
        std::cerr << "Error in helpers::computeKFromDispAndRestitutionCoefficientAndEffectiveMass(Mdouble disp, Mdouble r, Mdouble mass) restitution coefficient not set or has an unexpected value, (restitution coefficient=" << r << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeKFromDispAndRestitutionCoefficientAndEffectiveMass(Mdouble disp, Mdouble r, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return 0.25 * mathsFunc::square(disp)*(constants::sqr_pi / (mathsFunc::square(std::log(r))) + 1.0) / mass;
}

Mdouble helpers::computeRestitutionCoefficientFromCollisionTimeAndDispAndEffectiveMass	(	Mdouble	tc,
		Mdouble	disp,
		Mdouble	mass
	)

Calculates the resitution coefficient for a given collision time, dissipation, and effective mass.

Deprecated:

use species->computeRestitutionCoefficient(2.0*effectiveMass) instead

Definition at line 241 of file Helpers.cc.

{
    if (tc <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromCollisionTimeAndDispAndEffectiveMass(Mdouble tc, Mdouble disp, Mdouble mass) collision time is not set or has an unexpected value, (collision time=" << tc << ")" << std::endl;
        exit(-1);
    }
    if (disp < 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromCollisionTimeAndDispAndEffectiveMass(Mdouble tc, Mdouble disp, Mdouble mass) dissipation not set or has an unexpected value, (dissipation=" << disp << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromCollisionTimeAndDispAndEffectiveMass(Mdouble tc, Mdouble disp, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return std::exp(-0.5 * disp * tc / mass);
}

Mdouble helpers::computeRestitutionCoefficientFromKAndCollisionTimeAndEffectiveMass	(	Mdouble	k,
		Mdouble	tc,
		Mdouble	mass
	)

Calculates the restitution coefficient for a given stiffness, collision time, and effective mass.

Deprecated:

use species->computeRestitutionCoefficient(2.0*effectiveMass) instead

Definition at line 156 of file Helpers.cc.

References constants::sqr_pi, and mathsFunc::square().

{
    if (k <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble tc, Mdouble mass) stiffness is not set or has an unexpected value, (stiffness=" << k << ")" << std::endl;
        exit(-1);
    }
    if (tc <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble tc, Mdouble mass) collision time is not set or has an unexpected value, (collision time=" << tc << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble tc, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    if (k / mass * mathsFunc::square(tc) - constants::sqr_pi < 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKAndCollisionTimeAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) values for stiffness, collision time and mass lead to an overdamped system (stiffness=" << k << " collision time=" << tc << " mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return std::exp(-std::sqrt(k / mass * mathsFunc::square(tc) - constants::sqr_pi));
}

Mdouble helpers::computeRestitutionCoefficientFromKAndDispAndEffectiveMass	(	Mdouble	k,
		Mdouble	disp,
		Mdouble	mass
	)

Calculates the restitution coefficient time for a given stiffness, dissipation, and effective mass.

Deprecated:

use species->computeRestitutionCoefficient(2.0*effectiveMass) instead

Definition at line 66 of file Helpers.cc.

References constants::pi, and mathsFunc::square().

{
    if (k <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) stiffness is not set or has an unexpected value, (stiffness=" << k << ")" << std::endl;
        exit(-1);
    }
    if (disp < 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) dissipation is not set or has an unexpected value, (dissipation=" << disp << ")" << std::endl;
        exit(-1);
    }
    if (mass <= 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) mass is not set or has an unexpected value (mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    if (4.0 * mass * k - mathsFunc::square(disp) < 0)
    {
        std::cerr << "Error in helpers::computeRestitutionCoefficientFromKandDispAndEffectiveMass(Mdouble k, Mdouble disp, Mdouble mass) values for stiffness, dissipation and mass lead to an overdamped system (stiffness=" << k << " dissipation=" << disp << " mass=" << mass << ")" << std::endl;
        exit(-1);
    }
    return std::exp(-disp * constants::pi / std::sqrt(4.0 * mass * k - mathsFunc::square(disp)));
}

bool helpers::fileExists

(

std::string

strFilename

)

Function to check if a file exists, is used to check if a run has already need done.

This is a FileExist routine, which is used to test if a run have already need preformed, allows me to plug holes in parm studies.

Definition at line 429 of file Helpers.cc.

{
    struct stat stFileInfo;
    bool blnReturn;
    int intStat;

    // Attempt to get the file attributes

    intStat = stat(strFilename.c_str(), &stFileInfo);
    if (intStat == 0)
    {
        // We were able to get the file attributes
        // so the file obviously exists.
        blnReturn = true;
    }
    else
    {
        // We were not able to get the file attributes.
        // This may mean that we don't have permission to
        // access the folder which contains this file. If you
        // need to do that level of checking, lookup the
        // return values of stat which will give you
        // more details on why stat failed.
        blnReturn = false;
    }

    return blnReturn;
}

Mdouble helpers::getEffectiveMass	(	Mdouble	mass0,
		Mdouble	mass1
	)

Calculates the effective mass of a particle pair, i.e. half the harmonic mean of two particle masses.

The effective mass is an important parameter in a collision. E.g. the collision time and the restitution coefficient are functions of the effective mass.

Parameters

[in]	mass0	The mass of the first particle.
[in]	mass1	The mass of the second particle.

Returns

the effective mass of the particle pair.

Definition at line 482 of file Helpers.cc.

{
    return mass0 * mass1 / (mass0 + mass1);
}

void helpers::getLineFromStringStream	(	std::istream &	in,
		std::stringstream &	out
	)

Reads a line from one stringstream into another, and prepares the latter for reading in.

This function is used to avoid errors from reading in old or manually modified restart files. Instead of reading variable by variable directly from the restart stringstream, a full line is read first, from which the variables are read. Thus, if a line has the wrong number of arguments, it might affect the reading of the current line, but correctly reads the next line.

Example of usage:

std::stringstream line(std::stringstream::in | std::stringstream::out); std::stringstream is = restartFile.getFStream(); helpers::getLineFromStringStream(is, line); std::string dummy; line >> dummy;

Parameters

[in]	in	the stringstream from which a line is read out should be initialized as std::stringstream(std::stringstream::out)
[out]	out	the stringstream into which the line is read; should be initialized as std::stringstream(std::stringstream::in | std::stringstream::out)

Definition at line 389 of file Helpers.cc.

Referenced by MercuryBase::read(), BaseHandler< T >::read(), DPMBase::read(), SpeciesHandler::readObject(), InteractionHandler::readObject(), SpeciesHandler::readOldObject(), BoundaryHandler::readOldObject(), WallHandler::readOldObject(), and ParticleHandler::readOldObject().

{
    std::string line_string;
    getline(in, line_string);
    out.str(line_string);
    out.clear();
}

Mdouble helpers::getMaximumVelocity	(	Mdouble	k,
		Mdouble	disp,
		Mdouble	radius,
		Mdouble	mass
	)

Calculates the maximum relative velocity allowed for a normal collision of two particles of radius r and particle mass m (for higher velocities particles could pass through each other)

Definition at line 315 of file Helpers.cc.

References mathsFunc::square().

{
    // note: underestimate based on energy argument,
    // Ekin = 2*1/2*m*(v/2)^2 = 1/2*k*(2*r)^2, gives
    // return radius * sqrt(8.0*k/mass);

    // with dissipation, see S. Luding, Collisions & Contacts between two particles, eq 34
    Mdouble w = sqrt(k / mass - mathsFunc::square(disp / (2.0 * mass)));
    Mdouble w0 = sqrt(k / mass);
    Mdouble DispCorrection = exp(-disp / mass / w) * asin(w / w0);
    //std::cout << "DispCorrection" << DispCorrection << std::endl;
    return radius * sqrt(8.0 * k / mass) / DispCorrection;
}

unsigned int helpers::getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep	(	unsigned int	numberOfSaves,
		Mdouble	timeMax,
		Mdouble	timestep
	)

Returns the correct saveCount if the total number of saves, the final time and the time step is known.

MercuryDPM uses the DPMBase::setSaveCount to determine how often output is written. However, if the user wants to set the total number of saves instead of the saveCount, he can use this function to calculate the correct saveCount, assuming that the final time and the mean time step is known.

Example of use:

setSaveCount(helpers::getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep(numberOfSaves, getTimeMax(), getTimeStep()));

Parameters

[in]	numberOfSaves	the total number of output files the user wants at the end of the simulation.
[in]	timeMax	the final time of the simulation
[in]	timestep	the mean time step used during the simulation

Returns

the saveCount value that should be used to get the desired number of saves.

Definition at line 343 of file Helpers.cc.

References ERROR, and logger.

{
    if (numberOfSaves > 0 && timeMax > 0 && timestep > 0)
    {
        return static_cast<unsigned int>(ceil((timeMax + timestep) / timestep / static_cast<double>(numberOfSaves - 1)));
    }
    else
    {
        logger(ERROR, "[Helpers::getSaveCountFromNumberOfSavesAndTimeMaxAndTimestep()] numberOfSaves: %, timeMax: %, timestep: %", numberOfSaves, timeMax, timestep);
        logger(ERROR, " Arguments need to be positive");
        exit(-1);
    }
}

bool helpers::openFile	(	std::fstream &	file,
		std::string	filename,
		std::fstream::openmode	mode
	)

Provides a simple interface for opening a file.

Provides a simple interface for opening a file, in order to avoid that the user has to learn the syntax for opening a file.

Parameters

[out]	file	The std::fstream object that the user can write to.
[in]	filename	The name of the file.
[in]	mode	The openmode of the file, typically std::fstream::out or std::fstream::in.

Returns

true is the file was successfully opened, false else.

Definition at line 466 of file Helpers.cc.

{
    file.open(filename.c_str(), mode);
    if (file.fail())
        return false;
    else
        return true;
}

bool helpers::writeToFile	(	std::string	filename,
		std::string	filecontent
	)

Writes a string to a file.

Provides a simple interface for writing a string to a file. This function is mainly used to create ini or restart file that the code later reads back in.

Example of usage:

helpers::writeToFile("RestartUnitTest.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");

Parameters

[in]	filename	the name of the file
[in]	filecontent	the content

Returns

true on success.

Definition at line 411 of file Helpers.cc.

{
    std::fstream file;
    file.open(filename.c_str(), std::ios::out);
    if (file.fail())
    {
        std::cerr << "Error in writeToFile: file could not be opened" << std::endl;
        return false;
    }
    file << filecontent;
    file.close();
    return true;
}