BaseLib Namespace Reference

Detailed Description

Basic algorithms and helper functions provided for all other libraries.

Namespaces
	IO

Classes
class	Range
	Wraps a pair of iterators for use as a range in range-based for-loops. More...
class	ConfigTree
class	ConfigTreeTopLevel
class	CPUTime
	Count CPU time. More...
struct	DynamicSpan
class	Histogram
class	MemWatch
class	RunTime
	Count the running time. More...
class	ISubdivision
class	UniformSubdivision
class	GradualSubdivision
class	GradualSubdivisionFixedNum
class	TCLAPCustomOutput
struct	TimeInterval

Functions
template<typename T >
std::vector< T >	excludeObjectCopy (std::vector< T > const &src_vec, std::vector< std::size_t > const &exclude_positions)
template<typename T >
void	excludeObjectCopy (std::vector< T > const &src_vec, std::vector< std::size_t > const &exclude_positions, std::vector< T > &dest_vec)
template<typename InputIt , typename Predicate >
std::iterator_traits< InputIt >::reference	findElementOrError (InputIt begin, InputIt end, Predicate predicate, std::string const &error="")
template<typename Map , typename Key , typename Value >
void	insertIfTypeIndexKeyUniqueElseError (Map &map, Key const &key, Value &&value, std::string const &error_message)
template<typename Map , typename Key , typename Value >
void	insertIfKeyUniqueElseError (Map &map, Key const &key, Value &&value, std::string const &error_message)
template<typename Map , typename Key , typename Value >
void	insertIfKeyValueUniqueElseError (Map &map, Key const &key, Value &&value, std::string const &error_message)
template<typename Map , typename Key >
Map::mapped_type &	getOrError (Map &map, Key const &key, std::string const &error_message)
template<typename Map , typename Key >
Map::mapped_type const &	getOrError (Map const &map, Key const &key, std::string const &error_message)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename Container , typename Predicate >
Container::value_type const &	getIfOrError (Container const &container, Predicate &&predicate, std::string const &error_message)
template<typename T >
void	makeVectorUnique (std::vector< T > &v)
template<typename T , class Compare >
void	makeVectorUnique (std::vector< T > &v, Compare comp)
template<typename ValueType , typename IndexType >
void	reorderVector (std::vector< ValueType > &v, std::vector< IndexType > const &order)
template<typename Container >
void	uniquePushBack (Container &container, typename Container::value_type const &element)
template<typename Container >
bool	contains (Container const &container, typename Container::value_type const &element)
template<typename Container , typename Predicate >
bool	containsIf (Container const &container, Predicate &&predicate)
template<typename Container >
std::optional< typename Container::value_type >	findFirstNotEqualElement (Container const &container, typename Container::value_type const &element)
template<typename Container >
std::size_t	findIndex (Container const &container, typename Container::value_type const &element)
template<typename T1 , typename T2 >
void	cleanupVectorElements (std::vector< T1 * > const &items, std::vector< T2 * > const &dependent_items)
void	checkAndInvalidate (ConfigTree &conf)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
void	checkAndInvalidate (ConfigTree *const conf)
void	checkAndInvalidate (std::unique_ptr< ConfigTree > const &conf)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
template<typename T >
void	traverse_recursive (boost::property_tree::ptree &parent, boost::property_tree::ptree::path_type const &child_path, boost::property_tree::ptree &child, fs::path const &bench_dir, T &method)
template<typename T >
void	traverse (boost::property_tree::ptree &parent, const fs::path bench_dir, T &method)
void	replaceIncludes ([[maybe_unused]] boost::property_tree::ptree const &parent, [[maybe_unused]] boost::property_tree::ptree::path_type const &child_path, boost::property_tree::ptree &child, fs::path const &bench_dir)
void	patchStream (std::string patch_file, std::stringstream &prj_stream)
void	readAndPatchPrj (std::stringstream &prj_stream, std::string &prj_file, std::vector< std::string > patch_files)
ConfigTreeTopLevel	makeConfigTree (const std::string &filepath, const bool be_ruthless, const std::string &toplevel_tag, const std::vector< std::string > &patch_files)
template<typename E >
constexpr auto	to_underlying (E e) noexcept
	Converts an enumeration to its underlying type. More...
int	date2int (int y, int m, int d)
std::string	int2date (int date)
std::string	date2string (double ddate)
int	strDate2int (const std::string &s)
int	xmlDate2int (const std::string &s)
std::string	formatDate (std::chrono::time_point< std::chrono::system_clock > const &time)
bool	isProjectDirectorySet ()
	Returns true if the project directory is set. More...
bool	IsFileExisting (const std::string &strFilename)
	Returns true if given file exists. More...
std::tuple< std::string, std::string::size_type, std::string::size_type >	getParenthesizedString (std::string const &in, char const open_char, char const close_char, std::string::size_type pos)
std::string	containsKeyword (std::string const &str, std::string const &keyword)
template<typename T >
bool	substituteKeyword (std::string &result, std::string &parenthesized_string, std::string::size_type begin, std::string::size_type end, std::string const &keyword, T &data)
std::string	constructFormattedFileName (std::string const &format_specification, std::string const &mesh_name, int const timestep, double const t, int const iteration)
double	swapEndianness (double const &v)
std::string	dropFileExtension (std::string const &filename)
std::string	extractBaseName (std::string const &pathname)
std::string	extractBaseNameWithoutExtension (std::string const &pathname)
std::string	getFileExtension (const std::string &path)
bool	hasFileExtension (std::string const &extension, std::string const &filename)
std::string	copyPathToFileName (const std::string &file_name, const std::string &source)
std::string	extractPath (std::string const &pathname)
std::string	joinPaths (std::string const &pathA, std::string const &pathB)
std::string const &	getProjectDirectory ()
	Returns the directory where the prj file resides. More...
void	setProjectDirectory (std::string const &dir)
	Sets the project directory. More...
void	removeFile (std::string const &filename)
void	removeFiles (std::vector< std::string > const &files)
template<typename T >
void	writeValueBinary (std::ostream &out, T const &val)
	write value as binary into the given output stream More...
template<typename T >
T	swapEndianness (T const &v)
template<typename T >
T	readBinaryValue (std::istream &in)
template<typename T >
std::vector< T >	readBinaryArray (std::string const &filename, std::size_t const n)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const Histogram< T > &h)
void	setConsoleLogLevel (std::string const &level_string)
template<typename It1 , typename It2 , typename Comparator >
void	quicksort (It1 first1, It1 last1, It2 first2, Comparator compare)
template<typename It1 , typename It2 >
void	quicksort (It1 first1, It1 last1, It2 first2)
template<typename T1 , typename T2 = std::size_t>
void	quicksort (T1 *array, std::size_t beg, std::size_t end, T2 *perm)
template<typename T1 , typename T2 = std::size_t>
void	quicksort (std::vector< T1 > &array, std::size_t beg, std::size_t end, std::vector< T2 > &perm)
template<typename T1 , typename T2 = std::size_t>
void	quicksort (std::vector< T1 * > &array, std::size_t beg, std::size_t end, std::vector< T2 > &perm)
std::vector< std::string >	splitString (std::string const &str)
std::list< std::string >	splitString (const std::string &str, char delim)
std::string	replaceString (const std::string &searchString, const std::string &replaceString, std::string stringToReplace)
void	trim (std::string &str, char ch)
void	simplify (std::string &str)
std::string	format (const char *format_str,...)
std::string	randomString (std::size_t length)
	Returns a random string of the given length containing just a-z,A-Z,0-9. More...
std::string	getUniqueName (std::vector< std::string > const &existing_names, std::string const &input_name)
	Append '-' and a number such that the name is unique. More...
template<typename T >
T	str2number (const std::string &str)
TimeInterval	createTimeInterval (ConfigTree const &config)

Variables
std::shared_ptr< spdlog::logger >	console = spdlog::stdout_color_mt("ogs")

Function Documentation

checkAndInvalidate() [1/3]

void BaseLib::checkAndInvalidate

