squid_n_core/model/

wall.rs

//! 壁関連の型（開口・壁属性・雑壁・鉄骨/BRB/PCa 属性など）。

use super::*;

/// 複数開口の取り扱い（耐震壁の開口。RC 規準）。
/// 建物全体で一律に選択する（`Model::multi_opening_mode`）。
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum MultiOpeningMode {
    /// 等価開口とする（既定）: l0′·h0′=Σli·hi、l0′:h0′=lw:hw で1開口に置換。
    #[default]
    Equivalent,
    /// 包絡する: 全開口の包絡矩形1つに置換（位置 `offset` が必要。
    /// 位置不明の開口は包絡対象にできず個別のまま残る）。
    Envelope,
    /// 包絡開口・等価開口自動判定: 包絡可能な開口対がなくなるまで繰り返し
    /// 包絡開口を作成し、残った開口で「等価開口とする」と同様の評価を行う。
    Auto,
}

/// 壁の個別開口（耐震壁の複数開口の取り扱い。RC 規準）。
///
/// 寸法は壁面内で定義する: `width`=壁長さ方向の開口長さ l0 [mm]、
/// `height`=壁高さ方向の開口高さ h0 [mm]。
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct WallOpening {
    /// 開口長さ l0 [mm]（壁長さ方向）。
    pub width: f64,
    /// 開口高さ h0 [mm]（壁高さ方向）。
    pub height: f64,
    /// 開口左下の位置 [mm]（壁面内: [壁始端からの水平距離, 壁下端からの高さ]）。
    /// 包絡開口の作成・開口の位置効果評価（将来対応）用。None は位置不定
    /// （等価開口による面積評価のみに用いられる）。
    #[serde(default)]
    pub offset: Option<[f64; 2]>,
}

impl WallOpening {
    /// 開口面積 [mm²]。
    pub fn area(&self) -> f64 {
        (self.width * self.height).max(0.0)
    }

    /// 壁面内の矩形 (x0, z0, x1, z1)。位置不明（offset=None）は None。
    fn rect(&self) -> Option<[f64; 4]> {
        let [x, z] = self.offset?;
        Some([x, z, x + self.width.max(0.0), z + self.height.max(0.0)])
    }

    /// 2開口の包絡開口（外接矩形）。どちらかの位置が不明なら None。
    pub fn envelope(&self, other: &WallOpening) -> Option<WallOpening> {
        let a = self.rect()?;
        let b = other.rect()?;
        let x0 = a[0].min(b[0]);
        let z0 = a[1].min(b[1]);
        let x1 = a[2].max(b[2]);
        let z1 = a[3].max(b[3]);
        Some(WallOpening {
            width: x1 - x0,
            height: z1 - z0,
            offset: Some([x0, z0]),
        })
    }

    /// 自動判定モードで 2 開口を包絡してよいかの判定
    /// （複数開口の取り扱いの判定図。RC 規準）。
    ///
    /// **l < 1.5·h または l < 1m（1000mm）のとき包絡開口とみなす。**
    /// - l: 開口間距離（矩形間の純距離。重なっていれば 0）
    /// - h: 包絡開口とした場合の高さ
    ///
    /// 位置（offset）不明の開口は距離を定義できないため包絡不可。
    pub fn can_envelope(&self, other: &WallOpening) -> bool {
        let (Some(a), Some(b)) = (self.rect(), other.rect()) else {
            return false;
        };
        // 開口間距離 l: 各方向の純間隔（重なっていれば 0）の合成
        let gap_x = (a[0].max(b[0]) - a[2].min(b[2])).max(0.0);
        let gap_z = (a[1].max(b[1]) - a[3].min(b[3])).max(0.0);
        let l = (gap_x * gap_x + gap_z * gap_z).sqrt();
        // 包絡開口とした場合の高さ h
        let h = a[3].max(b[3]) - a[1].min(b[1]);
        l < 1.5 * h || l < 1000.0
    }
}

