helpers Namespace Reference

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

Functions
bool	removeFromCommandline (int &argc, char *argv[], std::string varName, int nArgs)
	May be used to hide arguments from argc and argv. More...
bool	readFromCommandLine (int argc, char *argv[], std::string varName)
	Returns true if command line arguments contain varName, false else. More...
template<typename T >
T	readFromCommandLine (int argc, char *argv[], std::string varName, T value)
template<typename T , size_t n>
std::array< T, n >	readArrayFromCommandLine (int argc, char *argv[], std::string varName, std::array< T, n > value)
template<typename T >
std::vector< T >	readVectorFromCommandLine (int argc, char *argv[], std::string varName, size_t n, std::vector< T > values)
template<>
std::string	readFromCommandLine< std::string > (int argc, char *argv[], std::string varName, std::string value)
bool	writeToFile (std::string filename, std::string filecontent)
	Writes a string to a file. More...
void	writeCommandLineToFile (const std::string filename, const int argc, char *const argv[])
	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...
std::vector< double >	readArrayFromFile (std::string filename, int &n, int &m)
void	more (std::string filename, unsigned nLines=constants::unsignedMax)
bool	createDirectory (std::string)
std::string	getPath ()
template<typename T >
bool	readOptionalVariable (std::istream &is, const std::string &name, T &variable)
	Reads optional variables in the restart file. More...
template<typename T >
T	readFromFile (const std::string fileName, const std::string varName, const T defaultValue)
MERCURYDPM_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 and tangential restitution coefficient r, beta for a collision of effective/reduced mass m. From Deen...Kuipers2006, eq. 43 and 30. More...
MERCURYDPM_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...
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...
Mdouble	getRayleighTime (Mdouble radius, Mdouble shearModulus, Mdouble poisson, Mdouble density)
	Returns the Rayleigh time step for a Hertz contact law. 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...
Mdouble	round (Mdouble value, unsigned int precision)
	rounds a floating point number with a given precision More...
std::vector< Mdouble >	linspace (Mdouble a, Mdouble b, int N)
	creates a 1D linear space partition More...
void	gnuplot (std::string command)
	Plots to a gnuplot window. More...
Mdouble	getRealTime ()
int	qSortCompare (const void *x, const void *y)
	For use with qsort. More...
double	getPercentile (const double *array, size_t nel, double perc)
	Returns the 100*perc-th percentile of array. More...
int	getMaximumNumberOfOMPThreads ()
	Gets the maximum number of OpenMP threads. More...
std::string	lower (std::string s)
	returns the input string after converting upper-case characters to lower case 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	isNext (std::istream &is, const std::string name)
bool	compare (std::istream &is, std::string s)
	Checks if the next argument in the input stream is a certain string. More...
std::string	toString (Mdouble value, unsigned precision)
	converts a floating point number into a string with a given precision More...
template<typename T >
std::string	toString (const T &n)
template<typename T >
std::string	toString (const std::vector< T > &vec)
void	check (double real, double ideal, double error, std::string errorMessage)
void	check (Vec3D real, Vec3D ideal, double error, std::string errorMessage)
void	check (Matrix3D real, Matrix3D ideal, double error, std::string errorMessage)
void	check (MatrixSymmetric3D real, MatrixSymmetric3D ideal, double error, std::string errorMessage)

Function Documentation

addToFile()

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

Adds a string to an existing file.

Todo:

gmb Make this MPI compatible.

Note

Not used function.

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

References INFO, and logger.

check() [1/4]

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

{
    checkTemplate(real, ideal, error, whatIsChecked);
}

References checkTemplate().

Referenced by ForceLawsMPI2Test::actionsAfterSolve(), ScaleCoupledBeam::actionsAfterSolve(), DPM::actionsBeforeTimeStep(), Beam::checkBeamDeflection(), CoupledBeam::CoupledBeam(), InsertionBoundary::generateParticle(), BidisperseCubeInsertionBoundary::generateParticle(), PolydisperseInsertionBoundary::generateParticle(), main(), ExtremeOverlapVolumeUnitTest::setupInitialConditions(), and InertiaTensorTester::test().

