Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
agentfem
finite-element-method
scientific-machine-learning
physics-ai
simulation
heat-transfer
License:
File size: 7,567 Bytes
d095916 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | """Reproducible AgentFEM small-problem dataset factory. SI units; serial MPI."""
import argparse, hashlib, json, time
from pathlib import Path
import numpy as np
import ufl
from mpi4py import MPI
from scipy.stats import qmc
from agentfem import mesh, models, fields, studies, constitutive, constraints
from agentfem.solvers import LinearSolverOptions
ROOT = Path(__file__).resolve().parent
SOLVER = LinearSolverOptions(ksp_type="preonly", pc_type="lu")
def run(kind, p, folder, refinement=1, analytical=False):
folder.mkdir(parents=True, exist_ok=True)
started = time.monotonic()
if kind == "heat":
L,H,k,x1,y1,x2,y2,s1,s2,q1,q2 = p
domain = mesh.rectangle((0,0),(L,H),(48*refinement,32*refinement),cell_type="triangle")
model = models.create(study=studies.steady_heat_transfer(dimension=2),mesh=domain)
f = model.field(fields.temperature(domain,value=300.))
model.material(constitutive.thermoelastic(young=200e9,poisson=.3,density=7800,
thermal_expansion=12e-6,conductivity=k,specific_heat=500,reference_temperature=300))
boundary = mesh.boundary(domain,lambda x: np.isclose(x[0],0)|np.isclose(x[0],L)|np.isclose(x[1],0)|np.isclose(x[1],H),tag=1)
model.fix(f,on=boundary,value=300.)
x=ufl.SpatialCoordinate(domain)
source = (k*((np.pi/L)**2+(np.pi/H)**2)*10*ufl.sin(np.pi*x[0]/L)*ufl.sin(np.pi*x[1]/H)
if analytical else q1*ufl.exp(-((x[0]-x1*L)**2+(x[1]-y1*H)**2)/(2*s1*s1))+q2*ufl.exp(-((x[0]-x2*L)**2+(x[1]-y2*H)**2)/(2*s2*s2)))
model.heat_source(source)
else:
if kind == "cylinder":
a,b,E,nu,pressure = p
domain=mesh.rectangle((a,0),(b,.02),(24*refinement,2*refinement),cell_type="quadrilateral")
study=studies.static_solid(dimension=2,assumption="axisymmetric")
else:
import gmsh
L,H,r,E,nu,traction=p
if not gmsh.isInitialized(): gmsh.initialize()
gmsh.clear(); gmsh.option.setNumber("General.Terminal",0)
gmsh.model.add("double_edge_notch")
plate=gmsh.model.occ.addRectangle(0,0,0,L,H)
c1=gmsh.model.occ.addDisk(L/2,0,0,r,r)
c2=gmsh.model.occ.addDisk(L/2,H,0,r,r)
surfaces,_=gmsh.model.occ.cut([(2,plate)],[(2,c1),(2,c2)])
gmsh.model.occ.synchronize()
gmsh.model.addPhysicalGroup(2,[t for d,t in surfaces],1)
gmsh.option.setNumber("Mesh.MeshSizeMin",H/(40*refinement))
gmsh.option.setNumber("Mesh.MeshSizeMax",H/(20*refinement))
gmsh.model.mesh.generate(2)
domain=mesh.import_gmsh_model(gmsh.model,gdim=2).domain
study=studies.static_solid(dimension=2,assumption="plane_stress")
model=models.create(study=study,mesh=domain)
f=model.field(fields.displacement(domain,degree=2))
model.material(constitutive.isotropic_elastic(young=E,poisson=nu,density=7800))
if kind=="cylinder":
model.constraint(constraints.axisymmetric_plane_strain(f))
boundary=mesh.face(domain,axis="x",value=a,tag=1)
model.pressure(pressure,on=boundary)
else:
left=mesh.boundary(domain,lambda x:np.isclose(x[0],0),tag=1)
right=mesh.boundary(domain,lambda x:np.isclose(x[0],L),tag=2)
model.fix(f,on=left,value=0.)
model.traction((traction,0.),on=right)
result=model.step(target=f,solver_options=SOLVER,output=folder/"fields.xdmf").solve_result()
result.verify("engineering").require()
result.write_manifest(folder/"result.json")
coords=f.value.function_space.tabulate_dof_coordinates()
values=f.value.x.array.reshape(len(coords),-1).copy()
assert np.isfinite(values).all()
np.savez_compressed(folder/"field.npz",coordinates_m=coords,values=values)
info={"parameters":list(map(float,p)),"refinement":refinement,"seconds":time.monotonic()-started,
"field_dofs":int(values.size),"max_field":float(np.max(np.linalg.norm(values,axis=1))) if kind!="heat" else float(values.max()),
"min_field":float(values.min())}
if kind=="cylinder":
r=coords[:,0]; A=pressure*a*a/(b*b-a*a); B=pressure*a*a*b*b/(b*b-a*a)
exact=(1+nu)/E*((1-2*nu)*A*r+B/r)
info["relative_nodal_l2_error"]=float(np.linalg.norm(values[:,0]-exact)/np.linalg.norm(exact))
assert info["relative_nodal_l2_error"]<.001
if kind=="heat" and analytical:
exact=10*np.sin(np.pi*coords[:,0]/L)*np.sin(np.pi*coords[:,1]/H)
info["relative_nodal_l2_error"]=float(np.linalg.norm(values[:,0]-300-exact)/np.linalg.norm(exact))
assert info["relative_nodal_l2_error"]<.01
(folder/"sample.json").write_text(json.dumps(info,indent=2))
return info
def parameters(kind,n):
bounds={"heat":([.08,.05,15,.15,.15,.55,.55,.004,.004,1e6,1e6],[.16,.1,200,.45,.45,.85,.85,.012,.012,8e6,8e6]),
"notch":([.12,.04,.12,70e9,.22,10e6],[.2,.07,.30,210e9,.34,50e6]),
"cylinder":([.02,1.3,70e9,.22,1e6],[.08,2.8,210e9,.34,20e6])}
low,high=bounds[kind]
vals=qmc.scale(qmc.Sobol(len(low),scramble=True,seed=20260923).random_base2(int(np.log2(n))),low,high)
if kind=="notch": vals[:,2]*=vals[:,1]
if kind=="cylinder": vals[:,1]*=vals[:,0]
return vals
if __name__=="__main__":
ap=argparse.ArgumentParser(); ap.add_argument("kind",choices=["heat","notch","cylinder"])
ap.add_argument("--count",type=int,default=256); ap.add_argument("--validate",action="store_true")
ap.add_argument("--refinement",type=int,default=1)
ap.add_argument("--start",type=int,default=0); ap.add_argument("--stop",type=int,default=None)
args=ap.parse_args(); assert args.count>0 and args.count&(args.count-1)==0
root=ROOT/"generated"/(args.kind if args.refinement==1 else args.kind+f"_r{args.refinement}")
if args.validate:
p=parameters(args.kind,4)[0]
a=run(args.kind,p,root/"validation"/"coarse",analytical=args.kind=="heat")
b=run(args.kind,p,root/"validation"/"fine",2,analytical=args.kind=="heat")
report={"coarse":a,"fine":b,"relative_max_field_change":abs(a["max_field"]-b["max_field"])/abs(b["max_field"])}
(root/"validation.json").write_text(json.dumps(report,indent=2)); print(json.dumps(report),flush=True)
else:
rows=[]
order=np.random.default_rng(20260924).permutation(args.count)
test=set(order[:args.count//8]); validation=set(order[args.count//8:args.count//4])
for i,p in enumerate(parameters(args.kind,args.count)):
if i<args.start or i>=(args.stop if args.stop is not None else args.count): continue
dest=root/"samples"/f"{i:05d}"
info=json.loads((dest/"sample.json").read_text()) if (dest/"sample.json").exists() else run(args.kind,p,dest,args.refinement)
info={"id":f"{i:05d}","split":"test" if i in test else "validation" if i in validation else "train",**info}
rows.append(info)
if i%16==0: print(args.kind,i+1,"/",args.count,flush=True)
paths=[root/"samples"/f"{i:05d}"/"sample.json" for i in range(args.count)]
if all(p.exists() for p in paths):
rows=[{"id":f"{i:05d}","split":"test" if i in test else "validation" if i in validation else "train",**json.loads(p.read_text())} for i,p in enumerate(paths)]
(root/"index.json").write_text(json.dumps(rows,indent=2))
print("COMPLETE",args.kind,len(rows),flush=True)
else: print("SHARD COMPLETE",args.kind,args.start,args.stop,flush=True)
|