/// 壁要素（`ElementKind::Wall`/`Shell`）の壁属性
/// （壁自重（固定荷重）の開口、柱際スリット、および
/// 剛性計算の開口低減・耐震壁判定に用いる個別開口寸法。RC 規準）。
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct WallAttr {
    pub elem: ElemId,
    /// 開口面積の合計 [mm²]。壁自重から ρ·t·開口面積·g を控除する。
    /// `openings`（個別開口）が非空の場合はそちらの面積和を優先し、
    /// 本フィールドは無視される（`total_opening_area` 参照）。
    #[serde(default)]
    pub opening_area: f64,
    /// 開口部（サッシ等）の重量 [N]。控除後に加算する。
    #[serde(default)]
    pub opening_weight: f64,
    /// 耐震スリット。由来する壁版の [`super::WallPlate::slit`] を写したもので、
    /// 意味も添字の規則も同じである。いずれかの辺が切れていれば耐震壁として
    /// 成立しない。
    #[serde(default)]
    pub slit: super::WallSlit,
    /// 個別開口の寸法リスト。非空の場合、開口の面積評価（自重控除・
    /// 開口周比 r0・開口低減率 r）と耐震壁検定の開口供給はこのリストを
    /// 優先する。空の場合は従来どおり `opening_area`（合計面積のみ）で評価する。
    #[serde(default)]
    pub openings: Vec<WallOpening>,
    /// 仕上げ・増打ちの面荷重強度 [N/mm²]。由来する壁版の
    /// [`super::WallPlate::finish_intensity`] を写したもので、意味も同じである。
    /// **躯体の自重は含まない。**
    ///
    /// 壁エレメントになる壁版もこの重さを持つため、要素経由の自重算定
    /// （`squid_n_load::story_gen::self_weight_calc`）が読む。写し忘れると、
    /// 入力された仕上げ・増打ちが壁エレメントの壁だけ黙って落ちる。
    #[serde(default)]
    pub finish_intensity: f64,
}

impl WallAttr {
    /// 開口の合計面積 [mm²]。個別開口 `openings` が非空ならその面積和、
    /// 空なら `opening_area` を返す（全消費側はこのメソッドを経由すること）。
    pub fn total_opening_area(&self) -> f64 {
        if self.openings.is_empty() {
            self.opening_area.max(0.0)
        } else {
            self.openings.iter().map(WallOpening::area).sum()
        }
    }

    /// 個別開口の (l0, h0) ペア列。個別開口が未入力（面積のみ）なら None。
    /// 面積ゼロの開口は除外する。
    pub fn opening_dims(&self) -> Option<Vec<(f64, f64)>> {
        Self::dims_of(&self.openings)
    }

    /// 複数開口の取り扱い（`mode`）適用後の (l0, h0) ペア列。
    /// 個別開口が未入力（面積のみ）なら None（消費側は `opening_area` で評価）。
    pub fn opening_dims_for(&self, mode: MultiOpeningMode) -> Option<Vec<(f64, f64)>> {
        Self::dims_of(&self.openings_for_mode(mode))
    }

    /// 複数開口の取り扱い（`mode`）適用後の開口合計面積 [mm²]。
    /// 包絡モードでは包絡矩形の面積となるため、生の面積和
    /// （`total_opening_area`、自重控除用）とは異なり得る。
    pub fn total_opening_area_for(&self, mode: MultiOpeningMode) -> f64 {
        if self.openings.is_empty() {
            self.opening_area.max(0.0)
        } else {
            self.openings_for_mode(mode)
                .iter()
                .map(WallOpening::area)
                .sum()
        }
    }