(

ConfigTree &

conf

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 470 of file ConfigTree.cpp.

{
    conf.checkAndInvalidate();
}

Referenced by BaseLib::ConfigTreeTopLevel::checkAndInvalidate().

checkAndInvalidate() [2/3]

void BaseLib::checkAndInvalidate

(

ConfigTree *const

conf

)

Check if conf has been read entirely and invalidate it.

This method can safely be called on nullptr's.

See also

ConfigTree::checkAndInvalidate()

Definition at line 475 of file ConfigTree.cpp.

{
    if (conf)
    {
        conf->checkAndInvalidate();
    }
}

checkAndInvalidate() [3/3]

void BaseLib::checkAndInvalidate

(

std::unique_ptr< ConfigTree > const &

conf

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 483 of file ConfigTree.cpp.

{
    if (conf)
    {
        conf->checkAndInvalidate();
    }
}

cleanupVectorElements()

template<typename T1 , typename T2 >

void BaseLib::cleanupVectorElements	(	std::vector< T1 * > const &	items,
		std::vector< T2 * > const &	dependent_items
	)

Util function to cleanup vectors

Definition at line 300 of file Algorithm.h.

{
    for (auto dependent_item : dependent_items)
    {
        delete dependent_item;
    }
    for (auto item : items)
    {
        delete item;
    }
}

Referenced by FileIO::SwmmInterface::convertSwmmInputToGeometry(), FileIO::Gocad::GocadAsciiReader::createMesh(), FileIO::GMSInterface::readGMS3DMMesh(), FileIO::TetGenInterface::readTetGenMesh(), and MeshLib::MeshRevision::simplifyMesh().

constructFormattedFileName()

std::string BaseLib::constructFormattedFileName	(	std::string const &	format_specification,
		std::string const &	mesh_name,
		int const	timestep,
		double const	t,
		int const	iteration
	)

Definition at line 116 of file FileTools.cpp.

{
    char const open_char = '{';
    char const close_char = '}';
    std::string::size_type begin = 0;
    std::string::size_type end = std::string::npos;
    std::string result = format_specification;
 
    while (begin != std::string::npos)
    {
        auto length_before_substitution = result.length();
        // find next parenthesized string
        std::string str = "";
        std::tie(str, begin, end) =
            getParenthesizedString(result, open_char, close_char, begin);
        if (!substituteKeyword(result, str, begin, end, "timestep", timestep) &&
            !substituteKeyword(result, str, begin, end, "time", t) &&
            !substituteKeyword(result, str, begin, end, "iteration", iteration))
        {
            substituteKeyword(result, str, begin, end, "meshname", mesh_name);
        }
        begin = end - (length_before_substitution - result.length());
    }
 
    return result;
}

References getParenthesizedString(), and substituteKeyword().

Referenced by ProcessLib::Output::OutputFile::constructFilename(), and anonymous_namespace{Output.cpp}::constructPVDName().

contains()

template<typename Container >

bool BaseLib::contains	(	Container const &	container,
		typename Container::value_type const &	element
	)

Definition at line 256 of file Algorithm.h.

{
    return std::find(container.begin(), container.end(), element) !=
           container.end();
}

Referenced by ProcessLib::LIE::duGlobalEnrichments(), and MaterialLib::Solids::MFront::getEquivalentPlasticStrainOffset().

containsIf()

template<typename Container , typename Predicate >

bool BaseLib::containsIf	(	Container const &	container,
		Predicate &&	predicate
	)

Definition at line 264 of file Algorithm.h.

{
    return std::find_if(container.begin(), container.end(), predicate) !=
           container.end();
}

Referenced by ProjectData::parseProcesses().

containsKeyword()

std::string BaseLib::containsKeyword	(	std::string const &	str,
		std::string const &	keyword
	)

Definition at line 71 of file FileTools.cpp.

{
    auto const position = str.find(keyword);
    if (position != std::string::npos)
    {
        return str.substr(0, position);
    }
    return "";
}

Referenced by substituteKeyword().

copyPathToFileName()

std::string BaseLib::copyPathToFileName	(	const std::string &	file_name,
		const std::string &	source
	)

Checks if file_name already contains a qualified path and if not copies the path from source.

Definition at line 196 of file FileTools.cpp.

{
    auto filePath = fs::path(file_name);
    if (filePath.has_parent_path())
    {
        return filePath.string();
    }
    return (fs::path(source) /= filePath).string();
}

Referenced by ProjectData::ProjectData(), anonymous_namespace{ProjectData.cpp}::readMeshes(), anonymous_namespace{ProjectData.cpp}::readSingleMesh(), and GeoLib::IO::XmlStnInterface::readStations().

createTimeInterval()

TimeInterval BaseLib::createTimeInterval

(

ConfigTree const &

config

)

Input File Parameter:

prj__time_loop__processes__process__time_interval

Input File Parameter:

prj__time_loop__processes__process__time_interval__start

Input File Parameter:

prj__time_loop__processes__process__time_interval__end

Definition at line 21 of file TimeInterval.cpp.

{
    auto const& time_interval_config = config.getConfigSubtree("time_interval");
 
    const auto start_time =
        time_interval_config.getConfigParameter<double>("start");
 
    const auto end_time =
        time_interval_config.getConfigParameter<double>("end");
 
    return {start_time, end_time};
}

References BaseLib::ConfigTree::getConfigParameter(), and BaseLib::ConfigTree::getConfigSubtree().

Referenced by ProcessLib::createDirichletBoundaryConditionWithinTimeInterval().

date2int()

int BaseLib::date2int	(	int	y,
		int	m,
		int	d
	)

Converts three integers representing a date into a double. Note: It is not really checked if the date actually makes sense.

Definition at line 26 of file DateTools.cpp.

{
    if ((y < 1000 || y > 9999) || (m < 1 || m > 12) || (d < 1 || d > 31))
    {
        WARN("date2int(): Input not in expected range.");
        return 0;
    }
 
    int ddate(0);
    ddate = y * 10000;
    ddate += (m * 100);
    ddate += d;
 
    return ddate;
}

References WARN().

Referenced by strDate2int(), and xmlDate2int().

date2string()

std::string BaseLib::date2string

(

double

ddate

)

Converts a double representing a date into a string. Note: It is not really checked if the date actually makes sense.

Parameters

ddate

Number containing date in double format yyyymmdd

Returns

A string containing the date in format "dd.mm.yyyy".

Definition at line 65 of file DateTools.cpp.

{
    if (ddate < 10000101 || ddate > 99991231)
    {
        WARN("date2String(): Input not in expected format.");
        return "0.0.0000";
    }
 
    auto rest(static_cast<int>(ddate));
    auto y = static_cast<int>(std::floor(rest / 10000.0));
    rest = rest % (y * 10000);
    auto m = static_cast<int>(std::floor(rest / 100.0));
    if (m < 1 || m > 12)
    {
        WARN("date2String(): month not in [1:12].");
    }
    rest = rest % (m * 100);
    int d = rest;
    if (d < 1 || d > 31)
    {
        WARN("date2String(): day not in [1:31].");
    }
 
    std::string day = std::to_string(d);
    if (d < 10)
    {
        day = "0" + day;
    }
    std::string month = std::to_string(m);
    if (m < 10)
    {
        month = "0" + month;
    }
    std::string s = std::to_string(y) + "-" + month + "-" + day;
    return s;
}

References WARN().

Referenced by GeoLib::IO::XmlStnInterface::writeBoreholeData().

dropFileExtension()

std::string BaseLib::dropFileExtension

(

std::string const &

filename

)

Returns a string with file extension as found by getFileExtension() dropped.

Definition at line 169 of file FileTools.cpp.

{
    auto const filename_path = fs::path(filename);
    return (filename_path.parent_path() / filename_path.stem()).string();
}

Referenced by convert(), extractBaseNameWithoutExtension(), VtkRaster::findWorldFile(), identifyAndWriteBoundaryMeshes(), main(), FileIO::Gocad::GocadAsciiReader::readFile(), MeshLib::IO::readMeshFromFile(), writeCsvOutput(), and writeMeshOutput().

excludeObjectCopy() [1/2]

template<typename T >

std::vector<T> BaseLib::excludeObjectCopy	(	std::vector< T > const &	src_vec,
		std::vector< std::size_t > const &	exclude_positions
	)

excludeObjectCopy copies only those objects that position within the source vector is not in the exclude_positions vector. The implementation of the algorithm requires that the given positions in exclude_positions are sorted in ascending order.

Parameters

src_vec	the vector of source objects
exclude_positions	the positions of objects in the source vector that do not have to be copied

Returns

vector that contains the copied objects

Definition at line 33 of file Algorithm.h.

{
    std::vector<T> dest_vec;
    if (exclude_positions.empty())
    {
        dest_vec = src_vec;
        return dest_vec;
    }
 
    assert(exclude_positions.back() < src_vec.size());
 
    std::copy_n(src_vec.cbegin(), exclude_positions[0],
                std::back_inserter(dest_vec));
    for (std::size_t i = 1; i < exclude_positions.size(); ++i)
    {
        std::copy_n(src_vec.cbegin() + exclude_positions[i - 1] + 1,
                    exclude_positions[i] - (exclude_positions[i - 1] + 1),
                    std::back_inserter(dest_vec));
    }
    std::copy(src_vec.cbegin() + exclude_positions.back() + 1, src_vec.cend(),
              std::back_inserter(dest_vec));
 
    return dest_vec;
}

References MathLib::LinAlg::copy().

Referenced by MeshLib::PropertyVector< PROP_VAL_TYPE >::clone(), MeshLib::PropertyVector< T * >::clone(), and excludeObjectCopy().

excludeObjectCopy() [2/2]

template<typename T >

void BaseLib::excludeObjectCopy	(	std::vector< T > const &	src_vec,
		std::vector< std::size_t > const &	exclude_positions,
		std::vector< T > &	dest_vec
	)

Definition at line 61 of file Algorithm.h.

{
    dest_vec = excludeObjectCopy(src_vec, exclude_positions);
}

References excludeObjectCopy().

extractBaseName()

std::string BaseLib::extractBaseName

(

std::string const &

pathname

)

Extracts basename from given pathname with extension.

Returns a string containing everything after the last path separator. If the the pathname does not contain a path separator original pathname is returned.

Definition at line 175 of file FileTools.cpp.

{
    return fs::path(pathname).filename().string();
}

Referenced by OGSFileConverter::convertGLI2GML(), extractBaseNameWithoutExtension(), OGSFileConverter::fileExists(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), anonymous_namespace{postLIE.cpp}::postPVD(), FileIO::Legacy::readGLIFileV4(), and MeshLib::IO::NodePartitionedMeshReader::readMesh().

extractBaseNameWithoutExtension()

std::string BaseLib::extractBaseNameWithoutExtension

(

std::string const &

pathname

)

Extracts basename from given pathname without its extension.

Same as extractBaseName(), but drops the file extension too.

Definition at line 180 of file FileTools.cpp.

{
    std::string basename = extractBaseName(pathname);
    return dropFileExtension(basename);
}

References dropFileExtension(), and extractBaseName().

Referenced by FileIO::SwmmInterface::convertSwmmInputToGeometry(), anonymous_namespace{TestDefinition.cpp}::findVtkdiff(), FileIO::Gocad::GocadSGridReader::getMesh(), MeshLib::IO::Legacy::MeshIO::loadMeshFromFile(), main(), FileIO::FEFLOWMeshInterface::readFEFLOWFile(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), FileIO::GMSInterface::readGMS3DMMesh(), FileIO::GMSH::readGMSHMesh(), FileIO::TetGenInterface::readTetGenGeometry(), FileIO::TetGenInterface::readTetGenMesh(), MeshLib::IO::VtuInterface::readVTKFile(), MeshLib::IO::VtuInterface::readVTUFile(), and writeGeoOutput().

extractPath()

std::string BaseLib::extractPath

(

std::string const &

pathname

)

Extracts the path of a pathname.

Returns a string up to the last path separator not including it.

Definition at line 207 of file FileTools.cpp.

{
    return fs::path(pathname).parent_path().string();
}

Referenced by MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), main(), anonymous_namespace{postLIE.cpp}::postPVD(), readAndPatchPrj(), FileIO::Legacy::readGLIFileV4(), FileIO::Legacy::writeAllDataToGLIFileV4(), and FileIO::Legacy::writeGLIFileV4().

findElementOrError()

template<typename InputIt , typename Predicate >

std::iterator_traits<InputIt>::reference BaseLib::findElementOrError	(	InputIt	begin,
		InputIt	end,
		Predicate	predicate,
		std::string const &	error = ""
	)

Definition at line 69 of file Algorithm.h.

{
    auto it = std::find_if(begin, end, predicate);
    if (it == end)
    {
        OGS_FATAL("Element not found in the input range; {:s}", error);
    }
    return *it;
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::Phase::component(), ParameterLib::createParameter(), ProcessLib::SurfaceFluxData::createSurfaceFluxData(), ProcessLib::Output::doOutputAlways(), anonymous_namespace{ProcessVariable.cpp}::findMeshInConfig(), ProjectData::parseProcessVariables(), and MaterialPropertyLib::Medium::phase().

findFirstNotEqualElement()

template<typename Container >

std::optional<typename Container::value_type> BaseLib::findFirstNotEqualElement	(	Container const &	container,
		typename Container::value_type const &	element
	)

Definition at line 271 of file Algorithm.h.

{
    auto const it =
        std::find_if_not(container.begin(), container.end(),
                         [&element](typename Container::value_type const& e)
                         { return e == element; });
    return it == container.end() ? std::nullopt : std::make_optional(*it);
}

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool().

findIndex()

template<typename Container >

std::size_t BaseLib::findIndex	(	Container const &	container,
		typename Container::value_type const &	element
	)

Returns the index of first element in container or, if the element is not found a std::size_t maximum value.

The maximum value of std::size_t is chosen, because such an index cannot exist in a container; the maximum index is std::size_t::max-1.

Definition at line 287 of file Algorithm.h.

{
    auto const it = std::find(container.begin(), container.end(), element);
    if (it == container.end())
    {
        return std::numeric_limits<std::size_t>::max();
    }
    return std::distance(container.begin(), it);
}

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool(), and ProcessLib::ComponentTransport::LookupTable::getTableEntryID().

format()

std::string BaseLib::format	(	const char *	format_str,
			...
	)

Definition at line 85 of file StringTools.cpp.

{
    va_list args;
    va_start(args, format_str);
    // get the number of chars to write
    va_list args_tmp;
    va_copy(args_tmp, args);
    int char_length = std::vsnprintf(nullptr, 0, format_str, args_tmp);
    va_end(args_tmp);
    // allocate buffer and store formatted output there
    std::vector<char> buffer(char_length + 1);  // note +1 for null terminator
    vsnprintf(buffer.data(), buffer.size(), format_str, args);
    va_end(args);
 
    return std::string(buffer.data());
}

Referenced by MeshLib::IO::getPropertyDataTypeSize(), main(), substituteKeyword(), and MeshLib::IO::write_xdmf().

formatDate()

std::string BaseLib::formatDate

(

std::chrono::time_point< std::chrono::system_clock > const &

time

)

Formats the given time point according to RFC 3339 (cf. man-page of the unix date utility).

Example: 2006-08-14 02:34:56-06:00

Definition at line 137 of file DateTools.cpp.

{
    auto const time_t = std::chrono::system_clock::to_time_t(time);
    char time_str[100];
    if (std::strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S%z",
                      std::localtime(&time_t)))
    {
        return time_str;
    }
    return "FAILED FORMATTING THE GIVEN TIME POINT.";
}

Referenced by main().

getFileExtension()

std::string BaseLib::getFileExtension

(

std::string const &

path

)

Extract extension from filename

Definition at line 186 of file FileTools.cpp.

{
    return fs::path(path).extension().string();
}

Referenced by VtkVisImageItem::callVTKWriter(), VtkVisPointSetItem::callVTKWriter(), convert(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), hasFileExtension(), identifyAndWriteBoundaryMeshes(), FileIO::SwmmInterface::isSwmmInputFile(), main(), readAndPatchPrj(), FileIO::readGeometryFromFile(), FileIO::AsciiRasterInterface::readRaster(), FileIO::TetGenInterface::readTetGenGeometry(), writeCsvOutput(), FileIO::writeGeometryToFile(), and writeMeshOutput().

getIfOrError()

template<typename Container , typename Predicate >

Container::value_type const& BaseLib::getIfOrError	(	Container const &	container,
		Predicate &&	predicate,
		std::string const &	error_message
	)

Returns the value of from the given container if such an entry fulfilling the predicate exists; otherwise an error_message is printed and the program is aborted.

Definition at line 192 of file Algorithm.h.

{
    auto it = std::find_if(begin(container), end(container), predicate);
    if (it == end(container))
    {
        OGS_FATAL("Could not find element matching the predicate: {:s}",
                  error_message);
    }
    return *it;
}

References OGS_FATAL.

Referenced by ProcessLib::createPerProcessData().

getOrError() [1/2]

template<typename Map , typename Key >

Map::mapped_type& BaseLib::getOrError	(	Map &	map,
		Key const &	key,
		std::string const &	error_message
	)

Returns the value of key from the given map if such an entry exists; otherwise an error_message is printed and the program is aborted. Cf. also the const overload below.

Remarks

Use as:

 get_or_error<Value>(some_map, some_key, "error
message") 

Definition at line 147 of file Algorithm.h.

{
    auto it = map.find(key);
    if (it == map.end())
    {
        if constexpr (std::is_convertible<Key, std::string>::value)
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message, key);
        }
        else
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message,
                      std::to_string(key));
        }
    }
 
    return it->second;
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::createCurve(), ProcessLib::HeatTransportBHE::BHE::createFlowAndTemperatureControl(), ProcessLib::createPerProcessData(), ProjectData::parseNonlinearSolvers(), and ProcessLib::parseTimeIntervalOrCurve().

