toshi-hazard-post 0.7.1__py3-none-any.whl

scripts/calc_time.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+import sys
+
+def main(log_filepath):
+    log_filepath = Path(log_filepath)
+
+    times_jobtable = []
+    times_batchtable = []
+    times_calc = []
+    with log_filepath.open() as f:
+        for line in f.readlines():
+            if "starting" in line and "calculations with" in line:
+                nproc = int(line.split(' ')[-2])
+            elif "time to create batch table" in line:
+                times_batchtable.append(float(line.split(' ')[-2]))
+            elif "time to create job table" in line:
+                times_jobtable.append(float(line.split(' ')[-2]))
+            elif "time to perform one aggregation" in line:
+                times_calc.append(float(line.split(' ')[-2]))
+            elif "time to perform aggregations after job setup" in line:
+                total_time = float(line.split(' ')[-1])
+
+    print(f"Number of workers: {nproc}")
+    print(f"Total number of partitions used: {len(times_batchtable)}")
+    print(f"Total number of aggregate calculations: {len(times_calc)}")
+    print(f"Mean Partition Table Creation Time: {sum(times_batchtable)/len(times_batchtable):.02f} seconds")
+    print(f"Mean Job Table Creation Time: {sum(times_jobtable)/len(times_jobtable):.02f} seconds")
+    print(f"Mean Agg Calc Time: {sum(times_calc)/len(times_calc):.02f} seconds")
+    print(f"Total Time: {total_time} seconds")
+    print(f"Mean time per calculation (including I/O): {nproc * total_time/len(times_calc):.02f} CPU seconds")
+
+if __name__ == "__main__":
+    filepath = sys.argv[1]
+    main(filepath)

scripts/cli.py

@@ -0,0 +1,36 @@
+import logging
+import os
+
+import click
+
+from toshi_hazard_post.aggregation import run_aggregation
+from toshi_hazard_post.aggregation_args import load_input_args
+import toshi_hazard_store
+
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logging.getLogger('toshi_hazard_post').setLevel(logging.INFO)
+# logging.getLogger('toshi_hazard_post.aggregation_calc').setLevel(logging.DEBUG)
+# logging.getLogger('toshi_hazard_post.aggregation').setLevel(logging.DEBUG)
+# logging.getLogger('toshi_hazard_post.aggregation_calc').setLevel(logging.DEBUG)
+# logging.getLogger('toshi_hazard_post.logic_tree').setLevel(logging.DEBUG)
+logging.getLogger('toshi_hazard_store').setLevel(logging.ERROR)
+logging.getLogger('toshi_hazard_post').setLevel(logging.INFO)
+
+
+@click.group()
+def thp():
+    pass
+
+
+@thp.command(name='aggregate', help='aggregate hazard curves')
+@click.argument('input_file', type=click.Path(exists=True))
+def aggregate(input_file):
+
+    args = load_input_args(input_file)
+    click.echo("Toshi Hazard Post: hazard curve aggregation")
+    click.echo("=================================================")
+    run_aggregation(args)
+
+
+if __name__ == "__main__":
+    thp()  # pragma: no cover

scripts/cli_old.py

