baram2584/FESADev
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revert

Browse Source
This commit is contained in:
김경종
2026-06-10 10:03:11 +09:00
parent 87529c811a
commit 0912ee6f3b
174 changed files with 414 additions and 8544 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/fesa/analysis/Analysis.hpp
-22
View File
@@ -1,22 +0,0 @@
#pragma once
#include "fesa/core/AnalysisState.hpp"
#include "fesa/core/Domain.hpp"
namespace fesa::analysis {
class Analysis {
public:
virtual ~Analysis() = default;
virtual const char* name() const noexcept = 0;
void run(const fesa::core::Domain& domain, fesa::core::AnalysisState& state) {
doRun(domain, state);
}
protected:
virtual void doRun(const fesa::core::Domain& domain, fesa::core::AnalysisState& state) = 0;
};
} // namespace fesa::analysis
include/fesa/boundary/BoundaryCondition.hpp
-16
View File
@@ -1,16 +0,0 @@
#pragma once
namespace fesa::boundary {
enum class BoundaryConditionKind {
SinglePointConstraint
};
class BoundaryCondition {
public:
virtual ~BoundaryCondition() = default;
virtual BoundaryConditionKind kind() const noexcept = 0;
};
} // namespace fesa::boundary
include/fesa/boundary/SinglePointConstraint.hpp
-26
View File
@@ -1,26 +0,0 @@
#pragma once
#include "fesa/boundary/BoundaryCondition.hpp"
#include "fesa/core/ModelTypes.hpp"
namespace fesa::boundary {
using fesa::core::Dof;
using fesa::core::NodeId;
class SinglePointConstraint final : public BoundaryCondition {
public:
SinglePointConstraint(NodeId node_id, Dof dof, double value);
BoundaryConditionKind kind() const noexcept override;
NodeId nodeId() const noexcept;
Dof dof() const noexcept;
double value() const noexcept;
private:
NodeId node_id_;
Dof dof_;
double value_;
};
} // namespace fesa::boundary
include/fesa/core/AnalysisState.hpp
-52
View File
@@ -1,52 +0,0 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include <vector>
namespace fesa::core {
class AnalysisState {
public:
AnalysisState();
explicit AnalysisState(std::size_t dof_count);
std::size_t dofCount() const noexcept;
void resize(std::size_t dof_count);
const std::vector<double>& displacement() const noexcept;
const std::vector<double>& externalForce() const noexcept;
const std::vector<double>& internalForce() const noexcept;
const std::vector<double>& residual() const noexcept;
const std::vector<double>& reaction() const noexcept;
void setDisplacement(std::vector<double> values);
void setExternalForce(std::vector<double> values);
void setInternalForce(std::vector<double> values);
void setResidual(std::vector<double> values);
void setReaction(std::vector<double> values);
void clearForces() noexcept;
double currentTime() const noexcept;
void setCurrentTime(double value) noexcept;
std::int64_t incrementIndex() const noexcept;
void setIncrementIndex(std::int64_t value) noexcept;
std::int64_t iterationIndex() const noexcept;
void setIterationIndex(std::int64_t value) noexcept;
private:
void setVector(std::vector<double>& target, std::vector<double> values);
static void zero(std::vector<double>& values) noexcept;
std::size_t dof_count_;
std::vector<double> displacement_;
std::vector<double> external_force_;
std::vector<double> internal_force_;
std::vector<double> residual_;
std::vector<double> reaction_;
double current_time_;
std::int64_t increment_index_;
std::int64_t iteration_index_;
};
} // namespace fesa::core
include/fesa/core/BoundaryCondition.hpp
-21
View File
@@ -1,21 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
namespace fesa::core {
class BoundaryCondition {
public:
BoundaryCondition(NodeId node_id, Dof dof, double value);
NodeId nodeId() const noexcept;
Dof dof() const noexcept;
double value() const noexcept;
private:
NodeId node_id_;
Dof dof_;
double value_;
};
} // namespace fesa::core
include/fesa/core/Domain.hpp
-86
View File
@@ -1,86 +0,0 @@
#pragma once
#include "fesa/boundary/BoundaryCondition.hpp"
#include "fesa/core/ModelTypes.hpp"
#include "fesa/core/Node.hpp"
#include "fesa/core/StepDefinition.hpp"
#include "fesa/element/Element.hpp"
#include "fesa/load/Load.hpp"
#include "fesa/material/Material.hpp"
#include "fesa/property/Property.hpp"
#include "fesa/property/ShellProperty.hpp"
#include <cstddef>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
namespace fesa::core {
class Domain {
public:
void addNode(Node node);
void addElement(std::unique_ptr<fesa::element::Element> element);
void addMaterial(std::unique_ptr<fesa::material::Material> material);
void addProperty(std::unique_ptr<fesa::property::Property> property);
void addShellProperty(std::unique_ptr<fesa::property::ShellProperty> property);
void addNodeSet(std::string name, std::vector<NodeId> node_ids);
void addElementSet(std::string name, std::vector<ElementId> element_ids);
std::size_t addBoundaryCondition(std::unique_ptr<fesa::boundary::BoundaryCondition> boundary);
std::size_t addLoad(std::unique_ptr<fesa::load::Load> load);
void addStep(LinearStaticStepDefinition step);
const Node* findNode(NodeId id) const noexcept;
const Node& node(NodeId id) const;
std::size_t nodeCount() const noexcept;
const fesa::element::Element* findElement(ElementId id) const noexcept;
const fesa::element::Element& element(ElementId id) const;
std::size_t elementCount() const noexcept;
const fesa::material::Material* findMaterial(MaterialId id) const noexcept;
const fesa::material::Material& material(MaterialId id) const;
std::size_t materialCount() const noexcept;
const fesa::property::Property* findProperty(PropertyId id) const noexcept;
const fesa::property::Property& property(PropertyId id) const;
std::size_t propertyCount() const noexcept;
const fesa::property::ShellProperty* findShellProperty(PropertyId id) const noexcept;
const fesa::property::ShellProperty& shellProperty(PropertyId id) const;
std::size_t shellPropertyCount() const noexcept;
const std::vector<NodeId>* findNodeSet(const std::string& name) const noexcept;
const std::vector<NodeId>& nodeSet(const std::string& name) const;
std::size_t nodeSetCount() const noexcept;
const std::vector<ElementId>* findElementSet(const std::string& name) const noexcept;
const std::vector<ElementId>& elementSet(const std::string& name) const;
std::size_t elementSetCount() const noexcept;
const fesa::boundary::BoundaryCondition* findBoundaryCondition(std::size_t index) const noexcept;
const fesa::boundary::BoundaryCondition& boundaryCondition(std::size_t index) const;
std::size_t boundaryConditionCount() const noexcept;
const fesa::load::Load* findLoad(std::size_t index) const noexcept;
const fesa::load::Load& load(std::size_t index) const;
std::size_t loadCount() const noexcept;
const LinearStaticStepDefinition* findStep(StepId id) const noexcept;
const LinearStaticStepDefinition& step(StepId id) const;
std::size_t stepCount() const noexcept;
private:
std::unordered_map<NodeId, Node> nodes_;
std::unordered_map<ElementId, std::unique_ptr<fesa::element::Element>> elements_;
std::unordered_map<MaterialId, std::unique_ptr<fesa::material::Material>> materials_;
std::unordered_map<PropertyId, std::unique_ptr<fesa::property::Property>> properties_;
std::unordered_map<std::string, std::vector<NodeId>> node_sets_;
std::unordered_map<std::string, std::vector<ElementId>> element_sets_;
std::vector<std::unique_ptr<fesa::boundary::BoundaryCondition>> boundary_conditions_;
std::vector<std::unique_ptr<fesa::load::Load>> loads_;
std::unordered_map<StepId, LinearStaticStepDefinition> steps_;
};
} // namespace fesa::core
include/fesa/core/ElementDefinition.hpp
-29
View File
@@ -1,29 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
#include <array>
namespace fesa::core {
class ElementDefinition {
public:
ElementDefinition(
ElementId id,
ElementType type,
std::array<NodeId, 4> connectivity,
PropertyId property_id);
ElementId id() const noexcept;
ElementType type() const noexcept;
const std::array<NodeId, 4>& connectivity() const noexcept;
PropertyId propertyId() const noexcept;
private:
ElementId id_;
ElementType type_;
std::array<NodeId, 4> connectivity_;
PropertyId property_id_;
};
} // namespace fesa::core
include/fesa/core/LoadDefinition.hpp
-21
View File
@@ -1,21 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
namespace fesa::core {
class NodalLoadDefinition {
public:
NodalLoadDefinition(NodeId node_id, Dof dof, double value);
NodeId nodeId() const noexcept;
Dof dof() const noexcept;
double value() const noexcept;
private:
NodeId node_id_;
Dof dof_;
double value_;
};
} // namespace fesa::core
include/fesa/core/MaterialDefinition.hpp
-21
View File
@@ -1,21 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
namespace fesa::core {
class LinearElasticMaterialDefinition {
public:
LinearElasticMaterialDefinition(MaterialId id, double young_modulus, double poisson_ratio);
MaterialId id() const noexcept;
double youngModulus() const noexcept;
double poissonRatio() const noexcept;
private:
MaterialId id_;
double young_modulus_;
double poisson_ratio_;
};
} // namespace fesa::core
include/fesa/core/ModelTypes.hpp
-30
View File
@@ -1,30 +0,0 @@
#pragma once
#include <cstddef>
#include <cstdint>
namespace fesa::core {
using Id = std::int64_t;
using NodeId = Id;
using ElementId = Id;
using MaterialId = Id;
using PropertyId = Id;
using StepId = Id;
enum class Dof : std::uint8_t {
U1 = 0,
U2 = 1,
U3 = 2,
UR1 = 3,
UR2 = 4,
UR3 = 5
};
enum class ElementType {
Mitc4
};
constexpr std::size_t kDofPerNode = 6;
} // namespace fesa::core
include/fesa/core/Node.hpp
-26
View File
@@ -1,26 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
#include <array>
namespace fesa::core {
class Node {
public:
Node(NodeId id, double x, double y, double z);
static constexpr std::size_t dofCount() noexcept { return kDofPerNode; }
NodeId id() const noexcept;
double x() const noexcept;
double y() const noexcept;
double z() const noexcept;
const std::array<double, 3>& coordinates() const noexcept;
private:
NodeId id_;
std::array<double, 3> coordinates_;
};
} // namespace fesa::core
include/fesa/core/PropertyDefinition.hpp
-21
View File
@@ -1,21 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
namespace fesa::core {
class ShellPropertyDefinition {
public:
ShellPropertyDefinition(PropertyId id, MaterialId material_id, double thickness);
PropertyId id() const noexcept;
MaterialId materialId() const noexcept;
double thickness() const noexcept;
private:
PropertyId id_;
MaterialId material_id_;
double thickness_;
};
} // namespace fesa::core
include/fesa/core/StepDefinition.hpp
-31
View File
@@ -1,31 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
#include <cstddef>
#include <string>
#include <vector>
namespace fesa::core {
class LinearStaticStepDefinition {
public:
LinearStaticStepDefinition(
StepId id,
std::string name,
std::vector<std::size_t> boundary_condition_indices,
std::vector<std::size_t> load_indices);
StepId id() const noexcept;
const std::string& name() const noexcept;
const std::vector<std::size_t>& boundaryConditionIndices() const noexcept;
const std::vector<std::size_t>& loadIndices() const noexcept;
private:
StepId id_;
std::string name_;
std::vector<std::size_t> boundary_condition_indices_;
std::vector<std::size_t> load_indices_;
};
} // namespace fesa::core
include/fesa/element/Element.hpp
-26
View File
@@ -1,26 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
#include <array>
#include <cstddef>
namespace fesa::element {
using fesa::core::ElementId;
using fesa::core::ElementType;
using fesa::core::NodeId;
using fesa::core::PropertyId;
class Element {
public:
virtual ~Element() = default;
virtual ElementId id() const noexcept = 0;
virtual ElementType type() const noexcept = 0;
virtual std::size_t nodeCount() const noexcept = 0;
virtual const std::array<NodeId, 4>& connectivity() const noexcept = 0;
virtual PropertyId propertyId() const noexcept = 0;
};
} // namespace fesa::element
include/fesa/element/Mitc4Element.hpp
-24
View File
@@ -1,24 +0,0 @@
#pragma once
#include "fesa/element/Element.hpp"
namespace fesa::element {
class Mitc4Element final : public Element {
public:
Mitc4Element(ElementId id, std::array<NodeId, 4> connectivity, PropertyId property_id);
ElementId id() const noexcept override;
ElementType type() const noexcept override;
std::size_t nodeCount() const noexcept override;
std::size_t dofCount() const noexcept;
const std::array<NodeId, 4>& connectivity() const noexcept override;
PropertyId propertyId() const noexcept override;
private:
ElementId id_;
std::array<NodeId, 4> connectivity_;
PropertyId property_id_;
};
} // namespace fesa::element
include/fesa/io/Hdf5ResultWriter.hpp
-17
View File
@@ -1,17 +0,0 @@
#pragma once
#include <string>
namespace fesa::io {
class Hdf5ResultWriter {
public:
explicit Hdf5ResultWriter(std::string file_path);
const std::string& filePath() const noexcept;
private:
std::string file_path_;
};
} // namespace fesa::io
include/fesa/load/Load.hpp
-16
View File
@@ -1,16 +0,0 @@
#pragma once
namespace fesa::load {
enum class LoadKind {
Nodal
};
class Load {
public:
virtual ~Load() = default;
virtual LoadKind kind() const noexcept = 0;
};
} // namespace fesa::load
include/fesa/load/NodalLoad.hpp
-26
View File
@@ -1,26 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
#include "fesa/load/Load.hpp"
namespace fesa::load {
using fesa::core::Dof;
using fesa::core::NodeId;
class NodalLoad final : public Load {
public:
NodalLoad(NodeId node_id, Dof dof, double value);
LoadKind kind() const noexcept override;
NodeId nodeId() const noexcept;
Dof dof() const noexcept;
double value() const noexcept;
private:
NodeId node_id_;
Dof dof_;
double value_;
};
} // namespace fesa::load
include/fesa/material/LinearElasticMaterial.hpp
-21
View File
@@ -1,21 +0,0 @@
#pragma once
#include "fesa/material/Material.hpp"
namespace fesa::material {
class LinearElasticMaterial final : public Material {
public:
LinearElasticMaterial(MaterialId id, double young_modulus, double poisson_ratio);
MaterialId id() const noexcept override;
double youngModulus() const noexcept;
double poissonRatio() const noexcept;
private:
MaterialId id_;
double young_modulus_;
double poisson_ratio_;
};
} // namespace fesa::material
include/fesa/material/Material.hpp
-16
View File
@@ -1,16 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
namespace fesa::material {
using fesa::core::MaterialId;
class Material {
public:
virtual ~Material() = default;
virtual MaterialId id() const noexcept = 0;
};
} // namespace fesa::material
include/fesa/property/Property.hpp
-21
View File
@@ -1,21 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
namespace fesa::property {
using fesa::core::PropertyId;
enum class PropertyKind {
Shell
};
class Property {
public:
virtual ~Property() = default;
virtual PropertyId id() const noexcept = 0;
virtual PropertyKind kind() const noexcept = 0;
};
} // namespace fesa::property
include/fesa/property/ShellProperty.hpp
-26
View File
@@ -1,26 +0,0 @@
#pragma once
#include "fesa/core/ModelTypes.hpp"
#include "fesa/property/Property.hpp"
namespace fesa::property {
using fesa::core::MaterialId;
using fesa::core::PropertyId;
class ShellProperty final : public Property {
public:
ShellProperty(PropertyId id, MaterialId material_id, double thickness);
PropertyId id() const noexcept override;
PropertyKind kind() const noexcept override;
MaterialId materialId() const noexcept;
double thickness() const noexcept;
private:
PropertyId id_;
MaterialId material_id_;
double thickness_;
};
} // namespace fesa::property