PublicRisk.ai

PELICUN Loss Assessment - Technical Guide

Complete technical documentation for PELICUN probabilistic loss assessment including multi-hazard analysis, SIPmath integration, component damage, repair timelines, and casualty estimation

Overview

PELICUN (Probabilistic Estimation of Losses, Injuries, and Community resilience Under Natural disasters) is a state-of-the-art hazard-agnostic tool for probabilistic loss assessment. PublicRisk.ai integrates PELICUN 3.3 to provide advanced Monte Carlo-based loss estimation across multiple natural hazards.

Status: Production-ready (Phase 4 complete as of December 2025). Supports earthquakes, floods, hurricanes, and wildfires with full SIPmath integration.

Key Capabilities

  • Multi-Hazard Analysis: Earthquakes, floods, hurricanes, wildfires
  • Probabilistic Modeling: 1,000-10,000 Monte Carlo realizations
  • Component-Level Damage: Detailed damage states (DS0-DS4) for 700+ building components
  • SIPmath Integration: 99.5% compression using Metalog distributions
  • Advanced Analytics: Repair timelines, casualty estimation, portfolio assessment
  • Professional Reporting: PDF/CSV exports with executive summaries

Architecture

System Overview

Implementation Phases

All phases are complete and deployed as of December 2025.

PhaseFeaturesStatusLines of Code
Phase 1Core property assessment, earthquake analysis✅ Complete~2,000
Phase 2Multi-hazard (flood, hurricane, wildfire)✅ Complete~1,500
Phase 3Component damage, repair timeline, casualties✅ Complete~3,500
Phase 4SIPmath, 3D visualization, scenario comparison✅ Complete~2,500
TotalFull probabilistic loss assessment platform✅ Complete~10,000

API Reference

Base Configuration

Base URL: https://publicrisk--publicrisk-pelicun-service.modal.run

Timeouts:

  • Property assessment: 60 seconds
  • Multi-hazard analysis: 90 seconds
  • Component damage: 10 seconds
  • Repair timeline: 15 seconds
  • Casualty estimation: 10 seconds
  • SIPmath distribution: 30 seconds

Cold Start: First request after inactivity takes 30-60 seconds. Frontend displays progress indicators during initialization.


1. Property Assessment

Single-hazard property loss assessment.

POST /assess-property
Content-Type: application/json
{
  property: {
    lat: number;              // Latitude (WGS84)
    lng: number;              // Longitude (WGS84)
    building_type: string;    // HAZUS type (W1, S1L, C2M, etc.)
    occupancy: string;        // HAZUS occupancy (RES1, COM1, etc.)
    stories: number;          // Number of stories
    year_built: number;       // Year of construction
    square_feet: number;      // Building area
    replacement_value: number; // USD
    design_level?: string;    // 'Pre' | 'Low' | 'Moderate' | 'High'
  },
  hazard: {
    earthquake?: {
      pga: number;            // Peak Ground Acceleration (g)
      sa_03?: number;         // Spectral Acceleration at 0.3s
      sa_10?: number;         // Spectral Acceleration at 1.0s
    }
  },
  options?: {
    num_realizations?: number; // Default: 1000
    include_components?: boolean;
    include_injuries?: boolean;
  }
}
{
  assessment_id: string;
  property_id: string;
  timestamp: string;
  
  loss_estimate: {
    structural: {
      mean: number;           // Mean loss (USD)
      median: number;
      std: number;
      cov: number;            // Coefficient of variation
      percentiles: {
        P10: number;
        P50: number;
        P90: number;
        P95: number;
        P99: number;
      }
    },
    non_structural_drift: { /* same structure */ },
    non_structural_acceleration: { /* same structure */ },
    contents: { /* same structure */ },
    total_loss: { /* same structure */ }
  },
  
  damage_states: {
    DS0_no_damage: number;    // Percentage (0-100)
    DS1_slight: number;
    DS2_moderate: number;
    DS3_extensive: number;
    DS4_complete: number;
  },
  
  collapse: {
    probability: number;      // 0-1
    injuries_given_collapse: number;
    fatalities_given_collapse: number;
  },
  
  metadata: {
    pelicun_version: string;
    num_realizations: number;
    computation_time_seconds: number;
  }
}
curl -X POST \
  https://publicrisk--publicrisk-pelicun-service.modal.run/assess-property \
  -H "Content-Type: application/json" \
  -d '{
    "property": {
      "lat": 37.7749,
      "lng": -122.4194,
      "building_type": "W1",
      "occupancy": "RES1",
      "stories": 2,
      "year_built": 1965,
      "square_feet": 2400,
      "replacement_value": 850000,
      "design_level": "Low"
    },
    "hazard": {
      "earthquake": {
        "pga": 0.52,
        "sa_03": 0.73,
        "sa_10": 0.41
      }
    },
    "options": {
      "num_realizations": 5000,
      "include_components": true
    }
  }'

