Loader Class Reference

Class for loading setting file and particle file. More...

#include <loader.hpp>

Public Member Functions
	Loader ()=default
Input	load (const fs::path &settingPath, const fs::path &outputDirectory)
	Load the setting file and the particle file.

Private Member Functions
std::unique_ptr< ParticlesLoader::Interface >	getParticlesLoader (const fs::path &particlesPath)
	Get the Particles Loader object according to the input file extension.
void	copyInputFileToOutputDirectory (const fs::path &inputFilePath, const fs::path &outputDirectory)
	Copy the input file to the output directory.
Settings	loadSettingYaml (const fs::path &settingPath)

Private Attributes
std::unique_ptr< ParticlesLoader::Interface >	particlesLoader

Detailed Description

Class for loading setting file and particle file.

This class is responsible for loading the input. It loads the settings and the particles from the file system. It uses the YAML library to load the settings from a YAML file. It also uses the std::filesystem library to load the particles from a file.

Definition at line 22 of file loader.hpp.

Constructor & Destructor Documentation

Loader()

Loader::Loader ( )

default

Member Function Documentation

load()

Input Loader::load	(	const fs::path &	settingPath,
		const fs::path &	outputDirectory )

Load the setting file and the particle file.

Note

This function copy the setting file and the particle file to the output directory.

Parameters

settingPath	Path to the setting file
outputDirectory	Path to the output directory

Returns

Input object