    /// 複数開口の取り扱い（RC 規準）を適用した開口リスト。
    /// - `Equivalent`: 個別開口をそのまま返す（等価開口への統合は消費側の式）。
    /// - `Envelope`: 位置（offset）を持つ開口全体の包絡矩形 1 つに置換。
    ///   位置不明の開口は包絡できないため個別のまま残る。
    /// - `Auto`: 包絡可能（`WallOpening::can_envelope`、l<1.5h または l<1m）な開口対が
    ///   なくなるまで繰り返し包絡開口を作成し、残った開口を返す
    ///   （包絡できなくなった時点の開口状況で『等価開口とする』と
    ///   同様の判定を行う扱いに対応。等価開口への統合は消費側）。
    pub fn openings_for_mode(&self, mode: MultiOpeningMode) -> Vec<WallOpening> {
        match mode {
            MultiOpeningMode::Equivalent => self.openings.clone(),
            MultiOpeningMode::Envelope => {
                let mut out: Vec<WallOpening> = Vec::new();
                let mut merged: Option<WallOpening> = None;
                for o in &self.openings {
                    if o.rect().is_some() {
                        merged = Some(match merged {
                            Some(m) => m.envelope(o).expect("両者とも位置あり"),
                            None => o.clone(),
                        });
                    } else {
                        out.push(o.clone());
                    }
                }
                if let Some(m) = merged {
                    out.insert(0, m);
                }
                out
            }
            MultiOpeningMode::Auto => {
                let mut list: Vec<WallOpening> = self.openings.clone();
                loop {
                    let mut merged_pair: Option<(usize, usize)> = None;
                    'outer: for i in 0..list.len() {
                        for j in (i + 1)..list.len() {
                            if list[i].can_envelope(&list[j]) {
                                merged_pair = Some((i, j));
                                break 'outer;
                            }
                        }
                    }
                    let Some((i, j)) = merged_pair else {
                        break;
                    };
                    let env = list[i].envelope(&list[j]).expect("can_envelope=位置あり");
                    list.remove(j);
                    list[i] = env;
                }
                list
            }
        }
    }

    fn dims_of(openings: &[WallOpening]) -> Option<Vec<(f64, f64)>> {
        if openings.is_empty() {
            return None;
        }
        let dims: Vec<(f64, f64)> = openings
            .iter()
            .filter(|o| o.area() > 0.0)
            .map(|o| (o.width, o.height))
            .collect();
        if dims.is_empty() {
            None
        } else {
            Some(dims)
        }
    }
}

/// S 造部材の断面検定用属性（鋼構造設計規準。鉄骨の断面検定における
/// 断面性能）。継手部・スカラップによる断面欠損と横座屈長さの指定に用いる。
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct SteelDesignAttr {
    pub elem: ElemId,
    /// 継手部のフランジ欠損率 βf [%]（0=欠損なし）
    #[serde(default)]
    pub joint_flange_loss: f64,
    /// 継手部のウェブ欠損率 βw [%]
    #[serde(default)]
    pub joint_web_loss: f64,
    /// スカラップによるウェブ欠損率 αw [%]（端部断面に適用）
    #[serde(default)]
    pub scallop_web_loss: f64,
    /// 横座屈長さの直接入力 (始端, 中央, 終端) [mm]（None=自動）
    #[serde(default)]
    pub lb_direct: Option<(f64, f64, f64)>,
    /// 等間隔横補剛の本数（lb 自動計算: lb = L/(n+1)）
    #[serde(default)]
    pub lateral_brace_count: Option<u32>,
    /// 強軸まわり座屈長さの直接入力 lk_y [mm]（None=自動算定）
    #[serde(default)]
    pub lk_y_direct: Option<f64>,
    /// 弱軸まわり座屈長さの直接入力 lk_z [mm]（None=自動算定）
    #[serde(default)]
    pub lk_z_direct: Option<f64>,
    /// 横座屈修正係数 C の直接入力（None=自動算定）。
    /// 入力がある場合は自動算定（M2/M1 比・上限 2.3）を行わず入力値を採用する。
    #[serde(default)]
    pub c_direct: Option<f64>,
}

impl SteelDesignAttr {
    /// 欠損率が全て 0・横座屈長さ関連の指定が全て `None` か（＝側テーブルから
    /// 削除してよいか）。[`MemberDetailAttr::is_empty`](super::MemberDetailAttr::is_empty)
    /// の流儀に合わせる。
    pub fn is_empty(&self) -> bool {
        self.joint_flange_loss == 0.0
            && self.joint_web_loss == 0.0
            && self.scallop_web_loss == 0.0
            && self.lb_direct.is_none()
            && self.lateral_brace_count.is_none()
            && self.lk_y_direct.is_none()
            && self.lk_z_direct.is_none()
            && self.c_direct.is_none()
    }
}

/// 座屈補剛ブレース（BRB）の断面検定用属性。許容値はメーカー資料による入力値
/// （各メーカーの製品技術資料による）。
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct BrbAttr {
    pub elem: ElemId,
    /// 短期許容軸力 [N]（メーカー値）
    pub allowable_axial_short: f64,
    /// 限界座屈長さ [mm]（メーカー値）
    pub critical_length: f64,
    /// 座屈長さ低減距離 L1 [mm]（= (L1上+L1下)/2）
    #[serde(default)]
    pub length_reduction: f64,
}