check() [2/4]

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

{
    checkTemplate(real, ideal, error, whatIsChecked);
}

References checkTemplate().

check() [3/4]

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

{
    checkTemplate(real, ideal, error, whatIsChecked);
}

References checkTemplate().

check() [4/4]

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

{
    checkTemplate(real, ideal, error, whatIsChecked);
}

References checkTemplate().

compare()

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

Checks if the next argument in the input stream is a certain string.

{
    // 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 != s)
    {
        is.seekg(len, std::ios_base::beg);
        logger(INFO, "helpers::compare: Next stream value (%) is not %", dummy, s);
        return false;
    }
    return true;
}

References INFO, and logger.

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

computeDisptFromCollisionTimeAndRestitutionCoefficientAndTangentialRestitutionCoefficientAndEffectiveMass()

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 and tangential restitution coefficient r, beta for a collision of effective/reduced mass m. From Deen...Kuipers2006, eq. 43 and 30.

Todo:

what should be used instead of this function?

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

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

createDirectory()

bool helpers::createDirectory

(

std::string

path

)

Todo:

gmb Make this MPI compatible.

Note

Not used function.

Note

Is this necessary? Don't we use WSL for Windows?

Todo:

gmb log error using strerror(errno)

                                            {
    //see https://stackoverflow.com/questions/20358455/cross-platform-way-to-make-a-directory
    mode_t nMode = 0733; // UNIX style permissions
    int nError = 0;
#if defined(_WIN32)
    nError = _mkdir(path.c_str()); // can be used on Windows
#else
    nError = mkdir(path.c_str(), nMode); // can be used on non-Windows
#endif
    if (nError != 0) {
        // handle your error here
    }
    return false;
}

fileExists()

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.

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

Referenced by ParameterStudy1DDemo::actionsBeforeTimeLoop(), ParameterStudy2DDemo::actionsBeforeTimeLoop(), ParameterStudy3DDemo::actionsBeforeTimeLoop(), main(), DPMBase::readRestartFile(), FlowRule::run(), AngleOfRepose::run(), and SegregationPeriodic::setupInitialConditions().

getEffectiveMass()

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.

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

Referenced by main().

getLineFromStringStream()

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 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)

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

Referenced by main(), BaseHandler< T >::read(), InteractionHandler::read(), DPMBase::read(), BaseCluster::read(), MercuryBase::read(), SpeciesHandler::readAndAddObject(), WallHandler::readAndCreateOldObject(), DPMBase::readNextDataFile(), BoundaryHandler::readOldObject(), and SpeciesHandler::readOldObject().

getMaximumNumberOfOMPThreads()

int helpers::getMaximumNumberOfOMPThreads

(

)

Gets the maximum number of OpenMP threads.

Gets the maximum number of OpenMP threads if MERCURYDPM_USE_OMP is enabled.

Returns

int maximum number of OpenMP threads

{
#ifdef MERCURYDPM_USE_OMP
    return omp_get_max_threads();
#else
    logger(WARN, "You are getting the maximum number of OMP threads, but OMP is not turned on");
    return 1;
#endif
}

References logger, and WARN.

getMaximumVelocity()

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?

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

References mathsFunc::exp(), and mathsFunc::square().

Referenced by ChutePeriodic::setupInitialConditions(), Vreman::setupInitialConditions(), and SilbertPeriodic::setupInitialConditions().

getPath()

std::string helpers::getPath

(

)

Todo:

gmb log error using strerror(errno)

{
    char cCurrentPath[FILENAME_MAX];
    if (GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)) == NULL) {
        logger(WARN, "Get current dir failed: %", cCurrentPath);
    }
    return std::string(cCurrentPath);
}

References GetCurrentDir, logger, and WARN.

Referenced by DPMBase::writePythonFileForVTKVisualisation(), and HorizontalMixer::writeScript().

getPercentile()

double helpers::getPercentile	(	const double *	array,
		size_t	nel,
		double	perc
	)

