Interface EventSequenceQuantification

interface EventSequenceQuantification {
    barrierTreatment: RadionuclideBarrierTreatment;
    commonAssumptions?: BaseAssumption[];
    created: string;
    dependencyTreatment: DependencyRepresentation;
    description?: string;
    documentation: EventSequenceQuantificationDocumentation;
    eventSequenceFamilies: Record<string, EventSequenceFamilyQuantification>;
    importanceAnalysis: Record<string, ImportanceAnalysis>;
    limitationsDocumentation: EventSequenceQuantificationLimitationsDocumentation;
    logicalChallenges: {
        circularLogic: Record<string, CircularLogic>;
        flagEvents?: Record<string, FlagEvent>;
        mutuallyExclusiveEvents: Record<string, MutuallyExclusiveEvents>;
        systemSuccessTreatment: SystemSuccessTreatment;
    };
    mechanisticSourceTermAnalysisReferences?: string[];
    metadata: {
        analysisDate: string;
        analyst: string;
        approvalStatus?: string;
        assumptions?: BaseAssumption[];
        limitations?: string[];
        reviewer?: string;
        scope?: string[];
        version: string;
    };
    modelIntegration: ModelIntegration;
    modified: string;
    owner?: string;
    peerReviewDocumentation?: EventSequenceQuantificationPeerReviewDocumentation;
    preOperationalDocumentation?: EventSequenceQuantificationPreOperationalDocumentation;
    quantificationMethods: {
        approach: QuantificationApproach;
        computerCodes: {
            name: string;
            validationDocumentation: string;
            validationReference?: string;
            verificationDocumentation: string;
            version: string;
        }[];
        postInitiatorHFEHandling?: string;
        recoveryActionTreatment?: RecoveryActionTreatment;
        truncation: ConvergenceAnalysis;
    };
    quantificationResults: Record<string, EventSequenceFrequencyEstimate>;
    quantificationReview?: QuantificationReviewProcess;
    references?: {
        description: string;
        technicalElementId: string;
        technicalElementType: TechnicalElementTypes;
    }[];
    riskIntegrationInfo?: {
        riskIntegrationFeedback?: {
            analysisId: string;
            feedbackDate?: string;
            generalFeedback?: string;
            response?: {
                changes?: string[];
                description: string;
                status: "IN_PROGRESS"
                | "PENDING"
                | "COMPLETED";
            };
            sequenceFeedback?: {
                insights?: string[];
                recommendations?: string[];
                riskSignificance?: ImportanceLevel;
                sequenceId: string;
            }[];
        };
        riskSignificantSequences: {
            frequencyUnit: string;
            importanceMetrics?: {
                birnbaum?: number;
                fussellVesely?: number;
                raw?: number;
                rrw?: number;
            };
            meanFrequency: number;
            releaseCategoryId?: string;
            riskInsights?: string[];
            riskSignificance: "HIGH"
            | "MEDIUM"
            | "LOW"
            | "NONE";
            riskSignificanceBasis?: string;
            sequenceId: string;
            sequenceType: "INDIVIDUAL" | "FAMILY";
        }[];
    };
    status?: "DRAFT"
    | "APPROVED"
    | "REVIEW"
    | "DEPRECATED";
    tags?: string[];
    type: EVENT_SEQUENCE_QUANTIFICATION;
    uncertaintyAnalysis: EventQuantUncertaintyAnalysis;
    uncertaintyDocumentation: EventSequenceQuantificationUncertaintyDocumentation;
    version: string;
}

Hierarchy

TechnicalElement<TechnicalElementTypes.EVENT_SEQUENCE_QUANTIFICATION>
- EventSequenceQuantification

Properties

barrierTreatment

barrierTreatment: RadionuclideBarrierTreatment

Treatment of radionuclide barriers.

Remarks

Describes how barriers to prevent and mitigate event sequences are modeled.

Example

barrierTreatment: {
  barriersConsidered: ["Fuel Cladding", "RCS Boundary", "Containment"],
  barrierFailureModes: {
    "Fuel Cladding": ["Overtemperature", "Mechanical Damage"],
    // ... other barriers
  },
  // ... other barrier aspects
}

`Optional`commonAssumptions

commonAssumptions?: BaseAssumption[]

Common assumptions that apply across this technical element Using the standardized BaseAssumption interface

created

created: string

The date the technical element was created

dependencyTreatment

dependencyTreatment: DependencyRepresentation

Treatment of dependencies in quantification.

Remarks

Describes how functional, physical, and human dependencies are addressed.

Example

