Technical Elements Documentation
    Preparing search index...

    Interface CommonCauseFailureGroup

    Interface for a common cause failure group.

    SY-B1

    SY-B4

    interface CommonCauseFailureGroup {
        affectedComponents: string[];
        affectedSystems: systems_analysis.SystemReference[];
        attributes?: { name: string; value: string }[];
        dataAnalysisCCFParameterRef?: string;
        dataSources?: {
            dataType: "plant-specific" | "generic" | "expert-judgment";
            description: string;
            reference: string;
        }[];
        defenseMechanisms?: string[];
        description: string;
        factors?: { factor: { expression: { value: number }; level: number }[] };
        members?: { basicEvents: { id: string; name?: string }[] };
        modelParameters?: Record<string, number>;
        modelSpecificParameters?: {
            alphaFactorParameters?: {
                alphaFactors: Record<string, number>;
                totalFailureProbability: number;
            };
            betaFactorParameters?: { beta: number; totalFailureProbability: number };
            mglParameters?: {
                additionalFactors?: Record<string, number>;
                beta: number;
                delta?: number;
                gamma?: number;
                totalFailureProbability: number;
            };
            phiFactorParameters?: {
                phiFactors: Record<string, number>;
                totalFailureProbability: number;
            };
        };
        modelType: string;
        probabilityModel?: ProbabilityModel;
        quantificationMapping?: {
            openPsaMapping?: {
                factorMappings?: Record<string, string>;
                modelType: "MGL" | "beta-factor" | "alpha-factor" | "phi-factor";
            };
        };
        riskSignificanceJustification?: string;
        sharedCauseFactors?: {
            environment?: boolean;
            hardwareDesign?: boolean;
            installation?: boolean;
            maintenance?: boolean;
            manufacturer?: boolean;
            otherFactors?: string[];
        };
        totalFailureProbability?: number;
    }

    Hierarchy

    • Unique
    • Named
      • CommonCauseFailureGroup
    Index

    Properties

    affectedComponents affectedSystems attributes? dataAnalysisCCFParameterRef? dataSources? defenseMechanisms? description factors? members? modelParameters? modelSpecificParameters? modelType probabilityModel? quantificationMapping? riskSignificanceJustification? sharedCauseFactors? totalFailureProbability?

    Properties

    affectedComponents: string[]

    Components affected by this CCF group.

    ["EDG-01", "EDG-02"]
    affectedSystems: systems_analysis.SystemReference[]

    Systems affected by this CCF group.

    attributes?: { name: string; value: string }[]

    Attributes for the quantification adapter Enables passing additional information to the quantification engine

    dataAnalysisCCFParameterRef?: string

    Reference to CCF parameter in data analysis module Links this CCF group to its corresponding parameter in data analysis

    dataSources?: {
        dataType: "plant-specific" | "generic" | "expert-judgment";
        description: string;
        reference: string;
    }[]

    Supporting data sources for CCF parameters

    Type declaration

    • dataType: "plant-specific" | "generic" | "expert-judgment"

      Whether this is plant-specific or generic data

    • description: string

      Description of the data source

    • reference: string

      Reference to the source

    defenseMechanisms?: string[]

    Defense mechanisms in place to prevent or mitigate CCF. This is important for CCF analysis and can affect model parameters.

    description: string

    Description of the common cause failure group.

    "Failure of both emergency diesel generators due to a common manufacturing defect."
    factors?: { factor: { expression: { value: number }; level: number }[] }

    CCF factors formatted specifically for the quantification adapter This structure directly maps to the adapter's expected format

    members?: { basicEvents: { id: string; name?: string }[] }

    Members of this CCF group formatted for the quantification adapter This structure directly aligns with the adapter's expected format

    modelParameters?: Record<string, number>

    Parameters of the CCF model.

    { betaFactor: 0.05 }
    modelSpecificParameters?: {
        alphaFactorParameters?: {
            alphaFactors: Record<string, number>;
            totalFailureProbability: number;
        };
        betaFactorParameters?: { beta: number; totalFailureProbability: number };
        mglParameters?: {
            additionalFactors?: Record<string, number>;
            beta: number;
            delta?: number;
            gamma?: number;
            totalFailureProbability: number;
        };
        phiFactorParameters?: {
            phiFactors: Record<string, number>;
            totalFailureProbability: number;
        };
    }

    Model-specific parameters based on the modelType. Different CCF models require different parameters.

    Type declaration

    • OptionalalphaFactorParameters?: { alphaFactors: Record<string, number>; totalFailureProbability: number }

      Alpha factor model parameters

      • alphaFactors: Record<string, number>

        Alpha factors by failure multiplicity Key is the number of components failing (e.g., "1" for single failures, "2" for double failures) Value is the alpha factor for that multiplicity

      • totalFailureProbability: number

        Total failure probability for a single component

    • OptionalbetaFactorParameters?: { beta: number; totalFailureProbability: number }

      Beta factor model parameters (fraction of total component failure rate attributed to common cause)

      • beta: number

        Beta factor value (typically between 0.01 and 0.2)

      • totalFailureProbability: number

        Total failure probability for a single component

    • OptionalmglParameters?: {
          additionalFactors?: Record<string, number>;
          beta: number;
          delta?: number;
          gamma?: number;
          totalFailureProbability: number;
      }

      Multiple Greek Letter (MGL) model parameters

      • OptionaladditionalFactors?: Record<string, number>

        Additional factors for higher-order failures (optional)

      • beta: number

        Beta factor (fraction of total failure that is common cause)

      • Optionaldelta?: number

        Delta factor (conditional probability of four or more components failing)

      • Optionalgamma?: number

        Gamma factor (conditional probability of three or more components failing)

      • totalFailureProbability: number

        Total failure probability for a single component

    • OptionalphiFactorParameters?: { phiFactors: Record<string, number>; totalFailureProbability: number }

      Phi factor model parameters (direct specification of CCF probabilities)

      • phiFactors: Record<string, number>

        Phi factors by failure multiplicity Key is the number of components failing (e.g., "1" for single failures, "2" for double failures) Value is the fraction of total probability for that multiplicity

      • totalFailureProbability: number

        Total failure probability for a single component

    modelType: string

    The common cause model used.

    SY-B4

    "Multiple Greek Letter (MGL)"
    The modelType field should align with the types expected by the quantification adapter:
    - BETA_FACTOR, MGL, ALPHA_FACTOR, PHI_FACTOR are directly mapped
    - Other types may require mapping in the adapter
    probabilityModel?: ProbabilityModel

    Probability model from data analysis module Reuses the data analysis module's definition to avoid duplication

    quantificationMapping?: {
        openPsaMapping?: {
            factorMappings?: Record<string, string>;
            modelType: "MGL" | "beta-factor" | "alpha-factor" | "phi-factor";
        };
    }

    Mapping to guide how this CCF group should be quantified Maps to the format required by quantification engines

    Type declaration

    • OptionalopenPsaMapping?: {
          factorMappings?: Record<string, string>;
          modelType: "MGL" | "beta-factor" | "alpha-factor" | "phi-factor";
      }

      Mapping to OpenPSA/SCRAM format (for integration)

      • OptionalfactorMappings?: Record<string, string>

        Factor mappings for OpenPSA

      • modelType: "MGL" | "beta-factor" | "alpha-factor" | "phi-factor"

        CCF model type in OpenPSA format

    riskSignificanceJustification?: string

    Justification for why this CCF is or is not risk-significant.

    SY-B1

    sharedCauseFactors?: {
        environment?: boolean;
        hardwareDesign?: boolean;
        installation?: boolean;
        maintenance?: boolean;
        manufacturer?: boolean;
        otherFactors?: string[];
    }

    Shared cause factors that contribute to CCF potential. These factors help justify the CCF group definition.

    Type declaration

    • Optionalenvironment?: boolean

      Shared environment

    • OptionalhardwareDesign?: boolean

      Hardware design similarities

    • Optionalinstallation?: boolean

      Same installation procedures

    • Optionalmaintenance?: boolean

      Same maintenance procedures

    • Optionalmanufacturer?: boolean

      Same manufacturer

    • OptionalotherFactors?: string[]

      Other shared factors

    totalFailureProbability?: number

    Total failure probability for a single component This field is used directly by the quantification adapter

    Settings

    Member Visibility

    On This Page

    Properties