Returns the 100*perc-th percentile of array.

array should be sorted, e.g. qsort(xs, n, sizeof(double), qSortCompare); and perc should be a number between 0 and 1.

{
    size_t lower_ind = floor(perc * (nel - 1));
    size_t upper_ind = ceil(perc * (nel - 1));
    double lambda = (perc * (nel - 1)) - lower_ind;
    double lower_x = array[lower_ind];
    double upper_x = array[upper_ind];
    double percentile = (1 - lambda) * lower_x + lambda * upper_x;
    return percentile;
}

getRayleighTime()

Mdouble helpers::getRayleighTime	(	Mdouble	radius,
		Mdouble	shearModulus,
		Mdouble	poisson,
		Mdouble	density
	)

Returns the Rayleigh time step for a Hertz contact law.

An accepted time step for Hertz is 10-20% of the Rayleigh time step. See [Marigo2015]

{
    return constants::pi * radius * sqrt(density / shearModulus)/(0.1631 * poisson + 0.8766);
}

References constants::pi.

Referenced by NozzleDemo::setupInitialConditions(), and NozzleSelfTest::setupInitialConditions().

getRealTime()

Mdouble helpers::getRealTime

(

)

{
    // record start time
    static auto start = std::chrono::steady_clock::now();
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> diff = end - start;
    return diff.count();
}

getSaveCountFromNumberOfSavesAndTimeMaxAndTimeStep()

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.

{
    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: %\n Arguments need to be positive",
               numberOfSaves, timeMax, timeStep);
    }
    return 0;
}

References ERROR, and logger.

Referenced by ChutePeriodicDemo::ChutePeriodicDemo(), ChuteWithWedge::ChuteWithWedge(), main(), ChutePeriodic::setup(), AxisymmetricHopper::setupInitialConditions(), MovingIntersectionOfWallsUnitTest_Basic::setupInitialConditions(), MovingWall::setupInitialConditions(), SeparateFilesSelfTest::setupInitialConditions(), Slide::Slide(), and statistics_while_running< T >::statistics_while_running().

gnuplot()

void helpers::gnuplot

(

std::string

command

)

Plots to a gnuplot window.

Note

Not used function.

{
#ifdef __CYGWIN__
    logger(WARN, "[helpers::gnuplot] is not supported on Cygwin");
#elif _WIN32
    logger(WARN, "[helpers::gnuplot] is not supported on Windows");
#else
    FILE* pipe = popen("gnuplot -persist", "w");
    fprintf(pipe, "%s", command.c_str());
    fflush(pipe);
#endif
}

References logger, and WARN.

isNext()

bool helpers::isNext	(	std::istream &	is,
		const std::string	name
	)

reads next value in stream as a string and compares it with name. If name is equal to string, the function outputs true. If name is not equal to string, the function undoes the read by setting seekg, and outputs false.

Parameters

is
name

Returns

                                                         {
    std::string dummy;
    auto pos = is.tellg();
    is >> dummy;
    if (dummy != name) {
        is.seekg(pos);
        return false;
    } else {
        return true;
    }
}

References units::name.

Referenced by BaseWall::read().

linspace()

std::vector< Mdouble > helpers::linspace	(	Mdouble	a,
		Mdouble	b,
		int	N
	)

creates a 1D linear space partition

{
    Mdouble dx = (Max - Min) / static_cast<Mdouble>(numberOfBins - 1);
    Mdouble val;
    std::vector<Mdouble> linearVector(numberOfBins);
    typename std::vector<Mdouble>::iterator x;
    for (x = linearVector.begin(), val = Min; x != linearVector.end(); ++x, val += dx)
    {
        *x = val;
    }
    // ensure that last value is equal to Max.
    linearVector.pop_back();
    linearVector.push_back(Max);
    return linearVector;
}

lower()

std::string helpers::lower

(

std::string

s

)

returns the input string after converting upper-case characters to lower case

{
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    return s;
}

Referenced by WallHandler::readTriangleWall().

more()

void helpers::more	(	std::string	filename,
		unsigned	nLines = constants::unsignedMax
	)

