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	addToFile (std::string filename, std::string filecontent)
	Adds a string to an existing 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...
std::vector< double >	readArrayFromFile (std::string filename, int &n, int &m)
template<typename T >
std::string	to_string (const T &n)
template<typename T >
void	readOptionalVariable (std::istream &is, std::string name, T &variable)
void	loadingTest (const ParticleSpecies *species, Mdouble displacement, Mdouble velocity, Mdouble radius, std::string name)
	Used to test the loading/unloading properties of a contact law. More...
void	normalAndTangentialLoadingTest (const ParticleSpecies *species, Mdouble displacement, Mdouble tangentialDisplacement, Mdouble velocity, Mdouble radius, std::string name)
	Used to test the tangential loading/unloading/reloading properties of a frictional contact law. More...
void	objectivenessTest (const ParticleSpecies *species, Mdouble displacement, Mdouble tangentialDisplacement, Mdouble velocity, Mdouble radius, std::string name)
	Used to test the tangential loading/unloading/reloading properties of a frictional contact law. More...
template<typename T >
T	readFromFile (std::string fileName, std::string varName, T value)
	Allows a quick read-in from a parameter file. More...
bool	compare (std::istream &is, std::string s)
void	check (double real, double ideal, double error, std::string errorMessage)

Function Documentation

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

Adds a string to an existing file.

Definition at line 432 of file Helpers.cc.

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

void helpers::check	(	double	real,
		double	ideal,
		double	error,
		std::string	errorMessage
	)

Definition at line 770 of file Helpers.cc.

References mathsFunc::isEqual(), and logger.

                                                                                   {
    logger.assert_always(mathsFunc::isEqual(real, ideal, error),
                         errorMessage + ": % (should be %) ",real, ideal);
}

bool helpers::compare	(	std::istream &	is,
		std::string	s
	)

Definition at line 754 of file Helpers.cc.

References INFO, and logger.

Referenced by File::open(), DPMBase::write(), and File::write().

{
    // Get current position
    //check if the next line starts with 'interactionFile'; otherwise, skip interaction
    int len = is.tellg();
    std::string dummy;
    is >> dummy;
    if (dummy.compare(s) != 0)
    {
        is.seekg(len, std::ios_base::beg);
        return false;
        logger(INFO, "helpers::compare: Next stream value (%) is not %", dummy,s);
    }
    return true;
}

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 288 of file Helpers.cc.

References mathsFunc::log().

{
    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 48 of file Helpers.cc.

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

{
    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 118 of file Helpers.cc.

References mathsFunc::log(), 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 188 of file Helpers.cc.

References mathsFunc::log().

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 138 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 98 of file Helpers.cc.

References mathsFunc::log(), 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

Todo:

what should be used instead of this function?

Definition at line 309 of file Helpers.cc.

References helpers::KAndDispAndKtAndDispt::disp, helpers::KAndDispAndKtAndDispt::dispt, helpers::KAndDispAndKtAndDispt::k, helpers::KAndDispAndKtAndDispt::kt, mathsFunc::log(), 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, dissipationTimeScale, 2.0*effectiveMass); instead

Definition at line 40 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 228 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 208 of file Helpers.cc.

References mathsFunc::log(), 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 268 of file Helpers.cc.

References mathsFunc::log(), 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 248 of file Helpers.cc.

References mathsFunc::exp().

{
    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 163 of file Helpers.cc.

References mathsFunc::exp(), 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 73 of file Helpers.cc.

References mathsFunc::exp(), 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 450 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 503 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 396 of file Helpers.cc.

Referenced by BaseHandler< T >::read(), MercuryBase::read(), DPMBase::read(), DPMBase::readNextDataFile(), 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)

Todo:

what should be used instead of this function?

Definition at line 322 of file Helpers.cc.

References mathsFunc::exp(), and 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 350 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);
    }
}

void helpers::loadingTest	(	const ParticleSpecies *	species,
		Mdouble	displacement,
		Mdouble	velocity,
		Mdouble	radius,
		std::string	name
	)

Used to test the loading/unloading properties of a contact law.

Creates a DPMBase with a particles of unit size and a flat wall and loads/unloads the particle-wall contact.

Parameters

[in]	species	particle species specifying the contact law
[in]	displacement	peak displacement before unloading
[in]	velocity	loading/unloading velocity

Definition at line 535 of file Helpers.cc.

References DPMBase::actionsBeforeTimeStep(), assert, DPMBase::getTime(), DPMBase::getTimeMax(), INFO, logger, NO_FILE, ONE_FILE, InfiniteWall::set(), BaseInteractable::setAngularVelocity(), Files::setFileType(), DPMBase::setMax(), DPMBase::setMin(), DPMBase::setParticleDimensions(), BaseInteractable::setPosition(), BaseParticle::setRadius(), Files::setSaveCount(), BaseWall::setSpecies(), BaseParticle::setSpecies(), DPMBase::setSystemDimensions(), DPMBase::setTimeMax(), DPMBase::setTimeStep(), DPMBase::setupInitialConditions(), BaseInteractable::setVelocity(), and writeToFile().