dependencyTreatment: {
  dependenciesByType: {
    "FUNCTIONAL": {
      treatmentDescription: "Modeled through explicit system fault tree linking",
      modelingMethod: "Shared basic events and logical connections",
      examples: ["Support system X failure impacts frontline systems Y and Z"]
    },
    // ... other dependency types
  },
  // ... other dependency aspects
}

`Optional`description

description?: string

The description of the technical element

documentation

documentation: EventSequenceQuantificationDocumentation

Documentation of the Event Sequence Quantification process.

Remarks

Provides traceability of the work, including inputs, methods, and results.

Example

documentation: {
  processDescription: "Event trees and fault trees were integrated and quantified using a Monte Carlo simulation approach.",
  inputs: ["Component reliability databases", "Plant-specific operating experience"],
  appliedMethods: ["Fault Tree Linking", "Monte Carlo Uncertainty Propagation"],
  resultsSummary: "Overall CDF is estimated at 2.5e-5 per year, with...",
  // ... other documentation aspects
}

eventSequenceFamilies

eventSequenceFamilies: Record<string, EventSequenceFamilyQuantification>

Event sequence families defined for quantification.

Remarks

Specifies how individual event sequences are grouped into families for quantification.

importanceAnalysis

importanceAnalysis: Record<string, ImportanceAnalysis>

Importance analysis of contributors.

Remarks

Identifies significant contributors to risk.

Example

importanceAnalysis: {
  "FUSSELL_VESELY": {
    analysisType: "FUSSELL_VESELY",
    scope: "OVERALL",
    basicEventImportance: {
      "BE-001": 0.23,
      "BE-002": 0.18
    },
    significanceCutoff: 0.05,
    significantBasicEvents: ["BE-001", "BE-002"]
  }
}

limitationsDocumentation

limitationsDocumentation: EventSequenceQuantificationLimitationsDocumentation

Documentation of quantification limitations.

Remarks

Documents limitations that would impact applications.

Example

limitationsDocumentation: {
  quantificationLimitations: [
    {
      limitationId: "LIM-001",
      description: "Limited plant-specific data for certain components",
      applicationImpact: "May affect uncertainty in specific sequences",
      potentialWorkarounds: "Use of sensitivity studies to bound impact"
    }
  ],
  // ... other limitations documentation aspects
}

logicalChallenges

logicalChallenges: {
    circularLogic: Record<string, CircularLogic>;
    flagEvents?: Record<string, FlagEvent>;
    mutuallyExclusiveEvents: Record<string, MutuallyExclusiveEvents>;
    systemSuccessTreatment: SystemSuccessTreatment;
}

Handling of circular logic and mutually exclusive events.

Type declaration

circularLogic: Record<string, CircularLogic>
Circular logic situations and their resolutions
OptionalflagEvents?: Record<string, FlagEvent>
Flag events used in quantification
mutuallyExclusiveEvents: Record<string, MutuallyExclusiveEvents>
Mutually exclusive events and their treatment
systemSuccessTreatment: SystemSuccessTreatment
Treatment of system successes

Remarks

Describes how logical challenges in the model are addressed.

Example

logicalChallenges: {
  circularLogic: {
    "CIRC-001": {
      description: "Circular dependency between system A and system B",
      involvedElementIds: ["SYS-A", "SYS-B"],
      resolutionMethod: CircularLogicResolutionMethod.CONDITIONAL_SPLIT_FRACTIONS,
      resolutionDescription: "Used conditional split fractions to break the loop"
    }
  },
  mutuallyExclusiveEvents: {
    "MEX-001": {
      description: "Pump A and Pump B cannot both fail due to same cause",
      eventIds: ["BE-PUMP-A-CCF", "BE-PUMP-B-CCF"],
      basis: "Different design and location",
      treatmentMethod: "Explicit logic in fault trees"
    }
  }
}

`Optional`mechanisticSourceTermAnalysisReferences

mechanisticSourceTermAnalysisReferences?: string[]

References to the Mechanistic Source Term Analysis.

Remarks

Ensures integration between event sequence quantification and source term evaluation.

See

RG 1.247 Section C.1.3.15

Example

mechanisticSourceTermAnalysisReferences: ["MST-REP-001", "MST-CALC-002"]

metadata

metadata: {
    analysisDate: string;
    analyst: string;
    approvalStatus?: string;
    assumptions?: BaseAssumption[];
    limitations?: string[];
    reviewer?: string;
    scope?: string[];
    version: string;
}

Additional metadata specific to Event Sequence Quantification.

Remarks

Includes details like the version of the analysis, analyst, and review status.

Example