2. Multi-Hazard Assessment

Comprehensive multi-hazard loss assessment.

POST /assess-multi-hazard
Content-Type: application/json
{
  property: PropertyCharacteristics, // Same as above
  
  hazards: {
    earthquake?: EarthquakeHazard,
    flood?: {
      inundation_depth_ft: number;
      velocity_fps?: number;
      duration_hours?: number;
      water_type?: 'fresh' | 'salt';
    },
    wind?: {
      wind_speed_mph: number;
      exposure?: 'B' | 'C' | 'D';
      storm_surge_ft?: number;
    },
    wildfire?: {
      flame_intensity_kw_m2: number;
      ember_exposure?: 'low' | 'medium' | 'high';
    }
  },
  
  analysis_options?: {
    num_realizations?: number;
    consider_cascading?: boolean;
    spatial_correlation?: number; // 0-1
  }
}
{
  assessment_id: string;
  multi_hazard_results: {
    combined_loss: LossStatistics,
    
    loss_by_hazard: {
      earthquake?: LossStatistics,
      flood?: LossStatistics,
      wind?: LossStatistics,
      wildfire?: LossStatistics
    },
    
    cascading_failures?: {
      primary_hazard: string;
      triggered_hazards: string[];
      amplification_factor: number;
      description: string;
    }[],
    
    loss_correlation_matrix: number[][],
    
    combined_damage_states: {
      DS0_no_damage: number,
      DS1_slight: number,
      DS2_moderate: number,
      DS3_extensive: number,
      DS4_complete: number
    }
  }
}

3. Component Damage Analysis

Detailed component-level damage breakdown (FEMA P-58).

POST /component-damage
Content-Type: application/json
{
  assessment_id: string;      // From property assessment
  detail_level: 'summary' | 'full';
  filters?: {
    category?: string[];      // ['structural', 'non-structural', 'contents']
    min_contribution?: number; // Minimum % contribution to show
    damage_state?: string[];  // ['DS1', 'DS2', 'DS3', 'DS4']
  },
  sort?: {
    by: 'expected_loss' | 'repair_cost' | 'damage_probability';
    order: 'asc' | 'desc';
  }
}
{
  assessment_id: string;
  total_components: number;
  
  components_by_category: {
    structural: ComponentDamage[],
    non_structural_drift: ComponentDamage[],
    non_structural_acceleration: ComponentDamage[],
    contents: ComponentDamage[]
  },
  
  top_contributors: ComponentDamage[], // Top 10 by expected loss
  
  component_summary: {
    total_expected_loss: number;
    total_repair_cost: number;
    components_damaged: number;
    components_total: number;
  }
}

// ComponentDamage structure:
{
  component_id: string;       // "B.10.41.001a"
  description: string;        // "Reinforced Concrete Shear Wall"
  category: string;
  quantity: number;
  unit: string;
  
  damage_states: {
    DS0: { probability: number, cost: 0 },
    DS1: { probability: number, cost: number },
    DS2: { probability: number, cost: number },
    DS3: { probability: number, cost: number },
    DS4: { probability: number, cost: number }
  },
  
  expected_loss: ProbabilisticValue, // { mean, median, std, P10, P50, P90 }
  repair_cost: ProbabilisticValue,
  repair_time_days: ProbabilisticValue,
  contribution_pct: number    // % of total loss
}

4. Repair Timeline

Repair sequencing with critical path analysis.

POST /repair-timeline
Content-Type: application/json
{
  assessment_id: string;
  timeline_options?: {
    crew_size?: number;       // Default: 5
    working_hours_per_day?: number; // Default: 8
    consider_dependencies?: boolean; // Default: true
    parallel_work?: boolean;  // Default: true
  }
}
{
  assessment_id: string;
  
  repair_phases: RepairPhase[], // Chronological phases
  
  critical_path: CriticalPathItem[], // Components on critical path
  
  cost_breakdown: {
    labor_cost: number;
    material_cost: number;
    equipment_cost: number;
    total_cost: number;
  },
  
  summary: {
    total_duration_days: number;
    earliest_completion: string; // ISO date
    latest_completion: string;   // With delays
    parallel_efficiency: number; // 0-1
  }
}

