| """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) |
|
|
