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
std::size_t	countLeadingDashes (const std::string &s)
	Counts the leading dash ('-') characters in a string. More...
bool	removeFromCommandline (int &argc, char *argv[], const std::string &varName, int nArgs)
	May be used to hide arguments from argc and argv. More...
bool	readFromCommandLine (int argc, char *argv[], const std::string &varName)
	Returns true if command line arguments contain varName, false else. More...
template<typename T >
T	readFromCommandLine (int argc, char *argv[], const std::string &varName, T value)
template<typename T , size_t n>
std::array< T, n >	readArrayFromCommandLine (int argc, char *argv[], const std::string &varName, std::array< T, n > value)
template<typename T >
std::vector< T >	readVectorFromCommandLine (int argc, char *argv[], const std::string &varName, size_t n, std::vector< T > values)
template<>
std::string	readFromCommandLine< std::string > (int argc, char *argv[], const std::string &varName, std::string value)
bool	writeToFile (const std::string &filename, const 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 (const std::string &filename, const std::string &filecontent)
	Adds a string to an existing file. More...
bool	fileExists (const 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, const std::string &filename, std::fstream::openmode mode)
	Provides a simple interface for opening a file. More...
std::vector< double >	readArrayFromFile (const std::string &filename, int &n, int &m)
void	more (const std::string &filename, unsigned nLines=constants::unsignedMax)
bool	createDirectory (const std::string &directory, bool allowExists=false)
	Creates a directory. More...
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	getShearModulus (Mdouble youngsModulus, Mdouble poisson)
	Returns the shear modulus calculated from Young's modulus and Poisson's ratio. 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)
	Checks if the next argument in the input stream equals a certain string. When true, the current position is that of the next argument. When false, the current position remains unchanged. More...
MERCURYDPM_DEPRECATED bool	compare (std::istream &is, const std::string &s)
	Checks if the next argument in the input stream is a certain string. More...
bool	lookAhead (std::istream &is, const std::string &name, int number)
	Checks if the nth argument from the current position in the input stream equals a certain string. The current position remains unchanged. 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)
template<typename... Args>
std::string	stringFormat (const std::string &format, Args... args)
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	(	const std::string &	filename,
		const std::string &	filecontent
	)

Adds a string to an existing file.

Todo:

gmb Make this MPI compatible.

{
    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 MergeRestartFiles::filename, 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(), and calibrate::error.

Referenced by ForceLawsMPI2Test::actionsAfterSolve(), ScaleCoupledBeam::actionsAfterSolve(), DPM::actionsBeforeTimeStep(), Beam::checkBeamDeflection(), CoupledBeam::CoupledBeam(), main(), ExtremeOverlapVolumeUnitTest::setupInitialConditions(), PSDSelfTest::setupInitialConditions(), InertiaTensorTester::test(), and MortaringValidationProblem< ELEMENT, NON_MORTAR_ELEMENT >::verify_mortared_nodes_coincide().

check() [2/4]

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

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

References checkTemplate(), and calibrate::error.

check() [3/4]

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

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

References checkTemplate(), and calibrate::error.

check() [4/4]

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

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

References checkTemplate(), and calibrate::error.

compare()

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

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

Deprecated:

{
    logger(WARN, "helpers::compare() is deprecated. Use helpers::isNext() instead.");
    // 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(VERBOSE, "helpers::compare: Next stream value (%) is not %", dummy, s);
        return false;
    }
    return true;
}

References logger, s, oomph::Global_string_for_annotation::string(), VERBOSE, and WARN.

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 beta, helpers::KAndDispAndKtAndDispt::disp, helpers::KAndDispAndKtAndDispt::dispt, helpers::KAndDispAndKtAndDispt::k, helpers::KAndDispAndKtAndDispt::kt, Eigen::bfloat16_impl::log(), constants::pi, UniformPSDSelfTest::r, sqrt(), and mathsFunc::square().

countLeadingDashes()

std::size_t helpers::countLeadingDashes

(

const std::string &

s

)

Counts the leading dash ('-') characters in a string.

Parameters

[in]

s

String constaining dash ('-') characters.

Returns

Number of leading dashes ('-')

                                                        {
    std::size_t counter = 0;
 
    for(char c : s){
        if(c == '-'){
            ++counter;
        } else {
            break;
        }
    }
 
    return counter;
}

References calibrate::c, and s.

Referenced by helpers::readFromCommandLine< std::string >(), readArrayFromCommandLine(), readFromCommandLine(), and readVectorFromCommandLine().

