import numpy as np
def beam_reaction(forces, positions, span_length):
"""
単純支持梁の反力を計算する関数
:param forces: 荷重リスト (N)
:param positions: 荷重の作用位置 (m)
:param span_length: 梁の全長 (m)
"""
# 反力の計算（支点 A, B の反力を求める）
sum_moment_b = sum(f * p for f, p in zip(forces, positions)) # 点 B を基準としたモーメント
R_A = sum_moment_b / span_length # 支点 A の反力
R_B = sum(forces) - R_A # 支点 B の反力
print("\n【梁の反力計算】")
print(f"支点 A の反力: {R_A:.2f} N")
print(f"支点 B の反力: {R_B:.2f} N")
def column_axial_force(weight, axial_load):
"""
柱の軸力を計算する関数
:param weight: 柱にかかる重量 (N)
:param axial_load: 軸方向の追加荷重 (N)
"""
total_axial_force = weight + axial_load
print("\n【柱の軸力計算】")
print(f"柱にかかる合計軸力: {total_axial_force:.2f} N")
def truss_force(load, angle):
"""
トラスの力を計算する関数（単純な三角形トラスを想定）
:param load: 水平方向の外力 (N)
:param angle: トラスの角度 (度)
"""
radian = np.radians(angle)
force_tension = load / np.sin(radian) # 張力
force_compression = load / np.tan(radian) # 圧縮力
print("\n【トラスの力の計算】")
print(f"張力: {force_tension:.2f} N")
print(f"圧縮力: {force_compression:.2f} N")
# === 計算例 ===
# 【梁の反力】長さ 5m の梁に 3m 位置で 10N の荷重
beam_reaction(forces=[10], positions=[3], span_length=5)
# 【柱の軸力】柱の自重 500N に追加荷重 1000N
column_axial_force(weight=500, axial_load=1000)
# 【トラスの力】水平荷重 500N、角度 30°
truss_force(load=500, angle=30)
def calculate_stress_strain(force, area, original_length, deformation, youngs_modulus):
"""
フックの法則を用いた壁の応力・ひずみ計算関数
:param force: かかる力 (N)
:param area: 壁の断面積 (m²)
:param original_length: 壁の元の高さ (m)
:param deformation: 変形量 (m)
:param youngs_modulus: ヤング率 (Pa)
"""
# 応力 (Stress) 計算
stress = force / area
# ひずみ (Strain) 計算
strain = deformation / original_length
# フックの法則の適用 (σ = E * ε の検証)
theoretical_stress = youngs_modulus * strain
# 結果の表示
print("\n【応力とひずみの計算結果】")
print(f"応力 (Stress): {stress:.2f} Pa")
print(f"ひずみ (Strain): {strain:.6f}")
print(f"フックの法則による理論応力: {theoretical_stress:.2f} Pa")
# 応力の理論値と計算値の比較
if abs(stress - theoretical_stress) < 1e-3:
print("✅ フックの法則が成り立っている")
else:
print("⚠ フックの法則が成り立たない可能性あり")
# === 計算例 ===
# 壁に作用する力 10000 N、断面積 2m²、元の高さ 3m、変形量 0.001m、ヤング率 2×10⁹ Pa (コンクリート)
calculate_stress_strain(force=10000, area=2, original_length=3, deformation=0.001, youngs_modulus=2e9)
import numpy as np
from scipy.linalg import eig
def vibration_analysis(stiffness_matrix, mass_matrix):
"""
固有値問題を解いて振動解析を行う関数
:param stiffness_matrix: 剛性マトリックス (K)
:param mass_matrix: 質量マトリックス (M)
"""
# 一般化固有値問題 Kx = λMx を解く
eigenvalues, eigenvectors = eig(stiffness_matrix, mass_matrix)
# 固有振動数（ω = sqrt(λ)）を計算
natural_frequencies = np.sqrt(np.real(eigenvalues))
# 結果の表示
print("\n【固有値問題（振動解析）の結果】")
for i, freq in enumerate(natural_frequencies):
print(f"モード {i+1}: 固有振動数 (Hz) = {freq:.2f}")
# 共振防止のチェック（特定の周波数範囲を避ける）
dangerous_freqs = [50, 60, 100] # 共振を避けるべき周波数 (例: 電気機器や構造共振)
for freq in natural_frequencies:
for danger in dangerous_freqs:
if abs(freq - danger) < 5:
print(f"⚠ 注意: 固有振動数 {freq:.2f} Hz が共振リスクあり！")
# === 計算例 ===
# 2自由度系の剛性マトリックスと質量マトリックス
K = np.array([[10000, -5000], [-5000, 5000]]) # 剛性マトリックス
M = np.array([[2, 0], [0, 1]]) # 質量マトリックス
# 固有値解析
vibration_analysis(K, M)
import numpy as np
def finite_element_analysis(nodes, elements, forces, fixed_nodes, youngs_modulus, area):
"""
2Dトラス構造の有限要素解析 (FEM)
:param nodes: 節点座標 [(x1, y1), (x2, y2), ...]
:param elements: 要素接続 [(n1, n2), (n3, n4), ...]
:param forces: 外力 [Fx1, Fy1, Fx2, Fy2, ...]
:param fixed_nodes: 固定節点のリスト [n1, n2, ...]
:param youngs_modulus: ヤング率 (Pa)
:param area: 断面積 (m²)
"""
num_nodes = len(nodes)
num_dof = num_nodes * 2 # 各節点にx, yの自由度がある
# 全体剛性マトリックス K を初期化
K_global = np.zeros((num_dof, num_dof))
# 要素ごとの剛性マトリックスを計算し、全体剛性マトリックスに組み込む
for (n1, n2) in elements:
x1, y1 = nodes[n1]
x2, y2 = nodes[n2]
L = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) # 要素の長さ
c = (x2 - x1) / L
s = (y2 - y1) / L
k = (youngs_modulus * area / L) * np.array([
[ c*c, c*s, -c*c, -c*s],
[ c*s, s*s, -c*s, -s*s],
[-c*c, -c*s, c*c, c*s],
[-c*s, -s*s, c*s, s*s]
])
# 剛性マトリックスを全体剛性マトリックスに配置
indices = [n1 * 2, n1 * 2 + 1, n2 * 2, n2 * 2 + 1]
for i in range(4):
for j in range(4):
K_global[indices[i], indices[j]] += k[i, j]
# 境界条件の適用（固定節点の自由度をゼロにする）
for node in fixed_nodes:
index_x = node * 2
index_y = node * 2 + 1
K_global[index_x, :] = 0
K_global[:, index_x] = 0
K_global[index_x, index_x] = 1 # 1を設定
K_global[index_y, :] = 0
K_global[:, index_y] = 0
K_global[index_y, index_y] = 1 # 1を設定
# 変位を求める（K_global * U = F を解く）
U = np.linalg.solve(K_global, forces)
# 結果の表示
print("\n【有限要素法による解析結果】")
for i in range(num_nodes):
print(f"節点 {i}: 変位 (Ux, Uy) = ({U[i*2]:.6f}, {U[i*2+1]:.6f}) m")
# === 解析例 ===
# 2Dトラスの節点座標
nodes = {
0: (0, 0), # 節点0
1: (1, 0), # 節点1
2: (0.5, 1) # 節点2（上部）
}
# 要素接続 (節点の組)
elements = [
(0, 1), # 底部横方向
(1, 2), # 右斜め
(2, 0) # 左斜め
]
# 外力ベクトル（全自由度）
forces = np.array([
0, 0, # 節点0 (固定)
0, 0, # 節点1 (固定)
0, -10000 # 節点2（荷重 -10000N）
])
# 固定されている節点
fixed_nodes = [0, 1]
# 材料特性
youngs_modulus = 2e11 # Pa（鋼）
area = 0.01 # m²（断面積）
# 解析実行
finite_element_analysis(nodes, elements, forces, fixed_nodes, youngs_modulus, area)
def material_strength_calculation(material, force, area):
"""
材料の強度計算を行い、許容応力を超えていないかチェックする関数
:param material: 材料名 ("コンクリート", "鋼材", "木材")
:param force: かかる荷重 (N)
:param area: 断面積 (m²)
"""
# 材料ごとの許容応力 (MPa = N/mm²)
material_strengths = {
"コンクリート": 20e6, # 20 MPa = 20×10^6 N/m²
"鋼材": 250e6, # 250 MPa
"木材": 10e6 # 10 MPa
}
# 材料の許容応力を取得
if material not in material_strengths:
print(f"⚠ エラー: 指定された材料 '{material}' は対応していません。")
return
allowable_stress = material_strengths[material]
# 応力の計算
stress = force / area # N/m²（Pa）
# 計算結果を表示
print(f"\n【{material} の強度計算】")
print(f"かかる荷重: {force:.2f} N")
print(f"断面積: {area:.6f} m²")
print(f"計算された応力: {stress / 1e6:.2f} MPa")
print(f"許容応力: {allowable_stress / 1e6:.2f} MPa")
# 許容応力を超えているかのチェック
if stress > allowable_stress:
print(f"⚠ 警告: 応力が許容値を超えています！({stress / 1e6:.2f} MPa > {allowable_stress / 1e6:.2f} MPa)")
else:
print(f"✅ 材料の強度は安全範囲内です。")
# === 計算例 ===
# コンクリート (荷重 100,000N, 断面積 0.02m²)
material_strength_calculation("コンクリート", force=100000, area=0.02)
# 鋼材 (荷重 200,000N, 断面積 0.005m²)
material_strength_calculation("鋼材", force=200000, area=0.005)
# 木材 (荷重 10,000N, 断面積 0.001m²)
material_strength_calculation("木材", force=10000, area=0.001)
import numpy as np
def section_moment_of_inertia(shape, **kwargs):
"""
断面二次モーメントを計算する関数
:param shape: "rectangle" または "circle"
:param kwargs: 必要な寸法（b, h, d）
:return: 断面二次モーメント I (m⁴)
"""
if shape == "rectangle":
b, h = kwargs["b"], kwargs["h"]
I = (b * h**3) / 12
elif shape == "circle":
d = kwargs["d"]
I = (np.pi * d**4) / 64
else:
raise ValueError("⚠ 形状は 'rectangle' または 'circle' を指定してください。")
return I
def bending_stress(moment, I, c):
"""
曲げ応力を計算する関数
:param moment: 曲げモーメント (Nm)
:param I: 断面二次モーメント (m⁴)
:param c: 中立軸からの距離 (m)
:return: 曲げ応力 σ (Pa)
"""
stress = moment * c / I
return stress
def buckling_load(E, I, L):
"""
座屈荷重（オイラー座屈）を計算する関数
:param E: ヤング率 (Pa)
:param I: 断面二次モーメント (m⁴)
:param L: 柱の長さ (m)
:return: 座屈荷重 P_cr (N)
"""
P_cr = (np.pi**2 * E * I) / (L**2)
return P_cr
# === 計算例 ===
# 1. 矩形断面（幅 0.1m, 高さ 0.3m）
I_rect = section_moment_of_inertia("rectangle", b=0.1, h=0.3)
print(f"\n【矩形断面の断面二次モーメント】")
print(f"I = {I_rect:.6e} m⁴")
# 2. 円形断面（直径 0.1m）
I_circle = section_moment_of_inertia("circle", d=0.1)
print(f"\n【円形断面の断面二次モーメント】")
print(f"I = {I_circle:.6e} m⁴")
# 3. 曲げ応力（曲げモーメント 500Nm, 中立軸からの距離 h/2）
stress = bending_stress(moment=500, I=I_rect, c=0.3/2)
print(f"\n【矩形断面の曲げ応力】")
print(f"σ = {stress:.2f} Pa")
# 4. 座屈荷重（ヤング率 2×10^11 Pa（鋼）, 長さ 2m）
P_cr = buckling_load(E=2e11, I=I_rect, L=2)
print(f"\n【矩形断面の座屈荷重】")
print(f"P_cr = {P_cr:.2f} N")
import numpy as np
def creep_shrinkage_analysis(time, initial_strain, creep_coefficient, shrinkage_max, shrinkage_rate):
"""
クリープ変形と収縮変形を計算する関数
:param time: 経過時間の配列（時間単位）
:param initial_strain: 初期ひずみ（無次元）
:param creep_coefficient: クリープ係数
:param shrinkage_max: 最大収縮ひずみ（無次元）
:param shrinkage_rate: 収縮速度定数
"""
# クリープひずみの計算
creep_strain = initial_strain + creep_coefficient * np.log(time + 1)
# 収縮ひずみの計算
shrinkage_strain = shrinkage_max * (1 - np.exp(-shrinkage_rate * time))
# 結果を出力
print("\n【クリープと収縮の解析結果】")
for t, ε_c, ε_s in zip(time, creep_strain, shrinkage_strain):
print(f"時間 {t}h: クリープひずみ = {ε_c:.6e}, 収縮ひずみ = {ε_s:.6e}")
# === 計算例 ===
time_hours = np.array([1, 10, 100, 1000, 10000]) # 経過時間（1h, 10h, 100h, 1000h, 10000h）
initial_strain = 0.0002 # 初期ひずみ（200με）
creep_coefficient = 0.0001 # クリープ係数
shrinkage_max = 0.0003 # 最大収縮ひずみ（300με）
shrinkage_rate = 0.0005 # 収縮速度定数
# 解析実行
creep_shrinkage_analysis(time_hours, initial_strain, creep_coefficient, shrinkage_max, shrinkage_rate)
import numpy as np
import matplotlib.pyplot as plt
def construction_error_analysis(n_samples, mean_error, std_dev, tolerance):
"""
施工誤差の数値解析を行う関数 (Function to perform construction error analysis)
Parameters:
n_samples (int): サンプル数 (number of samples)
mean_error (float): 寸法誤差の平均値 [m] (mean error in meters)
std_dev (float): 寸法誤差の標準偏差 [m] (standard deviation of error in meters)
tolerance (float): 許容誤差範囲 [m] (tolerance in meters)
"""
# 施工誤差を正規分布に基づいてシミュレーションする
# (Simulate construction errors using a normal distribution)
errors = np.random.normal(mean_error, std_dev, n_samples)
# 統計解析 (Perform statistical analysis)
mean_value = np.mean(errors) # 平均誤差 (mean error)
std_value = np.std(errors) # 標準偏差 (standard deviation)
within_tolerance = np.sum(np.abs(errors) <= tolerance) / n_samples * 100
# 英語で結果を出力 (Print results in English)
print("=== Construction Error Analysis ===")
print(f"Number of samples: {n_samples}")
print(f"Mean error: {mean_value:.6f} m")
print(f"Standard deviation: {std_value:.6f} m")
print(f"Percentage within ±{tolerance} m tolerance: {within_tolerance:.2f}%")
# ヒストグラムを作成 (Create a histogram)
plt.figure(figsize=(8, 5))
plt.hist(errors, bins=30, density=True, alpha=0.7, edgecolor='black')
# 赤い破線で許容範囲を示す (Draw red dashed lines for the tolerance range)
plt.axvline(-tolerance, color='red', linestyle='dashed', label=f"-{tolerance} m tolerance")
plt.axvline(tolerance, color='red', linestyle='dashed', label=f"+{tolerance} m tolerance")
# 緑の実線で平均誤差を示す (Draw a green solid line for the mean error)
plt.axvline(mean_value, color='green', linestyle='solid', label=f"Mean error: {mean_value:.6f} m")
# 軸ラベルとタイトルを英語で設定 (Set the axis labels and title in English)
plt.xlabel("Error (m)")
plt.ylabel("Probability Density")
plt.title("Construction Error Distribution")
plt.legend()
plt.grid()
plt.show()
# === Example Usage ===
# サンプル数 (number of samples)
n_samples = 1000
# 寸法誤差の平均値 (mean error) [m]
mean_error = 0.002
# 寸法誤差の標準偏差 (standard deviation) [m]
std_dev = 0.005
# 許容誤差範囲 (tolerance) [m]
tolerance = 0.01
# 施工誤差の解析 (Perform the construction error analysis)
construction_error_analysis(n_samples, mean_error, std_dev, tolerance)
def lumen_method(lumen_output, utilization_factor, maintenance_factor, area):
"""
ルーメン法を用いた照度計算関数 (Lumen Method for Illuminance Calculation)
Parameters:
lumen_output (float): 光源の全光束 (lm, ルーメン)
utilization_factor (float): 利用率 (無次元)
maintenance_factor (float): 保守率 (無次元)
area (float): 照明する空間の面積 (m²)
Returns:
None
"""
# 照度 (Illuminance) の計算
illuminance = (lumen_output * utilization_factor * maintenance_factor) / area
# 結果の表示
print("\n=== 照明計算（ルーメン法） ===")
print(f"光束 (Luminous Flux): {lumen_output:.2f} lm")
print(f"利用率 (Utilization Factor): {utilization_factor:.2f}")
print(f"保守率 (Maintenance Factor): {maintenance_factor:.2f}")
print(f"空間面積 (Room Area): {area:.2f} m²")
print(f"平均照度 (Illuminance): {illuminance:.2f} lx (ルクス)")
# === 計算例 ===
lumen_output = 10000 # 光源の全光束 (lm)
utilization_factor = 0.7 # 利用率
maintenance_factor = 0.8 # 保守率
area = 50 # 照明する空間の面積 (m²)
# 照度計算
lumen_method(lumen_output, utilization_factor, maintenance_factor, area)
# RC Structure Strength Calculation / RC構造の強度計算
# Calculate the moment capacity of a reinforced concrete beam using a simplified formula:
# M = (A_s * f_y * d) / 1e6, where:
# A_s = area of reinforcement in mm^2
# f_y = yield strength of reinforcement in MPa (N/mm^2)
# d = effective depth in mm
# M is expressed in kN-m.
# 単純化した式を用いて、鉄筋コンクリート梁の曲げ耐力を計算します：
# M = (A_s * f_y * d) / 1e6
# A_s：鉄筋面積 (mm^2)
# f_y：鉄筋の降伏強度 (MPa)
# d ：有効深さ (mm)
# MはkN-mで表されます。
# RC beam parameters / RC梁のパラメータ
A_s = 1500 # Reinforcement area in mm^2 / 鉄筋面積 (mm^2)
f_y = 500 # Yield strength in MPa / 降伏強度 (MPa)
d = 500 # Effective depth in mm / 有効深さ (mm)
# Calculate moment capacity for RC structure / RC構造の曲げ耐力計算
M_RC = (A_s * f_y * d) / 1e6 # kN-m
print("RC Ramen Structure Moment Capacity:")
print(f" Moment Capacity: {M_RC:.2f} kN-m\n")
# Steel Structure Strength Calculation / 鉄骨構造の強度計算
# Calculate the moment capacity of a steel beam using the section modulus:
# M = (f_y_steel * S) / 1e6, where:
# f_y_steel = yield strength of steel in MPa (N/mm^2)
# S = section modulus in mm^3
# M is expressed in kN-m.
# 鉄骨ビームの曲げ耐力は、断面係数を用いて次式で計算します：
# M = (f_y_steel * S) / 1e6
# f_y_steel：鉄骨の降伏強度 (MPa)
# S ：断面係数 (mm^3)
# MはkN-mで表されます。
# Steel beam parameters / 鉄骨梁のパラメータ
f_y_steel = 350 # Yield strength of steel in MPa / 降伏強度 (MPa)
S = 2000000 # Section modulus in mm^3 / 断面係数 (mm^3)
# Calculate moment capacity for steel structure / 鉄骨構造の曲げ耐力計算
M_S = (f_y_steel * S) / 1e6 # kN-m
print("S Ramen Structure Moment Capacity:")
print(f" Moment Capacity: {M_S:.2f} kN-m")