metadata: {
  version: "1.0",
  analysisDate: "2024-07-26",
  analyst: "Jane Doe",
  reviewer: "John Smith",
  approvalStatus: "Approved",
  scope: ["Internal Events"],
  limitations: ["Conservative assumptions used for some parameters"],
  assumptions: [{ id: "A-001", description: "No external events considered in this quantification." }]
}

modelIntegration

modelIntegration: ModelIntegration

Integration of models from various technical elements.

Remarks

Describes how different PRA elements are integrated into the quantification.

Example

modelIntegration: {
  integrationMethod: "Linked Event Trees with Fault Trees",
  softwareTools: ["RISKMAN", "CAFTA"],
  integrationSteps: ["Link initiating events to event trees", "Map system failures to fault trees", "..."],
  integrationVerification: "Verified through manual checks of selected sequences"
}

modified

modified: string

The date the technical element was last modified

`Optional`owner

owner?: string

The owner of the technical element

`Optional`peerReviewDocumentation

peerReviewDocumentation?: EventSequenceQuantificationPeerReviewDocumentation

Peer review documentation.

Remarks

Documents peer review of the Event Sequence Quantification.

Example

peerReviewDocumentation: {
  reviewDate: "2024-08-15",
  reviewTeam: ["John Smith", "Jane Doe"],
  reviewScope: "Complete ESQ technical element",
  findings: [
    {
      findingId: "F-001",
      description: "Some dependency relationships not fully documented",
      significance: "MEDIUM",
      status: "CLOSED",
      resolution: "Documentation updated to include all dependencies",
      associatedRequirement: "ESQ-C1"
    }
  ],
  conclusions: "ESQ element meets requirements with minor improvements recommended"
}

`Optional`preOperationalDocumentation

preOperationalDocumentation?: EventSequenceQuantificationPreOperationalDocumentation

Documentation of pre-operational assumptions and limitations.

Remarks

Documents assumptions and limitations due to lack of as-built, as-operated details.

Example

preOperationalDocumentation: {
  preOperationalAssumptions: [
    {
      assumptionId: "PA-001",
      description: "Component reliability based on design specifications",
      impact: "May not reflect as-built performance",
      validationApproach: "Update with plant-specific data when available",
      validationTiming: "After first year of operation"
    }
  ],
  // ... other pre-operational documentation aspects
}

quantificationMethods

quantificationMethods: {
    approach: QuantificationApproach;
    computerCodes: {
        name: string;
        validationDocumentation: string;
        validationReference?: string;
        verificationDocumentation: string;
        version: string;
    }[];
    postInitiatorHFEHandling?: string;
    recoveryActionTreatment?: RecoveryActionTreatment;
    truncation: ConvergenceAnalysis;
}

Details of the quantification methods used.

Type declaration

approach: QuantificationApproach
Quantification approach used
computerCodes: {
    name: string;
    validationDocumentation: string;
    validationReference?: string;
    verificationDocumentation: string;
    version: string;
}[]
Computer codes used

Todo
Future enhancement: Consider adding more detailed V&V documentation including test cases, benchmarking results, and configuration management
OptionalpostInitiatorHFEHandling?: string
Handling of post-initiator human failure events
OptionalrecoveryActionTreatment?: RecoveryActionTreatment
Treatment of recovery actions

Implements
ESQ-A7

Todo
Future enhancement: Consider adding more detailed fields for timing, success criteria, and dependencies
truncation: ConvergenceAnalysis
Truncation details

Remarks

Specifies the computer codes, truncation levels, and overall approach.

Example

quantificationMethods: {
  approach: QuantificationApproach.FAULT_TREE_LINKING,
  computerCodes: [{ name: "RISKMAN", version: "3.2", verificationDocumentation: "VALID-001", validationDocumentation: "VALID-001" }],
  truncation: {
    method: TruncationMethod.ABSOLUTE_FREQUENCY,
    finalValue: 1.0e-9,
    convergenceDemonstration: "Sequence frequencies changed by less than 1% when truncation was lowered from 1.0e-9 to 1.0e-10"
  }
}

quantificationResults

quantificationResults: Record<string, EventSequenceFrequencyEstimate>

Quantification results for each event sequence and family.

Remarks

Includes frequency estimates, uncertainty analyses, and risk-significant contributors.

Example

quantificationResults: {
  "LOCA-Small-LossOfOffsitePower": {
    meanFrequency: { value: 1.0e-5, unit: "/year" },
    uncertaintyDistribution: { type: "LOGNORMAL", parameters: { median: 1.0e-5, errorFactor: 3.0 } },
    riskSignificantContributors: ["Diesel Generator Failure", "Operator Failure to Recover Offsite Power"]
  }
}