{
    class LoadingTest : public DPMBase {
        const ParticleSpecies* species;
        Mdouble displacement;
        Mdouble velocity;
        Mdouble radius;
    public:
        //public variables
        LoadingTest (const ParticleSpecies* species, Mdouble displacement, Mdouble velocity, Mdouble radius)
        : species(species), displacement(displacement), velocity(velocity), radius(radius) {}

        void setupInitialConditions() override
        {
            //setName("LoadingTest"+species->getName());
            setTimeMax(2.0*displacement/velocity);
            setTimeStep(2e-3*getTimeMax());
            setSaveCount(1);
            setFileType(FileType::NO_FILE);
            fStatFile.setFileType(FileType::ONE_FILE);

            setMax({radius,radius,radius+radius});
            setMin({-radius,-radius,0});
            setSystemDimensions(3);
            setParticleDimensions(3);

            speciesHandler.copyAndAddObject(*species);

            BaseParticle p;
            p.setSpecies(speciesHandler.getObject(0));
            p.setRadius(radius);
            p.setPosition({0,0,radius});
            particleHandler.copyAndAddObject(p);

            InfiniteWall w;
            w.setSpecies(speciesHandler.getObject(0));
            w.set(Vec3D(0,0,-1),Vec3D(0.0,0.0,0.0));
            wallHandler.copyAndAddObject(w);
        }

        void actionsBeforeTimeStep() override {
            BaseParticle* p = particleHandler.getLastObject();
            assert(p);
            p->setAngularVelocity({0,0,0});

            //Moving particle normally into surface
            if (getTime() <= displacement/velocity) {
                p->setVelocity({0,0,velocity});
                p->setPosition({0,0,radius-velocity*getTime()});
            } else {
                p->setVelocity({0,0,-velocity});
                p->setPosition({0,0,radius-displacement-displacement+velocity*getTime()});
            }
        }
    } test(species, displacement, velocity, radius);
    test.setName(name);
    test.solve();
    writeToFile(test.getName()+".gnu","plot '"+test.getName()+".fstat' u 7:9 w lp");
    logger(INFO,"finished loading test: run 'gnuplot %.gnu' to view output",test.getName());
}

void helpers::normalAndTangentialLoadingTest	(	const ParticleSpecies *	species,
		Mdouble	displacement,
		Mdouble	tangentialDisplacement,
		Mdouble	velocity,
		Mdouble	radius,
		std::string	name
	)

Used to test the tangential loading/unloading/reloading properties of a frictional contact law.

Creates a DPMBase with a particles of unit size and a flat wall and loads/unloads/reloads the particle-wall contact in tangential direction.

Parameters

[in]	species	particle species specifying the contact law
[in]	displacement	peak displacement before unloading
[in]	velocity	loading/unloading velocity

Definition at line 602 of file Helpers.cc.

References DPMBase::actionsBeforeTimeStep(), assert, DPMBase::getTime(), DPMBase::getTimeMax(), INFO, logger, NO_FILE, ONE_FILE, InfiniteWall::set(), BaseInteractable::setAngularVelocity(), Files::setFileType(), DPMBase::setMax(), DPMBase::setMin(), DPMBase::setParticleDimensions(), BaseInteractable::setPosition(), BaseParticle::setRadius(), Files::setSaveCount(), BaseWall::setSpecies(), BaseParticle::setSpecies(), DPMBase::setSystemDimensions(), DPMBase::setTimeMax(), DPMBase::setTimeStep(), DPMBase::setupInitialConditions(), BaseInteractable::setVelocity(), and writeToFile().