// RepairPhase structure:
{
  phase_number: number;
  phase_name: string;           // "Foundation Repair", "Frame Retrofit"
  start_day: number;
  duration_days: number;
  end_day: number;
  
  components: string[];         // Component IDs in this phase
  prerequisites: number[];      // Phase numbers that must complete first
  
  cost_estimate: number;
  labor_hours: number;
  critical_path_item: boolean;
}

5. Casualty Estimation

Injury and fatality estimation by severity level.

POST /casualty-estimate
Content-Type: application/json
{
  assessment_id: string;
  
  scenario?: {
    time_of_day: 'daytime' | 'nighttime' | 'custom';
    occupancy_rate?: number;  // 0-1, overrides time_of_day
    population?: number;      // Override default occupancy
  },
  
  casualty_options?: {
    include_severity_breakdown?: boolean; // Default: true
    include_injury_types?: boolean;
  }
}
{
  assessment_id: string;
  scenario: {
    time_of_day: string;
    occupancy_rate: number;
    population: number;
  },
  
  casualties_by_severity: {
    severity_1: CasualtyLevel, // Minor injuries
    severity_2: CasualtyLevel, // Moderate injuries (hospitalization)
    severity_3: CasualtyLevel, // Life-threatening injuries (ICU)
    severity_4: CasualtyLevel  // Fatalities
  },
  
  total_casualties: {
    injuries: number;         // Severity 1-3
    fatalities: number;       // Severity 4
    total: number;
  },
  
  contributing_factors: [
    {
      factor: string;         // "Structural collapse", "Non-structural falling"
      contribution_pct: number;
      severity_distribution: {
        severity_1: number,
        severity_2: number,
        severity_3: number,
        severity_4: number
      }
    }
  ]
}

// CasualtyLevel structure:
{
  count: number;              // Expected casualties
  probability: number;        // 0-1
  percentage: number;         // % of total casualties
  confidence_interval: {
    P10: number,
    P50: number,
    P90: number
  }
}

6. SIPmath Loss Distribution

Compressed loss distribution using Metalog distributions (99.5% data reduction).

GET /loss-distribution?assessment_id={id}&distribution_type={type}

Query Parameters:

ParameterTypeRequiredDescription
assessment_idstringYesAssessment ID from property assessment
distribution_typestringNototal_loss (default), structural, contents
formatstringNometalog (default), slurp, full_monte_carlo
{
  assessment_id: string;
  distribution_type: string;
  
  distribution: {
    type: 'metalog',
    quantiles: {
      q01: number,  // 1st percentile
      q25: number,  // 25th percentile
      q50: number,  // Median
      q75: number,  // 75th percentile
      q99: number   // 99th percentile
    },
    metalog_coefficients: number[] // For reconstruction
  },
  
  statistics: {
    mean: number,
    median: number,
    mode: number,
    std: number,
    skewness: number,
    kurtosis: number,
    cv: number,           // Coefficient of variation
    percentiles: {
      P01: number, P05: number, P10: number,
      P25: number, P50: number, P75: number,
      P90: number, P95: number, P99: number
    }
  },
  
  compression_metrics: {
    original_samples: number;    // e.g., 10000
    compressed_quantiles: number; // 5
    compression_ratio: number;    // 0.9995 (99.95%)
    monte_carlo_size_bytes: number;
    metalog_size_bytes: number;
    space_savings_pct: number;
  },
  
  slurp_export?: {
    var_name: string;      // "TotalLoss_W1_PGA052"
    trials: number[];      // 10,000 Monte Carlo samples
    format: 'slurp'
  }
}

SIPmath Benefits:

  • 99.5% compression: 10,000 samples → 5 quantiles
  • Lossless reconstruction: Metalog coefficients enable full distribution recovery
  • Portable: SLURP format interoperable with other risk tools
  • Fast: Reduced network transfer and storage

Data Models

Building Types (HAZUS Classification)

PELICUN uses HAZUS building taxonomy:

Wood Frame (W)

  • W1: Light wood frame (≤5,000 sq ft)
  • W1A: Wood frame, commercial/multi-family
  • W2: Wood frame, large (>5,000 sq ft)

