371 lines
8.5 KiB
C++
371 lines
8.5 KiB
C++
#ifndef SPHLITE_HPP
|
|
#define SPHLITE_HPP
|
|
|
|
#include "sphlite_c_api.h"
|
|
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace sphlite {
|
|
|
|
enum Phase {
|
|
PhaseWater = SPHLITE_PHASE_WATER,
|
|
PhaseGas = SPHLITE_PHASE_GAS,
|
|
PhaseExplosive = SPHLITE_PHASE_EXPLOSIVE,
|
|
PhaseSolid = SPHLITE_PHASE_SOLID,
|
|
PhaseShell = SPHLITE_PHASE_SHELL,
|
|
PhaseBoundary = SPHLITE_PHASE_BOUNDARY,
|
|
PhaseCoupling = SPHLITE_PHASE_COUPLING,
|
|
PhaseSolidFailed = SPHLITE_PHASE_SOLID_FAILED,
|
|
PhaseShellFailed = SPHLITE_PHASE_SHELL_FAILED
|
|
};
|
|
|
|
enum Status {
|
|
StatusActive = SPHLITE_STATUS_ACTIVE,
|
|
StatusInactive = SPHLITE_STATUS_INACTIVE,
|
|
StatusFailed = SPHLITE_STATUS_FAILED,
|
|
StatusReserved = SPHLITE_STATUS_RESERVED
|
|
};
|
|
|
|
struct Version {
|
|
int major;
|
|
int minor;
|
|
int patch;
|
|
};
|
|
|
|
struct ParticleState {
|
|
std::vector<int> particle_id_ext;
|
|
std::vector<int> phase;
|
|
std::vector<int> status;
|
|
std::vector<int> material_id;
|
|
std::vector<int> section_id;
|
|
std::vector<double> x;
|
|
std::vector<double> v;
|
|
std::vector<double> a;
|
|
std::vector<double> rho;
|
|
std::vector<double> pressure;
|
|
std::vector<double> internal_energy;
|
|
std::vector<double> temperature;
|
|
std::vector<double> h;
|
|
};
|
|
|
|
struct WaterSummary {
|
|
double mass;
|
|
double momentum[3];
|
|
double max_pressure;
|
|
double min_density;
|
|
double max_density;
|
|
};
|
|
|
|
struct WaterDtLimits {
|
|
double cfl;
|
|
double acceleration;
|
|
double viscous;
|
|
};
|
|
|
|
struct GasSummary {
|
|
double volume;
|
|
double center[3];
|
|
double mean_pressure;
|
|
double max_pressure;
|
|
};
|
|
|
|
struct GasBubbleMetrics {
|
|
double equivalent_radius;
|
|
double radius_rate;
|
|
double center[3];
|
|
};
|
|
|
|
struct GasDtLimits {
|
|
double cfl;
|
|
double acceleration;
|
|
double dtcrit;
|
|
};
|
|
|
|
struct GasExtendedSummary {
|
|
double mass;
|
|
double momentum[3];
|
|
double density_range[2];
|
|
double dt_limits[3];
|
|
};
|
|
|
|
struct GasSourceSummary {
|
|
double mass_source;
|
|
double momentum_source[3];
|
|
double energy_source;
|
|
};
|
|
|
|
struct ExplosiveSummary {
|
|
int particle_count;
|
|
int reacted_count;
|
|
double lambda_range[3];
|
|
double released_totals[5];
|
|
double detonation_time_range[2];
|
|
};
|
|
|
|
struct ExplosiveReleaseBalance {
|
|
double mass_values[4];
|
|
double energy_values[2];
|
|
double momentum_values[3];
|
|
};
|
|
|
|
struct SolidSummary {
|
|
int active_count;
|
|
int failed_count;
|
|
double mass;
|
|
double momentum[3];
|
|
double kinetic_energy;
|
|
double internal_energy;
|
|
double max_von_mises;
|
|
double plastic_strain_range[2];
|
|
double damage_range[2];
|
|
double softening_range[2];
|
|
double dt_limits[3];
|
|
};
|
|
|
|
class Error : public std::runtime_error {
|
|
public:
|
|
explicit Error(const std::string &message) : std::runtime_error(message) {}
|
|
};
|
|
|
|
inline std::string last_error_message()
|
|
{
|
|
int code = 0;
|
|
char message[256];
|
|
if (sphlite_get_last_error(&code, message, static_cast<int>(sizeof(message))) != 0) {
|
|
return "SPHLite C API parameter error";
|
|
}
|
|
return std::string(message);
|
|
}
|
|
|
|
inline void check(int ierr)
|
|
{
|
|
if (ierr != 0) {
|
|
throw Error(last_error_message());
|
|
}
|
|
}
|
|
|
|
inline void initialize()
|
|
{
|
|
check(sphlite_initialize());
|
|
}
|
|
|
|
inline void finalize()
|
|
{
|
|
check(sphlite_finalize());
|
|
}
|
|
|
|
inline Version version()
|
|
{
|
|
Version result = {0, 0, 0};
|
|
check(sphlite_get_version(&result.major, &result.minor, &result.patch));
|
|
return result;
|
|
}
|
|
|
|
inline void read_inp(const std::string &filename)
|
|
{
|
|
check(sphlite_read_inp(filename.c_str()));
|
|
}
|
|
|
|
inline void build_model()
|
|
{
|
|
check(sphlite_build_model());
|
|
}
|
|
|
|
inline int particle_count()
|
|
{
|
|
int count = 0;
|
|
check(sphlite_get_particle_count(&count));
|
|
return count;
|
|
}
|
|
|
|
inline void run_explicit()
|
|
{
|
|
check(sphlite_run_explicit());
|
|
}
|
|
|
|
inline ParticleState particle_state()
|
|
{
|
|
int count = particle_count();
|
|
ParticleState state;
|
|
state.particle_id_ext.resize(count);
|
|
state.phase.resize(count);
|
|
state.status.resize(count);
|
|
state.material_id.resize(count);
|
|
state.section_id.resize(count);
|
|
state.x.resize(3 * count);
|
|
state.v.resize(3 * count);
|
|
state.a.resize(3 * count);
|
|
state.rho.resize(count);
|
|
state.pressure.resize(count);
|
|
state.internal_energy.resize(count);
|
|
state.temperature.resize(count);
|
|
state.h.resize(count);
|
|
int actual = 0;
|
|
check(sphlite_get_particle_state(count, state.particle_id_ext.data(),
|
|
state.phase.data(), state.status.data(), state.material_id.data(),
|
|
state.section_id.data(), state.x.data(), state.v.data(), state.a.data(),
|
|
state.rho.data(), state.pressure.data(), state.internal_energy.data(),
|
|
state.temperature.data(), state.h.data(), &actual));
|
|
return state;
|
|
}
|
|
|
|
inline WaterSummary water_summary()
|
|
{
|
|
WaterSummary summary = {0.0, {0.0, 0.0, 0.0}, 0.0, 0.0, 0.0};
|
|
check(sphlite_get_water_summary(&summary.mass, summary.momentum,
|
|
&summary.max_pressure, &summary.min_density, &summary.max_density));
|
|
return summary;
|
|
}
|
|
|
|
inline WaterDtLimits water_dt_limits()
|
|
{
|
|
WaterDtLimits limits = {0.0, 0.0, 0.0};
|
|
check(sphlite_get_water_dt_limits(
|
|
&limits.cfl, &limits.acceleration, &limits.viscous));
|
|
return limits;
|
|
}
|
|
|
|
inline GasSummary gas_summary()
|
|
{
|
|
GasSummary summary = {0.0, {0.0, 0.0, 0.0}, 0.0, 0.0};
|
|
check(sphlite_get_gas_summary(&summary.volume, summary.center,
|
|
&summary.mean_pressure, &summary.max_pressure));
|
|
return summary;
|
|
}
|
|
|
|
inline GasBubbleMetrics gas_bubble_metrics()
|
|
{
|
|
GasBubbleMetrics metrics = {0.0, 0.0, {0.0, 0.0, 0.0}};
|
|
check(sphlite_get_gas_bubble_metrics(&metrics.equivalent_radius,
|
|
&metrics.radius_rate, metrics.center));
|
|
return metrics;
|
|
}
|
|
|
|
inline GasDtLimits gas_dt_limits()
|
|
{
|
|
GasDtLimits limits = {0.0, 0.0, 0.0};
|
|
check(sphlite_get_gas_dt_limits(&limits.cfl, &limits.acceleration,
|
|
&limits.dtcrit));
|
|
return limits;
|
|
}
|
|
|
|
inline GasExtendedSummary gas_extended_summary()
|
|
{
|
|
GasExtendedSummary summary = {
|
|
0.0, {0.0, 0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0, 0.0}};
|
|
check(sphlite_get_gas_extended_summary(&summary.mass, summary.momentum,
|
|
summary.density_range, summary.dt_limits));
|
|
return summary;
|
|
}
|
|
|
|
inline GasSourceSummary gas_source_summary()
|
|
{
|
|
GasSourceSummary summary = {0.0, {0.0, 0.0, 0.0}, 0.0};
|
|
check(sphlite_get_gas_source_summary(&summary.mass_source,
|
|
summary.momentum_source, &summary.energy_source));
|
|
return summary;
|
|
}
|
|
|
|
inline void set_ignition_point(double x, double y, double z, double time)
|
|
{
|
|
check(sphlite_set_ignition_point(x, y, z, time));
|
|
}
|
|
|
|
inline ExplosiveSummary explosive_summary()
|
|
{
|
|
ExplosiveSummary summary = {
|
|
0, 0, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 0.0, 0.0}, {0.0, 0.0}};
|
|
check(sphlite_get_explosive_summary(&summary.particle_count,
|
|
&summary.reacted_count, summary.lambda_range, summary.released_totals,
|
|
summary.detonation_time_range));
|
|
return summary;
|
|
}
|
|
|
|
inline ExplosiveReleaseBalance explosive_release_balance()
|
|
{
|
|
ExplosiveReleaseBalance balance = {
|
|
{0.0, 0.0, 0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0, 0.0}};
|
|
check(sphlite_get_explosive_release_balance(balance.mass_values,
|
|
balance.energy_values, balance.momentum_values));
|
|
return balance;
|
|
}
|
|
|
|
inline SolidSummary solid_summary()
|
|
{
|
|
SolidSummary summary = {
|
|
0, 0, 0.0, {0.0, 0.0, 0.0}, 0.0, 0.0, 0.0,
|
|
{0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0, 0.0}};
|
|
double values[SPHLITE_SOLID_SUMMARY_VALUE_COUNT] = {0.0};
|
|
check(sphlite_get_solid_summary(&summary.active_count,
|
|
&summary.failed_count, values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT));
|
|
summary.mass = values[0];
|
|
summary.momentum[0] = values[1];
|
|
summary.momentum[1] = values[2];
|
|
summary.momentum[2] = values[3];
|
|
summary.kinetic_energy = values[4];
|
|
summary.internal_energy = values[5];
|
|
summary.max_von_mises = values[6];
|
|
summary.plastic_strain_range[0] = values[7];
|
|
summary.plastic_strain_range[1] = values[8];
|
|
summary.damage_range[0] = values[9];
|
|
summary.damage_range[1] = values[10];
|
|
summary.softening_range[0] = values[11];
|
|
summary.softening_range[1] = values[12];
|
|
summary.dt_limits[0] = values[13];
|
|
summary.dt_limits[1] = values[14];
|
|
summary.dt_limits[2] = values[15];
|
|
return summary;
|
|
}
|
|
|
|
inline void set_output_directory(const std::string &path)
|
|
{
|
|
check(sphlite_set_output_directory(path.c_str()));
|
|
}
|
|
|
|
inline void write_output(int step, double time)
|
|
{
|
|
check(sphlite_write_output(step, time));
|
|
}
|
|
|
|
inline void write_restart(const std::string &filename)
|
|
{
|
|
check(sphlite_write_restart(filename.c_str()));
|
|
}
|
|
|
|
inline void read_restart(const std::string &filename)
|
|
{
|
|
check(sphlite_read_restart(filename.c_str()));
|
|
}
|
|
|
|
class Session {
|
|
public:
|
|
Session() : active_(true) { initialize(); }
|
|
|
|
~Session()
|
|
{
|
|
if (active_) {
|
|
sphlite_finalize();
|
|
}
|
|
}
|
|
|
|
Session(const Session &) = delete;
|
|
Session &operator=(const Session &) = delete;
|
|
|
|
void close()
|
|
{
|
|
if (active_) {
|
|
finalize();
|
|
active_ = false;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool active_;
|
|
};
|
|
|
|
} // namespace sphlite
|
|
|
|
#endif
|