`Optional`quantificationReview

quantificationReview?: QuantificationReviewProcess

Review process for quantification results.

Remarks

Documents the review of results for logical consistency and comparison to similar plants.

Todo

Future enhancement: Consider adding more detailed review documentation including peer review findings and resolution tracking

Example

quantificationReview: {
  reviewCriteria: ["Logical consistency", "Comparison to similar plants", "Reasonableness of results"],
  reviewFindings: [
    {
      id: "FIND-001",
      description: "Sequence XYZ frequency appears unusually high",
      correctiveActions: "Reviewed and corrected fault tree logic for system A"
    }
  ],
  plantComparison: {
    comparisonPlants: ["Plant X", "Plant Y"],
    keyDifferences: ["Different ECCS design", "Different support system dependencies"],
    differenceExplanation: "Higher LOCA frequencies due to different pipe material specifications"
  }
}

`Optional`references

references?: {
    description: string;
    technicalElementId: string;
    technicalElementType: TechnicalElementTypes;
}[]

References to other technical elements

`Optional`riskIntegrationInfo

riskIntegrationInfo?: {
    riskIntegrationFeedback?: {
        analysisId: string;
        feedbackDate?: string;
        generalFeedback?: string;
        response?: {
            changes?: string[];
            description: string;
            status: "IN_PROGRESS" | "PENDING" | "COMPLETED";
        };
        sequenceFeedback?: {
            insights?: string[];
            recommendations?: string[];
            riskSignificance?: ImportanceLevel;
            sequenceId: string;
        }[];
    };
    riskSignificantSequences: {
        frequencyUnit: string;
        importanceMetrics?: {
            birnbaum?: number;
            fussellVesely?: number;
            raw?: number;
            rrw?: number;
        };
        meanFrequency: number;
        releaseCategoryId?: string;
        riskInsights?: string[];
        riskSignificance: "HIGH"
        | "MEDIUM"
        | "LOW"
        | "NONE";
        riskSignificanceBasis?: string;
        sequenceId: string;
        sequenceType: "INDIVIDUAL" | "FAMILY";
    }[];
}

Risk integration information. This field provides information specifically structured for consumption by risk integration.

Type declaration

OptionalriskIntegrationFeedback?: {
    analysisId: string;
    feedbackDate?: string;
    generalFeedback?: string;
    response?: {
        changes?: string[];
        description: string;
        status: "IN_PROGRESS" | "PENDING" | "COMPLETED";
    };
    sequenceFeedback?: {
        insights?: string[];
        recommendations?: string[];
        riskSignificance?: ImportanceLevel;
        sequenceId: string;
    }[];
}
Feedback received from risk integration. This field contains feedback from risk integration that should be considered in future revisions of the event sequence quantification.
- analysisId: string
  ID of the risk integration analysis that provided the feedback
- OptionalfeedbackDate?: string
  Date the feedback was received
- OptionalgeneralFeedback?: string
  General feedback on the event sequence quantification
- Optionalresponse?: {
      changes?: string[];
      description: string;
      status: "IN_PROGRESS" | "PENDING" | "COMPLETED";
  }
  Response to the feedback
  - Optionalchanges?: string[]
    Changes made or planned in response to the feedback
  - description: string
    Description of how the feedback was or will be addressed
  - status: "IN_PROGRESS" | "PENDING" | "COMPLETED"
    Status of the response
- OptionalsequenceFeedback?: {
      insights?: string[];
      recommendations?: string[];
      riskSignificance?: ImportanceLevel;
      sequenceId: string;
  }[]
  Feedback on specific event sequences
riskSignificantSequences: {
    frequencyUnit: string;
    importanceMetrics?: {
        birnbaum?: number;
        fussellVesely?: number;
        raw?: number;
        rrw?: number;
    };
    meanFrequency: number;
    releaseCategoryId?: string;
    riskInsights?: string[];
    riskSignificance: "HIGH"
    | "MEDIUM"
    | "LOW"
    | "NONE";
    riskSignificanceBasis?: string;
    sequenceId: string;
    sequenceType: "INDIVIDUAL" | "FAMILY";
}[]
Risk-significant event sequences identified in this analysis. This provides a simplified view of risk-significant sequences for risk integration.

Remarks

This helps maintain a clean dependency structure where Risk Integration depends on Event Sequence Quantification rather than directly on multiple upstream elements.

`Optional`status

status?: "DRAFT" | "APPROVED" | "REVIEW" | "DEPRECATED"