Typical Use: Residential, small commercial, churches Vulnerability: Moderate to earthquakes, high to fire

Steel Frame (S)

  • S1L: Steel moment frame, low-rise (1-3 stories)
  • S1M: Steel moment frame, mid-rise (4-7 stories)
  • S1H: Steel moment frame, high-rise (8+ stories)
  • S2L: Steel braced frame, low-rise
  • S3: Steel light frame
  • S4L: Steel frame with cast-in-place concrete shear walls
  • S5L: Steel frame with unreinforced masonry infill

Typical Use: Commercial, office buildings Vulnerability: Low to moderate for earthquakes (if properly designed)

Concrete Frame (C)

  • C1L: Concrete moment frame, low-rise
  • C1M: Concrete moment frame, mid-rise
  • C1H: Concrete moment frame, high-rise
  • C2L: Concrete shear walls, low-rise
  • C2M: Concrete shear walls, mid-rise
  • C2H: Concrete shear walls, high-rise
  • C3L: Concrete frame with unreinforced masonry infill

Typical Use: High-rise residential, hospitals, government Vulnerability: Moderate to earthquakes, low to fire

Masonry (RM, URM)

  • RM1L: Reinforced masonry bearing walls, low-rise
  • RM2L: Reinforced masonry bearing walls with wood/metal deck
  • URML: Unreinforced masonry bearing walls, low-rise
  • URMM: Unreinforced masonry bearing walls, mid-rise

Typical Use: Historic buildings, warehouses Vulnerability: High to earthquakes (especially URM)


Damage States (FEMA P-58)

PELICUN uses a 5-level damage state classification:

StateCodeDescriptionDamage LevelRepair Action
No DamageDS0No visible damage0%None required
SlightDS1Minor cosmetic damage1-10%Patch and paint
ModerateDS2Visible structural damage10-30%Component repair
ExtensiveDS3Major structural damage30-60%Component replacement
CompleteDS4Collapse or irreparable60-100%Building replacement

FEMA P-58 Library: Contains 700+ component fragility curves covering structural, non-structural drift-sensitive, non-structural acceleration-sensitive, and contents.


Component Categories

1. Structural Components

  • Columns, beams, shear walls
  • Foundation elements
  • Roof/floor diaphragms
  • Connections

2. Non-Structural (Drift-Sensitive)

  • Partition walls, curtain walls
  • Stairs, egress components
  • Doors, windows
  • Architectural finishes

3. Non-Structural (Acceleration-Sensitive)

  • HVAC equipment, chillers
  • Electrical/mechanical systems
  • Elevators, escalators
  • Piping, conduit

4. Contents

  • Office equipment, computers
  • Manufacturing equipment
  • Inventory, stock
  • Furniture

Frontend Integration

Page Location

URL: /app/pelicun-assessment

Component: src/pages/PelicunAssessmentPage.tsx

Navigation: Listed in SharedSidebar as "PELICUN Assessment"

User Workflow

Step 1: Property Characteristics

Enter building details:

  • Location (lat/lng or address search)
  • Building type (HAZUS classification)
  • Occupancy type (RES1, COM1, etc.)
  • Construction year
  • Number of stories
  • Floor area (square feet)
  • Replacement value (USD)
  • Seismic design level (optional)

Step 2: Hazard Selection

Select one or more hazards:

  • Earthquake: PGA, SA(0.3s), SA(1.0s)
  • Flood: Inundation depth, velocity, duration
  • Hurricane/Wind: Wind speed, storm surge, exposure
  • Wildfire: Flame intensity, ember exposure

Step 3: Analysis Options

Configure analysis parameters:

  • Monte Carlo realizations (1,000-10,000)
  • Include component-level analysis
  • Include casualty estimation
  • Consider cascading failures (multi-hazard)
  • Spatial correlation factor

Step 4: Submit Assessment

Backend performs:

  1. Monte Carlo simulation (1-2 minutes)
  2. Component damage analysis
  3. Repair cost/time estimation
  4. Casualty calculation
  5. SIPmath compression

Step 5: Review Results

Tabbed interface shows:

  • Overview: Total loss, damage states, risk score
  • Component Damage: Detailed damage breakdown with DS0-DS4
  • Repair Timeline: Gantt chart with critical path
  • Casualties: Injury/fatality estimates by severity
  • SIPmath Distribution: Interactive loss distribution charts
  • Scenarios: Compare different hazard intensities
  • 3D Visualization: Building damage model (if available)