getOrError() [2/2]

template<typename Map , typename Key >

Map::mapped_type const& BaseLib::getOrError	(	Map const &	map,
		Key const &	key,
		std::string const &	error_message
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 168 of file Algorithm.h.

{
    auto it = map.find(key);
    if (it == map.end())
    {
        if constexpr (std::is_convertible<Key, std::string>::value)
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message, key);
        }
        else
        {
            OGS_FATAL("{:s} Key `{:s}' does not exist.", error_message,
                      std::to_string(key));
        }
    }
 
    return it->second;
}

References OGS_FATAL.

getParenthesizedString()

std::tuple< std::string, std::string::size_type, std::string::size_type > BaseLib::getParenthesizedString	(	std::string const &	in,
		char const	open_char,
		char const	close_char,
		std::string::size_type	pos
	)

Returns the begin and end position of the string enclosed in open_char and close_char and the enclosed string itself. Search starts at position pos within the string str. Nested open_char and close_char are not handled correctly.

Definition at line 49 of file FileTools.cpp.

{
    auto const pos_curly_brace_open = in.find_first_of(open_char, pos);
    if (pos_curly_brace_open == std::string::npos)
    {
        return std::make_tuple("", std::string::npos, std::string::npos);
    }
    auto const pos_curly_brace_close =
        in.find_first_of(close_char, pos_curly_brace_open);
    if (pos_curly_brace_close == std::string::npos)
    {
        return std::make_tuple("", std::string::npos, std::string::npos);
    }
    return std::make_tuple(
        in.substr(pos_curly_brace_open + 1,
                  pos_curly_brace_close - (pos_curly_brace_open + 1)),
        pos_curly_brace_open, pos_curly_brace_close);
}