@@ -0,0 +1,213 @@
+"""Console script for toshi_hazard_post."""
+
+import logging
+import os
+import sys
+
+import click
+import toml
+from toshi_hazard_store.model import migrate as migrate_ths
+
+# from toshi_hazard_post.hazard_aggregation import AggregationConfig, process_aggregation, process_deaggregation
+from toshi_hazard_post.hazard_aggregation.aggregation import process_aggregation
+from toshi_hazard_post.hazard_aggregation.aggregation_config import AggregationConfig
+from toshi_hazard_post.hazard_aggregation.aws_aggregation import distribute_aggregation, push_test_message
+from toshi_hazard_post.hazard_aggregation.aws_deaggregation import distribute_deaggregation
+from toshi_hazard_post.hazard_aggregation.deaggregation import process_deaggregation
+from toshi_hazard_post.hazard_grid.aws_gridded_hazard import distribute_gridded_hazard
+from toshi_hazard_post.hazard_grid.gridded_hazard import calc_gridded_hazard
+from toshi_hazard_post.hazard_grid.misc import get_filter_locations, get_site_lists, migrate
+
+log = logging.getLogger()
+logging.basicConfig(level=logging.INFO)
+logging.getLogger('nshm_toshi_client.toshi_client_base').setLevel(logging.INFO)
+logging.getLogger('urllib3').setLevel(logging.INFO)
+logging.getLogger('botocore').setLevel(logging.INFO)
+logging.getLogger('pynamodb').setLevel(logging.INFO)
+logging.getLogger('toshi_hazard_post').setLevel(logging.INFO)
+logging.getLogger('toshi_hazard_store').setLevel(logging.INFO)
+logging.getLogger('gql.transport.requests').setLevel(logging.WARN)
+
+formatter = logging.Formatter(fmt='%(asctime)s %(levelname)-8s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+screen_handler = logging.StreamHandler(stream=sys.stdout)
+screen_handler.setFormatter(formatter)
+log.addHandler(screen_handler)
+
+
+@click.group()
+def thp():
+    pass
+
+
+@thp.command(name='build-grid', help='calculate hazard grids used to create maps')
+@click.option('-H', '--hazard_model_ids', help='comma-delimted list of hazard model ids.')
+@click.option('-L', '--site-list', help='A site list ENUM.')
+@click.option('-I', '--imts', help='comma-delimited list of imts.')
+@click.option('-A', '--aggs', help='comma-delimited list of aggs.')
+@click.option('-V', '--vs30s', help='comma-delimited list of vs30s.')
+@click.option('-P', '--poes', help='comma-delimited list of poe_levels.')
+@click.option('-c', '--config', type=click.Path(exists=True))  # help="path to a valid THU configuration file."
+@click.option('-lsl', '--list-site-lists', help='print the list of sites list ENUMs and exit', is_flag=True)
+@click.option('-v', '--verbose', is_flag=True)
+@click.option('-d', '--dry-run', is_flag=True)
+@click.option('-m', '--migrate-tables', is_flag=True)
+@click.option('-f', '--force', is_flag=True)
+@click.option(
+    '--mode',
+    '-m',
+    default='LOCAL',
+    type=click.Choice(['AWS_BATCH', 'LOCAL'], case_sensitive=True),
+)
+@click.option(
+    '--iter-method',
+    '-i',
+    default='product',
+    type=click.Choice(['product', 'zip'], case_sensitive=True),
+)
+@click.option('-w', '--num-workers', default=4, show_default=True)
+def cli_gridded_hazard(
+    hazard_model_ids,
+    site_list,
+    imts,
+    aggs,
+    vs30s,
+    poes,
+    config,
+    list_site_lists,
+    verbose,
+    dry_run,
+    migrate_tables,
+    force,
+    mode,
+    iter_method,
+    num_workers,
+):
+    """Process gridded hazard for a given set of arguments."""
+
+    if list_site_lists:
+        click.echo("ENUM name\tDetails")
+        click.echo("===============\t======================================================================")
+        for rg in get_site_lists():
+            click.echo(f"{rg.name}\t{rg.value}")
+        return
+
+    # site_lists = site_lists.split(',') if site_lists else None
+
+    hazard_model_ids = hazard_model_ids.split(',') if hazard_model_ids else None
+    vs30s = vs30s.split(',') if vs30s else None
+    imts = imts.split(',') if imts else None
+    aggs = aggs.split(',') if aggs else None
+    poes = poes.split(',') if poes else None
+    filter_sites = None
+
+    if config:
+        conf = toml.load(config)
+        if verbose:
+            click.echo(f"using settings in {config} for export")
+
+        site_list = site_list or conf.get('site_list')
+        hazard_model_ids = hazard_model_ids or conf.get('hazard_model_ids')
+        imts = imts or conf.get('imts')
+        vs30s = vs30s or conf.get('vs30s')
+        aggs = aggs or conf.get('aggs')
+        poes = poes or conf.get('poes')
+        filter_sites = filter_sites or conf.get('filter_sites')
+
+    if verbose:
+        click.echo(f"{hazard_model_ids} {imts} {vs30s}")
+
+    if dry_run:
+        click.echo(f"dry-run {site_list} {hazard_model_ids} {imts} {vs30s}")
+        return
+
+    if migrate_tables:
+        click.echo("Ensuring that dynamodb tables are available in target region & stage.")
+        migrate()
+
+    if mode == "LOCAL":
+        try:
+            click.echo(filter_sites)
+            filter_locations = get_filter_locations(filter_sites)
+            click.echo(filter_locations)
+            calc_gridded_hazard(
+                location_grid_id=site_list,
+                poe_levels=poes,
+                hazard_model_ids=hazard_model_ids,
+                vs30s=vs30s,
+                imts=imts,
+                aggs=aggs,
+                num_workers=num_workers,
+                force=force,
+                filter_locations=filter_locations,
+                iter_method=iter_method,
+            )
+        except Exception as err:
+            click.echo(err)
+            raise click.UsageError('An error occurred, pls check usage.')
+
+        # haggs = query_v3.get_hazard_curves(locations, vs30s, hazard_model_ids, imts=imts, aggs=aggs)
+        click.echo('Done!')
+    elif mode == "AWS_BATCH":
+        try:
+            click.echo(filter_sites)
+            filter_locations = get_filter_locations(filter_sites)
+            click.echo(filter_locations)
+            distribute_gridded_hazard(
+                location_grid_id=site_list,
+                poe_levels=poes,
+                hazard_model_ids=hazard_model_ids,
+                vs30s=vs30s,
+                imts=imts,
+                aggs=aggs,
+                force=force,
+                filter_locations=filter_locations,
+                iter_method=iter_method,
+            )
+        except Exception as err:
+            click.echo(err)
+            raise click.UsageError('An error occurred, pls check usage.')
+
+
+@thp.command(name='aggregate', help='aggregate hazard curves or disaggregations')
+@click.option(
+    '--mode',
+    '-m',
+    default=lambda: os.environ.get("NZSHM22_THP_MODE", 'LOCAL'),
+    type=click.Choice(['AWS', 'AWS_BATCH', 'LOCAL'], case_sensitive=True),
+)
+@click.option('--deagg', '-d', is_flag=True)
+@click.option('--push-sns-test', '-pt', is_flag=True)
+@click.option('--migrate-tables', '-M', is_flag=True)
+@click.argument('config', type=click.Path(exists=True))  # help="path to a valid THP configuration file."
+def aggregate(config, mode, deagg, push_sns_test, migrate_tables):
+    """Main entrypoint."""
+    click.echo("Hazard post-processing pipeline as serverless AWS infrastructure.")
+    click.echo(f"mode: {mode}")
+
+    agconf = AggregationConfig(config)
+    # click.echo(agconf)
+    # log.info("Doit")
+
+    if push_sns_test:
+        push_test_message()
+        return
+
+    if mode == 'LOCAL':
+        if deagg:
+            process_deaggregation(agconf)
+        else:
+            process_aggregation(agconf)
+        return
+    if 'AWS_BATCH' in mode:  # TODO: multiple vs30s
+        if migrate_tables:
+            click.echo("Ensuring that dynamodb tables are available in target region & stage.")
+            migrate_ths()
+        if deagg:
+            distribute_deaggregation(agconf, mode)
+        else:
+            distribute_aggregation(agconf, mode)
+        return
+
+
+if __name__ == "__main__":
+    thp()  # pragma: no cover

scripts/container_task.sh

@@ -0,0 +1,5 @@
+# This is the AWS CONTAINER SCRIPT
+
+cd /app
+python3 -m ${PYTHON_TASK_MODULE} ${TASK_CONFIG_JSON_QUOTED}
+#END_OF_SCRIPT

toshi_hazard_post/__init__.py

@@ -0,0 +1,6 @@
+"""This is the top-level package for toshi_hazard_post.
+
+This application calculates seismic hazard from pre-calculated realizations.
+"""
+
+__version__ = '0.7.1'

toshi_hazard_post/aggregation.py

@@ -0,0 +1,174 @@
+"""Module for coordinating and launching aggregation jobs."""
+
+import itertools
+import logging
+import sys
+import time
+from concurrent.futures import Executor, ProcessPoolExecutor, as_completed
+from multiprocessing import shared_memory
+from pathlib import Path
+from typing import TYPE_CHECKING, Generator, Optional
+
+import numpy as np
+import pyarrow.orc as orc
+from nzshm_common.location.coded_location import bin_locations
+
+import toshi_hazard_post.constants as constants
+from toshi_hazard_post.aggregation_args import AggregationArgs
+from toshi_hazard_post.aggregation_calc import AggSharedArgs, AggTaskArgs, calc_aggregation
+from toshi_hazard_post.aggregation_setup import Site, get_logic_trees, get_sites
+from toshi_hazard_post.data import get_batch_table, get_job_datatable, get_realizations_dataset
+from toshi_hazard_post.local_config import NUM_WORKERS, WORKING_DIR
+from toshi_hazard_post.logic_tree import HazardLogicTree
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
+    from nzshm_common.location import CodedLocation
+
+    from toshi_hazard_post.logic_tree import HazardComponentBranch
+
+
+log = logging.getLogger(__name__)
+
+PARTITION_RESOLUTION = 1.0
+
+
+def _generate_agg_jobs(
+    sites: list[Site],
+    imts: list[str],
+    compatibility_key: str,
+    component_branches: list['HazardComponentBranch'],
+) -> Generator[tuple[int, 'CodedLocation', str, Path], None, None]:
+
+    gmms_digests = [branch.gmcm_hash_digest for branch in component_branches]
+    sources_digests = [branch.source_hash_digest for branch in component_branches]
+    n_expected = len(component_branches)
+
+    # group locations by vs30
+    vs30s_unique = set([site.vs30 for site in sites])
+
+    log.info("creating batches from %s sites and %s vs30s" % (len(sites), len(vs30s_unique)))
+    for vs30 in vs30s_unique:
+        locations = [site.location for site in sites if site.vs30 == vs30]
+        location_bins = bin_locations(locations, PARTITION_RESOLUTION)
+        for nloc_0, location_bin in location_bins.items():
+            dataset = get_realizations_dataset(vs30, nloc_0)
+            log.info("batch %d, %s" % (vs30, nloc_0))
+            batch_datatable = get_batch_table(
+                dataset, compatibility_key, sources_digests, gmms_digests, vs30, nloc_0, imts
+            )
+            for location, imt in itertools.product(location_bin.locations, imts):
+                job_datatable = get_job_datatable(batch_datatable, location, imt, n_expected)
+                filepath = Path(WORKING_DIR) / f"{vs30}_{nloc_0}_{location.downsample(0.001).code}_{imt}_dataset.dat"
+                log.debug("writing file %s for agg job %s, %s" % (filepath, location.code, imt))
+                t0 = time.perf_counter()
+                orc.write_table(job_datatable, filepath, compression='snappy')
+                t1 = time.perf_counter()
+                log.debug("time to write data: %0.5f seconds" % (t1 - t0))
+                yield vs30, location, imt, filepath
+
+
+def run_aggregation(args: AggregationArgs, pool_executor: Optional[Executor] = None) -> None:
+    """Main entry point for running aggregation caculations.
+
+    Args:
+        args: the aggregation configuration
+        pool_executor: the Executor (e.g. ProcessPoolExecutor) to use for launching the parallel tasks. If
+            none given, ProcessPoolExecutor(max_workers=NUM_WORKERS) is used
+    """
+    time0 = time.perf_counter()
+    # get the sites
+    log.info("getting sites . . .")
+    sites = get_sites(args.site_params.locations_file, args.site_params.locations, args.site_params.vs30s)
+    srm_logic_tree, gmcm_logic_tree = get_logic_trees(
+        args.hazard_model.nshm_model_version,
+        args.hazard_model.srm_logic_tree,
+        args.hazard_model.gmcm_logic_tree,
+    )
+
+    # create the logic tree objects and build the full logic tree
+    log.info("getting logic trees . . . ")
+    logic_tree = HazardLogicTree(srm_logic_tree, gmcm_logic_tree)
+    component_branches = logic_tree.component_branches
+
+    if not args.debug.restart:
+        log.info("calculating weights and branch hash table . . . ")
+        tic = time.perf_counter()
+        weights = logic_tree.weights
+        branch_hash_table: list | 'npt.NDArray' = logic_tree.branch_hash_table
+        toc = time.perf_counter()
+
+        log.info('time to build weight array and hash table %0.2f seconds' % (toc - tic))
+        log.info("Size of weight array: {}MB".format(weights.nbytes >> 20))
+        log.info("Size of hash table: {}MB".format(sys.getsizeof(branch_hash_table) >> 20))
+    else:
+        branch_hash_table = np.load(args.debug.restart[0])
+        weights = np.load(args.debug.restart[1])
+
+    agg_types = [a.value for a in args.calculation.agg_types]
+    imts = [i.value for i in args.calculation.imts]
+
+    weights_shm = shared_memory.SharedMemory(name=constants.WEIGHTS_SHM_NAME, create=True, size=weights.nbytes)
+    branch_hash_table = np.array(branch_hash_table)
+    branch_hash_table_shm = shared_memory.SharedMemory(
+        name=constants.BRANCH_HASH_TABLE_SHM_NAME, create=True, size=branch_hash_table.nbytes
+    )
+
+    bht: 'npt.NDArray' = np.ndarray(
+        branch_hash_table.shape, dtype=branch_hash_table.dtype, buffer=branch_hash_table_shm.buf
+    )
+    bht[:] = branch_hash_table[:]
+    wgt: 'npt.NDArray' = np.ndarray(weights.shape, dtype=weights.dtype, buffer=weights_shm.buf)
+    wgt[:] = weights[:]
+
+    shared_args = AggSharedArgs(
+        weights_shape=weights.shape,
+        branch_hash_table_shape=branch_hash_table.shape,
+        agg_types=agg_types,
+        hazard_model_id=args.general.hazard_model_id,
+        compatibility_key=args.general.compatibility_key,
+        skip_save=args.debug.skip_save,
+    )
+
+    time_parallel_start = time.perf_counter()
+    num_jobs = 0
+    log.info("starting %d calculations with %d workers" % (len(sites) * len(imts), NUM_WORKERS))
+
+    futures = {}
+    # ds1 = get_realizations_dataset()
+    pool_executor = pool_executor or ProcessPoolExecutor(max_workers=NUM_WORKERS)
+    with pool_executor as executor:
+        for vs30, location, imt, filepath in _generate_agg_jobs(
+            sites,
+            imts,
+            args.general.compatibility_key,
+            component_branches,
+            # ds1,
+        ):
+            task_args = AggTaskArgs(
+                location=location,
+                vs30=vs30,
+                imt=imt,
+                table_filepath=filepath,
+            )
+            future = executor.submit(calc_aggregation, task_args, shared_args)
+            futures[future] = task_args
+            num_jobs += 1
+
+        num_failed = 0
+        for future in as_completed(futures.keys()):
+            if exception := future.exception():
+                num_failed += 1
+                log.error("Exception encountered for task args %s: %s" % (futures[future], repr(exception)))
+
+    time_parallel_end = time.perf_counter()
+    branch_hash_table_shm.close()
+    branch_hash_table_shm.unlink()
+    weights_shm.close()
+    weights_shm.unlink()
+
+    time1 = time.perf_counter()
+    log.info("total time: processed %d calculations in %0.3f seconds" % (num_jobs, time1 - time0))
+    log.info("time to perform aggregations after job setup %0.3f" % (time_parallel_end - time_parallel_start))
+
+    print(f"THERE ARE {num_failed} FAILED JOBS . . . ")

toshi_hazard_post/aggregation_args.py

@@ -0,0 +1,215 @@
+"""This module defines pydantic classes and functions for the aggregation calculation configuration.
+
+Members:
+    AggregationArgs: pydantic class for aggregation configuration arguments.
+    load_input_args: function to return an AggregationArgs object built from a toml file.
+"""
+
+import csv
+from collections import namedtuple
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import tomlkit
+from nzshm_model import all_model_versions
+from pydantic import AfterValidator, BaseModel, FilePath, PositiveInt, ValidationInfo, field_validator, model_validator
+from toshi_hazard_store.model.constraints import AggregationEnum, IntensityMeasureTypeEnum
+from toshi_hazard_store.scripts.ths_import import chc_manager
+from typing_extensions import Annotated, Self
+
+
+def load_input_args(filepath: Union[str, Path]) -> 'AggregationArgs':
+    """Load the input arguments of a hazard aggregation calculation.
+
+    Args:
+        filepath: the path to the configuration toml file.
+
+    Returns:
+        The aggregation arguments.
+    """
+    config = tomlkit.parse(Path(filepath).read_text()).unwrap()
+    config['filepath'] = Path(filepath)
+    return AggregationArgs(**config)
+
+
+def _resolve_path(path: Union[Path, str], reference_filepath: Union[Path, str]) -> str:
+    path = Path(path)
+    if not path.is_absolute():
+        return str(Path(reference_filepath).parent / path)
+    return str(path)
+
+
+def _is_model_version(value: str) -> str:
+    if value not in all_model_versions():
+        raise ValueError("must specify valid nshm_model_version ({})".format(all_model_versions()))
+    return value
+
+
+def _is_compat_calc_id(compat_calc_id: str) -> str:
+    try:
+        chc_manager.load(compat_calc_id)
+    except FileNotFoundError:
+        raise ValueError("Compatible Hazard Calculation with unique ID {value} does not exist.")
+
+    return compat_calc_id
+
+
+class GeneralArgs(BaseModel):
+    """The general parameters of a hazard model.
+
+    Attributes:
+        compatibility_key: the toshi-hazard-store compatibility key
+        hazard_model_id: the name of the hazard model to use when storing result.
+    """
+
+    compatibility_key: Annotated[str, AfterValidator(_is_compat_calc_id)]
+    hazard_model_id: str
+
+
+class HazardModelArgs(BaseModel):
+    """The PSHA hazard model parameters.
+
+    Logic tree filepaths will override nshm_model_version logic trees.
+
+    Attributes:
+        nshm_model_version: the nzshm-model model version.
+        srm_logic_tree: the source logic tree filepath.
+        gmcm_logic_tree: the ground motion logic tree filepath.
+
+    """
+
+    nshm_model_version: Annotated[Optional[str], AfterValidator(_is_model_version)] = None
+    srm_logic_tree: Optional[FilePath] = None
+    gmcm_logic_tree: Optional[FilePath] = None
+
+    @model_validator(mode='after')
+    def _check_logic_trees(self) -> Self:
+        if not self.nshm_model_version and not (self.srm_logic_tree and self.gmcm_logic_tree):
+            raise ValueError(
+                """if nshm_model_version not specified, must provide both
+                gmcm_logic_tree and srm_logic_tree"""
+            )
+        return self
+
+
+class SiteArgs(BaseModel):
+    """Site parameters.
+
+    Restrictions:
+        - Must provide one of locations or locations_file but not both.
+        - vs30s must be provided as an attribute or in the locations file but not both.
+        - if vs30s are provided, they are treated as uniform for all sites.
+
+    Attributes:
+        vs30s:
+        locations:
+        locations_file:
+    """
+
+    vs30s: Optional[list[PositiveInt]] = None
+    locations: Optional[list[str]] = None
+    locations_file: Optional[FilePath] = None
+
+    @staticmethod
+    def _has_vs30(filepath: Path):
+        with filepath.open() as lf:
+            header = lf.readline()
+            if "vs30" in header:
+                return True
+        return False
+
+    @field_validator('locations_file', mode='after')
+    @classmethod
+    def _check_file_vs30s(cls, value: FilePath) -> FilePath:
+        with value.open() as loc_file:
+            site_reader = csv.reader(loc_file)
+            Site = namedtuple("Site", next(site_reader), rename=True)  # type:ignore
+            if 'vs30' in Site._fields:
+                for row in site_reader:
+                    site = Site(*row)
+                    try:
+                        vs30 = int(site.vs30)  # type:ignore
+                        assert vs30 > 0
+                    except ValueError:
+                        raise ValueError("not all vs30 values are valid {}".format(row))
+        return value
+
+    @model_validator(mode='after')
+    def _check_locations(self) -> Self:
+        if self.locations_file and self.locations:
+            raise ValueError("cannot specify both locations and locations_file")
+
+        if (not self.locations) and (not self.locations_file):
+            raise ValueError("must specify locations or locations_file")
+
+        file_has_vs30 = self.locations_file and self._has_vs30(self.locations_file)
+        if file_has_vs30 and self.vs30s:
+            raise ValueError("cannot specify both uniform and site-specific vs30s")
+        elif not file_has_vs30 and not self.vs30s:
+            raise ValueError("locations file must have vs30 column if uniform vs30s not provided")
+
+        return self
+
+
+class CalculationArgs(BaseModel):
+    """The calculation parameters.
+
+    Attributes:
+        imts: the intensity measure types.
+        agg_types: the aggregation types.
+    """
+
+    imts: list[IntensityMeasureTypeEnum] = [e for e in IntensityMeasureTypeEnum]
+    agg_types: list[AggregationEnum] = [e for e in AggregationEnum]
+
+
+class DebugArgs(BaseModel):
+    """The debugging parameters.
+
+    Attributes:
+        skip_save: set to True to skip saving the aggregations.
+        restart: tuple of the paths to branch_hash_table and weights numpy files used to quickly start a
+            calculation without needing to rebuild the logic tree.
+    """
+
+    skip_save: bool = False
+    restart: Optional[tuple[FilePath, FilePath]] = None
+
+
+class AggregationArgs(BaseModel):
+    """The arguments needed to setup a suite of aggregation calculations.
+
+    Attributes:
+        filepath: the location of the config file, used to resolve relative paths.
+        general: the general arguments.
+        hazard_model: the arguments for the hazard model specification.
+        site_params: the site parameters.
+        calculation: the calculation parameters.
+        debug: the debugging parameters.
+    """
+
+    filepath: FilePath
+    general: GeneralArgs
+    hazard_model: HazardModelArgs
+    site_params: SiteArgs
+    calculation: CalculationArgs
+    debug: DebugArgs = DebugArgs()
+
+    # resolve absolute paths (relative to input file) for optional logic tree and config fields
+    @field_validator('hazard_model', mode='before')
+    @classmethod
+    def _absolute_model_paths(cls, data: Any, info: ValidationInfo) -> Any:
+        if isinstance(data, dict):
+            for key in ["srm_logic_tree", "gmcm_logic_tree"]:
+                if data.get(key):
+                    data[key] = _resolve_path(data[key], info.data["filepath"])
+        return data
+
+    # resolve absolute paths (relative to input file) for optional site file
+    @field_validator('site_params', mode='before')
+    @classmethod
+    def _absolute_site_path(cls, data: Any, info: ValidationInfo) -> Any:
+        if isinstance(data, dict):
+            if data.get("locations_file"):
+                data["locations_file"] = _resolve_path(data["locations_file"], info.data["filepath"])
+        return data