Visualization Components

Loss Distribution Charts

Probability Density Function (PDF)

Bell curve showing loss distribution with kernel density estimation

Cumulative Distribution Function (CDF)

S-curve showing exceedance probability (P[Loss > x])

Tornado Diagram

Sensitivity analysis showing parameter impact on loss

Monte Carlo Histogram

Histogram of 10,000 loss realizations with percentile markers

Technology: Recharts for 2D charts, Three.js for 3D building models


Component Damage Table

Interactive table with:

  • Columns: Component ID, Description, Category, Quantity, DS1-DS4 probabilities, Expected Loss
  • Sorting: By loss contribution, repair cost, damage probability
  • Filtering: By category, damage state, minimum contribution
  • Export: CSV/Excel with full component list

Repair Timeline (Gantt Chart)

Features:

  • Color-coded phases: Foundation (blue), Structural (red), Non-structural (yellow), Finishes (green)
  • Critical path highlighting: Red border for critical components
  • Dependencies: Arrows showing prerequisite relationships
  • Hover tooltips: Duration, cost, labor hours
  • Interactive: Click phase to see component details

Casualty Estimation Card

Visual breakdown:

  • Severity 1 (Minor): 🟢 Green badge with count
  • Severity 2 (Moderate): 🟡 Yellow badge with count
  • Severity 3 (Life-threatening): 🟠 Orange badge with count
  • Severity 4 (Fatalities): 🔴 Red badge with count
  • Pie chart: Proportional severity distribution
  • Contributing factors: Bar chart showing causes (collapse, falling debris, etc.)

Advanced Features

Portfolio Assessment

Analyze multiple properties simultaneously with spatial correlation:

{
  properties: PropertyInPortfolio[], // Array of properties
  spatial_correlation: number,       // 0-1 (0 = independent, 1 = perfect correlation)
  hazard: EarthquakeHazard,         // Shared hazard scenario
  analysis_options: {
    num_realizations: 10000
  }
}

Response includes:

  • Aggregate loss distribution
  • Loss exceedance curve (AAL, PML@475yr, PML@2475yr)
  • Per-property loss summary
  • Spatial loss map
  • Correlation matrix

Use Cases:

  • Real estate portfolio risk analysis
  • Insurance pricing for multi-property policies
  • Municipal infrastructure risk assessment

Scenario Comparison

Compare losses under different hazard intensities:

Scenario: Vary PGA from 0.1g to 1.0g

PGA (g)Mean LossCollapse ProbRepair Time
0.1$42,0000.1%45 days
0.3$185,0002.5%120 days
0.5$420,00012%280 days
0.8$690,00035%450 days
1.0$850,00058%Total loss

Chart: Line chart showing loss vs PGA with confidence intervals

Scenario: Vary inundation depth from 1 ft to 10 ft

Depth (ft)Mean LossDamage RatioRecovery Time
1$28,0003.3%30 days
3$95,00011.2%90 days
5$275,00032.4%180 days
8$520,00061.2%365 days
10$720,00084.7%Total loss

Scenario: Vary wind speed from 74 mph (Cat 1) to 157+ mph (Cat 5)

CategoryWind (mph)Mean LossDamage State
Cat 174-95$65,000DS1 (Slight)
Cat 296-110$180,000DS2 (Moderate)
Cat 3111-129$385,000DS3 (Extensive)
Cat 4130-156$620,000DS3-DS4
Cat 5157+$850,000DS4 (Complete)

3D Building Visualization

Interactive 3D model showing damage:

Features:

  • Floor-by-floor coloring: Green (DS0) → Red (DS4)
  • Component highlighting: Click to see damage details
  • Before/after slider: Compare undamaged vs damaged state
  • Rotation/zoom controls: Orbit around building
  • Damage animation: Simulate damage progression over time

Technology: React Three Fiber + Drei helpers

Requirements:

  • WebGL-enabled browser
  • Minimum 2GB RAM
  • Works on desktop and tablet (not mobile)

Report Export

Generate professional PDF reports:

Executive Summary (2-3 pages):

  • Property overview with location map
  • Hazard scenario description
  • Key loss metrics (mean, P90, PML)
  • Damage state summary
  • Top 5 mitigation recommendations

Technical Appendix (10-15 pages):

  • Full component damage table
  • Repair timeline Gantt chart
  • Loss distribution charts (PDF, CDF)
  • Casualty estimation breakdown
  • Methodology and assumptions
  • PELICUN version and library details