Referenced by constructFormattedFileName().

getProjectDirectory()

std::string const & BaseLib::getProjectDirectory

(

)

Returns the directory where the prj file resides.

Definition at line 217 of file FileTools.cpp.

{
    if (!project_directory_is_set)
    {
        OGS_FATAL("The project directory has not yet been set.");
    }
    return project_directory;
}

References OGS_FATAL, anonymous_namespace{FileTools.cpp}::project_directory, and anonymous_namespace{FileTools.cpp}::project_directory_is_set.

Referenced by ChemistryLib::createChemicalSolverInterface< ChemicalSolver::Phreeqc >(), ProcessLib::ComponentTransport::createLookupTable(), MaterialLib::Solids::MFront::createMFront(), and main().

getUniqueName()

std::string BaseLib::getUniqueName	(	std::vector< std::string > const &	existing_names,
		std::string const &	input_name
	)

Append '-' and a number such that the name is unique.

Definition at line 120 of file StringTools.cpp.

{
    std::string result_name = input_name;
    std::size_t count = 1;
    while (std::find(existing_names.cbegin(),
                     existing_names.cend(),
                     result_name) != existing_names.end())
    {
        count++;
        result_name = input_name + "-" + std::to_string(count);
    }
    return result_name;
}

Referenced by GeoLib::GEOObjects::isUniquePointVecName(), MeshLib::RasterDataToMesh::projectToElements(), and MeshLib::RasterDataToMesh::projectToNodes().

hasFileExtension()

bool BaseLib::hasFileExtension	(	std::string const &	extension,
		std::string const &	filename
	)

Compares filename's extension with query extension. The comparison is case insensitive.

Definition at line 191 of file FileTools.cpp.

{
    return boost::iequals(extension, getFileExtension(filename));
}

References getFileExtension().

Referenced by main(), and anonymous_namespace{readMeshFromFile.cpp}::readMeshFromFileSerial().

insertIfKeyUniqueElseError()

template<typename Map , typename Key , typename Value >

void BaseLib::insertIfKeyUniqueElseError	(	Map &	map,
		Key const &	key,
		Value &&	value,
		std::string const &	error_message
	)

Inserts the given key with the given value into the map if an entry with the given key does not yet exist; otherwise an error_message is printed and the program is aborted.

Definition at line 106 of file Algorithm.h.

{
    auto const inserted = map.emplace(key, std::forward<Value>(value));
    if (!inserted.second)
    {  // insertion failed, i.e., key already exists
        OGS_FATAL("{:s} Key `{:s}' already exists.", error_message, key);
    }
}

References OGS_FATAL.

Referenced by ProcessLib::SecondaryVariableCollection::addNameMapping(), ProjectData::parseCurves(), ProjectData::parseLinearSolvers(), ProjectData::parseNonlinearSolvers(), GeoLib::IO::BoostXmlGmlInterface::readPoints(), GeoLib::IO::BoostXmlGmlInterface::readPolylines(), and GeoLib::IO::BoostXmlGmlInterface::readSurfaces().

insertIfKeyValueUniqueElseError()

template<typename Map , typename Key , typename Value >

void BaseLib::insertIfKeyValueUniqueElseError	(	Map &	map,
		Key const &	key,
		Value &&	value,
		std::string const &	error_message
	)

Inserts the given key with the given value into the map if neither an entry with the given key nor an entry with the given value already exists; otherwise an error_message is printed and the program is aborted.

Definition at line 121 of file Algorithm.h.

{
    auto value_compare = [&value](typename Map::value_type const& elem)
    { return value == elem.second; };
 
    if (std::find_if(map.cbegin(), map.cend(), value_compare) != map.cend())
    {
        OGS_FATAL("{:s} Value `{:s}' already exists.", error_message,
                  std::to_string(value));
    }
 
    auto const inserted = map.emplace(key, std::forward<Value>(value));
    if (!inserted.second)
    {  // insertion failed, i.e., key already exists
        OGS_FATAL("{:s} Key `{:s}' already exists.", error_message,
                  std::to_string(key));
    }
}

References OGS_FATAL.

insertIfTypeIndexKeyUniqueElseError()

template<typename Map , typename Key , typename Value >

void BaseLib::insertIfTypeIndexKeyUniqueElseError	(	Map &	map,
		Key const &	key,
		Value &&	value,
		std::string const &	error_message
	)

Inserts the given key with the given value into the map if an entry with the given key does not yet exist; otherwise an error_message is printed and the program is aborted. Note: The type of key must be std::type_index.

Definition at line 88 of file Algorithm.h.

{
    auto const inserted = map.emplace(key, std::forward<Value>(value));
    if (!inserted.second)
    {  // insertion failed, i.e., key already exists
        OGS_FATAL("{:s} Key `{:s}' already exists.", error_message,
                  std::to_string(key.hash_code()));
    }
}

References OGS_FATAL.

int2date()

std::string BaseLib::int2date

(

int

date

)

Converts an integer to a string date "dd.mm.yyyy" Note: (Almost) no checks are performed if the int makes sense as a date.

Definition at line 42 of file DateTools.cpp.

{
    if (date > 10000000 && date < 22000000)
    {
        auto y = static_cast<int>(std::floor(date / 10000.0));
        auto m = static_cast<int>(std::floor((date - (y * 10000)) / 100.0));
        int d = date - (y * 10000) - (m * 100);
        std::stringstream ss;
        if (d < 10)
        {
            ss << "0";
        }
        ss << d << ".";
        if (m < 10)
        {
            ss << "0";
        }
        ss << m << "." << y;
        return ss.str();
    }
    return "";
}

Referenced by DiagramList::readList().

IsFileExisting()

bool BaseLib::IsFileExisting

(

const std::string &

strFilename

)

Returns true if given file exists.

Returns true if given file exists.

Parameters

strFilename

the file name

Definition at line 43 of file FileTools.cpp.

{
    return fs::exists(fs::path(strFilename));
}

Referenced by ChemistryLib::createChemicalSolverInterface< ChemicalSolver::Phreeqc >(), ProcessLib::ComponentTransport::createLookupTable(), anonymous_namespace{TestDefinition.cpp}::findVtkdiff(), anonymous_namespace{postLIE.cpp}::postPVD(), MeshLib::IO::NodePartitionedMeshReader::read(), readAndPatchPrj(), MeshLib::IO::VtuInterface::readVTKFile(), and MeshLib::IO::VtuInterface::readVTUFile().