createDirectory()

bool helpers::createDirectory	(	const std::string &	directory,
		bool	allowExists = false
	)

Creates a directory.

Parameters

directory	Absoulte/relative path of the directory
allowExists	Won't fail if directory exists

Returns

Directory created

Parameters

directory	Absoulte/relative path of the directory
allowExists	Won't fail if directory exists

Returns

true/false

{
#ifdef MERCURYDPM_USE_MPI
    if (PROCESSOR_ID == 0)
    {
#endif
 
    if (directory == ".") {
        return true;
    }
 
    errno = 0;
    const int err = ::mkdir(directory.c_str(), 0777);
    if (err == 0) {
        return true;
    } else if(errno == EEXIST && allowExists) {
        return true;
    } else {
        logger(ERROR, "Unable to create directory `%`: % (%)", directory, strerror(errno), errno);
        return false;
    }
 
#ifdef MERCURYDPM_USE_MPI
    } else {
        return true;
    }
#endif
}

References ERROR, logger, and PROCESSOR_ID.

Referenced by DPMBase::initialiseVTK().

fileExists()

bool helpers::fileExists

(

const 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();
}

References out(), and oomph::Global_string_for_annotation::string().

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 Eigen::bfloat16_impl::asin(), Eigen::bfloat16_impl::exp(), k, UniformPSDSelfTest::radius, sqrt(), mathsFunc::square(), and w.

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

getPath()

std::string helpers::getPath

(

)

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

References logger, oomph::Global_string_for_annotation::string(), 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;
}

References Eigen::bfloat16_impl::ceil(), Eigen::bfloat16_impl::floor(), and lambda.

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 UniformPSDSelfTest::density, constants::pi, UniformPSDSelfTest::radius, and sqrt().

Referenced by main(), 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();
}

References Eigen::placeholders::end, and oomph::CumulativeTimings::start().

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 Eigen::bfloat16_impl::ceil(), 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().

getShearModulus()

Mdouble helpers::getShearModulus	(	Mdouble	youngsModulus,
		Mdouble	poisson
	)

Returns the shear modulus calculated from Young's modulus and Poisson's ratio.

                                                                      {
    return youngsModulus / (2.0 * (1 + poisson));
}

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
	)

Checks if the next argument in the input stream equals a certain string. When true, the current position is that of the next argument. When false, the current position remains unchanged.

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 plotDoE::name, and oomph::Global_string_for_annotation::string().

Referenced by DropletBoundary::read(), BaseWall::read(), and DPMBase::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;
}

References calibrate::val, and plotDoE::x.

Referenced by PSD::convertPdfPhiToPdfMeter(), PSD::setDistributionLogNormal(), PSD::setDistributionNormal(), and PSD::setDistributionUniform().

lookAhead()

bool helpers::lookAhead	(	std::istream &	is,
		const std::string &	name,
		int	number
	)

Checks if the nth argument from the current position in the input stream equals a certain string. The current position remains unchanged.

{
    logger.assert_always(number > 0, "Error in helpers::lookAhead(). Number must be greater than 0.");
    // Remember current position.
    auto pos = is.tellg();
    std::string dummy;
    // Read the next n values, i.e. n-1 values are skipped.
    for (int i = 0; i < number; i++)
        is >> dummy;
    // Set the position back.
    is.seekg(pos);
    // Return whether the nth value equals the searched name.
    return dummy == name;
}

References i, logger, plotDoE::name, and oomph::Global_string_for_annotation::string().

Referenced by DropletBoundary::read().

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

References s, and transform().

Referenced by HistogramHelper< Scalar, std::enable_if_t< Eigen::NumTraits< Scalar >::IsInteger > >::bin_width(), oomph::HypreHelpers::create_HYPRE_Matrix(), oomph::HypreHelpers::create_HYPRE_Vector(), fpdiff::fpdiff_helper(), oomph::Gauss_Rescaled< DIM, NPTS_1D >::Gauss_Rescaled(), PolarNSProblem< ELEMENT >::get_shear_stress(), HistogramHelper< Scalar, EnableIf >::HistogramHelper(), oomph::PiecewiseGauss< DIM, NPTS_1D >::knot(), oomph::DenseComplexMatrix::ludecompose(), main(), oomph::PiecewiseGauss< DIM, NPTS_1D >::PiecewiseGauss(), and WallHandler::readTriangleWall().

more()