Definition at line 16 of file loader.cpp.

                                                                           {
    Input input;
 
    input.settings = loadSettingYaml(settingPath);
 
    auto particlesPath          = input.settings.particlesPath;
    this->particlesLoader       = getParticlesLoader(particlesPath);
    auto [startTime, particles] = this->particlesLoader->load(particlesPath, input.settings.defaultDensity);
    input.startTime             = startTime;
    input.particles             = particles;
 
    copyInputFileToOutputDirectory(settingPath, outputDirectory);
    copyInputFileToOutputDirectory(particlesPath, outputDirectory);
 
    return input;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getParticlesLoader()

std::unique_ptr< ParticlesLoader::Interface > Loader::getParticlesLoader ( const fs::path & particlesPath )

private

Get the Particles Loader object according to the input file extension.

Parameters

particlesPath

Path to the particles file

Returns

std::unique_ptr<ParticlesLoader::Interface> Particles Loader object

Supported file formats: prof, csv

Definition at line 39 of file loader.cpp.

                                                                                              {
    auto extension = particlesPath.extension();
    if (extension == ".csv") {
        return std::make_unique<ParticlesLoader::Csv>();
    } else if (extension == ".prof") {
        return std::make_unique<ParticlesLoader::Prof>();
    } else {
        cerr << "unsupported file format: " << particlesPath.extension() << endl;
        std::exit(-1);
    }
}

Here is the caller graph for this function:

copyInputFileToOutputDirectory()

void Loader::copyInputFileToOutputDirectory ( const fs::path & inputFilePath, const fs::path & outputDirectory )

private

Copy the input file to the output directory.

Parameters

inputFilePath	Path to the input file
outputDirectory	Path to the output directory

Warning

If the file already exists in the output directory, the program will exit.

Definition at line 57 of file loader.cpp.

                                                                                                      {
    auto outputFilePath = outputDirectory / inputFilePath.filename();
    if (fs::exists(outputFilePath)) {
        cerr << "file " << outputFilePath << " already exists in the output directory" << endl;
        std::exit(-1);
    } else {
        fs::copy_file(inputFilePath, outputFilePath);
    }
}

Here is the caller graph for this function:

loadSettingYaml()

Settings Loader::loadSettingYaml ( const fs::path & settingPath )

private

Definition at line 67 of file loader.cpp.

                                                          {
    YAML::Node yaml = YAML::LoadFile(settingPath.string());
 
    Settings s;
 
    // computational conditions
    s.dim              = yaml["dim"].as<int>();
    s.particleDistance = yaml["particleDistance"].as<double>();
    s.dt               = yaml["dt"].as<double>();
    s.endTime          = yaml["endTime"].as<double>();
    s.outputPeriod     = yaml["outputPeriod"].as<double>();
    s.cflCondition     = yaml["cflCondition"].as<double>();
    s.numPhysicalCores = yaml["numPhysicalCores"].as<int>();
 
    // physical properties
    s.defaultDensity     = yaml["defaultDensity"].as<double>();
    s.kinematicViscosity = yaml["kinematicViscosity"].as<double>();
 
    // gravity
    s.gravity[0] = yaml["gravity"][0].as<double>();
    s.gravity[1] = yaml["gravity"][1].as<double>();
    s.gravity[2] = yaml["gravity"][2].as<double>();
 
    // free surface detection
    s.surfaceDetection_numberDensity_threshold = yaml["surfaceDetection-numberDensity-threshold"].as<double>();
    s.surfaceDetection_particleDistribution    = yaml["surfaceDetection-particleDistribution"].as<bool>();
    s.surfaceDetection_particleDistribution_threshold =
        yaml["surfaceDetection-particleDistribution-threshold"].as<double>();
 
    // pressure calculation method
    s.pressureCalculationMethod = yaml["pressureCalculationMethod"].as<std::string>();
    // for Implicit
    s.compressibility                  = yaml["compressibility"].as<double>();
    s.relaxationCoefficientForPressure = yaml["relaxationCoefficientForPressure"].as<double>();
    // for Explicit
    s.soundSpeed = yaml["soundSpeed"].as<double>();
 
    // collision
    s.collisionDistance        = yaml["collisionDistanceRatio"].as<double>() * s.particleDistance;
    s.coefficientOfRestitution = yaml["coefficientOfRestitution"].as<double>();
 
    // effective radius
    s.re_forNumberDensity = yaml["radiusRatioForNumberDensity"].as<double>() * s.particleDistance;
    s.re_forGradient      = yaml["radiusRatioForGradient"].as<double>() * s.particleDistance;
    s.re_forLaplacian     = yaml["radiusRatioForLaplacian"].as<double>() * s.particleDistance;
    s.reMax               = std::max({s.re_forNumberDensity, s.re_forGradient, s.re_forLaplacian});
 
    // domain
    s.domain.xMin    = yaml["domainMin"][0].as<double>();
    s.domain.xMax    = yaml["domainMax"][0].as<double>();
    s.domain.yMin    = yaml["domainMin"][1].as<double>();
    s.domain.yMax    = yaml["domainMax"][1].as<double>();
    s.domain.zMin    = yaml["domainMin"][2].as<double>();
    s.domain.zMax    = yaml["domainMax"][2].as<double>();
    s.domain.xLength = s.domain.xMax - s.domain.xMin;
    s.domain.yLength = s.domain.yMax - s.domain.yMin;
    s.domain.zLength = s.domain.zMax - s.domain.zMin;
 
    // particlesPath
    auto yamlDir          = settingPath.parent_path();
    auto relativeProfPath = yaml["particlesPath"].as<std::string>();
    s.particlesPath       = fs::weakly_canonical(yamlDir / relativeProfPath);
 
    // outputVtkFormatInBinary
    // check if outputVtkFormat is defined in the yaml file since it is optional
    if (yaml["outputVtkInBinary"]) {
        s.outputVtkInBinary = yaml["outputVtkInBinary"].as<bool>();
    } else {
        s.outputVtkInBinary = false;
    }
    return s;
}

Here is the caller graph for this function:

Member Data Documentation

particlesLoader

std::unique_ptr<ParticlesLoader::Interface> Loader::particlesLoader

private

Definition at line 37 of file loader.hpp.

---

The documentation for this class was generated from the following files:

• src/loader.hpp
• src/loader.cpp