CSV Data Export:

  • Monte Carlo samples (10,000 rows)
  • Component damage details
  • Repair cost breakdown
  • Casualty estimates by scenario

Reports generate in less than 10 seconds and support custom branding (logo, colors).


Testing

Unit Tests

Location: src/__tests__/pelicun/

Coverage:

  • Service layer: API calls, error handling, timeouts
  • Hooks: State management, data fetching
  • Components: Rendering, user interactions

Run tests:

npm run test -- pelicun

E2E Tests (Playwright)

Location: tests/pelicun/

Test Scenarios:

  1. Complete assessment workflow (property → hazard → results)
  2. Multi-hazard cascading failure detection
  3. Component damage filtering and sorting
  4. Repair timeline interaction
  5. SIPmath distribution visualization
  6. Scenario comparison with 3 scenarios
  7. PDF export generation

Run E2E tests:

npm run test:e2e -- pelicun

Performance Optimization

Backend Optimizations

  • Caching: Redis cache with 300s TTL for assessment results
  • Lazy loading: Component damage computed only when requested
  • Parallel processing: Multi-hazard scenarios run in parallel
  • SIPmath compression: 99.5% reduction in network transfer

Frontend Optimizations

  • Code splitting: Lazy-load PELICUN page (reduces initial bundle by 500KB)
  • Memoization: useMemo for expensive chart data transformations
  • Virtual scrolling: Component tables with 700+ rows
  • Progressive rendering: Show overview first, load details on demand

Performance Benchmarks

OperationDurationNotes
Single-hazard assessment15-30s1,000 realizations
Multi-hazard assessment45-90s5,000 realizations
Component damage query1-3sCached after first request
Repair timeline2-5sDependency graph computation
SIPmath distribution5-10sMetalog fitting
PDF report generation8-12sIncludes charts and tables

Cold starts add 30-60s on first request. Frontend displays animated progress indicator.


Troubleshooting

Common Issues

Symptom: "Assessment timed out after 90 seconds"

Causes:

  • Too many Monte Carlo realizations (>10,000)
  • Modal cold start (first request)
  • Backend overload (multiple simultaneous requests)

Solutions:

  1. Reduce num_realizations to 5,000 or less
  2. Wait for cold start to complete (~60s)
  3. Check Modal service health: GET /health
  4. Retry assessment after 2-3 minutes

Symptom: "Building type 'XYZ' not found in FEMA P-58 library"

Causes:

  • Invalid HAZUS building code
  • Custom building type not yet supported

Solutions:

  1. Use standard HAZUS codes (W1, S1L, C2M, etc.)
  2. Refer to "Building Types" section for valid codes
  3. For custom types, select closest equivalent
  4. Contact support to add new building types

Symptom: Red alert "High collapse probability (>20%)"

Meaning:

  • Building has >20% probability of structural collapse
  • Casualty estimates may be high
  • Total loss likely exceeds 80% replacement value

Actions:

  1. Review hazard intensity (may be extreme scenario)
  2. Check building design level (Pre-code buildings at highest risk)
  3. Review mitigation recommendations
  4. Consider retrofit or replacement

Symptom: "SLURP export not available"

Causes:

  • Assessment used deterministic inputs (not probabilistic)
  • Less than 1,000 Monte Carlo realizations
  • Export feature disabled in analysis options

Solutions:

  1. Re-run assessment with num_realizations >= 1000
  2. Enable SIPmath in analysis options
  3. Wait for assessment to complete fully
  4. Download from "SIPmath Distribution" tab

API Error Codes

CodeStatusDescriptionResolution
PELICUN_001400Invalid property characteristicsCheck lat/lng, building_type, replacement_value
PELICUN_002400Invalid hazard parametersVerify PGA, inundation_depth, wind_speed ranges
PELICUN_003400Missing required fieldsInclude all required fields in request body
PELICUN_004404Assessment not foundCheck assessment_id is correct
PELICUN_005422Building type not in libraryUse standard HAZUS building codes
PELICUN_006500PELICUN engine errorRetry request; check Modal logs
PELICUN_007503Service unavailable (cold start)Wait 60s and retry
PELICUN_008504Assessment timeoutReduce num_realizations or retry

Further Reading



Need Help? PELICUN assessments are complex. Contact the PublicRisk.ai support team for guidance on building types, hazard scenarios, or result interpretation.

On this page