void helpers::more	(	const 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, MergeRestartFiles::filename, i, INFO, calibrate::line, logger, NO_FLUSH, oomph::Global_string_for_annotation::string(), and constants::unsignedMax.

Referenced by commandLineCG(), and main().

openFile()

bool helpers::openFile	(	std::fstream &	file,
		const 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;
}

References MergeRestartFiles::filename.

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

References plotDoE::x, and y.

readArrayFromCommandLine()

template<typename T , size_t n>

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

    {
        const size_t nDashes = countLeadingDashes(varName);
        for (int i = 0; i < argc-1; ++i) {
            if (varName == argv[i]) {
                int j = i + 1;
                std::stringstream out;
                for (auto& v : value) {
                    v = atof(argv[j]);
                    out << v << ' ';
                    ++j;
                }
                logger(INFO, "readArrayFromCommandLine: % set to % ", varName.substr(nDashes), 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(nDashes), out.str());
        return value;
    }

References countLeadingDashes(), i, INFO, j, logger, out(), v, and Eigen::value.

readArrayFromFile()

std::vector< double > helpers::readArrayFromFile	(	const 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, MergeRestartFiles::filename, i, logger, m, n, v, and calibrate::val.

readFromCommandLine() [1/2]

bool helpers::readFromCommandLine	(	int	argc,
		char *	argv[],
		const 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

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

References countLeadingDashes(), i, INFO, and logger.

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

readFromCommandLine() [2/2]

template<typename T >

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

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

References countLeadingDashes(), i, INFO, logger, and Eigen::value.

readFromCommandLine< std::string >()

template<>

std::string helpers::readFromCommandLine< std::string >	(	int	argc,
		char *	argv[],
		const 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 UniformPSDSelfTest::fileName, INFO, logger, s, oomph::Global_string_for_annotation::string(), Eigen::value, 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 plotDoE::name, and oomph::Global_string_for_annotation::string().

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

readVectorFromCommandLine()

template<typename T >

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

    {
        const size_t nDashes = countLeadingDashes(varName);
        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 && argv[j][0] != '-'; ++j) {
                    values.push_back(atof(argv[j]));
                    out << values.back() << ' ';
                }
                logger(INFO, "readVectorFromCommandLine: % set to % ", varName.substr(nDashes), 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(nDashes), out.str());
        return values;
    }

References countLeadingDashes(), i, INFO, j, logger, out(), and v.

removeFromCommandline()

bool helpers::removeFromCommandline	(	int &	argc,
		char *	argv[],
		const 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.

{
    for (int i = 0; i < argc; ++i) {
        if (varName == argv[i]) 
        {
            char *tmp[nArgs + 1];
            
            for (int 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 (int j = argc - 1 - nArgs; j < argc; j++)
            {
                argv[j] = tmp[j + 1 + nArgs - argc];
            }
            argc -= nArgs + 1;
            
            return true;
        }
    }
    
    return false;
}

References i, j, and tmp.

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, Eigen::bfloat16_impl::pow(), Eigen::bfloat16_impl::round(), and Eigen::value.

stringFormat()

template<typename... Args>

std::string helpers::stringFormat	(	const std::string &	format,
		Args...	args
	)

    {
        int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1; // Extra space for '\0'
        if (size_s <= 0) {
            logger(ERROR, "snprintf() failed");
        }
        auto size = static_cast<size_t>(size_s);
        std::unique_ptr<char[]> buf(new char[size]);
        std::snprintf(buf.get(), size, format.c_str(), args...);
        return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
    }

References compute_granudrum_aor::args, ERROR, format(), logger, size, and oomph::Global_string_for_annotation::string().

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();
    }

References calibrate::val.

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 Eigen::bfloat16_impl::round(), and Eigen::value.

Referenced by ShearStage::actionsAfterSolve(), DeletionBoundary::checkBoundaryAfterParticleMoved(), computeFFc(), computeSimpleFFc(), Contact::Contact(), Indenter::Indenter(), main(), MeltableForceLaw2SelfTest::setupInitialConditions(), MeltableForceLawSelfTest::setupInitialConditions(), SingleParticle< SpeciesType >::setupInitialConditions(), SinterPair::SinterPair(), GranuDrum::writeResults(), and RotatingDrumBidisperse::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 MergeRestartFiles::filename, i, and writeToFile().

writeToFile()

bool helpers::writeToFile	(	const std::string &	filename,
		const 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 MergeRestartFiles::filename, logger, out(), 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(), RotatingDrumBidisperse::writeResults(), HorizontalMixer::writeScript(), LevelSetWall::writeToFile(), and Screw::writeVTK().