isProjectDirectorySet()

bool BaseLib::isProjectDirectorySet

(

)

Returns true if the project directory is set.

Definition at line 35 of file FileTools.cpp.

{
    return project_directory_is_set;
}

References anonymous_namespace{FileTools.cpp}::project_directory_is_set.

joinPaths()

std::string BaseLib::joinPaths	(	std::string const &	pathA,
		std::string const &	pathB
	)

Concat two paths. Does not check for validity.

Definition at line 212 of file FileTools.cpp.

{
    return (fs::path(pathA) /= fs::path(pathB)).string();
}

Referenced by ApplicationsLib::TestDefinition::TestDefinition(), anonymous_namespace{Output.cpp}::constructPVDName(), ChemistryLib::createChemicalSolverInterface< ChemicalSolver::Phreeqc >(), ProcessLib::ComponentTransport::createLookupTable(), MaterialLib::Solids::MFront::createMFront(), ProcessLib::Output::doOutputNonlinearIteration(), anonymous_namespace{TestDefinition.cpp}::findVtkdiff(), MeshLib::IO::getVtuFileNameForPetscOutputWithoutExtension(), main(), anonymous_namespace{postLIE.cpp}::postPVD(), readAndPatchPrj(), FileIO::Legacy::readPolyline(), FileIO::Legacy::readPolylinePointVector(), FileIO::Legacy::readSurface(), and FileIO::Legacy::writeTINSurfaces().

makeConfigTree()

ConfigTreeTopLevel BaseLib::makeConfigTree	(	std::string const &	filepath,
		bool const	be_ruthless,
		std::string const &	toplevel_tag,
		const std::vector< std::string > &	patch_files = {}
	)

Create a ConfigTree from an XML file.

Parameters

filepath	see ConfigTreeTopLevel::ConfigTreeTopLevel()
be_ruthless	see ConfigTreeTopLevel::ConfigTreeTopLevel()
toplevel_tag	name of the outermost tag in the XML file. The returned ConfigTree is rooted one level below that tag.
patch_files	optional vector of strings with patch file paths.

The parameter toplevel_tag is provided for compatibility with our existing configuration files whose toplevel tags are written in camel case, which conflicts with the naming rules of ConfigTree. Via that parameter the naming rules do not apply to the toplevel tag.

Unfortunately the XML parser shipped with boost::property_tree does not fully support the XML standard. Additionally there might be encoding issues. From their docs:

Please note that RapidXML does not understand the encoding specification.

If you pass it a > character buffer, it assumes the data is already correctly encoded; if you pass it a filename, > it will read the file using the character conversion of the locale you give it (or the global > locale if you give it none). This means that, in order to parse a UTF-8-encoded XML file into > a wptree, you have to supply an alternate locale, either directly or by replacing the global one.

See also

http://www.boost.org/doc/libs/1_60_0/doc/html/property_tree/parsers.html

Definition at line 242 of file ConfigTreeUtil.cpp.

{
    std::string prj_file = filepath;
    std::stringstream prj_stream;
    readAndPatchPrj(prj_stream, prj_file, patch_files);
 
    ConfigTree::PTree ptree;
 
    // note: Trimming whitespace and ignoring comments is crucial in order
    //       for our configuration tree implementation to work!
    try
    {
        read_xml(prj_stream, ptree,
                 boost::property_tree::xml_parser::no_comments |
                     boost::property_tree::xml_parser::trim_whitespace);
 
        if (toplevel_tag == "OpenGeoSysProject")
        {
            traverse(ptree, fs::path(prj_file).parent_path(), replaceIncludes);
        }
    }
    catch (boost::property_tree::xml_parser_error const& e)
    {
        OGS_FATAL("Error while parsing XML file `{:s}' at line {:d}: {:s}.",
                  e.filename(), e.line(), e.message());
    }
 
    DBUG("Project configuration from file '{:s}' read.", filepath);
 
    if (auto child = ptree.get_child_optional(toplevel_tag))
    {
        return ConfigTreeTopLevel(filepath, be_ruthless, std::move(*child));
    }
    OGS_FATAL("Tag <{:s}> has not been found in file `{:s}'.", toplevel_tag,
              filepath);
}

References DBUG(), OGS_FATAL, readAndPatchPrj(), replaceIncludes(), and traverse().

Referenced by main(), and GeoLib::IO::BoostXmlGmlInterface::readFile().

makeVectorUnique() [1/2]

template<typename T >

void BaseLib::makeVectorUnique

(

std::vector< T > &

v

)

Make the entries of the std::vector v unique. The remaining entries will be sorted.

Definition at line 209 of file Algorithm.h.

{
    std::sort(v.begin(), v.end());
    auto it = std::unique(v.begin(), v.end());
    v.erase(it, v.end());
}

Referenced by MaterialPropertyLib::collectVariables(), ProcessLib::ComponentTransport::createLookupTable(), ProcessLib::createOutput(), ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::findFracutreIntersections(), ProcessLib::findProcessVariables(), MeshLib::getBaseNodes(), ProcessLib::HeatTransportBHE::getBHEDataInMesh(), MeshGeoToolsLib::getCandidateElementsForLineSegmentIntersection(), ProcessLib::LIE::getFractureMatrixDataInMesh(), MeshGeoToolsLib::mapLineSegment(), reorderNonlinearNodes(), and MeshLib::ElementSearch::searchByNodeIDs().

makeVectorUnique() [2/2]

template<typename T , class Compare >

void BaseLib::makeVectorUnique	(	std::vector< T > &	v,
		Compare	comp
	)

Make the entries of the std::vector v unique using the given binary function. The remaining entries will be sorted.

Definition at line 219 of file Algorithm.h.

{
    std::sort(v.begin(), v.end(), comp);
    auto it = std::unique(v.begin(), v.end());
    v.erase(it, v.end());
}

operator<<()

template<typename T >

std::ostream& BaseLib::operator<<	(	std::ostream &	os,
		const Histogram< T > &	h
	)

Writes histogram to output stream.

Writes histogram properties in this order: number of bins, minimum, maximum, bin0 count, ..., binN-1 count.

Definition at line 203 of file Histogram.h.

{
    os << h.getNumberOfBins() << " " << h.getMinimum() << " " << h.getMaximum()
       << " ";
    std::copy(h.getBinCounts().begin(), h.getBinCounts().end(),
              std::ostream_iterator<T>(os, " "));
    return os << std::endl;
}

References MathLib::LinAlg::copy(), BaseLib::Histogram< T >::getBinCounts(), BaseLib::Histogram< T >::getMaximum(), BaseLib::Histogram< T >::getMinimum(), and BaseLib::Histogram< T >::getNumberOfBins().

patchStream()

void BaseLib::patchStream	(	std::string	patch_file,
		std::stringstream &	prj_stream
	)

Definition at line 119 of file ConfigTreeUtil.cpp.

{
    auto patch = xmlParseFile(patch_file.c_str());
    if (patch == NULL)
    {
        OGS_FATAL("Error reading XML diff file {:s}.", patch_file);
    }
 
    auto doc =
        xmlParseMemory(prj_stream.str().c_str(), prj_stream.str().size());
    if (doc == NULL)
    {
        OGS_FATAL("Error reading project file from memory.");
    }
 
    auto node = xmlDocGetRootElement(patch);
    int rc = 0;
    for (node = node ? node->children : NULL; node; node = node->next)
    {
        if (node->type != XML_ELEMENT_NODE)
        {
            continue;
        }
 
        if (!strcmp(reinterpret_cast<const char*>(node->name), "add"))
        {
            rc = xml_patch_add(doc, node);
        }
        else if (!strcmp(reinterpret_cast<const char*>(node->name), "replace"))
        {
            rc = xml_patch_replace(doc, node);
        }
        else if (!strcmp(reinterpret_cast<const char*>(node->name), "remove"))
        {
            rc = xml_patch_remove(doc, node);
        }
        else
        {
            OGS_FATAL(
                "Error while patching prj file with patch file {:}. Only "
                "'add', 'replace' and 'remove' elements are allowed! Got an "
                "element '{:s}' on line {:d}.",
                patch_file, node->name, node->line);
        }
 
        if (rc)
        {
            OGS_FATAL(
                "Error while patching prj file with patch file {:}. Error in "
                "element '{:s}' on line {:d}.",
                patch_file, node->name, node->line);
        }
    }
 
    xmlChar* xmlbuff;
    int buffersize;
    xmlDocDumpMemory(doc, &xmlbuff, &buffersize);
    prj_stream.str("");  // Empty stream
    prj_stream << xmlbuff;
 
    xmlFree(xmlbuff);
    xmlFreeDoc(doc);
    xmlFreeDoc(patch);
}

