Download backend/simulation.py from m4az19/saef-api: direct link, hf CLI and curl.
- Browser
- Download file 7.47 kB
-
https://huggingface.co/spaces/m4az19/saef-api/resolve/main/backend/simulation.py
- Command line
-
hf download hf://spaces/m4az19/saef-api/backend/simulation.py
-
curl -L -o simulation.py https://huggingface.co/spaces/m4az19/saef-api/resolve/main/backend/simulation.py
7.47 kB
| """Conservative head-gradient routing prototype, not a shallow-water solver.""" | |
| import numpy as np | |
| from pydantic import BaseModel, Field, model_validator, ConfigDict | |
| from typing import Optional | |
| from rasterio.features import rasterize | |
| from rasterio.warp import transform_geom | |
| from shapely.geometry import shape | |
| from shapely.ops import transform as shape_transform | |
| from pyproj import Transformer | |
| from .geo import load_grid, polygons | |
| from .store import get, put, now, path_for | |
| class Scenario(BaseModel): | |
| model_config=ConfigDict(allow_inf_nan=False) | |
| terrain_id:str | |
| name:str=Field(default='Rainfall scenario',max_length=100) | |
| rainfall_mm_h:float=Field(default=35,ge=0,le=300) | |
| rainfall_series_mm_h:Optional[list[float]]=Field(default=None,min_length=1,max_length=6) | |
| rain_duration_min:float=Field(default=45,gt=0,le=360) | |
| infiltration_mm_h:float=Field(default=8,ge=0,le=200) | |
| runoff:float=Field(default=.65,ge=0,le=1) | |
| upstream_m3_s:float=Field(default=4,ge=0,le=500) | |
| duration_min:float=Field(default=90,gt=0,le=360) | |
| output_step_min:float=Field(default=5,ge=1,le=30) | |
| initial_depth_m:float=Field(default=.1,ge=0,le=5) | |
| geometry_id:Optional[str]=None | |
| infrastructure_id:Optional[str]=None | |
| depth_threshold_m:float=Field(default=.03,ge=.005,le=1) | |
| conductivity_m_s:float=Field(default=2.,gt=0,le=20) | |
| def frames_limit(self): | |
| if self.duration_min/self.output_step_min>120: raise ValueError('At most 120 output steps') | |
| if self.rainfall_series_mm_h is not None: | |
| if any(not np.isfinite(x) or not 0<=x<=300 for x in self.rainfall_series_mm_h):raise ValueError('Hourly rainfall must be finite and between 0 and 300 mm/h') | |
| if len(self.rainfall_series_mm_h)*60<self.rain_duration_min:raise ValueError('Hourly series must cover the entire rainfall duration') | |
| return self | |
| def simulate(cfg:Scenario): | |
| a,t,crs=load_grid(cfg.terrain_id); z=a['z']; valid=a['valid']; n,m=z.shape | |
| dx,dy=abs(t.a),abs(t.e); cell=dx*dy | |
| depth=np.zeros_like(z); initial_label='NONE' | |
| if cfg.geometry_id: | |
| g=get('geometries',cfg.geometry_id) | |
| gs=[transform_geom('EPSG:4326',crs,f['geometry']) for f in g['geojson']['features']] | |
| depth[rasterize([(g,1) for g in gs],out_shape=z.shape,transform=t).astype(bool)&valid]=cfg.initial_depth_m | |
| initial_label='MANUALLY EDITED INPUT' | |
| infra=get('assets',cfg.infrastructure_id) if cfg.infrastructure_id else None | |
| features=(infra or {}).get('geojson',{}).get('features',[]) | |
| projector=Transformer.from_crs(4326,crs,always_xy=True).transform | |
| infra_shapes=[shape_transform(projector,shape(f['geometry'])) for f in features] | |
| inlet=int(np.argmin(np.where(valid[0],z[0],np.inf))) | |
| if not valid[0].any() and cfg.upstream_m3_s: raise ValueError('No valid upstream boundary cells') | |
| volume0=float(depth.sum()*cell); inputs=0.; infiltrated=0.; outflow=0.; first={}; frames=[] | |
| all_depth=[]; elapsed=0. | |
| targets=list(np.arange(0,cfg.duration_min*60, cfg.output_step_min*60))+[cfg.duration_min*60] | |
| # Adaptive substep bound for diffusive exchange; donor limiting keeps nonnegative volume. | |
| stable=min(10.,.2*min(dx,dy)/cfg.conductivity_m_s) | |
| for target in targets: | |
| while elapsed<target-1e-8: | |
| dt=min(stable,target-elapsed,3600-(elapsed%3600)) | |
| rain_dt=max(0.,min(elapsed+dt,cfg.rain_duration_min*60)-elapsed) | |
| rain_rate=cfg.rainfall_series_mm_h[min(int(elapsed//3600),len(cfg.rainfall_series_mm_h)-1)] if cfg.rainfall_series_mm_h else cfg.rainfall_mm_h | |
| add=rain_rate/3.6e6*rain_dt*cfg.runoff | |
| depth[valid]+=add; inputs+=add*int(valid.sum())*cell | |
| if cfg.upstream_m3_s: | |
| depth[0,inlet]+=cfg.upstream_m3_s*dt/cell; inputs+=cfg.upstream_m3_s*dt | |
| loss=np.minimum(depth,cfg.infiltration_mm_h/3.6e6*dt)*valid | |
| depth-=loss; infiltrated+=float(loss.sum()*cell) | |
| head=z+depth | |
| # Four-neighbor edge exchange driven by water-surface head. Dry barriers cannot emit. | |
| qx=cfg.conductivity_m_s*(head[:,:-1]-head[:,1:])/dx*dt | |
| qy=cfg.conductivity_m_s*(head[:-1,:]-head[1:,:])/dy*dt | |
| qx*=valid[:,:-1]&valid[:,1:]; qy*=valid[:-1,:]&valid[1:,:] | |
| outgoing=np.zeros_like(depth) | |
| outgoing[:,:-1]+=np.maximum(qx,0); outgoing[:,1:]+=np.maximum(-qx,0) | |
| outgoing[:-1,:]+=np.maximum(qy,0); outgoing[1:,:]+=np.maximum(-qy,0) | |
| factor=np.minimum(1.,depth/np.maximum(outgoing,1e-12)) | |
| qx*=np.where(qx>=0,factor[:,:-1],factor[:,1:]); qy*=np.where(qy>=0,factor[:-1,:],factor[1:,:]) | |
| depth[:,:-1]-=qx; depth[:,1:]+=qx; depth[:-1,:]-=qy; depth[1:,:]+=qy | |
| # South open boundary with finite drainage speed; other boundaries closed. | |
| drained=np.minimum(depth[-1],depth[-1]*cfg.conductivity_m_s*dt/dy) | |
| depth[-1]-=drained; outflow+=float(drained.sum()*cell) | |
| depth=np.maximum(depth,0); elapsed+=dt | |
| mask=(depth>=cfg.depth_threshold_m)&valid | |
| fc=polygons(mask,t,crs,{'kind':'SIMULATED SCENARIO','time_min':target/60}) | |
| from shapely.ops import unary_union | |
| flooded=unary_union([shape_transform(projector,shape(f['geometry'])) for f in fc['features']]) | |
| exposed=[]; by_category={} | |
| for k,(f,s) in enumerate(zip(features,infra_shapes)): | |
| hit=s.intersects(flooded) if not flooded.is_empty else False | |
| fid=str(f.get('id',k)); category=f.get('properties',{}).get('category','custom') | |
| if hit: | |
| first.setdefault(fid,target/60); by_category[category]=by_category.get(category,0)+1 | |
| exposed.append({'id':fid,'name':f.get('properties',{}).get('name',f'{category} {fid}'),'category':category,'exposed':hit, | |
| 'distance_m':None if flooded.is_empty else round(s.distance(flooded),2),'first_exposure_min':first.get(fid)}) | |
| frames.append({'time_min':target/60,'area_km2':float(mask.sum()*cell/1e6),'max_depth_m':float(depth.max()), | |
| 'volume_m3':float(depth.sum()*cell),'exposed_count':sum(x['exposed'] for x in exposed),'by_category':by_category, | |
| 'exposure':exposed,'extent':fc,'rainfall_mm_h':(cfg.rainfall_series_mm_h[min(int(target//3600),len(cfg.rainfall_series_mm_h)-1)] if cfg.rainfall_series_mm_h else cfg.rainfall_mm_h) if target<cfg.rain_duration_min*60 else 0, | |
| 'warning_tier':'EXPERIMENTAL ELEVATED' if any(x['exposed'] for x in exposed) else 'NO MODELED INTERSECTION'}) | |
| all_depth.append(depth.astype('float32')) | |
| result=put('simulations',{'config':cfg.model_dump(),'created_at':now(),'frames':frames,'initial_input':initial_label, | |
| 'terrain_source':get('assets',cfg.terrain_id),'infrastructure_source':infra, | |
| 'provenance':'SIMULATED SCENARIO','model_version':'head-routing-1.0', | |
| 'mass_balance':{'initial_m3':volume0,'input_m3':inputs,'infiltration_m3':infiltrated,'outflow_m3':outflow,'final_m3':frames[-1]['volume_m3'], | |
| 'residual_m3':volume0+inputs-infiltrated-outflow-frames[-1]['volume_m3']}, | |
| 'warnings':['Research routing model, not validated flood prediction','Uniform assumed rainfall; no catchment calibration','South boundary open, other boundaries closed','Depth is model state, not measured inundation']}) | |
| np.savez_compressed(path_for(result['id'],'depth.npz'),depth=np.stack(all_depth)) | |
| return result | |