The status of the technical element

`Optional`tags

tags?: string[]

Tags associated with the technical element

type

type: EVENT_SEQUENCE_QUANTIFICATION

The type of technical element

uncertaintyAnalysis

uncertaintyAnalysis: EventQuantUncertaintyAnalysis

Uncertainty and sensitivity analyses.

Remarks

Characterizes uncertainties and their impact on results.

Example

uncertaintyAnalysis: {
  propagationMethod: "MONTE_CARLO",
  numberOfSamples: 10000,
  randomSeed: 12345,
  parameterUncertainties: [
    {
      parameterId: "PARAM-001",
      distributionType: DistributionType.LOGNORMAL,
      distributionParameters: { mean: 1.0e-3, errorFactor: 3 },
      basis: "Industry data with Bayesian update"
    }
  ],
  // ... other uncertainty aspects
}

uncertaintyDocumentation

uncertaintyDocumentation: EventSequenceQuantificationUncertaintyDocumentation

Documentation of model uncertainties.

Remarks

Documents sources of model uncertainty, related assumptions, and alternatives.

Example

uncertaintyDocumentation: {
  modelUncertaintySources: [
    {
      sourceId: "MU-001",
      description: "Uncertainty in success criteria for system X",
      impact: "Moderate impact on sequence frequencies",
      relatedAssumptions: ["Success assumed based on design calculations"],
      alternativeApproaches: ["More conservative success criteria"],
      treatmentApproach: "Sensitivity analysis performed"
    }
  ],
  // ... other uncertainty documentation aspects
}

version

version: string

The version of the technical element

Interface EventSequenceQuantification

Hierarchy

Index

Properties

Properties

barrierTreatment

Remarks

Example

OptionalcommonAssumptions

created

dependencyTreatment

Remarks

Example

Optionaldescription

documentation

Remarks

Example

eventSequenceFamilies

Remarks

importanceAnalysis

Remarks

Example

limitationsDocumentation

Remarks

Example

logicalChallenges

Type declaration

circularLogic: Record<string, CircularLogic>

OptionalflagEvents?: Record<string, FlagEvent>

mutuallyExclusiveEvents: Record<string, MutuallyExclusiveEvents>

systemSuccessTreatment: SystemSuccessTreatment

Remarks

Example

OptionalmechanisticSourceTermAnalysisReferences

Remarks

See

Example

metadata

Remarks

Example

modelIntegration

Remarks

Example

modified

Optionalowner

OptionalpeerReviewDocumentation

Remarks

Example

OptionalpreOperationalDocumentation

Remarks

Example

quantificationMethods

Type declaration

approach: QuantificationApproach

computerCodes: { name: string; validationDocumentation: string; validationReference?: string; verificationDocumentation: string; version: string;}[]

Todo

OptionalpostInitiatorHFEHandling?: string

OptionalrecoveryActionTreatment?: RecoveryActionTreatment

Implements

Todo

truncation: ConvergenceAnalysis

Remarks

Example

quantificationResults

Remarks

Example

OptionalquantificationReview

Remarks

Todo

Example

Optionalreferences

OptionalriskIntegrationInfo

Type declaration

analysisId: string

OptionalfeedbackDate?: string

OptionalgeneralFeedback?: string

Optionalresponse?: { changes?: string[]; description: string; status: "IN_PROGRESS" | "PENDING" | "COMPLETED";}

Optionalchanges?: string[]

description: string

status: "IN_PROGRESS" | "PENDING" | "COMPLETED"

`Optional`commonAssumptions

`Optional`description

`Optional`flagEvents?: Record<string, FlagEvent>

`Optional`mechanisticSourceTermAnalysisReferences

`Optional`owner

`Optional`peerReviewDocumentation

`Optional`preOperationalDocumentation

computerCodes: {
name: string;
validationDocumentation: string;
validationReference?: string;
verificationDocumentation: string;
version: string;
}[]

`Optional`postInitiatorHFEHandling?: string

`Optional`recoveryActionTreatment?: RecoveryActionTreatment

`Optional`quantificationReview

`Optional`references

`Optional`riskIntegrationInfo

`Optional`feedbackDate?: string

`Optional`generalFeedback?: string

`Optional`response?: {
changes?: string[];
description: string;
status: "IN_PROGRESS" | "PENDING" | "COMPLETED";
}

`Optional`changes?: string[]

`Optional`sequenceFeedback?: {
insights?: string[];
recommendations?: string[];
riskSignificance?: ImportanceLevel;
sequenceId: string;
}[]

`Optional`status

`Optional`tags