References OGS_FATAL.

Referenced by readAndPatchPrj().

quicksort() [1/5]

template<typename It1 , typename It2 >

void BaseLib::quicksort	(	It1	first1,
		It1	last1,
		It2	first2
	)

Precondition

{first1 <= last1 and the second iterator can be incremented distance(first1, last1) times}

Definition at line 52 of file quicksort.h.

{
    using T1 = typename std::iterator_traits<It1>::value_type;
    using T2 = typename std::iterator_traits<It2>::value_type;
 
    quicksort(first1, last1, first2,
              [](std::pair<T1, T2> const& a, std::pair<T1, T2> const& b)
              { return a.first < b.first; });
}

References quicksort().

quicksort() [2/5]

template<typename It1 , typename It2 , typename Comparator >

void BaseLib::quicksort	(	It1	first1,
		It1	last1,
		It2	first2,
		Comparator	compare
	)

Precondition

{first1 <= last1 and the second iterator can be incremented distance(first1, last1) times}

Definition at line 26 of file quicksort.h.

{
    using T1 = typename std::iterator_traits<It1>::value_type;
    using T2 = typename std::iterator_traits<It2>::value_type;
 
    std::vector<std::pair<T1, T2>> data;
    data.reserve(std::distance(first1, last1));
    std::transform(first1, last1, first2, std::back_inserter(data),
                   [](T1 const& t1, T2 const& t2)
                   { return std::make_pair(t1, t2); });
 
    // Sort data using first element of the pair.
    std::sort(begin(data), end(data), compare);
 
    // Unzip sorted data.
    for (auto const& pair : data)
    {
        *first1 = pair.first;
        *first2 = pair.second;
        ++first1;
        ++first2;
    }
}

Referenced by quicksort(), and GeoLib::Polygon::splitPolygonAtPoint().

quicksort() [3/5]

template<typename T1 , typename T2 = std::size_t>

void BaseLib::quicksort	(	std::vector< T1 * > &	array,
		std::size_t	beg,
		std::size_t	end,
		std::vector< T2 > &	perm
	)

Definition at line 83 of file quicksort.h.

{
    assert(beg <= end);
    assert(end <= array.size());
    assert(perm.size() == array.size());
 
    // Zip input arrays.
    std::vector<std::pair<T1*, T2>> data;
    data.reserve(end - beg);
    std::transform(array.begin() + beg, array.begin() + end, perm.begin() + beg,
                   std::back_inserter(data),
                   [](T1* const& t1, T2 const& t2)
                   { return std::make_pair(t1, t2); });
 
    // Sort data using first element of the pair.
    std::sort(data.begin(), data.end(),
              [](std::pair<T1*, T2> const& a, std::pair<T1*, T2> const& b)
              { return (*a.first < *b.first); });
 
    // Unzip sorted data.
    for (std::size_t i = 0; i < data.size(); i++)
    {
        array[beg + i] = data[i].first;
        perm[beg + i] = data[i].second;
    }
}

quicksort() [4/5]

template<typename T1 , typename T2 = std::size_t>

void BaseLib::quicksort	(	std::vector< T1 > &	array,
		std::size_t	beg,
		std::size_t	end,
		std::vector< T2 > &	perm
	)

Definition at line 72 of file quicksort.h.

{
    assert(beg <= end);
    assert(end <= array.size());
    assert(perm.size() == array.size());
 
    quicksort(array.data(), beg, end, perm.data());
}

References quicksort().

quicksort() [5/5]

template<typename T1 , typename T2 = std::size_t>

void BaseLib::quicksort	(	T1 *	array,
		std::size_t	beg,
		std::size_t	end,
		T2 *	perm
	)

Precondition

{end<=array.size() and perm.size()==array.size()}

Definition at line 64 of file quicksort.h.

{
    assert(beg <= end);
 
    quicksort(array + beg, array + end, perm + beg);
}

References quicksort().

randomString()

std::string BaseLib::randomString

(

std::size_t const

length

)

Returns a random string of the given length containing just a-z,A-Z,0-9.

Definition at line 102 of file StringTools.cpp.

{
    static constexpr char charset[] =
        "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
    static const auto seed = static_cast<std::mt19937::result_type>(
        std::chrono::system_clock::now().time_since_epoch().count());
    static std::mt19937 generator{seed};
    static std::uniform_int_distribution<unsigned short> distribution(
        0, sizeof(charset) - 2);
 
    std::string s(length, 0);
    std::generate_n(
        begin(s), length, [&]() { return charset[distribution(generator)]; });
 
    return s;
}

Referenced by FileIO::createSurface().

readAndPatchPrj()

void BaseLib::readAndPatchPrj	(	std::stringstream &	prj_stream,
		std::string &	prj_file,
		std::vector< std::string >	patch_files
	)

Definition at line 186 of file ConfigTreeUtil.cpp.

{
    // Extract base project file path if an xml (patch) file is given as prj
    // file and it contains the base_file attribute.
    if (BaseLib::getFileExtension(prj_file) == ".xml")
    {
        if (!patch_files.empty())
        {
            OGS_FATAL(
                "It is not allowed to specify additional patch files "
                "if a patch file was already specified as the "
                "prj-file.");
        }
        auto patch = xmlParseFile(prj_file.c_str());
        auto node = xmlDocGetRootElement(patch);
        auto base_file = xmlGetProp(node, (const xmlChar*)"base_file");
        if (base_file == nullptr)
        {
            OGS_FATAL(
                "Error reading base prj file (base_file attribute) in given "
                "patch file {:s}.",
                prj_file);
        }
        patch_files = {prj_file};
        std::stringstream ss;
        ss << base_file;
        prj_file = BaseLib::joinPaths(BaseLib::extractPath(prj_file), ss.str());
    }
 
    // read base prj file into stream
    if (std::ifstream file(prj_file); file)
    {
        prj_stream << file.rdbuf();
    }
    else
    {
        if (!BaseLib::IsFileExisting(prj_file))
        {
            ERR("File {:s} does not exist.", prj_file);
        }
        DBUG("Stream state flags: {:b}.", file.rdstate());
        OGS_FATAL("Could not open project file '{:s}' for reading.", prj_file);
    }
 
    // apply xml patches to stream
    if (!patch_files.empty())
    {
        for (const auto& patch_file : patch_files)
        {
            patchStream(patch_file, prj_stream);
        }
        xmlCleanupParser();
    }
}

References DBUG(), ERR(), extractPath(), getFileExtension(), IsFileExisting(), joinPaths(), OGS_FATAL, and patchStream().

Referenced by makeConfigTree().

readBinaryArray()

template<typename T >

std::vector<T> BaseLib::readBinaryArray	(	std::string const &	filename,
		std::size_t const	n
	)

Definition at line 97 of file FileTools.h.

{
    std::ifstream in(filename.c_str());
    if (!in)
    {
        ERR("readBinaryArray(): Error while reading from file '{:s}'.",
            filename);
        ERR("Could not open file '{:s}' for input.", filename);
        in.close();
        return std::vector<T>();
    }
 
    std::vector<T> result;
    result.reserve(n);
 
    for (std::size_t p = 0; in && !in.eof() && p < n; ++p)
    {
        result.push_back(BaseLib::readBinaryValue<T>(in));
    }
 
    if (result.size() == n)
    {
        return result;
    }
 
    ERR("readBinaryArray(): Error while reading from file '{:s}'.", filename);
    ERR("Read different number of values. Expected {:d}, got {:d}.",
        n,
        result.size());
 
    if (!in.eof())
    {
        ERR("EOF reached.\n");
    }
 
    return std::vector<T>();
}

References ERR().

readBinaryValue()

template<typename T >

T BaseLib::readBinaryValue

(

std::istream &

in

)

Definition at line 89 of file FileTools.h.

{
    T v;
    in.read(reinterpret_cast<char*>(&v), sizeof(T));
    return v;
}

removeFile()

void BaseLib::removeFile

(

std::string const &

filename

)

Removes a file. If a file does not exist nothing will happen, other errors lead to OGS_FATAL call.

Definition at line 236 of file FileTools.cpp.

