source/components.py

"""Solid-FE mechanical ports using AgentFEM public operator assembly (serial).

Hexahedral Q2 displacement, linear-coordinate geometry. Cross sections at each
end are constrained to 6 rigid mechanical DOFs. Uniform radial thermal dilation
is superposed at the ports so free uniform expansion is not artificially blocked.
"""
from pathlib import Path
import json, time
import numpy as np
from scipy import sparse, linalg
from scipy.sparse.linalg import splu, eigsh


def skew(r):
    x,y,z=r
    return np.array([[0,-z,y],[z,0,-x],[-y,x,0.]])


def section(kind,s,length,radius,stub):
    if kind=='straight':return np.array([s*length,0.,0.]),np.array([0.,1.,0.])
    if stub==0:
        a=s*np.pi/2
        return np.array([radius*np.sin(a),radius*(1-np.cos(a)),0.]),np.array([-np.sin(a),np.cos(a),0.])
    if s<=1/3:return np.array([3*s*stub,0.,0.]),np.array([0.,1.,0.])
    if s>=2/3:return np.array([stub+radius,radius+(3*s-2)*stub,0.]),np.array([-1.,0.,0.])
    a=(3*s-1)*np.pi/2
    return np.array([stub+radius*np.sin(a),radius*(1-np.cos(a)),0.]),np.array([-np.sin(a),np.cos(a),0.])


def tube_mesh(kind='straight', length=.8, radius=.4, diameter=.2, thickness=.012,
              ns=12, nt=16, nr=1,stub=0.):
    """Hex ordering follows Basix's tensor-product reference hexahedron."""
    points=[]; cells=[]
    def idx(i,j,k): return (i*(nr+1)+j)*nt+(k%nt)
    for i in range(ns+1):
        s=i/ns
        c,normal=section(kind,s,length,radius,stub)
        for j in range(nr+1):
            r=diameter/2-thickness+j/nr*thickness
            for k in range(nt):
                th=2*np.pi*k/nt
                points.append(c+r*(np.cos(th)*normal+np.sin(th)*np.array([0.,0.,1.])))
    for i in range(ns):
        for j in range(nr):
            for k in range(nt):
                cells.append([idx(i,j,k),idx(i+1,j,k),idx(i,j+1,k),idx(i+1,j+1,k),
                              idx(i,j,k+1),idx(i+1,j,k+1),idx(i,j+1,k+1),idx(i+1,j+1,k+1)])
    ports=np.array([[0.,0.,0.],section(kind,1,length,radius,stub)[0]])
    return np.array(points),np.array(cells,dtype=np.int64),ports


