Workflow Parameters Reference¶

# High-resolution analysis for complex terrain
parameters = {
    'step': 3.0,  # 3-minute intervals
    'num_threads': 8
}

# Regional assessment with moderate resolution
parameters = {
    'step': 15.0,  # 15-minute intervals (default)
    'num_threads': 4
}

# Winter (clearer atmosphere)
winter_params = {'linke_value': 2.5}

# Summer (more water vapor and aerosols)
summer_params = {'linke_value': 3.5}

# Monsoon/humid season
humid_params = {'linke_value': 4.5}

# Forest analysis
forest_params = {
    'albedo_value': 0.15,
    'linke_value': 2.8  # Some canopy filtering
}

# Snow-covered terrain
snow_params = {
    'albedo_value': 0.85,
    'linke_value': 2.0  # Clear winter air
}

# Urban environment
urban_params = {
    'albedo_value': 0.12,
    'linke_value': 4.5  # Urban pollution
}

# Estimated processing times (10km x 10km @ 10m resolution)
# 1 thread:  ~4 hours
# 4 threads: ~1 hour (default)
# 8 threads: ~35 minutes
# 16 threads: ~20 minutes (diminishing returns)

# Summer solstice analysis
params = {'day': 172}  # June 21 (day 172)

# Winter solstice analysis  
params = {'day': 355}  # December 21 (day 355)

# Single year analysis
params = {
    'start_year': 2020,
    'end_year': 2020
}

# 5-year climatology
params = {
    'start_year': 2016,
    'end_year': 2020
}

# Long-term analysis (30+ years)
params = {
    'start_year': 1990,
    'end_year': 2020,
    'num_threads': 16  # Use more threads for large datasets
}

# Tight boundary (minimize download)
params = {'climate_buffer': 0.01}

# Include surrounding area for edge effects
params = {'climate_buffer': 0.25}

# Simple regional assessment
params = {'eemt_method': 'traditional'}

# Mountain watershed analysis
params = {'eemt_method': 'topographic'}

# Ecosystem carbon studies
params = {'eemt_method': 'vegetation'}

# Temperature-limited
NPP_t = 3000 * (1 - exp(1.315 - 0.119 * T))

# Precipitation-limited  
NPP_p = 3000 * (1 - exp(-0.000664 * P))

# Actual NPP (minimum)
NPP = min(NPP_t, NPP_p)

# Based on evapotranspiration
NPP = 3000 * (AET / PET)

# No compression (fastest write, largest files)
params = {'output_compression': 'none'}

# LZW (good balance, wide support)
params = {'output_compression': 'lzw'}

# Deflate (better compression, slower)
params = {'output_compression': 'deflate'}

# Zstd (best compression, newest)
params = {'output_compression': 'zstd'}

# Maintain input resolution
params = {}  # Default behavior

# Aggregate to coarser resolution
params = {'output_resolution': 30.0}  # 30m output

# Regional product
params = {'output_resolution': 100.0}  # 100m output

def validate_parameters(params: dict, workflow_type: str) -> dict:
    """Validate and sanitize workflow parameters"""

    # Common validations
    if params.get('step'):
        assert 3.0 <= params['step'] <= 60.0

    if params.get('linke_value'):
        assert 1.0 <= params['linke_value'] <= 8.0

    if params.get('albedo_value'):
        assert 0.0 <= params['albedo_value'] <= 1.0

    if params.get('num_threads'):
        assert 1 <= params['num_threads'] <= 32

    # EEMT-specific validations
    if workflow_type == 'eemt':
        assert params.get('start_year'), "start_year required for EEMT"
        assert params.get('end_year'), "end_year required for EEMT"
        assert params['start_year'] <= params['end_year']
        assert 1980 <= params['start_year'] <= 2024
        assert 1980 <= params['end_year'] <= 2024

    return params

high_accuracy = {
    'step': 3.0,
    'linke_value': 3.0,
    'albedo_value': 0.2,
    'num_threads': 16,
    'beam_rad': True,
    'diff_rad': True,
    'refl_rad': True
}

quick_regional = {
    'step': 30.0,
    'linke_value': 3.0,
    'albedo_value': 0.2,
    'num_threads': 4,
    'output_resolution': 100.0,
    'output_compression': 'lzw'
}

climate_analysis = {
    'start_year': 1990,
    'end_year': 2020,
    'step': 15.0,
    'eemt_method': 'topographic',
    'daymet_variables': ['tmin', 'tmax', 'prcp', 'vp', 'srad'],
    'output_format': 'netcdf'
}

snow_watershed = {
    'step': 10.0,
    'linke_value': 2.5,  # Clear mountain air
    'albedo_value': 0.65,  # Snow average
    'start_year': 2020,
    'end_year': 2020,
    'daymet_variables': ['tmin', 'tmax', 'prcp', 'swe'],
    'slope_threshold': 35.0  # Avalanche consideration
}

def estimate_memory(dem_size_mb: float, params: dict) -> float:
    """Estimate memory requirements in GB"""

    base_memory = 2.0  # OS and runtime

    # DEM memory (multiple copies for processing)
    dem_memory = dem_size_mb * 4 / 1024  

    # Thread memory (2GB per thread)
    thread_memory = params.get('num_threads', 4) * 2

    # Time series memory (for EEMT)
    if params.get('start_year'):
        years = params['end_year'] - params['start_year'] + 1
        timeseries_memory = dem_size_mb * years * 365 / 1024
    else:
        timeseries_memory = 0

    return base_memory + dem_memory + thread_memory + timeseries_memory

def estimate_runtime(dem_pixels: int, params: dict) -> float:
    """Estimate runtime in hours"""

    # Base rate: pixels per second per thread
    if params.get('step', 15) <= 5:
        rate = 1000  # High resolution
    elif params.get('step', 15) <= 15:
        rate = 5000  # Medium resolution
    else:
        rate = 10000  # Low resolution

    threads = params.get('num_threads', 4)

    # Solar workflow
    days = 365
    solar_time = (dem_pixels * days) / (rate * threads * 3600)

    # EEMT additions
    if params.get('start_year'):
        years = params['end_year'] - params['start_year'] + 1
        eemt_time = solar_time * years * 1.5  # Climate data overhead
    else:
        eemt_time = solar_time

    return eemt_time

# Enable verbose logging
debug_params = {
    'step': 15.0,
    'num_threads': 1,  # Single thread for debugging
    'verbose': True,
    'debug': True,
    'log_level': 'DEBUG'
}