{
    bool const success = fs::remove(fs::path(filename));
    if (success)
    {
        DBUG("Removed '{:s}'", filename);
    }
}

References DBUG().

Referenced by MainWindow::callGMSH(), consolidateGeometry(), main(), and removeFiles().

removeFiles()

void BaseLib::removeFiles

(

std::vector< std::string > const &

files

)

Remove files. If a file does not exist nothing will happen, other errors lead to OGS_FATAL call.

Definition at line 245 of file FileTools.cpp.

{
    for (auto const& file : files)
    {
        removeFile(file);
    }
}

References removeFile().

Referenced by main().

reorderVector()

template<typename ValueType , typename IndexType >

void BaseLib::reorderVector	(	std::vector< ValueType > &	v,
		std::vector< IndexType > const &	order
	)

Reorder a vector by a given index vector.

Note: It is good enough in performance for medium size vectors.

Definition at line 232 of file Algorithm.h.

{
    std::vector<ValueType> temp_v(v.size());
    temp_v.swap(v);
 
    for (std::size_t i = 0; i < order.size(); i++)
    {
        std::swap(v[i], temp_v[order[i]]);
    }
}

Referenced by MaterialLib::PorousMedium::createPorousMediaProperties(), MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties().

replaceIncludes()

void BaseLib::replaceIncludes	(	[[maybe_unused] ] boost::property_tree::ptree const &	parent,
		[[maybe_unused] ] boost::property_tree::ptree::path_type const &	child_path,
		boost::property_tree::ptree &	child,
		fs::path const &	bench_dir
	)

Definition at line 79 of file ConfigTreeUtil.cpp.

{
    using boost::property_tree::ptree;
    for (auto& [key, tree] : child)
    {
        if (key == "include")
        {
            auto filename = tree.get<std::string>("<xmlattr>.file");
            if (auto const filepath = fs::path(filename);
                filepath.is_relative())
            {
                filename = (bench_dir / filepath).string();
            }
            INFO("Including {:s} into project file.", filename);
 
            ptree include_tree;
            read_xml(filename, include_tree,
                     boost::property_tree::xml_parser::no_comments |
                         boost::property_tree::xml_parser::trim_whitespace);
 
            // Can only insert subtree at child
            auto& tmp_tree = child.put_child("include", include_tree);
 
            // Move subtree above child
            std::move(tmp_tree.begin(), tmp_tree.end(), back_inserter(child));
 
            // Erase child
            child.erase("include");
 
            // There can only be one include under a parent element!
            break;
        }
    }
}

References INFO().

Referenced by makeConfigTree().

replaceString()

std::string BaseLib::replaceString	(	const std::string &	searchString,
		const std::string &	replaceString,
		std::string	stringToReplace
	)

Replaces a substring with another in a string

Parameters

searchString	Search for this string
replaceString	Replace with this string
stringToReplace	Search and replace in this string

Returns

The modified string

Definition at line 50 of file StringTools.cpp.

{
    boost::replace_all(stringToReplace, searchString, replaceString);
    return stringToReplace;
}

Referenced by GeoLib::Station::createStation(), FileIO::FEFLOWMeshInterface::getIndexList(), FileIO::readDoubleFromStream(), and DiagramList::readList().

setConsoleLogLevel()

void BaseLib::setConsoleLogLevel

(

std::string const &

level_string

)

Definition at line 34 of file Logging.cpp.

{
    using namespace spdlog::level;
    std::map<std::string, level_enum> string_to_log_level = {
        {"none", off},  {"critical", critical}, {"error", err}, {"warn", warn},
        {"info", info}, {"debug", debug},       {"all", trace}};
 
    auto const level = string_to_log_level.find(level_string);
    if (level == string_to_log_level.end())
    {
        ERR("'{:s}' is not a valid log level!", level_string);
        OGS_FATAL("Wrong log level string.");
    }
    console->set_level(level->second);
    spdlog::set_default_logger(console);
}

References console, ERR(), and OGS_FATAL.

Referenced by main().

setProjectDirectory()

void BaseLib::setProjectDirectory

(

std::string const &

dir

)

Sets the project directory.

Definition at line 226 of file FileTools.cpp.

{
    if (project_directory_is_set)
    {
        OGS_FATAL("The project directory has already been set.");
    }
    project_directory = dir;
    project_directory_is_set = true;
}

References OGS_FATAL, anonymous_namespace{FileTools.cpp}::project_directory, and anonymous_namespace{FileTools.cpp}::project_directory_is_set.

Referenced by main().

simplify()

void BaseLib::simplify

(

std::string &

str

)

Removes multiple whitespaces (or other characters) from within a string. Equivalent functionality to Qt::QString::simplify().

Definition at line 76 of file StringTools.cpp.

{
    trim(str);
    str.erase(std::unique(str.begin(),
                          str.end(),
                          [](char a, char b) { return a == ' ' && b == ' '; }),
              str.end());
}

References trim().

Referenced by FileIO::TetGenInterface::getNFacets(), FileIO::TetGenInterface::parseSmeshFacets(), FileIO::TetGenInterface::readElementsFromStream(), and FileIO::TetGenInterface::readNodesFromStream().

splitString() [1/2]

std::list< std::string > BaseLib::splitString	(	const std::string &	str,
		char	delim
	)

Splits a string into a list of strings.

Parameters

str	String to be split
delim	Character indicating that the string should be split

Returns

List of strings

Definition at line 38 of file StringTools.cpp.

{
    std::list<std::string> strList;
    std::stringstream ss(str);
    std::string item;
    while (getline(ss, item, delim))
    {
        strList.push_back(item);
    }
    return strList;
}

splitString() [2/2]

std::vector< std::string > BaseLib::splitString

(

std::string const &

str

)

Splits a string into a vector of strings. This method only works for string separation recognised by the std::stringstream iterator such as ' ' or '\t'.

Parameters

str	String to be split

Returns

Vector of strings

Definition at line 28 of file StringTools.cpp.

{
    std::istringstream str_stream(str);
    std::vector<std::string> items;
    std::copy(std::istream_iterator<std::string>(str_stream),
              std::istream_iterator<std::string>(),
              std::back_inserter(items));
    return items;
}

References MathLib::LinAlg::copy().

Referenced by FileIO::SwmmInterface::addPointElevation(), FileIO::SwmmInterface::addRainGaugeTimeSeriesLocations(), GeoLib::Station::createStation(), FileIO::CsvInterface::findColumn(), FileIO::CsvInterface::getColumnNames(), FileIO::FEFLOWMeshInterface::getIndexList(), FileIO::TetGenInterface::getNFacets(), FileIO::Gocad::GocadAsciiReader::parseLine(), FileIO::Gocad::GocadAsciiReader::parseNodes(), FileIO::TetGenInterface::parseNodesFileHeader(), FileIO::Gocad::GocadAsciiReader::parseProperties(), FileIO::TetGenInterface::parseSmeshFacets(), FileIO::Gocad::GocadAsciiReader::parseSurface(), FileIO::Gocad::GocadAsciiReader::propertyCheck(), FileIO::GMSInterface::readBoreholesFromGMS(), FileIO::CsvInterface::readColumn(), FileIO::SwmmInterface::readCoordinates(), FileIO::Gocad::GocadAsciiReader::readData(), SensorData::readDataFromFile(), FileIO::FEFLOWMeshInterface::readElevation(), FileIO::SwmmInterface::readLineElements(), FileIO::SwmmInterface::readLinksAsPolylines(), FileIO::SwmmInterface::readNodeData(), FileIO::PetrelInterface::readPetrelWellTrace(), FileIO::PetrelInterface::readPetrelWellTraceData(), FileIO::CsvInterface::readPoints(), FileIO::SwmmInterface::readPollutants(), FileIO::SwmmInterface::readPolygons(), FileIO::SwmmInterface::readSubcatchments(), and splitMaterialIdString().

str2number()

template<typename T >

T BaseLib::str2number

(

const std::string &

str

)

Converts a string into a number (double, float, int, ...) Example: std::size_t number (str2number<std::size_t> (str));

Parameters

str	string to be converted

Returns

the number

Definition at line 59 of file StringTools.h.

{
    std::stringstream strs(str, std::stringstream::in | std::stringstream::out);
    T v;
    strs >> v;
    return v;
}

strDate2int()

int BaseLib::strDate2int

(

const std::string &

s

)

Converts a string containing a date into a double. Note: It is not really checked if the date actually makes sense.

Parameters

s	String containing the date, the expected format is "dd.mm.yyyy".

Returns

A number representing the date as dd.mm.yyyy.