{
    class LoadingTest : public DPMBase {
        const ParticleSpecies* species;
        Mdouble displacement;
        Mdouble tangentialDisplacement;
        Mdouble velocity;
        Mdouble radius;
    public:
        //public variables
        LoadingTest (const ParticleSpecies* species, Mdouble displacement, Mdouble tangentialDisplacement, Mdouble velocity, Mdouble radius)
         : species(species), displacement(displacement), tangentialDisplacement(tangentialDisplacement), velocity(velocity), radius(radius) {}

        void setupInitialConditions() override
        {
            //setName("TangentialLoadingTest"+species->getName());
            setTimeMax(4.0*tangentialDisplacement/velocity);
            setTimeStep(2e-3*getTimeMax());
            setSaveCount(1);
            setFileType(FileType::NO_FILE);
            fStatFile.setFileType(FileType::ONE_FILE);

            setMax({radius,radius,radius+radius});
            setMin({-radius,-radius,0});
            setSystemDimensions(3);
            setParticleDimensions(3);

            speciesHandler.copyAndAddObject(*species);

            BaseParticle p;
            p.setSpecies(speciesHandler.getObject(0));
            p.setRadius(radius);
            p.setPosition({0,0,radius-displacement});
            particleHandler.copyAndAddObject(p);

            InfiniteWall w;
            w.setSpecies(speciesHandler.getObject(0));
            w.set(Vec3D(0,0,-1),Vec3D(0.0,0.0,0.0));
            wallHandler.copyAndAddObject(w);
        }

        void actionsBeforeTimeStep() override {
            BaseParticle* p = particleHandler.getLastObject();
            assert(p);
            p->setAngularVelocity({0,0,0});

            //Moving particle normally into surface
            Mdouble time = getTime() / (tangentialDisplacement/velocity);
            if (time <= 1.0) {
                p->setVelocity({velocity,0,0});
                p->setPosition({velocity*getTime(),0,radius-displacement});
            } else if (time <= 3.0) {
                p->setVelocity({-velocity,0,0});
                p->setPosition({2.0*tangentialDisplacement-velocity*getTime(),0,radius-displacement});
            } else {
                p->setVelocity({velocity,0,0});
                p->setPosition({-4.0*tangentialDisplacement+velocity*getTime(),0,radius-displacement});
            }
        }

    } test(species, displacement, tangentialDisplacement, velocity, radius);
    test.setName(name);
    test.solve();
    writeToFile(test.getName()+".gnu","plot '"+test.getName()+".fstat' u 8:($10*$14) w lp");
    logger(INFO,"finished tangential loading test: run 'gnuplot %.gnu' to view output",test.getName());
}

void helpers::objectivenessTest	(	const ParticleSpecies *	species,
		Mdouble	displacement,
		Mdouble	tangentialDisplacement,
		Mdouble	velocity,
		Mdouble	radius,
		std::string	name
	)

Used to test the tangential loading/unloading/reloading properties of a frictional contact law.

Creates a DPMBase with a particles of unit size and a flat wall, loads the particle-wall contact in normal and tangential direction, then rotates.

Parameters

[in]	species	particle species specifying the contact law
[in]	displacement	peak displacement before unloading
[in]	velocity	loading/unloading velocity

Definition at line 677 of file Helpers.cc.

References DPMBase::actionsBeforeTimeStep(), assert, mathsFunc::cos(), BaseInteractable::getAngularVelocity(), BaseInteractable::getOrientation(), BaseInteractable::getPosition(), DPMBase::getTime(), DPMBase::getTimeMax(), BaseInteractable::getVelocity(), INFO, logger, NO_FILE, ONE_FILE, constants::pi, BaseInteractable::setAngularVelocity(), Files::setFileType(), DPMBase::setMax(), DPMBase::setMin(), BaseInteractable::setOrientation(), DPMBase::setParticleDimensions(), BaseInteractable::setPosition(), BaseParticle::setRadius(), Files::setSaveCount(), BaseParticle::setSpecies(), DPMBase::setSystemDimensions(), DPMBase::setTimeMax(), DPMBase::setTimeStep(), DPMBase::setupInitialConditions(), BaseInteractable::setVelocity(), mathsFunc::sin(), and writeToFile().