/// 免震支承材の種別（各免震部材指針）。
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum IsolatorKind {
    /// 天然ゴム系積層ゴム（マルチシアスプリング、水平バイリニア）。
    LaminatedRubber,
    /// 鉛プラグ挿入型積層ゴム（LRB。鉛 Qd + ゴム二次剛性のバイリニア）。
    LeadRubber,
    /// 高減衰ゴム系積層ゴム（HDR。等価せん断剛性が歪 γ 依存）。
    HighDampingRubber,
    /// 弾性すべり支承（摩擦ばね、Qmax=μ·N）。
    ElasticSliding,
}

fn default_ckd_gamma() -> [f64; 3] {
    [1.0, 0.0, 0.0]
}
fn default_cqd_gamma() -> [f64; 3] {
    [1.0, 0.0, 0.0]
}

/// 免震支承材の特性（`ElementKind::Isolator` 要素の非線形特性、
/// 各免震部材指針）。`Model::isolator_attrs` に要素 ID と対で保持する。
#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct IsolatorProps {
    /// 支承種別。
    pub kind: IsolatorKind,
    /// 水平初期（弾性）剛性 K1 [N/mm]。
    pub k1: f64,
    /// 水平二次剛性 K2 [N/mm]（積層ゴム系バイリニア。すべり支承は 0）。
    pub k2: f64,
    /// 降伏（特性）耐力 Qd [N]（積層ゴム系バイリニア）。すべり支承は 0。
    pub qd: f64,
    /// 鉛直剛性 Kv [N/mm]。
    pub kv: f64,
    /// 摩擦係数 μ（すべり支承。Qmax=μ·N）。
    pub mu: f64,
    /// 長期軸力 N [N]（摩擦力算定用、圧縮正）。
    pub n_long: f64,
    /// マルチシアスプリング本数 n（既定 8、天然ゴム系 2。表示・低減率照合用）。
    pub n_springs: u32,
    /// ゴム総厚 H [mm]（歪 γ=δ/H の算定用。0 以下で歪依存を無効化）。
    #[serde(default)]
    pub total_rubber_thickness: f64,
    /// 二次剛性の歪依存係数 CKd(γ)=c0+c1·γ+c2·γ²（K2(γ)=K2·CKd(γ)）。
    /// 既定 [1,0,0]（歪依存なし）。LRB・高減衰ゴムの歪依存（各免震部材の製品技術資料）。
    #[serde(default = "default_ckd_gamma")]
    pub ckd_gamma: [f64; 3],
    /// 特性耐力の歪依存係数 CQd(γ)=c0+c1·γ+c2·γ²（Qd(γ)=Qd·CQd(γ)）。既定 [1,0,0]。
    #[serde(default = "default_cqd_gamma")]
    pub cqd_gamma: [f64; 3],
}

impl Default for IsolatorProps {
    fn default() -> Self {
        IsolatorProps {
            kind: IsolatorKind::LaminatedRubber,
            k1: 1000.0,
            k2: 100.0,
            qd: 50_000.0,
            kv: 2_000_000.0,
            mu: 0.1,
            n_long: 0.0,
            n_springs: 8,
            total_rubber_thickness: 0.0,
            ckd_gamma: default_ckd_gamma(),
            cqd_gamma: default_cqd_gamma(),
        }
    }
}

/// 免震支承材の属性（要素 ID と特性の対）。
#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct IsolatorAttr {
    pub elem: ElemId,
    pub props: IsolatorProps,
}

/// 制振ダンパーの種別（各制振部材の力学モデル）。
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
pub enum DamperKind {
    /// マクスウェル要素（バネ Kd と粘性ダッシュポットの直列。速度依存型）。
    #[default]
    Maxwell,
    /// 履歴型（弾塑性バイリニア）ダンパー。鋼材系ダンパー（SUB／アンボンドブレース／
    /// 二重鋼管座屈補剛ブレース／鉛ダンパー／U 型ダンパー等の標準型バイリニア）。
    HystereticBilinear,
}

fn default_damper_qy() -> f64 {
    50_000.0
}
fn default_damper_k2_ratio() -> f64 {
    0.02
}