Todo:

gmb Make this MPI compatible.

{
    if (nLines != constants::unsignedMax)
        logger(INFO, "First % lines of %:\n", Flusher::NO_FLUSH, nLines, filename);
    std::fstream file;
    file.open(filename.c_str(), std::ios::in);
    if (file.fail())
        logger(ERROR, "Error in readArrayFromFile: file could not be opened");
    std::string line;
    for (unsigned i = 0; i < nLines; i++)
    {
        if (file.eof()) break;
        getline(file, line);
        logger(INFO, " %\n", line);
    }
    file.close();
}

References ERROR, constants::i, INFO, logger, NO_FLUSH, and constants::unsignedMax.

Referenced by commandLineCG(), and main().

openFile()

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.

Todo:

gmb Make this MPI compatible. Is it used?

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

Referenced by main().

qSortCompare()

int helpers::qSortCompare	(	const void *	x,
		const void *	y
	)

For use with qsort.

{
    double xx = *(double*) x, yy = *(double*) y;
    if (xx < yy) return -1;
    if (xx > yy) return 1;
    return 0;
}

readArrayFromCommandLine()

template<typename T , size_t n>

std::array<T,n> helpers::readArrayFromCommandLine	(	int	argc,
		char *	argv[],
		std::string	varName,
		std::array< T, n >	value
	)

    {
        for (int i = 0; i < argc-1; ++i) {
            if (varName == argv[i]) {
                unsigned j = i+1;
                std::stringstream out;
                for (auto& v : value) {
                    v = atof(argv[j]);
                    out << v << ' ';
                    ++j;
                }
                logger(INFO, "readArrayFromCommandLine: % set to % ", varName.substr(1), out.str());
                return value;
            }
        }
        //if the variable is not found
        std::stringstream out;
        for (auto& v : value) out << v << ' ';
        logger(INFO, "readArrayFromCommandLine: % set to default value % ", varName.substr(1), out.str());
        return value;
    }

References constants::i, INFO, and logger.

readArrayFromFile()

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

Todo:

gmb Make this MPI compatible.

Note

Not used function.

{
    std::fstream file;
    file.open(filename.c_str(), std::ios::in);
    if (file.fail())
    {
        logger(ERROR, "Error in readArrayFromFile: file could not be opened");
    }
    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;
}

References ERROR, constants::i, logger, and n.

readFromCommandLine() [1/2]

bool helpers::readFromCommandLine	(	int	argc,
		char *	argv[],
		std::string	varName
	)

Returns true if command line arguments contain varName, false else.

Returns true if command line arguments contain varName, false else Usage example: if (readFromCommandLine(argc, argv, '-verbose')) ...

Parameters

argc	pass through number of command line arguments
argv	pass through values of command line arguments
varName	name of command line arguments that is required to return true

Returns

true or false

{
    for (unsigned i=0; i<argc; ++i) {
        if (varName == argv[i]) {
            logger(INFO, "readFromCommandLine: % set to true",varName.substr(1));
            return true;
        }
    }
    //if the variable is not found
    logger(INFO, "readFromCommandLine: % set to default value false",varName.substr(1));
    return false;
}

References constants::i, INFO, and logger.

Referenced by Calibration::Calibration(), GranuDrum::GranuDrum(), GranuHeap::GranuHeap(), main(), Calibration::setSpecies(), Material::setSpecies(), and RotatingDrumWet::setupInitialConditions().

readFromCommandLine() [2/2]

template<typename T >

T helpers::readFromCommandLine	(	int	argc,
		char *	argv[],
		std::string	varName,
		T	value
	)

    {
        for (int i = 0; i < argc-1; ++i) {
            if (varName == argv[i]) {
                value = atof(argv[i+1]);
                logger(INFO, "readFromCommandLine: % set to % ", varName.substr(1), value);
                return value;
            }
        }
        //if the variable is not found
        logger(INFO, "readFromCommandLine: % set to default value % ", varName.substr(1), value);
        return value;
    }

References constants::i, INFO, and logger.