def assemble(spec):
    import basix.ufl
    from agentfem import mesh,models,studies,fields,constitutive
    xyz,cells,ports=tube_mesh(**{k:v for k,v in spec.items() if k in
                                ['kind','length','radius','diameter','thickness','ns','nt','nr','stub']})
    domain=mesh.from_arrays(cells=cells,coordinates=xyz,
                           coordinate_element=basix.ufl.element('Lagrange','hexahedron',1,shape=(3,)))
    model=models.create(study=studies.static_solid(dimension=3),mesh=domain,name=spec['id'])
    u=model.field(fields.displacement(domain,degree=2))
    model.material(constitutive.isotropic_elastic(young=spec.get('young',200e9),
                   poisson=.3,density=spec.get('density',7850.),name='reference_steel'))
    def csr(op):
        A=op.assemble_matrix(); a,b,c=A.getValuesCSR()
        result=sparse.csr_matrix((c.copy(),b.copy(),a.copy()),shape=A.getSize()); A.destroy()
        return result
    K=csr(model.stiffness(u)); M=csr(model.mass(u))
    X=u.function_space.tabulate_dof_coordinates()[:,:3]
    # Block size is 3: each scalar interpolation node carries a displacement vector.
    assert K.shape[0]==3*len(X)
    a=np.flatnonzero(np.isclose(X[:,0],0.,atol=1e-10))
    b=np.flatnonzero(np.isclose(X[:,0],ports[1,0],atol=1e-10)) if spec['kind']=='straight' else np.flatnonzero(np.isclose(X[:,1],ports[1,1],atol=1e-10))
    boundary_nodes=np.r_[a,b]
    boundary=np.array([3*i+c for i in boundary_nodes for c in range(3)])
    interior=np.setdiff1d(np.arange(K.shape[0]),boundary)
    B=np.zeros((len(boundary),12))
    radial=np.zeros(K.shape[0]); alpha=spec.get('alpha',12e-6)
    for n,node in enumerate(boundary_nodes):
        p=0 if n<len(a) else 1; r=X[node]-ports[p]
        B[n*3:n*3+3,p*6:p*6+3]=np.eye(3)
        B[n*3:n*3+3,p*6+3:p*6+6]=-skew(r)
        radial[3*node:3*node+3]=alpha*r
    Kii=K[interior][:,interior].tocsc(); lu=splu(Kii)
    C=np.zeros((K.shape[0],12)); C[boundary]=B
    C[interior]=-lu.solve((K[interior][:,boundary]@B))
    S=C.T@(K@C); S=(S+S.T)/2
    n_modes=spec.get('modes',8)
    ev,Phi=eigsh(Kii,k=n_modes,M=M[interior][:,interior],sigma=0.,which='LM',tol=1e-9)
    order=np.argsort(ev);ev=ev[order];Phi=Phi[:,order]
    modes=np.zeros((K.shape[0],n_modes)); modes[interior]=Phi
    T=np.column_stack([C,modes]); Kr=T.T@(K@T); Mr=T.T@(M@T)
    # K times the affine uniform-expansion displacement equals its exact thermal
    # load in this homogeneous linear solid. Port radial dilation is retained.
    ftemp=K@(alpha*X.ravel()); wT=radial.copy()
    wT[interior]=lu.solve((ftemp-K@radial)[interior])
    fT=C.T@(ftemp-K@radial)
    # Constraint modes make C^T K wT equal C^T K radial.
    fG=np.column_stack([M@np.tile(np.eye(3)[j],len(X)) for j in range(3)])
    wG=np.zeros((K.shape[0],3)); wG[interior]=lu.solve(fG[interior])
    g=C.T@fG
    # Rigid modes must have zero energy; translation load returns integrated mass.
    rigid=np.zeros((12,6))
    for p,c in enumerate(ports):
        rigid[p*6:p*6+3,:3]=np.eye(3)
        rigid[p*6:p*6+3,3:]=-skew(c)
        rigid[p*6+3:p*6+6,3:]=np.eye(3)
    metrics={'dofs':K.shape[0],'cells':len(cells),'rigid_residual':float(np.linalg.norm(S@rigid)/(np.linalg.norm(S)*np.linalg.norm(rigid))),
             'fixed_interface_hz':(np.sqrt(ev)/(2*np.pi)).tolist(),
             'mass_kg':float(np.tile([1.,0,0],len(X))@fG[:,0]),
             'stiffness_symmetry':float(sparse.linalg.norm(K-K.T)/sparse.linalg.norm(K))}
    # Ring averages define the centreline display recovery, not peak-stress data.
    ns=spec.get('ns',8); path=[]; R=[]; RT=[]; RG=[]; RM=[]
    for s in np.linspace(0,1,2*ns+1):
        center,normal=section(spec['kind'],s,spec['length'],spec['radius'],spec.get('stub',0))
        tangent=np.cross(normal,[0.,0.,1.]);dist=abs((X-center)@tangent)
        # Reject remote sections intersecting the same infinite cut plane.
        dist+=np.maximum(0,np.linalg.norm(X-center,axis=1)-spec['diameter'])*100
        selected=np.flatnonzero(dist<1e-7)
        if len(selected)==0: selected=np.argsort(dist)[:spec.get('nt',16)]
        ix=selected[:,None]*3+np.arange(3)
        path.append(center);R.append(C[ix].mean(axis=0));RT.append(wT[ix].mean(axis=0));RG.append(wG[ix].mean(axis=0));RM.append(modes[ix].mean(axis=0))
    return dict(spec=spec,xyz=X,cells=cells,ports=ports,K=K,M=M,interior=interior,boundary=boundary,B=B,
                C=C,wT=wT,wG=wG,ftemp=ftemp,fG=fG,T=T,S=S,Kr=Kr,Mr=Mr,fT=fT,g=g,
                path=np.array(path),recovery=np.array(R),thermal_recovery=np.array(RT),
                gravity_recovery=np.array(RG),mode_recovery=np.array(RM),metrics=metrics)


def save_component(c,folder):
    folder=Path(folder);folder.mkdir(parents=True,exist_ok=True)
    sparse.save_npz(folder/'stiffness.npz',c['K']);sparse.save_npz(folder/'mass.npz',c['M'])
    keys=['xyz','ports','interior','boundary','B','C','wT','wG','ftemp','fG','T','S','Kr','Mr','fT','g','path','recovery','thermal_recovery','gravity_recovery','mode_recovery']
    np.savez_compressed(folder/'component.npz',**{k:c[k] for k in keys})
    (folder/'metadata.json').write_text(json.dumps({'spec':c['spec'],'metrics':c['metrics']},indent=2))


if __name__=='__main__':
    import argparse
    p=argparse.ArgumentParser();p.add_argument('--kind',default='straight');p.add_argument('--out',required=True)
    args=p.parse_args(); spec=dict(id=args.kind,kind=args.kind,length=.8,radius=.4,diameter=.2,thickness=.012,ns=24,nt=24,nr=1,modes=12,stub=.4 if args.kind=='elbow' else 0.)
    start=time.time();c=assemble(spec);save_component(c,args.out)
    print(json.dumps(c['metrics'],indent=2));print('seconds',time.time()-start)