/// 制振ダンパー要素（`ElementKind::Damper`）の特性（各制振部材の力学モデル）。
///
/// - **マクスウェル（速度依存型）:** バネ剛性 `Kd` と粘性ダッシュポット
///   （力 `Fc=C0·sign(V)·|V|^α`）の直列。α=1 で線形粘性。`relief_velocity`
///   （リリーフ速度 Vr）を指定すると、Vr 超過域で減衰係数比 `c2_ratio` による
///   リリーフ特性（オイルダンパーのバイパス弁による頭打ち特性）を折れ線で
///   近似する（`element/src/springs/damper/maxwell.rs` 参照）。
/// - **履歴型バイリニア:** 初期軸剛性 `Kd`（=k1）、降伏軸力 `qy`、第2剛性比 `k2_ratio`
///   （k2=k2_ratio·k1）の弾塑性軸ばね（変位依存。静的・動的いずれでも作用）。
#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct DamperProps {
    /// ダンパー種別。
    pub kind: DamperKind,
    /// バネ剛性 Kd [N/mm]（履歴型では初期軸剛性 k1）。
    pub kd: f64,
    /// 粘性係数 C0 [N·(s/mm)^α]（マクスウェルのみ）。
    pub c0: f64,
    /// 速度指数 α（1.0 で線形粘性。マクスウェルのみ）。
    pub alpha: f64,
    /// 降伏軸力 qy [N]（履歴型のみ）。
    #[serde(default = "default_damper_qy")]
    pub qy: f64,
    /// 第2剛性比 k2/k1（履歴型のみ）。
    #[serde(default = "default_damper_k2_ratio")]
    pub k2_ratio: f64,
    /// リリーフ速度 Vr [mm/s]（マクスウェルのみ。オイルダンパーのリリーフ機構）。
    /// `None`（既定）はリリーフ特性なし（従来どおり `Fc=C0·sign(V)·|V|^α` を
    /// 全域に適用）。`Some(vr)`（vr>0）の場合、|V|≤vr は従来どおり、|V|>vr は
    /// `c2_ratio` による減衰係数比で頭打ちにした折れ線特性となる
    /// （式は `c2_ratio` の docs、および `maxwell.rs` 参照）。
    #[serde(default)]
    pub relief_velocity: Option<f64>,
    /// リリーフ後の減衰係数比 C2/C1（C1 はリリーフ速度 Vr における接線減衰係数
    /// `C1=C0·α·Vr^(α−1)`）。`relief_velocity` が `Some` の場合のみ意味を持つ
    /// （`None`＝リリーフなし）。既定 `None`（リリーフ無効時は未使用のため
    /// 0 でも同義だが、意図を明確にするため未指定を表す）。
    #[serde(default)]
    pub c2_ratio: Option<f64>,
}

impl Default for DamperProps {
    fn default() -> Self {
        DamperProps {
            kind: DamperKind::Maxwell,
            kd: 100_000.0,
            c0: 1_000.0,
            alpha: 1.0,
            qy: default_damper_qy(),
            k2_ratio: default_damper_k2_ratio(),
            relief_velocity: None,
            c2_ratio: None,
        }
    }
}

/// 制振ダンパーの属性（要素 ID と特性の対、`Model::damper_attrs`）。
#[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct DamperAttr {
    pub elem: ElemId,
    pub props: DamperProps,
}

/// 名前付き制振ダンパー定義（`Model::damper_defs`）。
///
/// 「断面を選ぶように制振要素を選んで部材に割当てる」UX の土台となる、
/// 再利用可能なダンパー諸元のプリセット。`ElemId` への参照は持たず、
/// 部材への割当時は `props` の値をコピーして `Model::damper_attrs` へ入れる
/// 設計とする（`DamperAttr` 同様、割当は値のコピーであり参照ではない）。
/// そのため本定義を更新・削除しても、既に割り当て済みの部材（`damper_attrs`）は
/// 影響を受けない。
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct DamperDef {
    /// 定義名（製品名・型式等、利用者が識別するための表示名）。
    pub name: String,
    /// ダンパー特性。
    pub props: DamperProps,
}

/// PCa（プレキャスト）梁の水平接合面検定用属性（水平接合面のせん断摩擦検定）。
#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct PcaBeamAttr {
    pub elem: ElemId,
    /// 水平接合面の摩擦係数 μ
    pub mu: f64,
    /// 接合面を横切る補強筋の体積比合計 p′w（あばら筋+接合面補強筋）
    pub pw_joint: f64,
    /// 補強筋の降伏強度 σy [N/mm²]
    pub sigma_y_joint: f64,
    /// 接合面の位置: 断面上端からの距離 [mm]（例: 後打ちスラブ厚）
    pub joint_depth_from_top: f64,
}