{
    class ObjectivenessTest : public DPMBase {
        const ParticleSpecies* species;
        Mdouble displacement;
        Mdouble tangentialDisplacement;
        Mdouble velocity;
        Mdouble radius;
    public:
        //public variables
        ObjectivenessTest (const ParticleSpecies* species, Mdouble displacement, Mdouble tangentialDisplacement, Mdouble velocity, Mdouble radius)
         : species(species), displacement(displacement), tangentialDisplacement(tangentialDisplacement), velocity(velocity), radius(radius) {}

        void setupInitialConditions() override
        {
            //setName("ObjectivenessTest"+species->getName());
            setTimeMax((tangentialDisplacement+0.5*constants::pi*radius)/velocity);
            setTimeStep(1e-4*getTimeMax());
            setSaveCount(20);
            setFileType(FileType::NO_FILE);
            dataFile.setFileType(FileType::ONE_FILE);
            fStatFile.setFileType(FileType::ONE_FILE);

            setMax(radius*Vec3D(2,2,2));
            setMin(radius*Vec3D(-2,-2,-2));
            setSystemDimensions(2);
            setParticleDimensions(3);

            speciesHandler.copyAndAddObject(*species);

            BaseParticle p;
            p.setSpecies(speciesHandler.getObject(0));
            p.setRadius(radius);
            p.setPosition({0,radius-displacement,0});
            particleHandler.copyAndAddObject(p);
            p.setPosition({0,-radius+displacement,0});
            particleHandler.copyAndAddObject(p);
        }

        void actionsBeforeTimeStep() override {
            BaseParticle* p = particleHandler.getObject(0);
            BaseParticle* q = particleHandler.getLastObject();
            assert(p);
            assert(q);

            //Moving particle normally into surface
            if (getTime() <= tangentialDisplacement/velocity) {
                p->setAngularVelocity({0,0,0});
                p->setVelocity({velocity,0,0});
                p->setPosition({-tangentialDisplacement+velocity*getTime(),radius-displacement,0});
                q->setAngularVelocity({0,0,0});
                q->setVelocity({-velocity,0,0});
                q->setPosition({tangentialDisplacement-velocity*getTime(),-radius+displacement,0});
            } else {
                Mdouble angle = velocity/(radius-displacement) * (getTime()-tangentialDisplacement/velocity);
                Mdouble s = sin(angle);
                Mdouble c = cos(angle);
                p->setAngularVelocity(velocity/(radius-displacement)*Vec3D(0,0,-1));
                //p->setAngularVelocity(Vec3D(0,0,0));
                //p->setOrientation({1,0,0,0});
                p->setVelocity(velocity*Vec3D(c,-s,0));
                //p->setVelocity(Vec3D(0,0,0));
                p->setPosition((radius-displacement)*Vec3D(s,c,0));
                q->setAngularVelocity(-p->getAngularVelocity());
                q->setOrientation(-p->getOrientation());
                q->setVelocity(-p->getVelocity());
                q->setPosition(-p->getPosition());
            }
        }

    } test (species, displacement, tangentialDisplacement, velocity, radius);
    test.setName(name);
    test.solve();
    writeToFile(test.getName()+".gnu","set size ratio -1; plot '"+test.getName()+".fstat' u 14:15 every 2 w lp");
    logger(INFO,"finished objectiveness test: run 'gnuplot %.gnu' to view output",test.getName());
}

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 487 of file Helpers.cc.

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

std::vector< double > helpers::readArrayFromFile	(	std::string	filename,
		int &	n,
		int &	m
	)

Definition at line 508 of file Helpers.cc.

{
    std::fstream file;
    file.open(filename.c_str(), std::ios::in);
    if (file.fail())
    {
        std::cerr << "Error in readArrayFromFile: file could not be opened" << std::endl;
        exit(-1);
    }
    file >> n >> m;
    std::vector<double> v;
    Mdouble val;
    for (int i=0; i<n*m; i++)
    {
        file >> val;
        v.push_back(val);
    }
    file.close();
    return v;
}

template<typename T >

T helpers::readFromFile	(	std::string	fileName,
		std::string	varName,
		T	value
	)

Allows a quick read-in from a parameter file.

For example, the following code reads in the variable time from the file in:

double time = readFromFile("in","time",24);

The in file needs to contain the string time, followed by the value, e.g.

time 20

If the file cannot be opened, or the parameter is not found, the variable is set to the default value specified by the third argument.

Parameters

fileName	name of input
varName	variable name as it appears in the input file
value	default value (used if the parameter could not be read)

Returns

value of variable

Definition at line 260 of file Helpers.h.

References INFO, logger, and WARN.

                                                                   {
        //open filestream
        std::ifstream is(fileName.c_str(), std::ios::in);
        if (is.fail()) {
            logger(INFO, "readFromFile: file % could not be opened, variable % set to default value %", fileName, varName, value);
            return value;
        }

        //read in variables, until the right one is fount
        std::string s;
        while(!is.eof()) {
            is >> s;
            if (!s.compare(varName)) {
                is >> value;
                logger(INFO,"readFromFile: variable % set to % ",varName,value);
                return value;
            }
        }

        //if the right variable is never found
        logger(WARN,"readFromFile: variable % not set in file %, set to default value % ", varName, fileName, value);
        return value;
    }

template<typename T >

void helpers::readOptionalVariable	(	std::istream &	is,
		std::string	name,
		T &	variable
	)

Todo:

checkAndRead should check if the next variable in the ifstream is equal to the string nam, and only read in this case; otherwise continue, but I don't know how to put the location in the ifstream back.

Definition at line 212 of file Helpers.h.

                                                                          {
        if (is.peek() == name.c_str()[0]) 
        {
            std::string dummy;
            is >> dummy >> variable;
        }
    }

template<typename T >

std::string helpers::to_string

(

const T &

n

)

Definition at line 203 of file Helpers.h.

Referenced by InteractionHandler::writeVTK(), ParticleHandler::writeVTK(), and WallHandler::writeVTKFile().

    {
        std::ostringstream stm ;
        stm << n ;
        return stm.str() ;
    }

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 418 of file Helpers.cc.

Referenced by loadingTest(), main(), normalAndTangentialLoadingTest(), objectivenessTest(), Screw::writeVTK(), and DPMBase::writeVTK().

{
    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;
}