Definition at line 102 of file DateTools.cpp.

{
    std::string str(s);
    if (s.length() > 10)
    {
        str = s.substr(0, 10);
    }
    std::size_t sep(str.find('.', 0));
    int d(atoi(str.substr(0, sep).c_str()));
    std::size_t sep2(str.find('.', sep + 1));
    int m(atoi(str.substr(sep + 1, sep2 - (sep + 1)).c_str()));
    int y(atoi(str.substr(sep2 + 1, s.length() - (sep2 + 1)).c_str()));
    return date2int(y, m, d);
}

References date2int().

Referenced by SensorData::readDataFromFile().

substituteKeyword()

template<typename T >

bool BaseLib::substituteKeyword	(	std::string &	result,
		std::string &	parenthesized_string,
		std::string::size_type	begin,
		std::string::size_type	end,
		std::string const &	keyword,
		T &	data
	)

Definition at line 82 of file FileTools.cpp.

{
    std::string precision_specification =
        containsKeyword(parenthesized_string, keyword);
 
    if (precision_specification.empty())
    {
        return false;
    }
 
    std::unordered_map<std::type_index, char> type_specification;
    type_specification[std::type_index(typeid(int))] = 'd';
    type_specification[std::type_index(typeid(double))] = 'f';  // default
    type_specification[std::type_index(typeid(std::string))] = 's';
 
    auto const& b = precision_specification.back();
    // see https://fmt.dev/latest/syntax.html#formatspec
    if (b == 'e' || b == 'E' || b == 'f' || b == 'F' || b == 'g' || b == 'G')
    {
        type_specification[std::type_index(typeid(double))] = b;
        precision_specification = precision_specification.substr(
            0, precision_specification.length() - 1);
    }
 
    std::string const generated_fmt_string =
        "{" + precision_specification +
        type_specification[std::type_index(typeid(data))] + "}";
    result = result.substr(0, begin) + fmt::format(generated_fmt_string, data) +
             result.substr(end + 1, result.length() - (end + 1));
    return true;
}

References containsKeyword(), and format().

Referenced by constructFormattedFileName().

swapEndianness() [1/2]

double BaseLib::swapEndianness

(

double const &

v

)

Definition at line 147 of file FileTools.cpp.

{
    union
    {
        double v;
        char c[sizeof(double)];
    } a{}, b{};
 
    a.v = v;
    for (unsigned short i = 0; i < sizeof(double) / 2; i++)
    {
        b.c[i] = a.c[sizeof(double) / 2 - i - 1];
    }
 
    for (unsigned short i = sizeof(double) / 2; i < sizeof(double); i++)
    {
        b.c[i] = a.c[sizeof(double) + sizeof(double) / 2 - i - 1];
    }
 
    return b.v;
}

References MaterialPropertyLib::c.

Referenced by FileIO::Gocad::GocadSGridReader::readNodesBinary().

swapEndianness() [2/2]

template<typename T >

T BaseLib::swapEndianness

(

T const &

v

)

Definition at line 69 of file FileTools.h.

{
    union
    {
        T v;
        char c[sizeof(T)];
    } a, b;
 
    a.v = v;
    for (unsigned short i = 0; i < sizeof(T); i++)
    {
        b.c[i] = a.c[sizeof(T) - i - 1];
    }
 
    return b.v;
}

References MaterialPropertyLib::c.

to_underlying()

template<typename E >

constexpr auto BaseLib::to_underlying ( E  e )

constexprnoexcept

Converts an enumeration to its underlying type.

Parameters

e	Enumeration value to convert

Returns

The integer value of the underlying type of Enum, converted from e.

https://en.cppreference.com/w/cpp/utility/to_underlying Implementation from Scott Meyers : Modern effective c++ , Item 10 Scoped enums

Definition at line 30 of file cpp23.h.

{
    return static_cast<std::underlying_type_t<E>>(e);
}

Referenced by MeshLib::IO::cellTypeOGS2XDMF(), MeshLib::IO::elemOGSTypeToXDMFType(), MeshLib::IO::getPropertyDataTypeSize(), MeshLib::IO::getPropertyDataTypeString(), MeshLib::IO::meshPropertyDatatypeSize(), and MeshLib::IO::meshPropertyDatatypeString().

traverse()

template<typename T >

void BaseLib::traverse	(	boost::property_tree::ptree &	parent,
		const fs::path	bench_dir,
		T &	method
	)

Definition at line 73 of file ConfigTreeUtil.cpp.

{
    traverse_recursive(parent, "", parent, bench_dir, method);
}

References traverse_recursive().

Referenced by makeConfigTree().

traverse_recursive()

template<typename T >

void BaseLib::traverse_recursive	(	boost::property_tree::ptree &	parent,
		boost::property_tree::ptree::path_type const &	child_path,
		boost::property_tree::ptree &	child,
		fs::path const &	bench_dir,
		T &	method
	)

Definition at line 55 of file ConfigTreeUtil.cpp.

{
    using boost::property_tree::ptree;
 
    method(parent, child_path, child, bench_dir);
    for (auto& [key, tree] : child)
    {
        ptree::path_type const cur_path = child_path / ptree::path_type(key);
        traverse_recursive(child, cur_path, tree, bench_dir, method);
    }
}

Referenced by traverse().

trim()

void BaseLib::trim	(	std::string &	str,
		char	ch = ' '
	)

Strip whitespace (or other characters) from the beginning and end of a string. Equivalent functionality to Qt::QString::trim().

Definition at line 58 of file StringTools.cpp.

{
    std::string::size_type pos = str.find_last_not_of(ch);
    if (pos != std::string::npos)
    {
        str.erase(pos + 1);
        pos = str.find_first_not_of(ch);
        if (pos != std::string::npos)
        {
            str.erase(0, pos);
        }
    }
    else
    {
        str.erase(str.begin(), str.end());
    }
}

Referenced by FileIO::FEFLOWMeshInterface::getIndexList(), getValue(), getVariables(), MeshLib::IO::Legacy::MeshIO::loadMeshFromFile(), FileIO::Gocad::parseGocadPropertyMetaData(), FileIO::Gocad::GocadAsciiReader::parseHeader(), FileIO::Gocad::parseName(), FileIO::FEFLOWMeshInterface::readELEMENTALSETS(), FileIO::FEFLOWMeshInterface::readElevation(), BaseLib::IO::readStringListFromFile(), FileIO::FEFLOWGeoInterface::readSuperMesh(), and simplify().

uniquePushBack()

template<typename Container >

void BaseLib::uniquePushBack	(	Container &	container,
		typename Container::value_type const &	element
	)

Definition at line 245 of file Algorithm.h.

{
    if (std::find(container.begin(), container.end(), element) ==
        container.end())
    {
        container.push_back(element);
    }
}

Referenced by GeoLib::EarClippingTriangulation::clipEars().

writeValueBinary()

template<typename T >

void BaseLib::writeValueBinary	(	std::ostream &	out,
		T const &	val
	)

write value as binary into the given output stream

Template Parameters

T	data type of the value

Parameters

out	output stream, have to be opened in binary mode
val	value

Definition at line 63 of file FileTools.h.

{
    out.write(reinterpret_cast<const char*>(&val), sizeof(T));
}

Referenced by ApplicationUtils::writeProperties().

xmlDate2int()

int BaseLib::xmlDate2int

(

const std::string &

s

)

Converts a string containing a date into a double. Note: It is not really checked if the date actually makes sense.

Parameters

s	String containing the date, the expected format is conform to the xml date type, i.e. "yyyy-mm-dd".

Returns

A number representing the date as yyyymmdd.

Definition at line 117 of file DateTools.cpp.

{
    if (s.length() == 10)
    {
        int d = atoi(s.substr(8, 2).c_str());
        if (d < 1 || d > 31)
        {
            WARN("xmlDate2double(): day not in [1:31].");
        }
        int m = atoi(s.substr(5, 2).c_str());
        if (m < 1 || m > 12)
        {
            WARN("xmlDate2double(): month not in [1:12].");
        }
        int y = atoi(s.substr(0, 4).c_str());
        return date2int(y, m, d);
    }
    return 0;
}

References date2int(), and WARN().

Referenced by GeoLib::StationBorehole::createStation().

Variable Documentation

console

std::shared_ptr< spdlog::logger > BaseLib::console = spdlog::stdout_color_mt("ogs")

Definition at line 29 of file Logging.cpp.

Referenced by CRITICAL(), DBUG(), ERR(), INFO(), setConsoleLogLevel(), and WARN().