readFromCommandLine< std::string >()

template<>

std::string helpers::readFromCommandLine< std::string >	(	int	argc,
		char *	argv[],
		std::string	varName,
		std::string	value
	)

readFromFile()

template<typename T >

T helpers::readFromFile	(	const std::string	fileName,
		const std::string	varName,
		const T	defaultValue
	)

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
defaultValue	default value (used if the parameter could not be read)

Returns

value of variable

    {
        //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, defaultValue);
            return defaultValue;
        }
        
        //read in variables, until the right one is fount
        std::string s;
        while (!is.eof())
        {
            is >> s;
            if (s == varName)
            {
                T value;
                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 %, using default value % ", varName, fileName, defaultValue);
        return defaultValue;
    }

References INFO, logger, and WARN.

Referenced by main().

readOptionalVariable()

template<typename T >

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

Reads optional variables in the restart file.

A variable is stored in the restart file by storing the variables name and value, e.g. " name value" If a variable is always written to the restart file, it can be read-in like this: is >> dummy >> variable; If a variable is optional, the variable name has to be checked, and should be read in like this: readOptionalVariable(is,"name",variable);

Todo:

readOptionalVariable should check the full variable name, not just the next value. However, I don't know how to put the location in the ifstream back.

    {
        const auto pos = is.tellg();
        std::string dummy;
        is >> dummy;
        if (dummy == name)
        {
            is >> variable;
            return true;
        } else {
            is.seekg(pos);
            return false;
        }
    }

References units::name.

Referenced by LiquidMigrationLSSpecies::read(), LiquidMigrationWilletSpecies::read(), InsertionBoundary::read(), BaseInteraction::read(), BaseSpecies::read(), InfiniteWall::read(), and BaseObject::read().

readVectorFromCommandLine()

template<typename T >

std::vector<T> helpers::readVectorFromCommandLine	(	int	argc,
		char *	argv[],
		std::string	varName,
		size_t	n,
		std::vector< T >	values
	)

    {
        for (int i = 0; i < argc-1; ++i) {
            if (varName == argv[i]) {
                // read until the next argument starts
                values.resize(0);
                std::stringstream out;
                for (int j = i+1; j<argc and argv[j][0]!='-'; ++j) {
                    values.push_back(atof(argv[j]));
                    out << values.back() << ' ';
                }
                logger(INFO, "readVectorFromCommandLine: % set to % ", varName.substr(1), out.str());
                return values;
            }
        }
        //if the variable is not found
        std::stringstream out;
        for (auto& v: values) out << v << ' ';
        logger(INFO, "readVectorFromCommandLine: % set to default value % ", varName.substr(1), out.str());
        return values;
    }

References constants::i, INFO, and logger.

removeFromCommandline()

bool helpers::removeFromCommandline	(	int &	argc,
		char *	argv[],
		std::string	varName,
		int	nArgs
	)

May be used to hide arguments from argc and argv.

Parameters

[in]	argc
[in]	argv
[in]	varName	The name of the commandline argument to be removed
[in]	nArgs	The number of additional command line arguments to remove

Returns

boolean True if the argument was found and removed

This function does hide the desired argument from the supplied argv argc combination. It does it by moving the specified arguent to the end of the supplied argv and reducing argc by the coorect number. Other pieces of code that rely on argc should therefor no longer see the hidden argument.

If used in comination with readFromCommandLine(...), this function allows handling of arguments that are not seen by solve(), even if commandline arguments are passed.

{
    int i, j;
    
    for (i=0; i<argc; ++i) {
        if (varName == argv[i]) 
        {
            char *tmp[nArgs+1];
            
            for (j=i; j<argc-1-nArgs; j++)
            {
                // Store the pointers of the handled argument
                if ( j < i + 1 + nArgs)
                {
                    tmp[j-i] = argv[j];
                }
                
                // Move the pointers after the argument to the front
                argv[j] = argv[j + nArgs + 1];
                
            }
            
            // Move the stored argument to the end
            for (j=argc-1-nArgs; j< argc; j++)
            {
                argv[j] = tmp[j + 1 + nArgs - argc];
            }
            argc -= nArgs + 1;
            
            return true;
        }
    }
    
    return false;
}

References constants::i.

Referenced by main().

round()

Mdouble helpers::round	(	Mdouble	value,
		unsigned int	precision
	)

rounds a floating point number with a given precision

{
    const double n = std::pow(10, precision);
    return std::round(value*n)/n;
}

References n.

Referenced by SpeciesTest::actionsAfterSolve(), Vreman::add_particles(), ChuteWithContraction::ChuteWithContraction(), ChuteWithPeriodicInflowAndContraction::ChuteWithPeriodicInflowAndContraction(), VariableBottom::createBottom(), HorizontalScrew::getDistanceAndNormal(), Coil::getDistanceAndNormal(), Screw::getDistanceAndNormalLabCoordinates(), GranuHeap::GranuHeap(), PointIsAboveCurve(), FileReader::read(), DPMBase::readParAndIniFiles(), AngleOfRepose::run(), VariableBottom::set_chute_parameters(), AngleOfRepose::set_study(), SilbertPeriodic::set_study(), ClosedCSCStats::setupInitialConditions(), CSCStats::setupInitialConditions(), BaseCluster::setupInitialConditions(), ScaleCoupledBeam::setupOomph(), WearableNurbsWall::storeDebris(), and toString().

toString() [1/3]

template<typename T >

std::string helpers::toString

(

const std::vector< T > &

vec

)

    {
        std::ostringstream stm;
        for (const auto val : vec) {
            stm << val << ' ';
        }
        return stm.str();
    }

toString() [2/3]

template<typename T >

std::string helpers::toString

(

const T &

n

)

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

References n.

toString() [3/3]

std::string helpers::toString	(	Mdouble	value,
		unsigned	precision
	)

converts a floating point number into a string with a given precision

{
    std::ostringstream stm;
    stm << round(value, precision);
    return stm.str();
}

References round().

Referenced by ShearStage::actionsAfterSolve(), DeletionBoundary::checkBoundaryAfterParticleMoved(), computeFFc(), computeSimpleFFc(), Contact::Contact(), Indenter::Indenter(), main(), SingleParticle< SpeciesType >::setupInitialConditions(), SinterPair::SinterPair(), and GranuDrum::writeResults().

writeCommandLineToFile()

void helpers::writeCommandLineToFile	(	const std::string	filename,
		const int	argc,
		char *const	argv[]
	)

Writes a string to a file.

Todo:

gmb Make this MPI compatible.

Note

Not used function.

{
    std::stringstream ss;
    for (int i=0; i<argc; ++i) {
        ss << argv[i] << ' ';
    }
    writeToFile(filename,ss.str());
}

References constants::i, and writeToFile().

writeToFile()

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.

Todo:

gmb Make this MPI compatible.

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

References logger, and WARN.

Referenced by ShearStage::actionsAfterSolve(), ScaleCoupledBeam::actionsBeforeSolve(), Beam::actionsBeforeSolve(), CoupledBeam::actionsBeforeSolve(), CoupledProblem::CoupledProblem(), statistics_while_running< T >::finishStatistics(), loadingTest(), main(), normalAndTangentialLoadingTest(), objectivenessTest(), LevelSetWall::setShapeFourSided(), GetDistanceAndNormalForIntersectionOfWalls::setupInitialConditions(), GetDistanceAndNormalForScrew::setupInitialConditions(), GetDistanceAndNormalForTriangleWall::setupInitialConditions(), GetDistanceAndNormalForTriangleWalls::setupInitialConditions(), SingleParticle< SpeciesType >::setupInitialConditions(), ShearStage::ShearStage(), SinterPair::SinterPair(), writeCommandLineToFile(), writeHelpers(), Calibration::writePSDToFile(), DPMBase::writePythonFileForVTKVisualisation(), GranuDrum::writeResults(), GranuHeap::writeResults(), HorizontalMixer::writeScript(), LevelSetWall::writeToFile(), and Screw::writeVTK().