From 2eab822f4e47949f0e5cd40c65a502d293f9737a Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 23 Oct 2025 14:38:31 -0400 Subject: [PATCH 01/54] add kernel generation for EM. The kernels are empty for now. --- maxima/g0/gk_collisionless/dg_gk-surf.mac | 138 ++++++++++ maxima/g0/gk_collisionless/dg_gk-vol.mac | 35 +++ .../gk_collisionless_flux-surf-vpar.mac | 239 ++++++++++++++++++ .../ms-dg_gyrokinetic-header.mac | 17 +- .../ms-dg_gyrokinetic-surf_add_em.mac | 83 ++++++ .../ms-dg_gyrokinetic-vol_add_em.mac | 72 ++++++ .../ms-gk_collisionless_flux-header.mac | 50 ++-- .../ms-gk_collisionless_flux_add_em.mac | 84 ++++++ 8 files changed, 694 insertions(+), 24 deletions(-) create mode 100644 maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf_add_em.mac create mode 100644 maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_add_em.mac create mode 100644 maxima/g0/gk_collisionless/ms-gk_collisionless_flux_add_em.mac diff --git a/maxima/g0/gk_collisionless/dg_gk-surf.mac b/maxima/g0/gk_collisionless/dg_gk-surf.mac index 77901135..0ee3b64b 100644 --- a/maxima/g0/gk_collisionless/dg_gk-surf.mac +++ b/maxima/g0/gk_collisionless/dg_gk-surf.mac @@ -272,3 +272,141 @@ calcGKBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrd )$ +calcGKAddEMSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( + [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, + surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, + tempVars,tempBasis,NSurfIndexing,numNodesIndexing, + rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, + BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, + hamil_e,alphaSurfL_e,alphaSurfR_e, + fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, + fnodal_l_e, fnodal_r_e, fmodproj_e], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), + basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) + ), + NSurf : length(bSurf), + numNodes : length(surfNodes), + /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size at the + vparallel surfaces */ + if (surfDir = cdim+1 and polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes, + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, + const double *flux_surf_l, const double *flux_surf_r, + double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_c,vmap_prime_r: velocity space mapping derivative in left, center and right cells.~%"), + printf(fh, " // flux_surf_l: Surface expansion of phase space flux on the left.~%"), + printf(fh, " // flux_surf_r: Surface expansion of phase space flux on the right.~%"), + printf(fh, " // out: output increment in center cell.~%"), + printf(fh, "~%"), + printf(fh, " return 0.0; ~%"), + printf(fh, "~%"), + + printf(fh, "} ~%"), + flush_output(fh) + +)$ + +calcGKAddEMBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( + [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, + surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, + tempVars,tempBasis,NSurfIndexing,numNodesIndexing, + rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, + BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, + hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, + fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), + basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) + ), + NSurf : length(bSurf), + numNodes : length(surfNodes), + + /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size at the + vparallel surfaces */ + if (surfDir = cdim+1 and polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes, + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, + const double *vmap_prime_edge, const double *vmap_prime_skin, + const double *flux_surf_edge, const double *flux_surf_skin, + const int edge, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_edge,vmap_prime_skin: velocity space mapping derivative in edge and skin cells.~%"), + printf(fh, " // flux_surf_edge: Surface expansion of phase space flux on the lower edges of the edge cell.~%"), + printf(fh, " // flux_surf_skin: Surface expansion of phase space flux on the lower edges of the skin cell.~%"), + printf(fh, " // edge: determines if the update is for the left edge (-1) or right edge (+1).~%"), + printf(fh, " // out: output increment in center cell.~%"), + printf(fh, "~%"), + printf(fh, " return 0.0; ~%"), + printf(fh, "~%"), + + printf(fh, "} ~%"), + flush_output(fh) + +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 01905ad3..5021a5f9 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -257,3 +257,38 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "} ~%") )$ + +buildGKAddEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( + [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, + hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + varLabel : makelist(string(varsP[d]),d,1,pDim), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, + const double q_, const double m_, const double *bmag, const double *phi, + const double *apar, const double *rtg33inv, const double *bioverJB, + const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential .~%"), + printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // fin: Distribution function.~%"), + printf(fh, " // out: output increment.~%"), + printf(fh, "~%"), + + printf(fh, " return 0.; ~%"), + printf(fh, "} ~%") +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index a172abb2..617facd2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -240,3 +240,242 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, "} ~%") )$ + +buildGKFluxVparAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, + numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, + bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, + hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + configNodes : gaussOrd(polyOrder+1, cdim), + numSurfNodes : length(surfNodes), + numConfigNodes : length(configNodes), + numVelNodes : numSurfNodes/numConfigNodes, + + /* if polyOrder = 1, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size in the + vparallel surfaces and/or we are more directly exploiting the sparsity of + alpha (e.g., in the x and z direction when no toroidal field, by=0) + and thus utilize fewer coefficients to reduce the number of operations */ + if (polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgv: volume DG geometry.~%"), + printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + if false then ( + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmag_e : doExpand1(bmag, bmagBasis), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + if edge = true then ( + evPoint : 1 + ) else ( + evPoint : -1 + ), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ + + /*fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), + JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), + + JfL_e : subst(surfVar=1,JfL_e), + JfR_e : subst(surfVar=-1,JfR_e), + + JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), + JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), + + vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), + + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_nodes : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), + dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) + ) + else ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ) + ), + + /* Now calculate apha at all quadrature nodes */ + /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + printf(fh, " double bmag_quad = 0.0; ~%"), + printf(fh, " double B3_quad = 0.0; ~%"), + printf(fh, " double Jc_quad = 0.0; ~%"), + printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + printf(fh, "~%"), + + for i : 1 thru numConfigNodes do ( + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + printf(fh, "~%"), + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + printf(fh, "~%"), + if no_by = true then ( + printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) + ), + if no_by = false then ( + printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), + if cdim = 3 then ( + for k : 1 thru cdim do ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ) + ), + if cdim = 2 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + if cdim = 1 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + printf(fh, ";~%") + ), + + printf(fh, "~%"), + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), + printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), + printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + ), + printf(fh, "~%") + ), + + /* Do the quad nodal to modal ops directly here*/ + /*printf(fh, "~%"), + printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), + fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), + + for i : 1 thru length(fmodproj_e) do ( + printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) + ), + + printf(fh, "~%"),*/ + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + if polyOrder=1 then ( pOrderCFL : 2 ), + printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), + vprimeStr : "/vmap_prime_min", + printf(fh, "~%"), + printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%") + ) else ( + printf(fh, " return 0.; ~%") + ), + flush_output(fh), + printf(fh, "} ~%") + +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 08e41563..7282821a 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -53,7 +53,12 @@ printPrototypes() := block([], const double *bmag, const double *phi, const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_vol_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const double *bmag, const double *phi, + const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, + const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), + for surfDir : 1 thru c+1 do ( if surfDir<=c then ( dirlabel : varsC[surfDir] @@ -78,9 +83,19 @@ printPrototypes() := block([], const double *flux_surf_l, const double *flux_surf_r, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), printf(fh, "GKYL_CU_DH double dg_gyrokinetic_boundary_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap_prime_edge, const double *vmap_prime_skin, + const double *flux_surf_edge, const double *flux_surf_skin, + const int edge, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), + if dirlabel=vpar then ( + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, + const double *flux_surf_l, const double *flux_surf_r, + double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_boundary_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, const double *vmap_prime_edge, const double *vmap_prime_skin, const double *flux_surf_edge, const double *flux_surf_skin, const int edge, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder) + ) ), printf(fh, "~%") ) diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf_add_em.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf_add_em.mac new file mode 100644 index 00000000..b4519e55 --- /dev/null +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf_add_em.mac @@ -0,0 +1,83 @@ +/* + Generate the surface kernels for gyrokinetics with general geometry. + Assumes surface alpha pre-computed so kernels are agnostic to different + forms of gyrokinetics (electrostatic vs. electromagnetic, etc.) + + The functions called in this file are in gkFuncs-surf.mac. +*/ +load("gk_collisionless/dg_gk-surf")$ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +minPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 1$ +minCdim_Ser : 1$ +maxCdim_Ser : 3$ + +/* Tensor order basis. No need to generate p=1. */ +minPolyOrder_Tensor : 2$ +maxPolyOrder_Tensor : 0$ +minCdim_Tensor : 1$ +maxCdim_Tensor : 0$ + +/* Vdim possibilities for each of Cdim=[1,2,3]. */ +gkVdims : [[1,2], [2], [2]]$ + +/* ...... END OF USER INPUTS........ */ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ + +clabels : ["x","y","z"]$ +vlabels : ["vpar","mu"]$ + +/* Possible combinations of variable dependence of background magnetic field. + with [] = const. Note that we assume axisymmetry, which means B cannot depend on y. */ +bVarsList : [x,z]$ + +includeSurfHeaders(fhIn, bname, c, v, porder, dir) := block([], + printf(fhIn, "#include ~%"), + if porder = 1 then ( /* Force hybrid basis (p=2 in velocity space). */ + printf(fhIn, "#include ~%", c, v) + ) elseif porder > 1 then ( + printf(fhIn, "#include ~%", bname, c+v, porder) + ) +)$ + +/* Generate kernels of selected types. */ +for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( + /* Advection in velocity space.*/ + fname : sconcat("~/max-out/dg_gyrokinetic_add_em_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + disp(printf(false,"Creating surface file: ~a",fname)), + + fh : openw(fname), + includeSurfHeaders(fh, bName[bInd], c, v, polyOrder, c+1), + funcName : sconcat("dg_gyrokinetic_add_em_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + calcGKAddEMSurfUpdateInDir(c+1, fh, funcName, c, v, bName[bInd], polyOrder, bVarsList), + close(fh), + + /* Advection in velocity space in the skin cell along vpar (for zero-flux BCs).*/ + fname : sconcat("~/max-out/dg_gyrokinetic_add_em_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + disp(printf(false,"Creating surface file: ~a",fname)), + + fh : openw(fname), + includeSurfHeaders(fh, bName[bInd], c, v, polyOrder, c+1), + funcName : sconcat("dg_gyrokinetic_add_em_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + calcGKAddEMBoundarySurfUpdateInDir(c+1, fh, funcName, c, v, bName[bInd], polyOrder, bVarsList), + close(fh) + ) + ) + ) +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_add_em.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_add_em.mac new file mode 100644 index 00000000..06d70168 --- /dev/null +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_add_em.mac @@ -0,0 +1,72 @@ +/* + Generate the volume kernels for collisionless gyrokinetic terms. + + The functions called in this file are in gkFuncs-vol.mac. +*/ +load("gk_collisionless/dg_gk-vol")$ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +minPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 1$ +minCdim_Ser : 1$ +maxCdim_Ser : 3$ + +/* Tensor order basis. No need to generate p=1. */ +minPolyOrder_Tensor : 2$ +maxPolyOrder_Tensor : 2$ +minCdim_Tensor : 1$ +maxCdim_Tensor : 0$ + +/* Vdim possibilities for each of Cdim=[1,2,3]. */ +gkVdims : [[1,2], [2], [2]]$ + +/* ...... END OF USER INPUTS........ */ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ + +/* Possible combinations of variable dependence of background magnetic field. + with [] = const. Note that we assume axisymmetry, which means B cannot depend on y. */ +bVarsList : [x,z]$ + +/* Generate kernels of selected types. */ +for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( + fname : sconcat("~/max-out/dg_gyrokinetic_add_em_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating volume file: ~a",fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("dg_gyrokinetic_add_em_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKAddEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), + close(fh) + + /* if cdim > 1, also generate a set of kernels for the case where there is no toroidal field (by = 0) */ + /* if (c > 1) then ( + fname : sconcat("~/max-out/dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating volume file (no by): ~a",fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, true), + close(fh) + ) */ + ) + ) + ) +)$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index ebef045a..1a8bdcef 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -34,9 +34,10 @@ maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ /* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension. */ -byOpt : [[false], [false, true], [false, true]]$ -byStr : ["", "no_by_"]$ + dimension, or make the kernel only add electromagnetic terms. */ +byOpt : [[false, false], [false, false, false], [false, false, true]]$ +emOpt : [[false, true], [false, true, false], [false, true, false]]$ +optStr : ["", "add_em_", "no_by_"]$ /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ @@ -55,48 +56,51 @@ printPrototypes() := block([], for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + add_em : emOpt[c][byI], + opt_str : optStr[byI], + if not(add_em) then ( + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ) ) ), - dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + double* GKYL_RESTRICT flux_surf); ~%", opt_str, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ), printf(fh, "~%") diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_add_em.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_add_em.mac new file mode 100644 index 00000000..5f4b9bfc --- /dev/null +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_add_em.mac @@ -0,0 +1,84 @@ +/* + Generate the kernel for surface expansions of the phase space characteristics. + + The functions called in this file are in gkFuncs-alpha-surf.mac. +*/ +load("gk_collisionless/gk_collisionless_flux-surf-conf")$ +load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +minPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 1$ +minCdim_Ser : 1$ +maxCdim_Ser : 3$ + +/* Tensor order basis. No need to generate p=1. */ +minPolyOrder_Tensor : 2$ +maxPolyOrder_Tensor : 2$ +minCdim_Tensor : 1$ +maxCdim_Tensor : 0$ + +/* ...... END OF USER INPUTS........ */ + +/* Vdim possibilities for each of Cdim=[1,2,3]. */ +gkVdims : [[1,2], [2], [2]]$ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ + +clabels : ["x","y","z"]$ +vlabels : ["vpar","mu"]$ + +/* Options for writing kernels with and without toroidal field (b_y=0), one per + dimension, or make the kernel only add electromagnetic terms. */ +byOpt : [[false, false], [false, false, false], [false, false, true]]$ +emOpt : [[false, true], [false, true, false], [false, true, false]]$ +optStr : ["", "add_em_", "no_by_"]$ + +/* Options for writing kernels used at multiblock boundaries. One for each + dimension. */ +mb_bcOpt : [[false,true],[false,true],[false,true]]$ +mb_bcStr : ["", "multib_boundary_"]$ + +/* Generate kernels of selected types. */ +for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ + + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( + for byI : 1 thru length(byOpt[c]) do ( + no_by : byOpt[c][byI], + add_em : emOpt[c][byI], + opt_str : optStr[byI], + + if add_em then ( + /* Surface flux in vparallel direction.*/ + fname : sconcat("~/max-out/gk_collisionless_flux_",opt_str,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",opt_str,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_",opt_str,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + if add_em then ( + buildGKFluxVparAddEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false) + ) else ( + buildGKFluxVparESKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false) + ), + close(fh) + ) + ) + ) + ) + ) +)$ From 598b7a0ddf4f5d533b5cc1d767a754bef9b84f7e Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 23 Oct 2025 14:40:28 -0400 Subject: [PATCH 02/54] change the path to a generic path --- maxima/g0/twist_shift_calc/twistShift-calc.mac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maxima/g0/twist_shift_calc/twistShift-calc.mac b/maxima/g0/twist_shift_calc/twistShift-calc.mac index 097320c4..868f546d 100644 --- a/maxima/g0/twist_shift_calc/twistShift-calc.mac +++ b/maxima/g0/twist_shift_calc/twistShift-calc.mac @@ -41,7 +41,7 @@ for bInd : 1 thru length(bName) do ( print("pOrder = ",pOrder), vStr : "", if (v>0) then (vStr: sconcat(v,"v")), - fname : sconcat("/home/akash/max-out/bc_twistshift_gyrokinetic_", bName[bInd], "_", c, "x", vStr, "_p", pOrder, ".c"), + fname : sconcat("~/max-out/bc_twistshift_gyrokinetic_", bName[bInd], "_", c, "x", vStr, "_p", pOrder, ".c"), fh : openw(fname), disp(printf(false,sconcat("Creating ~ax", vStr, "P~a ", bName[bInd]),c,pOrder)), From ea126b3fb4a9dc7b0d47c3407cea4c5b520b98a6 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 23 Oct 2025 14:59:38 -0400 Subject: [PATCH 03/54] reorganize the em scripts and code. The em kernels are still empty --- maxima/g0/gk_collisionless/dg_gk-surf.mac | 139 --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 35 - .../g0/gk_collisionless/em/dg_gk-surf_em.mac | 158 +++ .../g0/gk_collisionless/em/dg_gk-vol_em.mac | 327 ++++++ maxima/g0/gk_collisionless/em/gkUtil.mac | 954 ++++++++++++++++++ .../em/gk_collisionless_flux-surf-vpar_em.mac | 244 +++++ .../ms-dg_gyrokinetic-surf_em.mac} | 0 .../ms-dg_gyrokinetic-vol_em.mac} | 0 .../em/ms-gk_collisionless_flux-header_em.mac | 126 +++ .../ms-gk_collisionless_flux_em.mac} | 0 .../gk_collisionless_flux-surf-conf.mac | 2 +- .../gk_collisionless_flux-surf-vpar.mac | 241 +---- .../ms-dg_gyrokinetic-header.mac | 19 +- .../ms-dg_gyrokinetic-surf.mac | 2 +- .../ms-dg_gyrokinetic-vol.mac | 2 +- .../ms-gk_collisionless_flux-header.mac | 52 +- .../ms-gk_collisionless_flux.mac | 2 +- 17 files changed, 1840 insertions(+), 463 deletions(-) create mode 100644 maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac create mode 100644 maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac create mode 100644 maxima/g0/gk_collisionless/em/gkUtil.mac create mode 100644 maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac rename maxima/g0/gk_collisionless/{ms-dg_gyrokinetic-surf_add_em.mac => em/ms-dg_gyrokinetic-surf_em.mac} (100%) rename maxima/g0/gk_collisionless/{ms-dg_gyrokinetic-vol_add_em.mac => em/ms-dg_gyrokinetic-vol_em.mac} (100%) create mode 100644 maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac rename maxima/g0/gk_collisionless/{ms-gk_collisionless_flux_add_em.mac => em/ms-gk_collisionless_flux_em.mac} (100%) diff --git a/maxima/g0/gk_collisionless/dg_gk-surf.mac b/maxima/g0/gk_collisionless/dg_gk-surf.mac index 0ee3b64b..b657bab1 100644 --- a/maxima/g0/gk_collisionless/dg_gk-surf.mac +++ b/maxima/g0/gk_collisionless/dg_gk-surf.mac @@ -271,142 +271,3 @@ calcGKBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrd flush_output(fh) )$ - -calcGKAddEMSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( - [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, - surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, - tempVars,tempBasis,NSurfIndexing,numNodesIndexing, - rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, - BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, - hamil_e,alphaSurfL_e,alphaSurfR_e, - fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - fnodal_l_e, fnodal_r_e, fmodproj_e], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), - basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) - ), - NSurf : length(bSurf), - numNodes : length(surfNodes), - /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size at the - vparallel surfaces */ - if (surfDir = cdim+1 and polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes, - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, - const double *flux_surf_l, const double *flux_surf_r, - double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_c,vmap_prime_r: velocity space mapping derivative in left, center and right cells.~%"), - printf(fh, " // flux_surf_l: Surface expansion of phase space flux on the left.~%"), - printf(fh, " // flux_surf_r: Surface expansion of phase space flux on the right.~%"), - printf(fh, " // out: output increment in center cell.~%"), - printf(fh, "~%"), - printf(fh, " return 0.0; ~%"), - printf(fh, "~%"), - - printf(fh, "} ~%"), - flush_output(fh) - -)$ - -calcGKAddEMBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( - [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, - surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, - tempVars,tempBasis,NSurfIndexing,numNodesIndexing, - rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, - BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, - hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, - fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), - basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) - ), - NSurf : length(bSurf), - numNodes : length(surfNodes), - - /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size at the - vparallel surfaces */ - if (surfDir = cdim+1 and polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes, - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, - const double *vmap_prime_edge, const double *vmap_prime_skin, - const double *flux_surf_edge, const double *flux_surf_skin, - const int edge, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_edge,vmap_prime_skin: velocity space mapping derivative in edge and skin cells.~%"), - printf(fh, " // flux_surf_edge: Surface expansion of phase space flux on the lower edges of the edge cell.~%"), - printf(fh, " // flux_surf_skin: Surface expansion of phase space flux on the lower edges of the skin cell.~%"), - printf(fh, " // edge: determines if the update is for the left edge (-1) or right edge (+1).~%"), - printf(fh, " // out: output increment in center cell.~%"), - printf(fh, "~%"), - printf(fh, " return 0.0; ~%"), - printf(fh, "~%"), - - printf(fh, "} ~%"), - flush_output(fh) - -)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 5021a5f9..fccd4ab1 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -256,39 +256,4 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, " return 0.; ~%"), printf(fh, "} ~%") -)$ - -buildGKAddEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - varLabel : makelist(string(varsP[d]),d,1,pDim), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, - const double q_, const double m_, const double *bmag, const double *phi, - const double *apar, const double *rtg33inv, const double *bioverJB, - const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential .~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // fin: Distribution function.~%"), - printf(fh, " // out: output increment.~%"), - printf(fh, "~%"), - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") )$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac b/maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac new file mode 100644 index 00000000..f2facaa3 --- /dev/null +++ b/maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac @@ -0,0 +1,158 @@ +/* + Create kernels for the surface term of the gyrokinetic collisionless terms. +*/ +load("modal-basis")$ +load("out-scripts")$ +load(stringproc)$ +load("scifac")$ +load("utilities_gyrokinetic")$ +load("nodal_operations/nodal_functions")$ +fpprec : 24$ + +/* Types of boundary stencils: + - domain_bound: Domain boundary. + - interblock_bound: Interblock boundary. +*/ +bound_surf_bc_type : ["domain_bound","interblock_bound"]$ + +/* Boundary sidex. */ +bound_side : ["lower","upper"]$ + +calcGKAddEMSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( + [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, + surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, + tempVars,tempBasis,NSurfIndexing,numNodesIndexing, + rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, + BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, + hamil_e,alphaSurfL_e,alphaSurfR_e, + fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, + fnodal_l_e, fnodal_r_e, fmodproj_e], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), + basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) + ), + NSurf : length(bSurf), + numNodes : length(surfNodes), + /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size at the + vparallel surfaces */ + if (surfDir = cdim+1 and polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes, + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, + const double *flux_surf_l, const double *flux_surf_r, + double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_c,vmap_prime_r: velocity space mapping derivative in left, center and right cells.~%"), + printf(fh, " // flux_surf_l: Surface expansion of phase space flux on the left.~%"), + printf(fh, " // flux_surf_r: Surface expansion of phase space flux on the right.~%"), + printf(fh, " // out: output increment in center cell.~%"), + printf(fh, "~%"), + printf(fh, " return 0.0; ~%"), + printf(fh, "~%"), + + printf(fh, "} ~%"), + flush_output(fh) + +)$ + +calcGKAddEMBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( + [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, + surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, + tempVars,tempBasis,NSurfIndexing,numNodesIndexing, + rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, + BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, + hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, + fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), + basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) + ), + NSurf : length(bSurf), + numNodes : length(surfNodes), + + /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size at the + vparallel surfaces */ + if (surfDir = cdim+1 and polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes, + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, + const double *vmap_prime_edge, const double *vmap_prime_skin, + const double *flux_surf_edge, const double *flux_surf_skin, + const int edge, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_edge,vmap_prime_skin: velocity space mapping derivative in edge and skin cells.~%"), + printf(fh, " // flux_surf_edge: Surface expansion of phase space flux on the lower edges of the edge cell.~%"), + printf(fh, " // flux_surf_skin: Surface expansion of phase space flux on the lower edges of the skin cell.~%"), + printf(fh, " // edge: determines if the update is for the left edge (-1) or right edge (+1).~%"), + printf(fh, " // out: output increment in center cell.~%"), + printf(fh, "~%"), + printf(fh, " return 0.0; ~%"), + printf(fh, "~%"), + + printf(fh, "} ~%"), + flush_output(fh) + +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac b/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac new file mode 100644 index 00000000..678f4a6a --- /dev/null +++ b/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac @@ -0,0 +1,327 @@ +/* + Create kernels for the volume term of the gyrokinetic collisionless terms. +*/ + +load("modal-basis")$ +load("out-scripts")$ +load(stringproc)$ +load("scifac")$ +load("utilities_gyrokinetic")$ +load("utilities")$ +fpprec : 24$ + +buildGKAddEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( + [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, + hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + varLabel : makelist(string(varsP[d]),d,1,pDim), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, + const double q_, const double m_, const double *bmag, const double *phi, + const double *apar, const double *rtg33inv, const double *bioverJB, + const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential .~%"), + printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // fin: Distribution function.~%"), + printf(fh, " // out: output increment.~%"), + printf(fh, "~%"), + + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru pDim do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ + printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), + printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), + printf(fh, "~%"), + replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], + dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), + [dvparSq=4/rdvpar2Sq]), + + /* Create pointers to the components of b_i. */ + allVarLabelsC : ["x","y","z"], + for d : 1 thru 3 do ( + printf(fh, " const double *bioverJB_~a = &bioverJB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) + ), + printf(fh, "~%"), + + /* Create pointers to the components of dualcurlbhatoverB. */ + allVarLabelsC : ["x","y","z"], + for d : 1 thru 3 do ( + printf(fh, " const double *dualcurlbhatoverB_~a = &dualcurlbhatoverB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) + ), + printf(fh, "~%"), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + apar_e : doExpand1(apar,bC), + bmag_e : doExpand1(bmag, bmagBasis), + + + /* dualcurlbhatoverB_x_e : doExpand1(dualcurlbhatoverB_x, bmagBasis), + dualcurlbhatoverB_y_e : doExpand1(dualcurlbhatoverB_y, bmagBasis), + dualcurlbhatoverB_z_e : doExpand1(dualcurlbhatoverB_z, bmagBasis), */ + /* Zero out some terms below to avoid the discontinuity of alpha in the + parallel direction (due to the discontinuity of Apar). Otherwise some + other treatment of some Apar terms or alpha may be needed. Initially we + had a step averaging alpha across the surface (just for the parallel + direction), but NRM suspects this might've caused instability in some + cases. Hence the zeros below. */ + discontFac : 0, + if cdim > 1 then (rdy2 : rdx2vec[2]) else (rdy2 : 0), + if cdim > 2 then (rdz2 : rdx2vec[3]) else (rdz2 : 0), + /* Expand e^x . \nabla \times A_\parallel / Bmag on basis. */ + dualcurlbAparoverB_x_e : (rdy2*diff(apar_e*b_z_e,y) - discontFac*rdz2*diff(apar_e*b_y_e,z))*jacobTotInv_e, + /* Expand e^y . \nabla \times A_\parallel / Bmag on basis. */ + dualcurlbAparoverB_y_e : (discontFac*rdz2*diff(apar_e*b_x_e,z) - rdx2vec[1]*diff(apar_e*b_z_e,x))*jacobTotInv_e, + /* Expand e^z . \nabla \times A_\parallel / Bmag on basis. */ + dualcurlbAparoverB_z_e : (discontFac*(rdx2vec[1]*diff(apar_e*b_y_e,x) - rdy2*diff(apar_e*b_x_e,y)))*jacobTotInv_e, + + varsP : listofvars(bP), + numP : length(bP), + + /* Project Bstar's onto basis, and print to arrays. */ + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + if cdim > 1 then ( + dualcurlbAparoverB_c : calcInnerProdList(varsP, 1, bP, dualcurlbAparoverB_x_e), + if (surfDir = 0 or surfDir = 1 or surfDir = cdim+1) then ( + printf(fh, " double dualcurlbAparoverB~a[~a] = {0.}; ~%", sideStr,numP), + writeCExprsNoExpand1(eval_string(sconcat("dualcurlbAparoverB",sideStr)), gcfac(subst(replaceList, dualcurlbAparoverB_c))), + printf(fh, "~%"), + flush_output(fh) + ), + dualcurlbAparoverB_noZero_c : makelistNoZeros1(dualcurlbAparoverB_c, eval_string(sconcat("dualcurlbAparoverB",sideStr))), + dualcurlbAparoverB_e : dualcurlbAparoverB_noZero_c . bP, + + dualcurlbAparoverB_y_c : calcInnerProdList(varsP, 1, bP, dualcurlbAparoverB_y_e), + if (surfDir = 0 or surfDir = 2 or surfDir = cdim+1) then ( + printf(fh, " double dualcurlbAparoverB_y~a[~a] = {0.}; ~%", sideStr, numP), + writeCExprsNoExpand1(eval_string(sconcat("dualcurlbAparoverB_y",sideStr)), gcfac(subst(replaceList, dualcurlbAparoverB_y_c))), + printf(fh, "~%"), + flush_output(fh) + ), + dualcurlbAparoverB_y_noZero_c : makelistNoZeros1(dualcurlbAparoverB_y_c, eval_string(sconcat("dualcurlbAparoverB_y",sideStr))), + dualcurlbAparoverB_y_e : dualcurlbAparoverB_y_noZero_c . bP + ), + if cdim # 2 then ( + dualcurlbAparoverB_z_c : calcInnerProdList(varsP, 1, bP, dualcurlbAparoverB_z_e), + if (surfDir=0 or surfDir>=cdim) then ( + printf(fh, " double dualcurlbAparoverB_z~a[~a] = {0.}; ~%", sideStr, numP), + writeCExprsNoExpand1(eval_string(sconcat("dualcurlbAparoverB_z",sideStr)), gcfac(subst(replaceList, dualcurlbAparoverB_z_c))), + printf(fh, "~%"), + flush_output(fh) + ), + dualcurlbAparoverB_z_noZero_c : makelistNoZeros1(dualcurlbAparoverB_z_c, eval_string(sconcat("dualcurlbAparoverB_z",sideStr))), + dualcurlbAparoverB_z_e : dualcurlbAparoverB_z_noZero_c . bP + ), + + /* Make Bstar/Bmag vector. */ + /* if cdim = 1 then ( + dualcurlbAparoverB_list : [dualcurlbAparoverB_z_e] + ) elseif cdim = 2 then ( + dualcurlbAparoverB_list : [dualcurlbAparoverB_x_e, dualcurlbAparoverB_y_e] + ) elseif cdim = 3 then ( + dualcurlbAparoverB_list : [dualcurlbAparoverB_x_e, dualcurlbAparoverB_y_e, dualcurlbAparoverB_z_e] + ), */ + + rtg33inv_e : doExpand1(rtg33inv, bmagBasis), + bioverJB_x_e : doExpand1(bioverJB_x, bmagBasis), + bioverJB_y_e : doExpand1(bioverJB_y, bmagBasis), + bioverJB_z_e : doExpand1(bioverJB_z, bmagBasis), + + dualcurlbAparoverB_list : [dualcurlbAparoverB_x_e, dualcurlbAparoverB_y_e, dualcurlbAparoverB_z_e], + bioverJB_list : [bioverJB_x_e, bioverJB_y_e, bioverJB_z_e], + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + + /*Expand Jf*/ + Jf_e : doExpand1(fin,bP), + + /* Calculate expressions for dericatives of the hamiltonian*/ + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_e : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_e[i] : diff(hamil_e,varsP[i]) + ) + else ( + dH_dz_e[i] : diff(hamil_e*rdx2vec[i],varsP[i]) + ) + ), + + /*Make sure to avoid having hamil[i]^2 or vmap[i]^2 in expressions*/ + replaceListVpar : [vmap[1]^2=vmap2], + printf(fh, " double vmap2 = vmap[1]*vmap[1]; ~%"), + printf(fh, "~%"), + + mvpar_e : dH_dz_e[vpardim]/vmap_prime_e[1], + mvparsq_e : mvpar_e*mvpar_e/m_, + isqlist : [], + for i : 1 thru numP do ( + if freeof(hamil[i]^2, expand(mvparsq_e)) = false then ( + isqlist : append(isqlist,[i]) + ) + ), + + replaceListHamil : [], + printf(fh, " double hamil2[~a] = {0.}; ~%", length(isqlist)), + for i : 1 thru length(isqlist) do ( + printf(fh, " hamil2[~a] = hamil[~a]*hamil[~a]; ~%", i-1, isqlist[i], isqlist[i]), + replaceListHamil : append(replaceListHamil, [hamil[isqlist[i]]^2=hamil2[i-1]]) + ), + printf(fh, "~%"), + + /* Note: no contribution from mu. */ + for dir : 1 thru cdim+1 do ( + + dirLabel : varLabel[dir], + + wDir : eval_string(sconcat("w",dirLabel)), + rdDirVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + dirVar : varsP[dir], /* Variable in current direction. */ + + if dir = cdim then ( + alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ + ) + else if dir = vpardim then ( + alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ + ) + else ( + alpha_e : 0 + ), + + + if no_by = false then ( + if cdim = 3 then ( + curvdriftdir : dir + ), + if cdim = 2 then ( + if dir = 1 then ( + curvdriftdir : dir + ), + if dir = 2 then ( + curvdriftdir : 3 + ) + ), + if cdim = 1 then ( + curvdriftdir : 3 + ), + + if dir < vpardim then ( + alpha_e : alpha_e + dualcurlbAparoverB_list[curvdriftdir]*dH_dz_e[vpardim]/vmap_prime_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/m_/q_ + ), + if cdim = 3 then ( + if dir = 1 then ( + alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[3] - bioverJB_list[3]*dH_dz_e[2]) + ), + if dir = 2 then ( + alpha_e : alpha_e + 1/q_ * (bioverJB_list[3]*dH_dz_e[1] - bioverJB_list[1]*dH_dz_e[3]) + ), + if dir = 3 then ( + alpha_e : alpha_e + 1/q_ * (bioverJB_list[1]*dH_dz_e[2] - bioverJB_list[2]*dH_dz_e[1]) + ) + ), + if cdim = 2 then ( + if dir = 1 then ( + alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[2]) + ), + if dir = 2 then ( + alpha_e : alpha_e - 1/q_ * (bioverJB_list[2]*dH_dz_e[1]) + ) + ), + if dir = vpardim then ( + if cdim = 3 then ( + for k : 1 thru cdim do ( + alpha_e : alpha_e - dualcurlbAparoverB_list[k]*dH_dz_e[k]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ) + ), + if cdim = 2 then ( + alpha_e : alpha_e - dualcurlbAparoverB_list[1]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - dualcurlbAparoverB_list[3]*dH_dz_e[2]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ), + if cdim = 1 then ( + alpha_e : alpha_e - dualcurlbAparoverB_list[3]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ) + ) + + ), + + if dir < vpardim then ( + alpha_e : alpha_e*rdx2vec[dir] + ) + else if dir = vpardim then ( + alpha_e : alpha_e/vmap_prime_e[1] + ), + + /* Project alpha on basis and write to array. */ + printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), + alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), + alpha_c : subst(replaceList, alpha_c), + alpha_c : subst(replaceListHamil, alpha_c), + alpha_c : subst(replaceListVpar, alpha_c), + alpha_c : subst(dvparSimp, alpha_c), + alphaLabel : eval_string(sconcat(alpha, dirLabel)), + clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, + makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + writeCExprsCollect1(alphaLabel, alpha_c, clst), + printf(fh, "~%"), + flush_output(fh), + alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), + alpha_e : doExpand(alphaNoZero_c, bP), + + alphaJf_e : alpha_e*Jf_e, + + printf(fh, "~%"), + volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), + volTerm_c : subst(replaceList, volTerm_c), + writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), + flush_output(fh), + printf(fh, "~%") + + ), + + + printf(fh, " return 0.; ~%"), + printf(fh, "} ~%") +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/gkUtil.mac b/maxima/g0/gk_collisionless/em/gkUtil.mac new file mode 100644 index 00000000..b5914a42 --- /dev/null +++ b/maxima/g0/gk_collisionless/em/gkUtil.mac @@ -0,0 +1,954 @@ +/* + Utility functions for GK Maxima scripts. +*/ +load("vect")$ +load("nodal_operations/nodal_functions")$ +load("nodal_operations/quadrature_functions")$ +load("utilities_gyrokinetic")$ + +expandInputFields(bC,bP,dxv,bmagBasis) := block( + [varsP,pdim,cdim,vdim,bmag_e,bmagInv_e,phi_e,Apar_e,dApardt_e,dApardtPrev_e, + AparL_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,BdriftX_e,BdriftY_e,jnk, + vmapBasis,vmapSqBasis,vmap_c,vmapSq_c,vmapBnum,vmapSqBnum,d], + + varsP : listofvars(bP), + pdim : length(varsP), + cdim : length(listofvars(bC)), + vdim : pdim-cdim, + + /* Expand background magnetic field and potentials. */ + bmag_e : doExpand1(bmag,bmagBasis), + phi_e : doExpand1(phi,bC), + Apar_e : doExpand1(apar,bC), + dApardt_e : doExpand1(apardot,bC), + dApardtPrev_e : doExpand1(apardot_prev,bC), + /* NOTE: even though Apar and dApar/dt are allowed to be discontinuous + in the parallel (z) direction, the surface term in the z direction + does not involve Apar. Since Apar is continuous in the other directions, + it does not matter if we use the right or left value. */ + + cmag_e : doExpand1(cmag,bmagBasis), + + b_x_e : doExpand1(b_x, bmagBasis), + b_y_e : doExpand1(b_y, bmagBasis), + b_z_e : doExpand1(b_z, bmagBasis), + jacobTotInv_e : doExpand1(jacobtot_inv, bmagBasis), + + /* Basis for the velocity space mapping. */ + [jnk,vmapBasis] : loadBasis("Ser", 1, 1), [jnk,vmapSqBasis] : loadBasis("Ser", 1, 2), + vmapBnum : length(vmapBasis), vmapSqBnum : length(vmapSqBasis), + + vmap_e : [], vmapSq_e : [], vmap_prime_e : [], + for d : 1 thru vdim do ( + vmap_c : makelist(vmap[(d-1)*vmapBnum+i-1],i,1,vmapBnum), + vmap_e : endcons(doExpand(vmap_c,subst(x=varsP[cdim+d],vmapBasis)), vmap_e), + + vmapSq_c : makelist(vmapSq[(d-1)*vmapSqBnum+i-1],i,1,vmapSqBnum), + vmapSq_e : endcons(doExpand(vmapSq_c,subst(x=varsP[cdim+d],vmapSqBasis)), vmapSq_e), + + vmap_prime_e : endcons(vmap_prime[d-1], vmap_prime_e) + ), + + expOut : [bmag_e,cmag_e,phi_e,Apar_e,dApardt_e,dApardtPrev_e, + b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,vmapSq_e, + vmap_prime_e], + + return(expOut) +)$ + +calcAndWrite_HamilES(fH,charge,mass,wv,rdv2,bP,inFlds,sideStr) := block( + [varsP,numP,pDim,vdim,bmag_e,phi_e,hamil_e,hamil_c,replaceList,hamilCvar,hamilNoZero_c], + /* Expand the Hamiltonian, and write them out. */ + + varsP : listofvars(bP), + numP : length(bP), + pDim : length(varsP), + vdim : 1, + if isInList(mu,varsP) then vdim : 2, + + /* Extract magnetic field and electrostatic potential. */ + bmag_e : inFlds[1], + phi_e : inFlds[3], + vmap_e : inFlds[11], + vmapSq_e : inFlds[12], + + hamil_e : charge*phi_e + (1/2)*mass*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + + /* Project Hamiltonian onto basis functions */ + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + + /* Write Hamiltonian. */ + printf(fh, " double hamil~a[~a] = {0.}; ~%", sideStr, numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil",sideStr)), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fH, "~%"), + flush_output(fH), + + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + + return(hamil_e) +)$ + +calc_HamilES_no_write(charge,mass,wv,rdv2,bP,inFlds) := block( + [varsP,numP,pDim,vdim,bmag_e,phi_e,hamil_e,hamil_c,hamilNoZero_c], + /* Expand the Hamiltonian, and write them out. */ + + varsP : listofvars(bP), + numP : length(bP), + pDim : length(varsP), + vdim : 0, + if isInList(vpar,varsP) then vdim : vdim+1, + if isInList(mu,varsP) then vdim : vdim+1, + + /* Extract magnetic field and electrostatic potential. */ + bmag_e : inFlds[1], + phi_e : inFlds[3], + vmap_e : inFlds[11], + vmapSq_e : inFlds[12], + + hamil_e : charge*phi_e + (1/2)*mass*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + + /* Project Hamiltonian onto basis functions */ + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + + hamilNoZero_c : makelistNoZeros1(hamil_c, hamil), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + + return(hamil_e) +)$ + +calcAndWrite_BstardBmag(fH,cdim,bP,bmagBasis,surfDir,mass,charge,wvpar,rdx2,rdv2,inFlds,sideStr) := block ( + [cmag_e,Apar_e,BmagInv_e,BdriftX_e,BdriftY_e,BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,b_x_e,b_y_e,b_z_e, + jacobTotInv_e,rdy2,rdz2,AparL_e,BstarZdBmagL_e,varsP,numP,replaceList,BstarXdBmag_c,BstarYdBmag_c,BstarZdBmag_c, + BstarXdBmag_noZero_c,BstarYdBmag_noZero_c,BstarZdBmag_noZero_c,BstarZdBmagL_c,BstarZdBmagL_noZero_c,BstardBmagL_e], + /* Compute the Bstar divided by B and write it out. */ + + cmag_e : inFlds[2], + Apar_e : inFlds[4], + b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], + jacobTotInv_e : inFlds[10], + + if cdim > 1 then (rdy2 : rdx2[2]) else (rdy2 : 0), + if cdim > 2 then (rdz2 : rdx2[3]) else (rdz2 : 0), + + /* Zero out some terms below to avoid the discontinuity of alpha in the + parallel direction (due to the discontinuity of Apar). Otherwise some + other treatment of some Apar terms or alpha may be needed. Initially we + had a step averaging alpha across the surface (just for the parallel + direction), but NRM suspects this might've caused instability in some + cases. Hence the zeros below. */ + discontFac : 0, + + /* Expand BstarX/Bmag on basis. */ + BstarXdBmag_e : (-((mass/charge)*(wvpar+vpar/rdv2[1]))*rdz2*diff(b_y_e,z) + + rdy2*diff(Apar_e*b_z_e,y) - discontFac*rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e, + /* Expand BstarY/Bmag on basis. */ + BstarYdBmag_e : (-((mass/charge)*(wvpar+vpar/rdv2[1]))*(rdx2[1]*diff(b_z_e,x) - rdz2*diff(b_x_e,z)) + + discontFac*rdz2*diff(Apar_e*b_x_e,z) - rdx2[1]*diff(Apar_e*b_z_e,x))*jacobTotInv_e, + /* Expand BstarZ/Bmag on basis. */ + BstarZdBmag_e : (cmag_e + ((mass/charge)*(wvpar+vpar/rdv2[1]))*rdx2[1]*diff(b_y_e,x) + + discontFac*(rdx2[1]*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y)))*jacobTotInv_e, + + varsP : listofvars(bP), + numP : length(bP), + + /* Project Bstar's onto basis, and print to arrays. */ + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + if cdim > 1 then ( + BstarXdBmag_c : calcInnerProdList(varsP, 1, bP, BstarXdBmag_e), + if (surfDir = 0 or surfDir = 1 or surfDir = cdim+1) then ( + printf(fh, " double BstarXdBmag~a[~a] = {0.}; ~%", sideStr,numP), + writeCExprsNoExpand1(eval_string(sconcat("BstarXdBmag",sideStr)), gcfac(subst(replaceList, BstarXdBmag_c))), + printf(fh, "~%"), + flush_output(fh) + ), + BstarXdBmag_noZero_c : makelistNoZeros1(BstarXdBmag_c, eval_string(sconcat("BstarXdBmag",sideStr))), + BstarXdBmag_e : BstarXdBmag_noZero_c . bP, + + BstarYdBmag_c : calcInnerProdList(varsP, 1, bP, BstarYdBmag_e), + if (surfDir = 0 or surfDir = 2 or surfDir = cdim+1) then ( + printf(fh, " double BstarYdBmag~a[~a] = {0.}; ~%", sideStr, numP), + writeCExprsNoExpand1(eval_string(sconcat("BstarYdBmag",sideStr)), gcfac(subst(replaceList, BstarYdBmag_c))), + printf(fh, "~%"), + flush_output(fh) + ), + BstarYdBmag_noZero_c : makelistNoZeros1(BstarYdBmag_c, eval_string(sconcat("BstarYdBmag",sideStr))), + BstarYdBmag_e : BstarYdBmag_noZero_c . bP + ), + if cdim # 2 then ( + BstarZdBmag_c : calcInnerProdList(varsP, 1, bP, BstarZdBmag_e), + if (surfDir=0 or surfDir>=cdim) then ( + printf(fh, " double BstarZdBmag~a[~a] = {0.}; ~%", sideStr, numP), + writeCExprsNoExpand1(eval_string(sconcat("BstarZdBmag",sideStr)), gcfac(subst(replaceList, BstarZdBmag_c))), + printf(fh, "~%"), + flush_output(fh) + ), + BstarZdBmag_noZero_c : makelistNoZeros1(BstarZdBmag_c, eval_string(sconcat("BstarZdBmag",sideStr))), + BstarZdBmag_e : BstarZdBmag_noZero_c . bP + ), + + /* Make Bstar/Bmag vector. */ + if cdim = 1 then ( + BstardBmag_e : [BstarZdBmag_e] + ) elseif cdim = 2 then ( + BstardBmag_e : [BstarXdBmag_e, BstarYdBmag_e] + ) elseif cdim = 3 then ( + BstardBmag_e : [BstarXdBmag_e, BstarYdBmag_e, BstarZdBmag_e] + ), + + return(BstardBmag_e) +)$ + +calcAndWrite_BstarZdBmag(fH,cdim,bP,bmagBasis,surfDir,mass,charge,wvpar,rdx2,rdv2,inFlds,sideStr) := block ( + [cmag_e,Apar_e,BmagInv_e,BdriftX_e,BdriftY_e,BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,b_x_e,b_y_e,b_z_e, + jacobTotInv_e,rdy2,rdz2,AparL_e,BstarZdBmagL_e,varsP,numP,replaceList,BstarXdBmag_c,BstarYdBmag_c,BstarZdBmag_c, + BstarXdBmag_noZero_c,BstarYdBmag_noZero_c,BstarZdBmag_noZero_c,BstarZdBmagL_c,BstarZdBmagL_noZero_c,BstardBmagL_e], + /* Compute the Bstar divided by B and write it out. */ + + cmag_e : inFlds[2], + b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], + jacobTotInv_e : inFlds[10], + + if cdim > 1 then (rdy2 : rdx2[2]) else (rdy2 : 0), + if cdim > 2 then (rdz2 : rdx2[3]) else (rdz2 : 0), + + if (sideStr="L") then (Apar_e : inFlds[11]) + elseif (sideStr="R") then (Apar_e : inFlds[12]) + else (Apar_e : inFlds[4]), + + /* Expand BstarZ/Bmag on basis. */ + BstarZdBmag_e : (cmag_e + ((mass/charge)*(wvpar+vpar/rdv2[1]))*rdx2[1]*diff(b_y_e,x) + + (rdx2[1]*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y)))*jacobTotInv_e, + + varsP : listofvars(bP), + numP : length(bP), + + /* Project Bstar's onto basis, and print to arrays. */ + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + BstarZdBmag_c : calcInnerProdList(varsP, 1, bP, BstarZdBmag_e), + printf(fh, " double BstarZdBmag~a[~a]; ~%", sideStr, numP), + writeCExprsNoExpand1(eval_string(sconcat("BstarZdBmag",sideStr)), gcfac(subst(replaceList, BstarZdBmag_c))), + printf(fh, "~%"), + flush_output(fh), + BstarZdBmag_noZero_c : makelistNoZeros1(BstarZdBmag_c, eval_string(sconcat("BstarZdBmag",sideStr))), + BstarZdBmag_e : BstarZdBmag_noZero_c . bP, + + return(BstarZdBmag_e) +)$ + +poissonBracket(f,g,mass,charge,rdx2V,rdv2V,pbFacs,no_by) := block( + [varsCall,cdim,varsC,rdy2,rdz2,BstardBmag_e,bmagInv_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e], + /* Compute the Poisson bracket in general geometry. */ + + /* Function that computes the gradient. */ + /* + For some reason the following use of "vect" functions was giving extra + brackets when generating volume kernels. Opt for our own function instead. + scalefactors(varsC), + fgrad(fIn) := ev(express(grad(fIn)),diff)*rdx2V, + */ + fgrad(fIn,vars,diffFacs) := makelist(diff(fIn,vars[d]),d,1,length(vars))*diffFacs, + + cdim : length(rdx2V), + if (cdim = 1) then ( + varsCall : [x], + rdy2 : 0, + rdz2 : 0 + ) else if (cdim = 2) then ( + varsCall : [x,z], + rdy2 : 0, + rdz2 : rdx2V[2] + ) else if (cdim = 3) then ( + varsCall : [x,y,z], + rdy2 : rdx2V[2], + rdz2 : rdx2V[3] + ), + + varsC : makelist(varsCall[d],d,1,cdim), + BstardBmag_e : pbFacs[1], + b_x_e : pbFacs[2], b_y_e : pbFacs[3], b_z_e : pbFacs[4], + jacobTotInv_e : pbFacs[5], vmap_prime_e : pbFacs[6], + + if (no_by) then ( b_y_e : 0 ), + + pb_e : (1/mass)*BstardBmag_e . + ((rdv2V[1]/vmap_prime_e[1])*(fgrad(f,varsC,rdx2V)*diff(g,vpar)-fgrad(g,varsC,rdx2V)*diff(f,vpar))) + +(-(1/charge)*b_z_e*rdx2V[1]*rdy2*(diff(f,x)*diff(g,y)-diff(f,y)*diff(g,x)) + +(1/charge)*b_y_e*rdx2V[1]*rdz2*(diff(f,x)*diff(g,z)-diff(f,z)*diff(g,x)) + -(1/charge)*b_x_e*rdy2*rdz2*(diff(f,y)*diff(g,z)-diff(f,z)*diff(g,y)))*jacobTotInv_e, + + return(pb_e) +)$ + +calcAndWrite_alphaEM(fH,surfDir,bP,polyOrder,basisType,mass,charge,rdx2V,rdv2V, + inFlds,hamil_e,BstardBmag_e,sideStr,isStep2) := block( + [varsP,varLabel,dirLabel,wSurf,rdSurfVar2,surfVar,surfIntVars,pbAuxFlds,bmagInv_e,b_x_e, + b_y_e,b_z_e,jacobTotInv_e,alpha_e,Apar_e,dApardt_e,dApardtPrev_e,alphaL_e, + bSurf,numSurf,evPoint,alpha_c,alphaCvar,alphaNoZero_c,alphaUpCvar,alphaUpNoZero_c], + /* Calculate phase space velocity alpha in direction of surfVar. */ + /* We assume alpha.n is continuous across boundary, although H may not be. */ + /* Distinguish between alpha and alphaUp, where alphaUp is the one used to + determine upwind direction. */ + + varsP : listofvars(bP), + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + wSurf : eval_string(sconcat("w",dirLabel)), + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + + b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], + jacobTotInv_e : inFlds[10], + + pbAuxFlds : [BstardBmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,vmapSq_e], + alpha_e : poissonBracket(wSurf+surfVar/rdSurfVar2,hamil_e,mass,charge,rdx2V,rdv2V,pbAuxFlds), + + Apar_e : inFlds[4], dApardt_e : inFlds[5], + + alphaUp_e : alpha_e, + if surfVar = vpar then ( + alpha_e : alpha_e - (charge/mass)*dApardt_e, + alphaUp_e : alpha_e + ), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder) + ) else ( + bSurf : basisFromVars(basisType,surfIntVars,polyOrder) + ), + numSurf : length(bSurf), + + if sideStr="L" then (evPoint : -1) + elseif sideStr="R" then (evPoint : 1), + + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + /* Project full alpha expression evaluated at interior surface + onto surface basis and print to C variable alpha. */ + alpha_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,alpha_e)), + printf(fh, " double alpha~a[~a] = {0.}; ~%", sideStr, numSurf), + alphaCvar : eval_string(sconcat("alpha",sideStr)), + writeCExprsNoExpand1(alphaCvar, subst(replaceList,alpha_c)), + printf(fh, "~%"), + flush_output(fh), + alphaNoZero_c : makelistNoZeros1(alpha_c, alphaCvar), + alphaSurf_e : doExpand(alphaNoZero_c, bSurf), + + alphaUpSurf_e : alphaSurf_e, + + return([alphaUp_e,alphaSurf_e,alphaUpSurf_e]) +)$ + +calcAndWrite_alpha(fH,surfDir,bP,polyOrder,basisType,mass,charge,rdx2V,rdv2V, + inFlds,hamil_e,BstardBmag_e,sideStr,no_by,isStep2) := block( + [varsP,varLabel,dirLabel,wSurf,rdSurfVar2,surfVar,surfIntVars,b_x_e,b_y_e,b_z_e, + jacobTotInv_e,vmap_e,vmap_prime_e,pbAuxFlds,cdim,surfVar_phys,alpha_e,bSurf, + numSurf,evPoint,alpha_c,alphaCvar,clst,alphaNoZero_c], + /* Calculate phase space velocity alpha in direction of surfVar. */ + /* We assume alpha.n is continuous across boundary, although H may not be. */ + /* Distinguish between alpha and alphaUp, where alphaUp is the one used to + determine upwind direction. */ + + varsP : listofvars(bP), + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + wSurf : eval_string(sconcat("w",dirLabel)), + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + + b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], + jacobTotInv_e : inFlds[10], vmap_e : inFlds[11], vmap_prime_e : inFlds[13], + + pbAuxFlds : [BstardBmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_prime_e], + + cdim : length(rdx2V), + surfVar_phys : wSurf+surfVar/rdSurfVar2, + if (surfDir > cdim) then ( surfVar_phys : vmap_e[surfDir-cdim] ), + + alpha_e : poissonBracket(surfVar_phys,hamil_e,mass,charge,rdx2V,rdv2V,pbAuxFlds,no_by), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder) + ) else ( + bSurf : basisFromVars(basisType,surfIntVars,polyOrder) + ), + numSurf : length(bSurf), + + if sideStr="L" then (evPoint : -1) + elseif sideStr="R" then (evPoint : 1), + + dvparSimp : makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), + + /* Project full alpha expression evaluated at interior surface + onto surface basis and print to C variable alpha. */ + alpha_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,alpha_e)), + alpha_c : subst(dvparSimp, alpha_c), + clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, + makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + alphaCvar : eval_string(sconcat("alpha",sideStr)), + writeCExprsCollect1(alphaCvar, alpha_c, clst), + printf(fh, "~%"), + flush_output(fh), + alphaNoZero_c : makelistNoZeros1(alpha_c, alphaCvar), + alphaSurf_e : doExpand(alphaNoZero_c, bSurf), + + return(alphaSurf_e) +)$ + +calc_alpha_no_write(fH,surfDir,bP,polyOrder,basisType,mass,charge,rdx2V,rdv2V, + inFlds,hamil_e,BstardBmag_e,sideStr,no_by,isStep2) := block( + [varsP,varLabel,dirLabel,wSurf,rdSurfVar2,surfVar,surfIntVars,b_x_e,b_y_e,b_z_e, + jacobTotInv_e,vmap_e,vmap_prime_e,pbAuxFlds,cdim,surfVar_phys,alpha_e,bSurf, + numSurf,evPoint,alpha_c,alphaCvar,clst,alphaNoZero_c], + /* Calculate phase space velocity alpha in direction of surfVar. */ + /* We assume alpha.n is continuous across boundary, although H may not be. */ + /* Distinguish between alpha and alphaUp, where alphaUp is the one used to + determine upwind direction. */ + + varsP : listofvars(bP), + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + wSurf : eval_string(sconcat("w",dirLabel)), + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + + b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], + jacobTotInv_e : inFlds[10], vmap_e : inFlds[11], vmap_prime_e : inFlds[13], + + pbAuxFlds : [BstardBmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_prime_e], + + cdim : length(rdx2V), + surfVar_phys : wSurf+surfVar/rdSurfVar2, + if (surfDir > cdim) then ( surfVar_phys : vmap_e[surfDir-cdim] ), + + alpha_e : poissonBracket(surfVar_phys,hamil_e,mass,charge,rdx2V,rdv2V,pbAuxFlds,no_by), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder) + ) else ( + bSurf : basisFromVars(basisType,surfIntVars,polyOrder) + ), + numSurf : length(bSurf), + + if sideStr="L" then (evPoint : -1) + elseif sideStr="R" then (evPoint : 1), + + /* Project full alpha expression evaluated at interior surface + onto surface basis and print to C variable alpha. */ + alpha_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,alpha_e)), + alphaCvar : eval_string(sconcat("alpha",sideStr)), + alphaNoZero_c : makelistNoZeros1(alpha_c, alphaCvar), + alphaSurf_e : doExpand(alphaNoZero_c, bSurf), + + return(alphaSurf_e) +)$ + +calc_surfAvgAlpha(bP,surfVar,alpha_e,evAtLower) := block( + [i,v,varsP,numP,surfIntVars,surfBasis,ignoreVars,alphaSurfAvg_c,alphaSurfAvg_e,evPoint], + /* Calculate the surface-averaged alpha. */ + + varsP : listofvars(bP), + numP : length(bP), + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + + if evAtLower then (evPoint:-1) else (evPoint:1), + + /* alpha coefficients are for an expansion in the full-dim phase basis. We + need to project onto the a basis on the surface with the right normalization + and dimensionality. */ + surfBasis : copylist(bP), + ignoreVars : listify(setdifference(setify(varsP),setify(surfIntVars))), + for i : 1 thru numP do ( + for v : 1 thru length(ignoreVars) do ( + if not freeof(ignoreVars[v],bP[i]) then ( surfBasis[i] : 0 ) + )), + alphaSurfAvg_c : calcInnerProdList(surfIntVars,1,surfBasis,subst(surfVar=evPoint,alpha_e)), + alphaSurfAvg_e : doExpand(alphaSurfAvg_c,surfBasis), + alphaSurfAvg_s : fullratsimp(innerProd(surfIntVars,1,alphaSurfAvg_e,1)/innerProd(surfIntVars,1,1,1)), + + return(alphaSurfAvg_s) +)$ + +calcAndWrite_surfAvgAlpha(fH,bP,surfDir,alpha_e,sideStr) := block([replaceList,evAtLower], + /* Given the phase-space velocity alpha, compute the average over the surface + perpendicular to the surfVar dimension, and at the lower/upper boundary if + sideStr=R/L. Write it out too.*/ + + surfVar : varsP[surfDir], /* Surface variable. */ + + if sideStr="R" then (evAtLower:true) else (evAtLower:false), + + alphaSurfAvg_s : calc_surfAvgAlpha(bP,surfVar,alpha_e,evAtLower), + + printf(fH, " // Surface-averaged phase velocity in this direction.~%"), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, + wvparL^2=wvparSqL, rdvpar2L^2=rdvpar2SqL, rdx2L^2=rdx2SqL, + wvparR^2=wvparSqR, rdvpar2R^2=rdvpar2SqR, rdx2R^2=rdx2SqR, m_^2=mSq, q_^2=qSq], + printf(fH, " double alphaSurfAvg~a = ~a; ~%~%", sideStr, float(subst(replaceList, alphaSurfAvg_s))), + flush_output(fH), + + return(alphaSurfAvg_s) +)$ + +calcAndWrite_upwindIncr_wSurfAvgAlpha(fH,bP,polyOrder,surfDir,sideStr,alphaSurf_e,isStep2) := block( + [varsP,numP,surfIntVars,fL_e,fR_e,fhatSurf_e,replaceList,fhatAlpha_c,incr_r,tMod,incrMod_r], + /* Given a surface expansion of the phase-space velocity, alpha, determine the upwinding + based on the surface average of alpha. Write the common increment to left/right cells + (the actual output from the C kernel should be this increment times some scaling factor). */ + + varsP : listofvars(bP), + numP : length(bP), + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + + /* Expand distribution function. */ + fL_e : doExpand1(fL,bP), fR_e : doExpand1(fR,bP), + + printf(fH, " if (alphaSurfAvg~a>0) { ~%", sideStr), + + fhatSurf_e : subst(surfVar=1, fL_e), + + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, + wvparL^2=wvparSqL, rdvpar2L^2=rdvpar2SqL, rdx2L^2=rdx2SqL, + wvparR^2=wvparSqR, rdvpar2R^2=rdvpar2SqR, rdx2R^2=rdx2SqR, m_^2=mSq, q_^2=qSq], + /* Write out the increment to the right cell. Omit a dxv factor we incorporate later. */ + fhatAlpha_c : calcInnerProdList(surfIntVars, alphaSurf_e, subst(surfVar=-1, bP), fhatSurf_e), + incrR_c : fullratsimp(fhatAlpha_c), + writeCExprsNoExpand1(incr, subst(replaceList, incrR_c)), + flush_output(fH), + + if surfVar=vpar and polyOrder=1 and (not isStep2) then ( + tMod : calcInnerProdList(surfIntVars, 1, subst(surfVar=-1, bP), fhatSurf_e), + incrModR_c : fullratsimp(tMod), + writeCExprsNoExpand1(incrEmMod, subst(replaceList, incrModR_c)) + ), + + printf(fH, " } else { ~%"), + + fhatSurf_e : subst(surfVar=-1, fR_e), + + if surfVar=vpar and polyOrder=1 and (not isStep2) then ( + tMod : calcInnerProdList(surfIntVars, 1, subst(surfVar=-1, bP), fhatSurf_e), + incrModR_c : fullratsimp(tMod), + writeCExprsNoExpand1(incrEmMod, subst(replaceList, incrModR_c)) + ), + + fhatAlpha_c : calcInnerProdList(surfIntVars, alphaSurf_e, subst(surfVar=-1, bP), fhatSurf_e), + incrR_c : fullratsimp(fhatAlpha_c), + + fhatAlpha_c : calcInnerProdList(surfIntVars, alphaSurf_e, subst(surfVar=1, bP), fhatSurf_e), + incrL_c : -fullratsimp(fhatAlpha_c), + + writeCExprsNoExpand1(incr, subst(replaceList, incrR_c)), + printf(fH, " }~%"), + flush_output(fH), + + return([incrL_c,incrR_c]) +)$ + +calcAndWrite_upwindIncr_wQuadNodeAlpha(fH,basisType,polyOrder,bP,surfDir,sideStr, + alphaSurf_e,alphaUpSurf_e,fLR,isStep2) := block( + [varsP,numP,pDim,surfIntVars,vdim,cdim,surf_cvars,surf_vvars,surfNodes, + numNodes,fL_e,fR_e,fOrdL_n,fOrdR_n,alphaOrd_n, + fHatSurf_e,replaceList,Ghat_c,evPoint], + /* Compute the common increment to left/right cells with upwinding based on + the quadrature-node values of the phase-space velocity alpha. Write them + out. The actual output should be these increments scaled by some + cell-length factor. */ + + varsP : listofvars(bP), + numP : length(bP), + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + pDim : length(varsP), + + vdim : 0, + if isInList(vpar,varsP) then vdim : vdim+1, + if isInList(mu,varsP) then vdim : vdim+1, + cdim : pDim-vdim, + + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), + basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) + ), + numNodes : length(surfNodes), + + /* Expand distribution function. */ + fL_e : doExpand1(fLR[1],bP), + fR_e : doExpand1(fLR[2],bP), + + /* Evaluate alpha at ordinates. + Note: alphaSurf_e is already a surface expansion. */ + alphaOrd_n : gcfac(float(evAtNodes(alphaUpSurf_e,surfNodes,surfIntVars))), + /* Determine upwinding at each surface quadrature node. */ + printf(fH, " double fUpOrd~a[~a] = {0.};~%", sideStr, numNodes), + for i : 1 thru numNodes do ( + printf(fH, " if (~a > 0.) {~%", float(expand(fullratsimp(alphaOrd_n[i]/abs(content(args(alphaOrd_n[i])[1])[1]))))), + printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_r(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[1]), + printf(fh, " } else { ~%"), + printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_l(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[2]), + printf(fh, " } ~%") + ), + printf(fH, "~%"), + flush_output(fH), + + /* Write coefficients of modal surface expansion fupwind. */ + printf(fh, " // Project tensor nodal quadrature basis back onto modal basis. ~%"), + printf(fH, " double fUp~a[~a] = {0.};~%", sideStr, length(bSurf)), + if polyOrder=1 then ( /* Force p=1 to use hybrid basis. */ + dirStr : "x", + if surfDir = cdim+1 then (dirStr : "vpar") elseif surfDir = cdim+2 then (dirStr : "mu"), + printf(fh, " ~a_~adir_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, dirStr, sideStr, sideStr) + ) else ( + printf(fh, " ~a_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, sideStr, sideStr) + ), + printf(fh, "~%"), + flush_output(fH), + fHatSurf_e : doExpand1(eval_string(sconcat("fUp",sideStr)), bSurf), + + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + + if (sideStr="L") then (evPoint : -1) + elseif (sideStr="R") then (evPoint : 1), + + Ghat_c : calcInnerProdList(surfIntVars, alphaSurf_e, bSurf, fHatSurf_e), + Ghat_e : doExpand(Ghat_c, bSurf), + printf(fH, " double Ghat~a[~a] = {0.}; ~%", sideStr, length(bSurf)), + writeCExprs1(eval_string(sconcat("Ghat",sideStr)), Ghat_c), + printf(fH, "~%"), + flush_output(fH), + /* Zero out components of Ghat which are empty. */ + GhatNoZero : makelistNoZeros1(Ghat_c, eval_string(sconcat("Ghat",sideStr))), + Ghat_e : doExpand(GhatNoZero, bSurf), + + incr_c : fullratsimp(calcInnerProdList(surfIntVars, -evPoint, subst(surfVar=evPoint, bP), Ghat_e)), + + return(incr_c) +)$ + +calcAndWrite_upwindIncr_cflFreq_wQuadNodeAlpha(fH,basisType,polyOrder,bP,surfDir,sideStr, + alphaSurf_e,alphaUpSurf_e,fLR,isStep2) := block( + [varsP,numP,surfVar,surfIntVars,pDim,vdim,cdim,surf_cvars,surf_vvars,surfNodes, + bSurf,basisStr,numNodes,fL_e,fR_e,alphaOrd_n,i, + dirStr,fHatSurf_e,evPoint,Ghat_c,Ghat_e,GhatNoZero,incr_c], + + varsP : listofvars(bP), + numP : length(bP), + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + pDim : length(varsP), + + vdim : 0, + if isInList(vpar,varsP) then vdim : vdim+1, + if isInList(mu,varsP) then vdim : vdim+1, + cdim : pDim-vdim, + + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), + basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) + ), + numNodes : length(surfNodes), + + /* Expand distribution function. */ + fL_e : doExpand1(fLR[1],bP), + fR_e : doExpand1(fLR[2],bP), + + /* Evaluate alpha at ordinates. + Note: alphaSurf_e is already a surface expansion. */ + alphaOrd_n : gcfac(float(evAtNodes(alphaUpSurf_e,surfNodes,surfIntVars))), + + /* Determine upwinding and cflFreq at each surface quadrature node. */ + printf(fH, " double fUpOrd~a[~a] = {0.};~%", sideStr, numNodes), + printf(fH, " double alpha~a_n = 0.;~%", sideStr), + printf(fH, "~%"), + for i : 1 thru numNodes do ( + printf(fH, " alpha~a_n = ~a;~%", sideStr, float(expand(fullratsimp(alphaOrd_n[i])))), + printf(fH, " if (alpha~a_n > 0.) {~%", sideStr), + printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_r(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[1]), + printf(fh, " } else { ~%"), + printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_l(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[2]), + printf(fh, " } ~%"), + /* The extra factor of bP[1] below remains unexplained. NRM might've + stumbled up one it by trial and error. It may also have been meant + to average all the quad node values, but that meaning is only correct + for pure p=1. */ + printf(fh, " cflFreq = fmax(cflFreq, fabs(alpha~a_n)); ~%", sideStr, sideStr) + ), + printf(fH, "~%"), + flush_output(fH), + + /* Write coefficients of modal surface expansion fupwind. */ + printf(fh, " // Project tensor nodal quadrature basis back onto modal basis. ~%"), + printf(fH, " double fUp~a[~a] = {0.};~%", sideStr, length(bSurf)), + if polyOrder=1 then ( /* Force p=1 to use hybrid basis. */ + dirStr : "x", + if surfDir = cdim+1 then (dirStr : "vpar") elseif surfDir = cdim+2 then (dirStr : "mu"), + printf(fh, " ~a_~adir_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, dirStr, sideStr, sideStr) + ) else ( + printf(fh, " ~a_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, sideStr, sideStr) + ), + printf(fh, "~%"), + flush_output(fH), + fHatSurf_e : doExpand1(eval_string(sconcat("fUp",sideStr)), bSurf), + + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + + if (sideStr="L") then (evPoint : -1) + elseif (sideStr="R") then (evPoint : 1), + + Ghat_c : calcInnerProdList(surfIntVars, alphaSurf_e, bSurf, fHatSurf_e), + Ghat_e : doExpand(Ghat_c, bSurf), + printf(fH, " double Ghat~a[~a] = {0.}; ~%", sideStr, length(bSurf)), + writeCExprs1(eval_string(sconcat("Ghat",sideStr)), Ghat_c), + printf(fH, "~%"), + flush_output(fH), + /* Zero out components of Ghat which are empty. */ + GhatNoZero : makelistNoZeros1(Ghat_c, eval_string(sconcat("Ghat",sideStr))), + Ghat_e : doExpand(GhatNoZero, bSurf), + + incr_c : fullratsimp(calcInnerProdList(surfIntVars, -evPoint, subst(surfVar=evPoint, bP), Ghat_e)), + + return(incr_c) +)$ + +calcAndWrite_quadCFLfreq_wPhaseAlpha(basisType,polyOrder,bP,surfDir,alpha_e) := block( + [i,varsP,numP,cdim,vdim,pDim,surfVar,surfIntVars,pOrderCFL,surf_cvars,surf_vvars,surfNodes, + numNodes,alphaSurfL_c,alphaSurfL_e,alphaSurfL_n,alphaSurfR_c,alphaSurfR_e,alphaSurfR_n], + /* Compute the CFL frequency from quadrature node contributions on the + surfaces in the dir dimension, given a phase-space volume expansion + of the speed (i.e. coming from doExpand(alpha,bP)). */ + + varsP : listofvars(bP), + numP : length(bP), + pDim : length(varsP), + surfVar : varsP[surfDir], /* Surface variable. */ + surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ + vdim : 0, + if isInList(vpar,varsP) then vdim : vdim+1, + if isInList(mu,varsP) then vdim : vdim+1, + cdim : pDim-vdim, + + /* Identify polyOrder in velocity space as p=2 for p=1 since we force p=1 to + mean gkhybrid basis. */ + pOrderCFL : polyOrder, + if polyOrder=1 and surfDir=cdim+1 then ( pOrderCFL : 2 ), + + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + /* Evaluate cfl by evaluating at all surface quadrature points. */ + /* Get quadrature nodes on surface. */ + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1) + ), + numNodes : length(surfNodes), + + /* Coefficients of alpha written out to the file above are phase-space volume + expansion coefficients. Need to evaluate at the surface and project onto + surface basis, before (expanding and) evaluating at surface nodes. */ + /* The extra factor of bP[1] below remains unexplained. NRM might've + stumbled up one it by trial and error. */ + alphaSurfL_n : gcfac(float(evAtNodes(subst(surfVar=-1,alpha_e)*bP[1],surfNodes,surfIntVars)*bP[1])), + printf(fh, " // Evaluate alpha at left surface quadrature points.~%"), + for i : 1 thru numNodes do ( + printf(fh, " alphaL = ~a; ~%", gcfac(float(alphaSurfL_n[i]))), + printf(fh, " cflFreq += -~a*(alphaL-fabs(alphaL)); ~%",float(0.5*(2*pOrderCFL+1))) + ), + + alphaSurfR_n : gcfac(float(evAtNodes(subst(surfVar=+1,alpha_e)*bP[1],surfNodes,surfIntVars)*bP[1])), + printf(fh, " // Evaluate alpha at right surface quadrature points.~%"), + for i : 1 thru numNodes do ( + printf(fh, " alphaR = ~a; ~%", gcfac(float(alphaSurfR_n[i]))), + printf(fh, " cflFreq += ~a*(alphaR+fabs(alphaR)); ~%",float(0.5*(2*pOrderCFL+1))) + ) +)$ + +/* + Utility functions for computing surface DG updates + for the generic case applicable to all our kinetic equations: + For a *continuous* phase space flux alpha, if sign(alpha) is a constant + we can use simple upwind fluxes. + F = alpha_surf*f^- (if sign(alpha_surf) = 1), + F = alpha_surf*f^+ (if sign(alpha_surf) = -1) + Otherwise, we project sign(alpha_surf) first evaluating sign(alpha_surf) + at quadrature points and then using a nodal-to-modal transformation do + F = alpha_surf ( 1/2*(f^+ + f^-) - 1/2*sgn_alpha_surf*(f^+ - f^-) + + In this notation alpha_surf is the expansion of the *continuous* phase space flux + on the given surface, f^+ is the distribution function evaluated just outside the surface + and f^- is the distribution function evaluated just inside the surface + +------+------+ + | | | + | f^-|f^+ | + | | | + +------+------+ + alpha_surf +*/ + +/* Determine the upwinded distribution function in gyrokinetics */ +calcAndWrite_GKfUpwind(file_handle,cdim,surfDir,surfVar,surfIntVars,bSurf,fl_e,fr_e,basisStr,sideStr,no_by) := block( + [fstrL, fstrR, fLNm, fRNm, fUpNm, sgn_alpha_surfNm, sgn_alphaUpNm, NSurf,fSurfl_c, fSurfr_c, fSurfl_e, fSurfr_e, + surfNodes,nodeVars,basisNodal,sgn_alphaNodal_e,bSurf_no_by,sgn_alphaHatModProj_e,sgn_alphaUp_e,fUp_c], + + /* Naming convention for subsequent distribution function evaluations + for a cell-based update. If performing the left surface update + we need fl(surfVar=+1) and fc(surfVar=-1) (f_lr and f_cl) and if we are performing + the right surface update we need fc(surfVar=+1) and fr(surfVar=-1) (f_cr and f_rl) */ + if (sideStr = "L") then ( + fstrL : "lr", + fstrR : "cl" + ) else ( + fstrL : "cr", + fstrR : "rl" + ), + fLNm : eval_string(sconcat("f_",fstrL)), + fRNm : eval_string(sconcat("f_",fstrR)), + fUpNm : eval_string(sconcat("fUp",sideStr)), + sgn_alpha_surfNm : eval_string(sconcat("sgn_alpha_surf",sideStr)), + sgn_alphaUpNm : eval_string(sconcat("sgn_alphaUp",sideStr)), + + NSurf : length(bSurf), + printf(file_handle, " double fUp~a[~a] = {0.};~%", sideStr, NSurf), + fSurfl_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=1, fl_e)), + fSurfr_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=-1, fr_e)), + fSurfl_e : doExpand1(fLNm, bSurf), + fSurfr_e : doExpand1(fRNm, bSurf), + + clst : [vmap_prime_l[0],vmap_prime_l[1],vmap_prime_c[0],vmap_prime_c[1], + vmap_prime_r[0],vmap_prime_r[1],vmap_prime_edge[0],vmap_prime_edge[1], + vmap_prime_skin[0],vmap_prime_skin[1]], + /* If sign(alpha_surf) is single signed + 1. f^- (if sign(alpha_surf) = 1), + 2. f^+ (if sign(alpha_surf) = -1) */ + printf(file_handle, " if (const_sgn_alpha~a[0] == 1) { ~%", sideStr), + printf(file_handle, " if (sgn_alpha_surf~a[0] == 1.0) { ~%", sideStr), + writeCExprsCollect1(fUpNm, fSurfl_c, clst), + printf(file_handle, " } else { ~%"), + writeCExprsCollect1(fUpNm, fSurfr_c, clst), + printf(file_handle, " } ~%"), + + /* Else sign(alpha_surf) is changing quadrature point to quadrature point + 1/2*(f^+ + f^-) - 1/2*sgn_alpha_surf*(f^+ - f^-) */ + printf(file_handle, " } else { ~%"), + printf(file_handle, " double f_~a[~a] = {0.};~%", fstrL, NSurf), + printf(file_handle, " double f_~a[~a] = {0.};~%", fstrR, NSurf), + if (polyOrder = 1) then ( /* Force p=1 to use hybrid basis. */ + /* if no toroidal field and p=1, use a further reduced quadrature evaluation + to exploit the larger sparsity in the x and z updates. + The x update is surfDir = 1 and the z update is surfDir = cdim */ + if (no_by and surfDir = 1) then ( + surfNodes : gaussOrd(1+1, 1), + nodeVars : [z], + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", 1, 1, nodeVars, surfNodes), + sgn_alphaNodal_e : doExpand1(sgn_alpha_surfNm,basisNodal), + bSurf_no_by : basisFromVars("gkhyb",nodeVars,polyOrder), + sgn_alphaHatModProj_e : fullratsimp(calcInnerProdList(nodeVars, 1, bSurf_no_by, sgn_alphaNodal_e)), + printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, length(bSurf_no_by)), + writeCExprs1(sgn_alphaUpNm, sgn_alphaHatModProj_e), + sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf_no_by) + ) + else if (no_by and surfDir = cdim) then ( + surfNodes : gaussOrdGkHyb(1+1, [x], [vpar]), + nodeVars : [x,vpar], + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", 1, 1, nodeVars, surfNodes), + sgn_alphaNodal_e : doExpand1(sgn_alpha_surfNm,basisNodal), + bSurf_no_by : basisFromVars("gkhyb",nodeVars,polyOrder), + sgn_alphaHatModProj_e : fullratsimp(calcInnerProdList(nodeVars, 1, bSurf_no_by, sgn_alphaNodal_e)), + printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, length(bSurf_no_by)), + writeCExprs1(sgn_alphaUpNm, sgn_alphaHatModProj_e), + sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf_no_by) + ) + else ( + dirStr : "x", + if (surfDir = cdim+1) then (dirStr : "vpar") elseif (surfDir = cdim+2) then (dirStr : "mu"), + printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, NSurf), + printf(file_handle, " ~a_~adir_upwind_quad_to_modal(~a, ~a); ~%", basisStr, dirStr, sgn_alpha_surfNm, sgn_alphaUpNm), + sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf) + ) + ) else ( + printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, NSurf), + printf(file_handle, " ~a_upwind_quad_to_modal(~a, ~a); ~%", basisStr, sgn_alpha_surfNm, sgn_alphaUpNm), + sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf) + ), + printf(file_handle, "~%"), + + writeCExprsCollect1(fLNm, fSurfl_c, clst), + printf(file_handle, "~%"), + flush_output(file_handle), + + writeCExprsCollect1(fRNm, fSurfr_c, clst), + printf(file_handle, "~%"), + flush_output(file_handle), + + fUp_c : calcInnerProdList(surfIntVars, 1, bSurf, 0.5*(fSurfl_e + fSurfr_e) - 0.5*sgn_alphaUp_e*(fSurfr_e - fSurfl_e)), + writeCExprsNoExpand1(fUpNm, gcfac(float(expand(fUp_c)))), + printf(file_handle, "~%"), + flush_output(file_handle), + + printf(file_handle, " } ~%") +)$ + +/* Determine the upwinded distribution function in gyrokinetics */ +calcAndWrite_sgn_alpha(file_handle,surfIntVars,surfNodes,numNodes,alphaSurf_e,sideStr) := block( + [alphaOrd_n], + /* Determine sign(alpha_surf) for upwinding at each surface quadrature node. */ + + /* Evaluate alpha at ordinates. + Note: alphaSurf_e is already a surface expansion. */ + alphaOrd_n : gcfac(float(evAtNodes(alphaSurf_e,surfNodes,surfIntVars))), + + printf(file_handle, " int const_sgn_alpha_surf = 1; ~%"), + printf(file_handle, " ~%"), + /* Write out first quadrature point + We are going to compare the signs of the quadrature points to see if the sign is constant */ + printf(file_handle, " if (~a > 0.) ~%", gcfac(float(expand(fullratsimp(alphaOrd_n[1]))))), + printf(file_handle, " sgn_alpha_surf~a[0] = 1.0; ~%", sideStr), + printf(file_handle, " else ~%"), + printf(file_handle, " sgn_alpha_surf~a[0] = -1.0; ~%", sideStr), + printf(file_handle, " ~%"), + /* Write out the other quadrature point evaluations and compare the signs point by point */ + for i : 2 thru numNodes do ( + printf(file_handle, " if (~a > 0.) ~%", gcfac(float(expand(fullratsimp(alphaOrd_n[i]))))), + printf(file_handle, " sgn_alpha_surf~a[~a] = 1.0; ~%", sideStr, i-1), + printf(file_handle, " else ~%"), + printf(file_handle, " sgn_alpha_surf~a[~a] = -1.0; ~%", sideStr, i-1), + printf(file_handle, " ~%"), + printf(file_handle, " if (sgn_alpha_surf~a[~a] == sgn_alpha_surf~a[~a]) ~%", sideStr, i-1, sideStr, i-2), + printf(file_handle, " const_sgn_alpha_surf = const_sgn_alpha_surf ? 1 : 0; ~%"), + printf(file_handle, " else ~%"), + printf(file_handle, " const_sgn_alpha_surf = 0; ~%"), + printf(file_handle, " ~%") + ) +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac new file mode 100644 index 00000000..d1208032 --- /dev/null +++ b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac @@ -0,0 +1,244 @@ +load("modal-basis")$ +load("out-scripts")$ +load(stringproc)$ +load("scifac")$ +load("utilities_gyrokinetic")$ +fpprec : 24$ + +buildGKFluxVparAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, + numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, + bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, + hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + configNodes : gaussOrd(polyOrder+1, cdim), + numSurfNodes : length(surfNodes), + numConfigNodes : length(configNodes), + numVelNodes : numSurfNodes/numConfigNodes, + + /* if polyOrder = 1, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size in the + vparallel surfaces and/or we are more directly exploiting the sparsity of + alpha (e.g., in the x and z direction when no toroidal field, by=0) + and thus utilize fewer coefficients to reduce the number of operations */ + if (polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgv: volume DG geometry.~%"), + printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmag_e : doExpand1(bmag, bmagBasis), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + if edge = true then ( + evPoint : 1 + ) else ( + evPoint : -1 + ), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ + + /*fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), + JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), + + JfL_e : subst(surfVar=1,JfL_e), + JfR_e : subst(surfVar=-1,JfR_e), + + JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), + JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), + + vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), + + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_nodes : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), + dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) + ) + else ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ) + ), + + /* Now calculate apha at all quadrature nodes */ + /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + printf(fh, " double bmag_quad = 0.0; ~%"), + printf(fh, " double B3_quad = 0.0; ~%"), + printf(fh, " double Jc_quad = 0.0; ~%"), + printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + printf(fh, "~%"), + + for i : 1 thru numConfigNodes do ( + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + printf(fh, "~%"), + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + printf(fh, "~%"), + if no_by = true then ( + printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) + ), + if no_by = false then ( + printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), + if cdim = 3 then ( + for k : 1 thru cdim do ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ) + ), + if cdim = 2 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + if cdim = 1 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + printf(fh, ";~%") + ), + + printf(fh, "~%"), + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), + printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), + printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + ), + printf(fh, "~%") + ), + + /* Do the quad nodal to modal ops directly here*/ + /*printf(fh, "~%"), + printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), + fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), + + for i : 1 thru length(fmodproj_e) do ( + printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) + ), + + printf(fh, "~%"),*/ + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + if polyOrder=1 then ( pOrderCFL : 2 ), + printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), + vprimeStr : "/vmap_prime_min", + printf(fh, "~%"), + printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%") + + printf(fh, " return 0.; ~%") + flush_output(fh), + printf(fh, "} ~%") + +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf_add_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac similarity index 100% rename from maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf_add_em.mac rename to maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_add_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac similarity index 100% rename from maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_add_em.mac rename to maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac diff --git a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac new file mode 100644 index 00000000..1a8bdcef --- /dev/null +++ b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac @@ -0,0 +1,126 @@ +/* Compute the header file for gyrokinetic collisionless flux kernels. */ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +maxPolyOrder_Ser : 2$ +minCdim_Ser : 1$ +minVdim_Ser : 1$ +maxCdim_Ser : 3$ +maxVdim_Ser : 2$ + +/* Tensor order basis. */ +maxPolyOrder_Tensor : 2$ +minCdim_Tensor : 1$ +minVdim_Tensor : 1$ +maxCdim_Tensor : 0$ +maxVdim_Tensor : 0$ + +/* Number of velocity dimensions allowed for each + configuration-space dimension. */ +gkVdims : [[1,2], [2], [2]]$ + +/* ...... END OF USER INPUTS........ */ + +varsC : [x, y, z]$ +varsV : [vpar, mu]$ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +minVdim : [minVdim_Ser, minVdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ +maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ + +/* Options for writing kernels with and without toroidal field (b_y=0), one per + dimension, or make the kernel only add electromagnetic terms. */ +byOpt : [[false, false], [false, false, false], [false, false, true]]$ +emOpt : [[false, true], [false, true, false], [false, true, false]]$ +optStr : ["", "add_em_", "no_by_"]$ + +/* Options for writing kernels used at multiblock boundaries. One for each + dimension. */ +mb_bcOpt : [[false,true],[false,true],[false,true]]$ +mb_bcStr : ["", "multib_boundary_"]$ + +printPrototypes() := block([], + for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + + for byI : 1 thru length(byOpt[c]) do ( + no_by : byOpt[c][byI], + add_em : emOpt[c][byI], + opt_str : optStr[byI], + if not(add_em) then ( + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ) + ) + ), + + + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", opt_str, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ), + + printf(fh, "~%") + ) + ) + ) + ) +)$ + +fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels.h")$ +printf(fh, "#pragma once~%")$ +printf(fh, "~%")$ +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ +printf(fh, "~%")$ +printf(fh, "EXTERN_C_BEG~%")$ +printf(fh, "~%")$ +printPrototypes()$ +printf(fh, "~%")$ +printf(fh, "EXTERN_C_END~%")$ +close(fh)$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_add_em.mac b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac similarity index 100% rename from maxima/g0/gk_collisionless/ms-gk_collisionless_flux_add_em.mac rename to maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 34e06ea7..80e91ba2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -296,4 +296,4 @@ buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), printf(fh, "} ~%") -)$ +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 617facd2..1b5f0054 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -239,243 +239,4 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), printf(fh, "} ~%") -)$ - -buildGKFluxVparAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, - numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, - bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, - hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - configNodes : gaussOrd(polyOrder+1, cdim), - numSurfNodes : length(surfNodes), - numConfigNodes : length(configNodes), - numVelNodes : numSurfNodes/numConfigNodes, - - /* if polyOrder = 1, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size in the - vparallel surfaces and/or we are more directly exploiting the sparsity of - alpha (e.g., in the x and z direction when no toroidal field, by=0) - and thus utilize fewer coefficients to reduce the number of operations */ - if (polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgv: volume DG geometry.~%"), - printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - if false then ( - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmag_e : doExpand1(bmag, bmagBasis), - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - if edge = true then ( - evPoint : 1 - ) else ( - evPoint : -1 - ), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ - - /*fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), - JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), - - JfL_e : subst(surfVar=1,JfL_e), - JfR_e : subst(surfVar=-1,JfR_e), - - JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), - JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), - - vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), - - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_nodes : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), - dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) - ) - else ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ) - ), - - /* Now calculate apha at all quadrature nodes */ - /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - printf(fh, " double bmag_quad = 0.0; ~%"), - printf(fh, " double B3_quad = 0.0; ~%"), - printf(fh, " double Jc_quad = 0.0; ~%"), - printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - printf(fh, "~%"), - - for i : 1 thru numConfigNodes do ( - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), - printf(fh, "~%"), - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - printf(fh, "~%"), - if no_by = true then ( - printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) - ), - if no_by = false then ( - printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), - if cdim = 3 then ( - for k : 1 thru cdim do ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ) - ), - if cdim = 2 then ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - if cdim = 1 then ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - printf(fh, ";~%") - ), - - printf(fh, "~%"), - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), - printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), - printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ), - printf(fh, "~%") - ), - - /* Do the quad nodal to modal ops directly here*/ - /*printf(fh, "~%"), - printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), - fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), - - for i : 1 thru length(fmodproj_e) do ( - printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) - ), - - printf(fh, "~%"),*/ - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - if polyOrder=1 then ( pOrderCFL : 2 ), - printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), - vprimeStr : "/vmap_prime_min", - printf(fh, "~%"), - printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%") - ) else ( - printf(fh, " return 0.; ~%") - ), - flush_output(fh), - printf(fh, "} ~%") - -)$ +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 7282821a..88182f28 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -53,12 +53,7 @@ printPrototypes() := block([], const double *bmag, const double *phi, const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_vol_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const double *bmag, const double *phi, - const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, - const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - + for surfDir : 1 thru c+1 do ( if surfDir<=c then ( dirlabel : varsC[surfDir] @@ -83,19 +78,9 @@ printPrototypes() := block([], const double *flux_surf_l, const double *flux_surf_r, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), printf(fh, "GKYL_CU_DH double dg_gyrokinetic_boundary_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap_prime_edge, const double *vmap_prime_skin, - const double *flux_surf_edge, const double *flux_surf_skin, - const int edge, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), - if dirlabel=vpar then ( - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, - const double *flux_surf_l, const double *flux_surf_r, - double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_boundary_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, const double *vmap_prime_edge, const double *vmap_prime_skin, const double *flux_surf_edge, const double *flux_surf_skin, const int edge, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder) - ) ), printf(fh, "~%") ) @@ -117,4 +102,4 @@ printf(fh, "~%")$ printPrototypes()$ printf(fh, "~%")$ printf(fh, "EXTERN_C_END~%")$ -close(fh)$ +close(fh)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac index 18f5db41..f4f8e358 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac @@ -102,4 +102,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index ef0b8a40..eb27bf41 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -69,4 +69,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index 1a8bdcef..d7efdee5 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -34,10 +34,9 @@ maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ /* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension, or make the kernel only add electromagnetic terms. */ -byOpt : [[false, false], [false, false, false], [false, false, true]]$ -emOpt : [[false, true], [false, true, false], [false, true, false]]$ -optStr : ["", "add_em_", "no_by_"]$ + dimension. */ +byOpt : [[false], [false, true], [false, true]]$ +byStr : ["", "no_by_"]$ /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ @@ -56,51 +55,48 @@ printPrototypes() := block([], for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], - add_em : emOpt[c][byI], - opt_str : optStr[byI], - if not(add_em) then ( - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + no_byStr : byStr[byI], + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ) + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ) ), + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", opt_str, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ), printf(fh, "~%") @@ -123,4 +119,4 @@ printf(fh, "~%")$ printPrototypes()$ printf(fh, "~%")$ printf(fh, "EXTERN_C_END~%")$ -close(fh)$ +close(fh)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 25581b85..62aed087 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -102,4 +102,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ +)$ \ No newline at end of file From a789c8f46c5a08f0247fe241d711de8dd624ea87 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 23 Oct 2025 15:03:19 -0400 Subject: [PATCH 04/54] restore electrostatic files --- maxima/g0/gk_collisionless/dg_gk-surf.mac | 1 + maxima/g0/gk_collisionless/dg_gk-vol.mac | 2 +- maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac | 2 +- maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac | 2 +- maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac | 2 +- maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac | 2 +- maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac | 2 +- maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac | 2 +- maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac | 2 +- 9 files changed, 9 insertions(+), 8 deletions(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-surf.mac b/maxima/g0/gk_collisionless/dg_gk-surf.mac index b657bab1..77901135 100644 --- a/maxima/g0/gk_collisionless/dg_gk-surf.mac +++ b/maxima/g0/gk_collisionless/dg_gk-surf.mac @@ -271,3 +271,4 @@ calcGKBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrd flush_output(fh) )$ + diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index fccd4ab1..01905ad3 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -256,4 +256,4 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, " return 0.; ~%"), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 80e91ba2..34e06ea7 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -296,4 +296,4 @@ buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 1b5f0054..a172abb2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -239,4 +239,4 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 88182f28..08e41563 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -102,4 +102,4 @@ printf(fh, "~%")$ printPrototypes()$ printf(fh, "~%")$ printf(fh, "EXTERN_C_END~%")$ -close(fh)$ \ No newline at end of file +close(fh)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac index f4f8e358..18f5db41 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac @@ -102,4 +102,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index eb27bf41..ef0b8a40 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -69,4 +69,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index d7efdee5..ebef045a 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -119,4 +119,4 @@ printf(fh, "~%")$ printPrototypes()$ printf(fh, "~%")$ printf(fh, "EXTERN_C_END~%")$ -close(fh)$ \ No newline at end of file +close(fh)$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 62aed087..25581b85 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -102,4 +102,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ \ No newline at end of file +)$ From 90d8dd8b8dfe2b9ce168f23e06455b56d7237e75 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 23 Oct 2025 16:55:15 -0400 Subject: [PATCH 05/54] this commit is able to create all the add em kernels (empty) and the associated headers. --- .../g0/gk_collisionless/em/dg_gk-vol_em.mac | 282 ------------------ .../em/gk_collisionless_flux-surf-conf_em.mac | 85 ++++++ .../em/gk_collisionless_flux-surf-vpar_em.mac | 156 +--------- .../em/ms-dg_gyrokinetic-header_em.mac | 105 +++++++ .../em/ms-dg_gyrokinetic-surf_em.mac | 2 +- .../em/ms-dg_gyrokinetic-vol_em.mac | 2 +- .../em/ms-gk_collisionless_flux-header_em.mac | 52 ++-- .../em/ms-gk_collisionless_flux_em.mac | 71 +++-- 8 files changed, 263 insertions(+), 492 deletions(-) create mode 100644 maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac create mode 100644 maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac diff --git a/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac b/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac index 678f4a6a..7536cfd2 100644 --- a/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac +++ b/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac @@ -40,288 +40,6 @@ buildGKAddEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_b printf(fh, " // fin: Distribution function.~%"), printf(fh, " // out: output increment.~%"), printf(fh, "~%"), - - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pDim do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - - /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ - printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), - printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), - printf(fh, "~%"), - replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), - [dvparSq=4/rdvpar2Sq]), - - /* Create pointers to the components of b_i. */ - allVarLabelsC : ["x","y","z"], - for d : 1 thru 3 do ( - printf(fh, " const double *bioverJB_~a = &bioverJB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - /* Create pointers to the components of dualcurlbhatoverB. */ - allVarLabelsC : ["x","y","z"], - for d : 1 thru 3 do ( - printf(fh, " const double *dualcurlbhatoverB_~a = &dualcurlbhatoverB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - apar_e : doExpand1(apar,bC), - bmag_e : doExpand1(bmag, bmagBasis), - - - /* dualcurlbhatoverB_x_e : doExpand1(dualcurlbhatoverB_x, bmagBasis), - dualcurlbhatoverB_y_e : doExpand1(dualcurlbhatoverB_y, bmagBasis), - dualcurlbhatoverB_z_e : doExpand1(dualcurlbhatoverB_z, bmagBasis), */ - /* Zero out some terms below to avoid the discontinuity of alpha in the - parallel direction (due to the discontinuity of Apar). Otherwise some - other treatment of some Apar terms or alpha may be needed. Initially we - had a step averaging alpha across the surface (just for the parallel - direction), but NRM suspects this might've caused instability in some - cases. Hence the zeros below. */ - discontFac : 0, - if cdim > 1 then (rdy2 : rdx2vec[2]) else (rdy2 : 0), - if cdim > 2 then (rdz2 : rdx2vec[3]) else (rdz2 : 0), - /* Expand e^x . \nabla \times A_\parallel / Bmag on basis. */ - dualcurlbAparoverB_x_e : (rdy2*diff(apar_e*b_z_e,y) - discontFac*rdz2*diff(apar_e*b_y_e,z))*jacobTotInv_e, - /* Expand e^y . \nabla \times A_\parallel / Bmag on basis. */ - dualcurlbAparoverB_y_e : (discontFac*rdz2*diff(apar_e*b_x_e,z) - rdx2vec[1]*diff(apar_e*b_z_e,x))*jacobTotInv_e, - /* Expand e^z . \nabla \times A_\parallel / Bmag on basis. */ - dualcurlbAparoverB_z_e : (discontFac*(rdx2vec[1]*diff(apar_e*b_y_e,x) - rdy2*diff(apar_e*b_x_e,y)))*jacobTotInv_e, - - varsP : listofvars(bP), - numP : length(bP), - - /* Project Bstar's onto basis, and print to arrays. */ - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - if cdim > 1 then ( - dualcurlbAparoverB_c : calcInnerProdList(varsP, 1, bP, dualcurlbAparoverB_x_e), - if (surfDir = 0 or surfDir = 1 or surfDir = cdim+1) then ( - printf(fh, " double dualcurlbAparoverB~a[~a] = {0.}; ~%", sideStr,numP), - writeCExprsNoExpand1(eval_string(sconcat("dualcurlbAparoverB",sideStr)), gcfac(subst(replaceList, dualcurlbAparoverB_c))), - printf(fh, "~%"), - flush_output(fh) - ), - dualcurlbAparoverB_noZero_c : makelistNoZeros1(dualcurlbAparoverB_c, eval_string(sconcat("dualcurlbAparoverB",sideStr))), - dualcurlbAparoverB_e : dualcurlbAparoverB_noZero_c . bP, - - dualcurlbAparoverB_y_c : calcInnerProdList(varsP, 1, bP, dualcurlbAparoverB_y_e), - if (surfDir = 0 or surfDir = 2 or surfDir = cdim+1) then ( - printf(fh, " double dualcurlbAparoverB_y~a[~a] = {0.}; ~%", sideStr, numP), - writeCExprsNoExpand1(eval_string(sconcat("dualcurlbAparoverB_y",sideStr)), gcfac(subst(replaceList, dualcurlbAparoverB_y_c))), - printf(fh, "~%"), - flush_output(fh) - ), - dualcurlbAparoverB_y_noZero_c : makelistNoZeros1(dualcurlbAparoverB_y_c, eval_string(sconcat("dualcurlbAparoverB_y",sideStr))), - dualcurlbAparoverB_y_e : dualcurlbAparoverB_y_noZero_c . bP - ), - if cdim # 2 then ( - dualcurlbAparoverB_z_c : calcInnerProdList(varsP, 1, bP, dualcurlbAparoverB_z_e), - if (surfDir=0 or surfDir>=cdim) then ( - printf(fh, " double dualcurlbAparoverB_z~a[~a] = {0.}; ~%", sideStr, numP), - writeCExprsNoExpand1(eval_string(sconcat("dualcurlbAparoverB_z",sideStr)), gcfac(subst(replaceList, dualcurlbAparoverB_z_c))), - printf(fh, "~%"), - flush_output(fh) - ), - dualcurlbAparoverB_z_noZero_c : makelistNoZeros1(dualcurlbAparoverB_z_c, eval_string(sconcat("dualcurlbAparoverB_z",sideStr))), - dualcurlbAparoverB_z_e : dualcurlbAparoverB_z_noZero_c . bP - ), - - /* Make Bstar/Bmag vector. */ - /* if cdim = 1 then ( - dualcurlbAparoverB_list : [dualcurlbAparoverB_z_e] - ) elseif cdim = 2 then ( - dualcurlbAparoverB_list : [dualcurlbAparoverB_x_e, dualcurlbAparoverB_y_e] - ) elseif cdim = 3 then ( - dualcurlbAparoverB_list : [dualcurlbAparoverB_x_e, dualcurlbAparoverB_y_e, dualcurlbAparoverB_z_e] - ), */ - - rtg33inv_e : doExpand1(rtg33inv, bmagBasis), - bioverJB_x_e : doExpand1(bioverJB_x, bmagBasis), - bioverJB_y_e : doExpand1(bioverJB_y, bmagBasis), - bioverJB_z_e : doExpand1(bioverJB_z, bmagBasis), - - dualcurlbAparoverB_list : [dualcurlbAparoverB_x_e, dualcurlbAparoverB_y_e, dualcurlbAparoverB_z_e], - bioverJB_list : [bioverJB_x_e, bioverJB_y_e, bioverJB_z_e], - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - - /*Expand Jf*/ - Jf_e : doExpand1(fin,bP), - - /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_e : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_e[i] : diff(hamil_e,varsP[i]) - ) - else ( - dH_dz_e[i] : diff(hamil_e*rdx2vec[i],varsP[i]) - ) - ), - - /*Make sure to avoid having hamil[i]^2 or vmap[i]^2 in expressions*/ - replaceListVpar : [vmap[1]^2=vmap2], - printf(fh, " double vmap2 = vmap[1]*vmap[1]; ~%"), - printf(fh, "~%"), - - mvpar_e : dH_dz_e[vpardim]/vmap_prime_e[1], - mvparsq_e : mvpar_e*mvpar_e/m_, - isqlist : [], - for i : 1 thru numP do ( - if freeof(hamil[i]^2, expand(mvparsq_e)) = false then ( - isqlist : append(isqlist,[i]) - ) - ), - - replaceListHamil : [], - printf(fh, " double hamil2[~a] = {0.}; ~%", length(isqlist)), - for i : 1 thru length(isqlist) do ( - printf(fh, " hamil2[~a] = hamil[~a]*hamil[~a]; ~%", i-1, isqlist[i], isqlist[i]), - replaceListHamil : append(replaceListHamil, [hamil[isqlist[i]]^2=hamil2[i-1]]) - ), - printf(fh, "~%"), - - /* Note: no contribution from mu. */ - for dir : 1 thru cdim+1 do ( - - dirLabel : varLabel[dir], - - wDir : eval_string(sconcat("w",dirLabel)), - rdDirVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - dirVar : varsP[dir], /* Variable in current direction. */ - - if dir = cdim then ( - alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ - ) - else if dir = vpardim then ( - alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ - ) - else ( - alpha_e : 0 - ), - - - if no_by = false then ( - if cdim = 3 then ( - curvdriftdir : dir - ), - if cdim = 2 then ( - if dir = 1 then ( - curvdriftdir : dir - ), - if dir = 2 then ( - curvdriftdir : 3 - ) - ), - if cdim = 1 then ( - curvdriftdir : 3 - ), - - if dir < vpardim then ( - alpha_e : alpha_e + dualcurlbAparoverB_list[curvdriftdir]*dH_dz_e[vpardim]/vmap_prime_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/m_/q_ - ), - if cdim = 3 then ( - if dir = 1 then ( - alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[3] - bioverJB_list[3]*dH_dz_e[2]) - ), - if dir = 2 then ( - alpha_e : alpha_e + 1/q_ * (bioverJB_list[3]*dH_dz_e[1] - bioverJB_list[1]*dH_dz_e[3]) - ), - if dir = 3 then ( - alpha_e : alpha_e + 1/q_ * (bioverJB_list[1]*dH_dz_e[2] - bioverJB_list[2]*dH_dz_e[1]) - ) - ), - if cdim = 2 then ( - if dir = 1 then ( - alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[2]) - ), - if dir = 2 then ( - alpha_e : alpha_e - 1/q_ * (bioverJB_list[2]*dH_dz_e[1]) - ) - ), - if dir = vpardim then ( - if cdim = 3 then ( - for k : 1 thru cdim do ( - alpha_e : alpha_e - dualcurlbAparoverB_list[k]*dH_dz_e[k]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - ) - ), - if cdim = 2 then ( - alpha_e : alpha_e - dualcurlbAparoverB_list[1]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - dualcurlbAparoverB_list[3]*dH_dz_e[2]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - ), - if cdim = 1 then ( - alpha_e : alpha_e - dualcurlbAparoverB_list[3]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - ) - ) - - ), - - if dir < vpardim then ( - alpha_e : alpha_e*rdx2vec[dir] - ) - else if dir = vpardim then ( - alpha_e : alpha_e/vmap_prime_e[1] - ), - - /* Project alpha on basis and write to array. */ - printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), - alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), - alpha_c : subst(replaceList, alpha_c), - alpha_c : subst(replaceListHamil, alpha_c), - alpha_c : subst(replaceListVpar, alpha_c), - alpha_c : subst(dvparSimp, alpha_c), - alphaLabel : eval_string(sconcat(alpha, dirLabel)), - clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], - writeCExprsCollect1(alphaLabel, alpha_c, clst), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), - alpha_e : doExpand(alphaNoZero_c, bP), - - alphaJf_e : alpha_e*Jf_e, - - printf(fh, "~%"), - volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), - volTerm_c : subst(replaceList, volTerm_c), - writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), - flush_output(fh), - printf(fh, "~%") - - ), - - printf(fh, " return 0.; ~%"), printf(fh, "} ~%") )$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac new file mode 100644 index 00000000..50c5cfcc --- /dev/null +++ b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac @@ -0,0 +1,85 @@ +load("modal-basis")$ +load("out-scripts")$ +load(stringproc)$ +load("scifac")$ +load("utilities_gyrokinetic")$ +load("nodal_operations/nodal_functions")$ +fpprec : 24$ + +buildGKFluxConfAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, + numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, + vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, + jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + if cdim = 1 then ( + surfConfigNodes : [1] + ) + else ( + surfConfigNodes : gaussOrd(polyOrder+1, cdim-1) + ), + numSurfNodes : length(surfNodes), + numSurfConfigNodes : length(surfConfigNodes), + numVelNodes : numSurfNodes/numSurfConfigNodes, + numMuNodes : 1, + if vdim > 1 then ( numMuNodes : 2), + numVparNodes : numVelNodes/numMuNodes, + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, + const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgs: surface DG geometry.~%"), + printf(fh, " // gkdgs: gyrokinetic surface DG geometry.~%"), + printf(fh, " // bmag: bmag represented on the surface.~%"), + printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), + printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + + printf(fh, " return 0.; ~%"), + printf(fh, "} ~%") +)$ diff --git a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac index d1208032..f856ffb8 100644 --- a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac +++ b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac @@ -85,160 +85,6 @@ buildGKFluxVparAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), printf(fh, "~%"), - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmag_e : doExpand1(bmag, bmagBasis), - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - if edge = true then ( - evPoint : 1 - ) else ( - evPoint : -1 - ), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ - - /*fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), - JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), - - JfL_e : subst(surfVar=1,JfL_e), - JfR_e : subst(surfVar=-1,JfR_e), - - JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), - JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), - - vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), - - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_nodes : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), - dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) - ) - else ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ) - ), - - /* Now calculate apha at all quadrature nodes */ - /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - printf(fh, " double bmag_quad = 0.0; ~%"), - printf(fh, " double B3_quad = 0.0; ~%"), - printf(fh, " double Jc_quad = 0.0; ~%"), - printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - printf(fh, "~%"), - - for i : 1 thru numConfigNodes do ( - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), - printf(fh, "~%"), - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - printf(fh, "~%"), - if no_by = true then ( - printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) - ), - if no_by = false then ( - printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), - if cdim = 3 then ( - for k : 1 thru cdim do ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ) - ), - if cdim = 2 then ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - if cdim = 1 then ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - printf(fh, ";~%") - ), - - printf(fh, "~%"), - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), - printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), - printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ), - printf(fh, "~%") - ), - - /* Do the quad nodal to modal ops directly here*/ - /*printf(fh, "~%"), - printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), - fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), - - for i : 1 thru length(fmodproj_e) do ( - printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) - ), - - printf(fh, "~%"),*/ - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - if polyOrder=1 then ( pOrderCFL : 2 ), - printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), - vprimeStr : "/vmap_prime_min", - printf(fh, "~%"), - printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%") - - printf(fh, " return 0.; ~%") - flush_output(fh), + printf(fh, " return 0.; ~%"), printf(fh, "} ~%") - )$ diff --git a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac new file mode 100644 index 00000000..3ecb7cfd --- /dev/null +++ b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac @@ -0,0 +1,105 @@ +/* Compute the header file for gyrokinetic collisionless equation object kernels. */ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +maxPolyOrder_Ser : 2$ +minCdim_Ser : 1$ +minVdim_Ser : 1$ +maxCdim_Ser : 3$ +maxVdim_Ser : 2$ + +/* Tensor order basis. */ +maxPolyOrder_Tensor : 2$ +minCdim_Tensor : 1$ +minVdim_Tensor : 1$ +maxCdim_Tensor : 0$ +maxVdim_Tensor : 0$ + +/* Number of velocity dimensions allowed for each + configuration-space dimension. */ +gkVdims : [[1,2], [2], [2]]$ + +/* ...... END OF USER INPUTS........ */ + +varsC : [x, y, z]$ +varsV : [vpar, mu]$ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +minVdim : [minVdim_Ser, minVdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ +maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ + +printPrototypes() := block([], + for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_vol_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const double *bmag, const double *phi, + const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, + const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_no_by_vol_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const double *bmag, const double *phi, + const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, + const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), + + for surfDir : 1 thru c+1 do ( + if surfDir<=c then ( + dirlabel : varsC[surfDir] + ) else ( + dirlabel : varsV[surfDir-c] + ), + + if surfDir<=c then ( + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, " + ) else ( + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, " + ), + + if surfDir<=c then ( + vprimeargs : "" + ) else ( + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, " + ), + + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, + const double *flux_surf_l, const double *flux_surf_r, + double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_boundary_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap_prime_edge, const double *vmap_prime_skin, + const double *flux_surf_edge, const double *flux_surf_skin, + const int edge, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder) + ), + printf(fh, "~%") + ) + ) + ) + ) +)$ + +fh : openw("~/max-out/gkyl_dg_gyrokinetic_kernels.h")$ +printf(fh, "#pragma once~%")$ +printf(fh, "~%")$ +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ +printf(fh, "~%")$ +printf(fh, "EXTERN_C_BEG~%")$ +printf(fh, "~%")$ +printPrototypes()$ +printf(fh, "~%")$ +printf(fh, "EXTERN_C_END~%")$ +close(fh)$ diff --git a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac index b4519e55..85a5baf4 100644 --- a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac +++ b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac @@ -5,7 +5,7 @@ The functions called in this file are in gkFuncs-surf.mac. */ -load("gk_collisionless/dg_gk-surf")$ +load("gk_collisionless/em/dg_gk-surf_em")$ /* ...... USER INPUTS........ */ diff --git a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac index 06d70168..e2766cb2 100644 --- a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac +++ b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac @@ -3,7 +3,7 @@ The functions called in this file are in gkFuncs-vol.mac. */ -load("gk_collisionless/dg_gk-vol")$ +load("gk_collisionless/em/dg_gk-vol_em")$ /* ...... USER INPUTS........ */ diff --git a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac index 1a8bdcef..f51e3991 100644 --- a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac +++ b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac @@ -34,10 +34,9 @@ maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ /* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension, or make the kernel only add electromagnetic terms. */ -byOpt : [[false, false], [false, false, false], [false, false, true]]$ -emOpt : [[false, true], [false, true, false], [false, true, false]]$ -optStr : ["", "add_em_", "no_by_"]$ + dimension. */ +byOpt : [[false], [false, true], [false, true]]$ +byStr : ["", "no_by_"]$ /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ @@ -56,51 +55,48 @@ printPrototypes() := block([], for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], - add_em : emOpt[c][byI], - opt_str : optStr[byI], - if not(add_em) then ( - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + no_byStr : byStr[byI], + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_em_~a~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_em_~a~aedge_surf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", opt_str, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ) + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ) ), + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_em_~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", opt_str, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ), printf(fh, "~%") @@ -110,7 +106,7 @@ printPrototypes() := block([], ) )$ -fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels.h")$ +fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels_add_em.h")$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac index 5f4b9bfc..4844eeb9 100644 --- a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac +++ b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac @@ -3,8 +3,8 @@ The functions called in this file are in gkFuncs-alpha-surf.mac. */ -load("gk_collisionless/gk_collisionless_flux-surf-conf")$ -load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ +load("gk_collisionless/em/gk_collisionless_flux-surf-conf_em")$ +load("gk_collisionless/em/gk_collisionless_flux-surf-vpar_em")$ /* ...... USER INPUTS........ */ @@ -36,10 +36,9 @@ clabels : ["x","y","z"]$ vlabels : ["vpar","mu"]$ /* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension, or make the kernel only add electromagnetic terms. */ -byOpt : [[false, false], [false, false, false], [false, false, true]]$ -emOpt : [[false, true], [false, true, false], [false, true, false]]$ -optStr : ["", "add_em_", "no_by_"]$ + dimension. */ +byOpt : [[false], [false, true], [false, true]]$ +byStr : ["", "no_by_"]$ /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ @@ -58,25 +57,47 @@ for bInd : 1 thru length(bName) do ( for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], - add_em : emOpt[c][byI], - opt_str : optStr[byI], - - if add_em then ( - /* Surface flux in vparallel direction.*/ - fname : sconcat("~/max-out/gk_collisionless_flux_",opt_str,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",opt_str,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_",opt_str,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - if add_em then ( - buildGKFluxVparAddEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false) - ) else ( - buildGKFluxVparESKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false) - ), - close(fh) - ) + no_byStr : byStr[byI], + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + /* Surface flux in direction dir in configuration space.*/ + for dir : 1 thru c do ( + + fname : sconcat("~/max-out/gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfAddEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), + close(fh), + + fname : sconcat("~/max-out/gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfAddEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), + close(fh) + ) + ), + + /* Surface flux in vparallel direction.*/ + fname : sconcat("~/max-out/gk_collisionless_flux_add_em_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_em_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxVparAddEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false), + close(fh) ) ) ) From fc855f84f356546f373f7b2c537d5bf6398dbb03 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 4 Nov 2025 11:55:52 -0500 Subject: [PATCH 06/54] New way of handling the EM kernels. We now generate two types of EM kernels, add_apar and add_apardot kernels. We conserve the electrostatic part of the scripts. --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 286 ++++++ .../g0/gk_collisionless/em/dg_gk-surf_em.mac | 158 --- .../g0/gk_collisionless/em/dg_gk-vol_em.mac | 45 - maxima/g0/gk_collisionless/em/gkUtil.mac | 954 ------------------ .../em/gk_collisionless_flux-surf-conf_em.mac | 85 -- .../em/gk_collisionless_flux-surf-vpar_em.mac | 90 -- .../em/ms-dg_gyrokinetic-header_em.mac | 105 -- .../em/ms-dg_gyrokinetic-surf_em.mac | 83 -- .../em/ms-dg_gyrokinetic-vol_em.mac | 72 -- .../em/ms-gk_collisionless_flux-header_em.mac | 122 --- .../em/ms-gk_collisionless_flux_em.mac | 105 -- .../gk_collisionless_flux-surf-conf.mac | 302 ++++++ .../gk_collisionless_flux-surf-vpar.mac | 417 ++++++++ .../ms-dg_gyrokinetic-header.mac | 21 + .../ms-dg_gyrokinetic-vol.mac | 17 + .../ms-gk_collisionless_flux-header.mac | 83 ++ .../ms-gk_collisionless_flux.mac | 50 +- 17 files changed, 1174 insertions(+), 1821 deletions(-) delete mode 100644 maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/gkUtil.mac delete mode 100644 maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac delete mode 100644 maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 01905ad3..62df8500 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -257,3 +257,289 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "} ~%") )$ + +addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( + [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, + hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + varLabel : makelist(string(varsP[d]),d,1,pDim), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, + const double q_, const double m_, const double *bmag, const double *jacobtot_inv, + const double *b_i, const double *phi, const double *apar, const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // jacobtot_inv: reciprocal of the conf-space jacobian time the guiding center coordinate Jacobian.~%"), + printf(fh, " // b_i: covariant components of the field aligned unit vector.~%"), + printf(fh, " // apar: parallel component of magnetic vector potential.~%"), + printf(fh, " // phi: electrostatic potential .~%"), + printf(fh, " // fin: Distribution function.~%"), + printf(fh, " // out: output increment.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru pDim do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ + printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), + printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), + printf(fh, "~%"), + replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], + dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), + [dvparSq=4/rdvpar2Sq]), + + allVarLabelsC : ["x","y","z"], + for d : 1 thru 3 do ( + printf(fh, " const double *b_~a = &b_i[~a];~%", allVarLabelsC[d], numC*(d-1)) + ), + printf(fh, "~%"), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmag_e : doExpand1(bmag, bmagBasis), + rtg33inv_e : doExpand1(rtg33inv, bmagBasis), + bioverJB_x_e : doExpand1(bioverJB_x, bmagBasis), + bioverJB_y_e : doExpand1(bioverJB_y, bmagBasis), + bioverJB_z_e : doExpand1(bioverJB_z, bmagBasis), + b_x_e : doExpand1(b_x, bmagBasis), + b_y_e : doExpand1(b_y, bmagBasis), + if (no_by or cdim = 1) then (b_y_e : 0), + b_z_e : doExpand1(b_z, bmagBasis), + jacobTotInv_e : doExpand1(jacobtot_inv, bmagBasis), + + bioverJB_list : [bioverJB_x_e, bioverJB_y_e, bioverJB_z_e], + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + + /*Expand Jf*/ + Jf_e : doExpand1(fin,bP), + + /* Calculate expressions for dericatives of the hamiltonian*/ + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_e : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_e[i] : diff(hamil_e,varsP[i]) + ) + else ( + dH_dz_e[i] : diff(hamil_e*rdx2vec[i],varsP[i]) + ) + ), + + /*Make sure to avoid having hamil[i]^2 or vmap[i]^2 in expressions*/ + replaceListVpar : [vmap[1]^2=vmap2], + printf(fh, " double vmap2 = vmap[1]*vmap[1]; ~%"), + printf(fh, "~%"), + + mvpar_e : dH_dz_e[vpardim]/vmap_prime_e[1], + mvparsq_e : mvpar_e*mvpar_e/m_, + isqlist : [], + for i : 1 thru numP do ( + if freeof(hamil[i]^2, expand(mvparsq_e)) = false then ( + isqlist : append(isqlist,[i]) + ) + ), + + replaceListHamil : [], + printf(fh, " double hamil2[~a] = {0.}; ~%", length(isqlist)), + for i : 1 thru length(isqlist) do ( + printf(fh, " hamil2[~a] = hamil[~a]*hamil[~a]; ~%", i-1, isqlist[i], isqlist[i]), + replaceListHamil : append(replaceListHamil, [hamil[isqlist[i]]^2=hamil2[i-1]]) + ), + printf(fh, "~%"), + + /* Expand Apar.*/ + Apar_e : doExpand1(apar,bC), + + /* Expand dBperp/Bmag. */ + dBperpoverB_x : (rdy2*diff(Apar_e*b_z_e,y) - rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e, + dBperpoverB_y : (rdz2*diff(Apar_e*b_x_e,z) - rdx2*diff(Apar_e*b_z_e,x))*jacobTotInv_e, + dBperpoverB_z : (rdx2*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y))*jacobTotInv_e, + dBperpoverB_list : [dBperpoverB_x, dBperpoverB_y, dBperpoverB_z], + + /* Note: no contribution from mu. */ + for dir : 1 thru cdim+1 do ( + + dirLabel : varLabel[dir], + + wDir : eval_string(sconcat("w",dirLabel)), + rdDirVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + dirVar : varsP[dir], /* Variable in current direction. */ + + alpha_e : 0, + + if no_by = false then ( + if cdim = 3 then ( + curvdriftdir : dir + ), + if cdim = 2 then ( + if dir = 1 then ( + curvdriftdir : dir + ), + if dir = 2 then ( + curvdriftdir : 3 + ) + ), + if cdim = 1 then ( + curvdriftdir : 3 + ), + + if dir < vpardim then ( + alpha_e : alpha_e + dBperpoverB_list[curvdriftdir]/m_ * mvpar_e + ), + if dir = vpardim then ( + if cdim = 3 then ( + for k : 1 thru cdim do ( + alpha_e : alpha_e - dBperpoverB_list[k]/m_ * dH_dz_e[k] + ) + ), + if cdim = 2 then ( + alpha_e : alpha_e - dBperpoverB_list[1]/m_ * dH_dz_e[1] - dBperpoverB_list[3]/m_ * dH_dz_e[2] + ), + if cdim = 1 then ( + alpha_e : alpha_e - dBperpoverB_list[3]/m_ * dH_dz_e[1] + ) + ) + ), + + if dir < vpardim then ( + alpha_e : alpha_e*rdx2vec[dir] + ) + else if dir = vpardim then ( + alpha_e : alpha_e/vmap_prime_e[1] + ), + + /* Project alpha on basis and write to array. */ + printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), + alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), + alpha_c : subst(replaceList, alpha_c), + alpha_c : subst(replaceListHamil, alpha_c), + alpha_c : subst(replaceListVpar, alpha_c), + alpha_c : subst(dvparSimp, alpha_c), + alphaLabel : eval_string(sconcat(alpha, dirLabel)), + clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, + makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + writeCExprsCollect1(alphaLabel, alpha_c, clst), + printf(fh, "~%"), + flush_output(fh), + alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), + alpha_e : doExpand(alphaNoZero_c, bP), + + alphaJf_e : alpha_e*Jf_e, + + printf(fh, "~%"), + volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), + volTerm_c : subst(replaceList, volTerm_c), + writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), + flush_output(fh), + printf(fh, "~%") + + ), + + printf(fh, " return 0.; ~%"), + printf(fh, "} ~%") + +)$ + +addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( + [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, + hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + varLabel : makelist(string(varsP[d]),d,1,pDim), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a(const double q_, const double m_, const double *apardot, + const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // apardot: time derivative of parallel component of magnetic vector potential.~%"), + printf(fh, " // fin: Distribution function.~%"), + printf(fh, " // out: output increment.~%"), + printf(fh, "~%"), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /*Expand Jf*/ + Jf_e : doExpand1(fin,bP), + + /* Expand Apardot */ + apardot_e : doExpand1(apardot,bP), + + /* Note: only a vpar contribution. */ + dir : cdim+1, + dirLabel : varLabel[dir], + + alpha_e : -q_/m_ * apardot_e, + + /* Project alpha on basis and write to array. */ + printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), + alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), + alphaLabel : eval_string(sconcat(alpha, dirLabel)), + clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, + makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + writeCExprsCollect1(alphaLabel, alpha_c, clst), + printf(fh, "~%"), + flush_output(fh), + alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), + alpha_e : doExpand(alphaNoZero_c, bP), + + alphaJf_e : alpha_e*Jf_e, + + printf(fh, "~%"), + volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), + writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), + flush_output(fh), + printf(fh, "~%"), + + printf(fh, " return 0.; ~%"), + printf(fh, "} ~%") + +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac b/maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac deleted file mode 100644 index f2facaa3..00000000 --- a/maxima/g0/gk_collisionless/em/dg_gk-surf_em.mac +++ /dev/null @@ -1,158 +0,0 @@ -/* - Create kernels for the surface term of the gyrokinetic collisionless terms. -*/ -load("modal-basis")$ -load("out-scripts")$ -load(stringproc)$ -load("scifac")$ -load("utilities_gyrokinetic")$ -load("nodal_operations/nodal_functions")$ -fpprec : 24$ - -/* Types of boundary stencils: - - domain_bound: Domain boundary. - - interblock_bound: Interblock boundary. -*/ -bound_surf_bc_type : ["domain_bound","interblock_bound"]$ - -/* Boundary sidex. */ -bound_side : ["lower","upper"]$ - -calcGKAddEMSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( - [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, - surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, - tempVars,tempBasis,NSurfIndexing,numNodesIndexing, - rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, - BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, - hamil_e,alphaSurfL_e,alphaSurfR_e, - fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - fnodal_l_e, fnodal_r_e, fmodproj_e], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), - basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) - ), - NSurf : length(bSurf), - numNodes : length(surfNodes), - /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size at the - vparallel surfaces */ - if (surfDir = cdim+1 and polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes, - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, - const double *flux_surf_l, const double *flux_surf_r, - double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_c,vmap_prime_r: velocity space mapping derivative in left, center and right cells.~%"), - printf(fh, " // flux_surf_l: Surface expansion of phase space flux on the left.~%"), - printf(fh, " // flux_surf_r: Surface expansion of phase space flux on the right.~%"), - printf(fh, " // out: output increment in center cell.~%"), - printf(fh, "~%"), - printf(fh, " return 0.0; ~%"), - printf(fh, "~%"), - - printf(fh, "} ~%"), - flush_output(fh) - -)$ - -calcGKAddEMBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB) := block( - [pDim,varsC,bC,varsP,bP,vSub,surfVar,varLabel,dirLabel, - surfIntVars,surf_cvars,surf_vvars,surfNodes,bSurf,basisStr,NSurf,numNodes, - tempVars,tempBasis,NSurfIndexing,numNodesIndexing, - rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, - BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, - hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, - fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), - basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) - ), - NSurf : length(bSurf), - numNodes : length(surfNodes), - - /* if polyOrder = 1 and we're doing the vpar update, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size at the - vparallel surfaces */ - if (surfDir = cdim+1 and polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes, - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, - const double *vmap_prime_edge, const double *vmap_prime_skin, - const double *flux_surf_edge, const double *flux_surf_skin, - const int edge, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_edge,vmap_prime_skin: velocity space mapping derivative in edge and skin cells.~%"), - printf(fh, " // flux_surf_edge: Surface expansion of phase space flux on the lower edges of the edge cell.~%"), - printf(fh, " // flux_surf_skin: Surface expansion of phase space flux on the lower edges of the skin cell.~%"), - printf(fh, " // edge: determines if the update is for the left edge (-1) or right edge (+1).~%"), - printf(fh, " // out: output increment in center cell.~%"), - printf(fh, "~%"), - printf(fh, " return 0.0; ~%"), - printf(fh, "~%"), - - printf(fh, "} ~%"), - flush_output(fh) - -)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac b/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac deleted file mode 100644 index 7536cfd2..00000000 --- a/maxima/g0/gk_collisionless/em/dg_gk-vol_em.mac +++ /dev/null @@ -1,45 +0,0 @@ -/* - Create kernels for the volume term of the gyrokinetic collisionless terms. -*/ - -load("modal-basis")$ -load("out-scripts")$ -load(stringproc)$ -load("scifac")$ -load("utilities_gyrokinetic")$ -load("utilities")$ -fpprec : 24$ - -buildGKAddEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - varLabel : makelist(string(varsP[d]),d,1,pDim), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, - const double q_, const double m_, const double *bmag, const double *phi, - const double *apar, const double *rtg33inv, const double *bioverJB, - const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential .~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // fin: Distribution function.~%"), - printf(fh, " // out: output increment.~%"), - printf(fh, "~%"), - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") -)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/gkUtil.mac b/maxima/g0/gk_collisionless/em/gkUtil.mac deleted file mode 100644 index b5914a42..00000000 --- a/maxima/g0/gk_collisionless/em/gkUtil.mac +++ /dev/null @@ -1,954 +0,0 @@ -/* - Utility functions for GK Maxima scripts. -*/ -load("vect")$ -load("nodal_operations/nodal_functions")$ -load("nodal_operations/quadrature_functions")$ -load("utilities_gyrokinetic")$ - -expandInputFields(bC,bP,dxv,bmagBasis) := block( - [varsP,pdim,cdim,vdim,bmag_e,bmagInv_e,phi_e,Apar_e,dApardt_e,dApardtPrev_e, - AparL_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,BdriftX_e,BdriftY_e,jnk, - vmapBasis,vmapSqBasis,vmap_c,vmapSq_c,vmapBnum,vmapSqBnum,d], - - varsP : listofvars(bP), - pdim : length(varsP), - cdim : length(listofvars(bC)), - vdim : pdim-cdim, - - /* Expand background magnetic field and potentials. */ - bmag_e : doExpand1(bmag,bmagBasis), - phi_e : doExpand1(phi,bC), - Apar_e : doExpand1(apar,bC), - dApardt_e : doExpand1(apardot,bC), - dApardtPrev_e : doExpand1(apardot_prev,bC), - /* NOTE: even though Apar and dApar/dt are allowed to be discontinuous - in the parallel (z) direction, the surface term in the z direction - does not involve Apar. Since Apar is continuous in the other directions, - it does not matter if we use the right or left value. */ - - cmag_e : doExpand1(cmag,bmagBasis), - - b_x_e : doExpand1(b_x, bmagBasis), - b_y_e : doExpand1(b_y, bmagBasis), - b_z_e : doExpand1(b_z, bmagBasis), - jacobTotInv_e : doExpand1(jacobtot_inv, bmagBasis), - - /* Basis for the velocity space mapping. */ - [jnk,vmapBasis] : loadBasis("Ser", 1, 1), [jnk,vmapSqBasis] : loadBasis("Ser", 1, 2), - vmapBnum : length(vmapBasis), vmapSqBnum : length(vmapSqBasis), - - vmap_e : [], vmapSq_e : [], vmap_prime_e : [], - for d : 1 thru vdim do ( - vmap_c : makelist(vmap[(d-1)*vmapBnum+i-1],i,1,vmapBnum), - vmap_e : endcons(doExpand(vmap_c,subst(x=varsP[cdim+d],vmapBasis)), vmap_e), - - vmapSq_c : makelist(vmapSq[(d-1)*vmapSqBnum+i-1],i,1,vmapSqBnum), - vmapSq_e : endcons(doExpand(vmapSq_c,subst(x=varsP[cdim+d],vmapSqBasis)), vmapSq_e), - - vmap_prime_e : endcons(vmap_prime[d-1], vmap_prime_e) - ), - - expOut : [bmag_e,cmag_e,phi_e,Apar_e,dApardt_e,dApardtPrev_e, - b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,vmapSq_e, - vmap_prime_e], - - return(expOut) -)$ - -calcAndWrite_HamilES(fH,charge,mass,wv,rdv2,bP,inFlds,sideStr) := block( - [varsP,numP,pDim,vdim,bmag_e,phi_e,hamil_e,hamil_c,replaceList,hamilCvar,hamilNoZero_c], - /* Expand the Hamiltonian, and write them out. */ - - varsP : listofvars(bP), - numP : length(bP), - pDim : length(varsP), - vdim : 1, - if isInList(mu,varsP) then vdim : 2, - - /* Extract magnetic field and electrostatic potential. */ - bmag_e : inFlds[1], - phi_e : inFlds[3], - vmap_e : inFlds[11], - vmapSq_e : inFlds[12], - - hamil_e : charge*phi_e + (1/2)*mass*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - - /* Project Hamiltonian onto basis functions */ - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - - /* Write Hamiltonian. */ - printf(fh, " double hamil~a[~a] = {0.}; ~%", sideStr, numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil",sideStr)), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fH, "~%"), - flush_output(fH), - - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - - return(hamil_e) -)$ - -calc_HamilES_no_write(charge,mass,wv,rdv2,bP,inFlds) := block( - [varsP,numP,pDim,vdim,bmag_e,phi_e,hamil_e,hamil_c,hamilNoZero_c], - /* Expand the Hamiltonian, and write them out. */ - - varsP : listofvars(bP), - numP : length(bP), - pDim : length(varsP), - vdim : 0, - if isInList(vpar,varsP) then vdim : vdim+1, - if isInList(mu,varsP) then vdim : vdim+1, - - /* Extract magnetic field and electrostatic potential. */ - bmag_e : inFlds[1], - phi_e : inFlds[3], - vmap_e : inFlds[11], - vmapSq_e : inFlds[12], - - hamil_e : charge*phi_e + (1/2)*mass*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - - /* Project Hamiltonian onto basis functions */ - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - - hamilNoZero_c : makelistNoZeros1(hamil_c, hamil), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - - return(hamil_e) -)$ - -calcAndWrite_BstardBmag(fH,cdim,bP,bmagBasis,surfDir,mass,charge,wvpar,rdx2,rdv2,inFlds,sideStr) := block ( - [cmag_e,Apar_e,BmagInv_e,BdriftX_e,BdriftY_e,BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,b_x_e,b_y_e,b_z_e, - jacobTotInv_e,rdy2,rdz2,AparL_e,BstarZdBmagL_e,varsP,numP,replaceList,BstarXdBmag_c,BstarYdBmag_c,BstarZdBmag_c, - BstarXdBmag_noZero_c,BstarYdBmag_noZero_c,BstarZdBmag_noZero_c,BstarZdBmagL_c,BstarZdBmagL_noZero_c,BstardBmagL_e], - /* Compute the Bstar divided by B and write it out. */ - - cmag_e : inFlds[2], - Apar_e : inFlds[4], - b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], - jacobTotInv_e : inFlds[10], - - if cdim > 1 then (rdy2 : rdx2[2]) else (rdy2 : 0), - if cdim > 2 then (rdz2 : rdx2[3]) else (rdz2 : 0), - - /* Zero out some terms below to avoid the discontinuity of alpha in the - parallel direction (due to the discontinuity of Apar). Otherwise some - other treatment of some Apar terms or alpha may be needed. Initially we - had a step averaging alpha across the surface (just for the parallel - direction), but NRM suspects this might've caused instability in some - cases. Hence the zeros below. */ - discontFac : 0, - - /* Expand BstarX/Bmag on basis. */ - BstarXdBmag_e : (-((mass/charge)*(wvpar+vpar/rdv2[1]))*rdz2*diff(b_y_e,z) - + rdy2*diff(Apar_e*b_z_e,y) - discontFac*rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e, - /* Expand BstarY/Bmag on basis. */ - BstarYdBmag_e : (-((mass/charge)*(wvpar+vpar/rdv2[1]))*(rdx2[1]*diff(b_z_e,x) - rdz2*diff(b_x_e,z)) - + discontFac*rdz2*diff(Apar_e*b_x_e,z) - rdx2[1]*diff(Apar_e*b_z_e,x))*jacobTotInv_e, - /* Expand BstarZ/Bmag on basis. */ - BstarZdBmag_e : (cmag_e + ((mass/charge)*(wvpar+vpar/rdv2[1]))*rdx2[1]*diff(b_y_e,x) - + discontFac*(rdx2[1]*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y)))*jacobTotInv_e, - - varsP : listofvars(bP), - numP : length(bP), - - /* Project Bstar's onto basis, and print to arrays. */ - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - if cdim > 1 then ( - BstarXdBmag_c : calcInnerProdList(varsP, 1, bP, BstarXdBmag_e), - if (surfDir = 0 or surfDir = 1 or surfDir = cdim+1) then ( - printf(fh, " double BstarXdBmag~a[~a] = {0.}; ~%", sideStr,numP), - writeCExprsNoExpand1(eval_string(sconcat("BstarXdBmag",sideStr)), gcfac(subst(replaceList, BstarXdBmag_c))), - printf(fh, "~%"), - flush_output(fh) - ), - BstarXdBmag_noZero_c : makelistNoZeros1(BstarXdBmag_c, eval_string(sconcat("BstarXdBmag",sideStr))), - BstarXdBmag_e : BstarXdBmag_noZero_c . bP, - - BstarYdBmag_c : calcInnerProdList(varsP, 1, bP, BstarYdBmag_e), - if (surfDir = 0 or surfDir = 2 or surfDir = cdim+1) then ( - printf(fh, " double BstarYdBmag~a[~a] = {0.}; ~%", sideStr, numP), - writeCExprsNoExpand1(eval_string(sconcat("BstarYdBmag",sideStr)), gcfac(subst(replaceList, BstarYdBmag_c))), - printf(fh, "~%"), - flush_output(fh) - ), - BstarYdBmag_noZero_c : makelistNoZeros1(BstarYdBmag_c, eval_string(sconcat("BstarYdBmag",sideStr))), - BstarYdBmag_e : BstarYdBmag_noZero_c . bP - ), - if cdim # 2 then ( - BstarZdBmag_c : calcInnerProdList(varsP, 1, bP, BstarZdBmag_e), - if (surfDir=0 or surfDir>=cdim) then ( - printf(fh, " double BstarZdBmag~a[~a] = {0.}; ~%", sideStr, numP), - writeCExprsNoExpand1(eval_string(sconcat("BstarZdBmag",sideStr)), gcfac(subst(replaceList, BstarZdBmag_c))), - printf(fh, "~%"), - flush_output(fh) - ), - BstarZdBmag_noZero_c : makelistNoZeros1(BstarZdBmag_c, eval_string(sconcat("BstarZdBmag",sideStr))), - BstarZdBmag_e : BstarZdBmag_noZero_c . bP - ), - - /* Make Bstar/Bmag vector. */ - if cdim = 1 then ( - BstardBmag_e : [BstarZdBmag_e] - ) elseif cdim = 2 then ( - BstardBmag_e : [BstarXdBmag_e, BstarYdBmag_e] - ) elseif cdim = 3 then ( - BstardBmag_e : [BstarXdBmag_e, BstarYdBmag_e, BstarZdBmag_e] - ), - - return(BstardBmag_e) -)$ - -calcAndWrite_BstarZdBmag(fH,cdim,bP,bmagBasis,surfDir,mass,charge,wvpar,rdx2,rdv2,inFlds,sideStr) := block ( - [cmag_e,Apar_e,BmagInv_e,BdriftX_e,BdriftY_e,BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,b_x_e,b_y_e,b_z_e, - jacobTotInv_e,rdy2,rdz2,AparL_e,BstarZdBmagL_e,varsP,numP,replaceList,BstarXdBmag_c,BstarYdBmag_c,BstarZdBmag_c, - BstarXdBmag_noZero_c,BstarYdBmag_noZero_c,BstarZdBmag_noZero_c,BstarZdBmagL_c,BstarZdBmagL_noZero_c,BstardBmagL_e], - /* Compute the Bstar divided by B and write it out. */ - - cmag_e : inFlds[2], - b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], - jacobTotInv_e : inFlds[10], - - if cdim > 1 then (rdy2 : rdx2[2]) else (rdy2 : 0), - if cdim > 2 then (rdz2 : rdx2[3]) else (rdz2 : 0), - - if (sideStr="L") then (Apar_e : inFlds[11]) - elseif (sideStr="R") then (Apar_e : inFlds[12]) - else (Apar_e : inFlds[4]), - - /* Expand BstarZ/Bmag on basis. */ - BstarZdBmag_e : (cmag_e + ((mass/charge)*(wvpar+vpar/rdv2[1]))*rdx2[1]*diff(b_y_e,x) - + (rdx2[1]*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y)))*jacobTotInv_e, - - varsP : listofvars(bP), - numP : length(bP), - - /* Project Bstar's onto basis, and print to arrays. */ - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - BstarZdBmag_c : calcInnerProdList(varsP, 1, bP, BstarZdBmag_e), - printf(fh, " double BstarZdBmag~a[~a]; ~%", sideStr, numP), - writeCExprsNoExpand1(eval_string(sconcat("BstarZdBmag",sideStr)), gcfac(subst(replaceList, BstarZdBmag_c))), - printf(fh, "~%"), - flush_output(fh), - BstarZdBmag_noZero_c : makelistNoZeros1(BstarZdBmag_c, eval_string(sconcat("BstarZdBmag",sideStr))), - BstarZdBmag_e : BstarZdBmag_noZero_c . bP, - - return(BstarZdBmag_e) -)$ - -poissonBracket(f,g,mass,charge,rdx2V,rdv2V,pbFacs,no_by) := block( - [varsCall,cdim,varsC,rdy2,rdz2,BstardBmag_e,bmagInv_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e], - /* Compute the Poisson bracket in general geometry. */ - - /* Function that computes the gradient. */ - /* - For some reason the following use of "vect" functions was giving extra - brackets when generating volume kernels. Opt for our own function instead. - scalefactors(varsC), - fgrad(fIn) := ev(express(grad(fIn)),diff)*rdx2V, - */ - fgrad(fIn,vars,diffFacs) := makelist(diff(fIn,vars[d]),d,1,length(vars))*diffFacs, - - cdim : length(rdx2V), - if (cdim = 1) then ( - varsCall : [x], - rdy2 : 0, - rdz2 : 0 - ) else if (cdim = 2) then ( - varsCall : [x,z], - rdy2 : 0, - rdz2 : rdx2V[2] - ) else if (cdim = 3) then ( - varsCall : [x,y,z], - rdy2 : rdx2V[2], - rdz2 : rdx2V[3] - ), - - varsC : makelist(varsCall[d],d,1,cdim), - BstardBmag_e : pbFacs[1], - b_x_e : pbFacs[2], b_y_e : pbFacs[3], b_z_e : pbFacs[4], - jacobTotInv_e : pbFacs[5], vmap_prime_e : pbFacs[6], - - if (no_by) then ( b_y_e : 0 ), - - pb_e : (1/mass)*BstardBmag_e . - ((rdv2V[1]/vmap_prime_e[1])*(fgrad(f,varsC,rdx2V)*diff(g,vpar)-fgrad(g,varsC,rdx2V)*diff(f,vpar))) - +(-(1/charge)*b_z_e*rdx2V[1]*rdy2*(diff(f,x)*diff(g,y)-diff(f,y)*diff(g,x)) - +(1/charge)*b_y_e*rdx2V[1]*rdz2*(diff(f,x)*diff(g,z)-diff(f,z)*diff(g,x)) - -(1/charge)*b_x_e*rdy2*rdz2*(diff(f,y)*diff(g,z)-diff(f,z)*diff(g,y)))*jacobTotInv_e, - - return(pb_e) -)$ - -calcAndWrite_alphaEM(fH,surfDir,bP,polyOrder,basisType,mass,charge,rdx2V,rdv2V, - inFlds,hamil_e,BstardBmag_e,sideStr,isStep2) := block( - [varsP,varLabel,dirLabel,wSurf,rdSurfVar2,surfVar,surfIntVars,pbAuxFlds,bmagInv_e,b_x_e, - b_y_e,b_z_e,jacobTotInv_e,alpha_e,Apar_e,dApardt_e,dApardtPrev_e,alphaL_e, - bSurf,numSurf,evPoint,alpha_c,alphaCvar,alphaNoZero_c,alphaUpCvar,alphaUpNoZero_c], - /* Calculate phase space velocity alpha in direction of surfVar. */ - /* We assume alpha.n is continuous across boundary, although H may not be. */ - /* Distinguish between alpha and alphaUp, where alphaUp is the one used to - determine upwind direction. */ - - varsP : listofvars(bP), - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - wSurf : eval_string(sconcat("w",dirLabel)), - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - - b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], - jacobTotInv_e : inFlds[10], - - pbAuxFlds : [BstardBmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,vmapSq_e], - alpha_e : poissonBracket(wSurf+surfVar/rdSurfVar2,hamil_e,mass,charge,rdx2V,rdv2V,pbAuxFlds), - - Apar_e : inFlds[4], dApardt_e : inFlds[5], - - alphaUp_e : alpha_e, - if surfVar = vpar then ( - alpha_e : alpha_e - (charge/mass)*dApardt_e, - alphaUp_e : alpha_e - ), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder) - ) else ( - bSurf : basisFromVars(basisType,surfIntVars,polyOrder) - ), - numSurf : length(bSurf), - - if sideStr="L" then (evPoint : -1) - elseif sideStr="R" then (evPoint : 1), - - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - /* Project full alpha expression evaluated at interior surface - onto surface basis and print to C variable alpha. */ - alpha_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,alpha_e)), - printf(fh, " double alpha~a[~a] = {0.}; ~%", sideStr, numSurf), - alphaCvar : eval_string(sconcat("alpha",sideStr)), - writeCExprsNoExpand1(alphaCvar, subst(replaceList,alpha_c)), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaCvar), - alphaSurf_e : doExpand(alphaNoZero_c, bSurf), - - alphaUpSurf_e : alphaSurf_e, - - return([alphaUp_e,alphaSurf_e,alphaUpSurf_e]) -)$ - -calcAndWrite_alpha(fH,surfDir,bP,polyOrder,basisType,mass,charge,rdx2V,rdv2V, - inFlds,hamil_e,BstardBmag_e,sideStr,no_by,isStep2) := block( - [varsP,varLabel,dirLabel,wSurf,rdSurfVar2,surfVar,surfIntVars,b_x_e,b_y_e,b_z_e, - jacobTotInv_e,vmap_e,vmap_prime_e,pbAuxFlds,cdim,surfVar_phys,alpha_e,bSurf, - numSurf,evPoint,alpha_c,alphaCvar,clst,alphaNoZero_c], - /* Calculate phase space velocity alpha in direction of surfVar. */ - /* We assume alpha.n is continuous across boundary, although H may not be. */ - /* Distinguish between alpha and alphaUp, where alphaUp is the one used to - determine upwind direction. */ - - varsP : listofvars(bP), - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - wSurf : eval_string(sconcat("w",dirLabel)), - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - - b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], - jacobTotInv_e : inFlds[10], vmap_e : inFlds[11], vmap_prime_e : inFlds[13], - - pbAuxFlds : [BstardBmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_prime_e], - - cdim : length(rdx2V), - surfVar_phys : wSurf+surfVar/rdSurfVar2, - if (surfDir > cdim) then ( surfVar_phys : vmap_e[surfDir-cdim] ), - - alpha_e : poissonBracket(surfVar_phys,hamil_e,mass,charge,rdx2V,rdv2V,pbAuxFlds,no_by), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder) - ) else ( - bSurf : basisFromVars(basisType,surfIntVars,polyOrder) - ), - numSurf : length(bSurf), - - if sideStr="L" then (evPoint : -1) - elseif sideStr="R" then (evPoint : 1), - - dvparSimp : makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), - - /* Project full alpha expression evaluated at interior surface - onto surface basis and print to C variable alpha. */ - alpha_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,alpha_e)), - alpha_c : subst(dvparSimp, alpha_c), - clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], - alphaCvar : eval_string(sconcat("alpha",sideStr)), - writeCExprsCollect1(alphaCvar, alpha_c, clst), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaCvar), - alphaSurf_e : doExpand(alphaNoZero_c, bSurf), - - return(alphaSurf_e) -)$ - -calc_alpha_no_write(fH,surfDir,bP,polyOrder,basisType,mass,charge,rdx2V,rdv2V, - inFlds,hamil_e,BstardBmag_e,sideStr,no_by,isStep2) := block( - [varsP,varLabel,dirLabel,wSurf,rdSurfVar2,surfVar,surfIntVars,b_x_e,b_y_e,b_z_e, - jacobTotInv_e,vmap_e,vmap_prime_e,pbAuxFlds,cdim,surfVar_phys,alpha_e,bSurf, - numSurf,evPoint,alpha_c,alphaCvar,clst,alphaNoZero_c], - /* Calculate phase space velocity alpha in direction of surfVar. */ - /* We assume alpha.n is continuous across boundary, although H may not be. */ - /* Distinguish between alpha and alphaUp, where alphaUp is the one used to - determine upwind direction. */ - - varsP : listofvars(bP), - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - wSurf : eval_string(sconcat("w",dirLabel)), - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - - b_x_e : inFlds[7], b_y_e : inFlds[8], b_z_e : inFlds[9], - jacobTotInv_e : inFlds[10], vmap_e : inFlds[11], vmap_prime_e : inFlds[13], - - pbAuxFlds : [BstardBmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_prime_e], - - cdim : length(rdx2V), - surfVar_phys : wSurf+surfVar/rdSurfVar2, - if (surfDir > cdim) then ( surfVar_phys : vmap_e[surfDir-cdim] ), - - alpha_e : poissonBracket(surfVar_phys,hamil_e,mass,charge,rdx2V,rdv2V,pbAuxFlds,no_by), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder) - ) else ( - bSurf : basisFromVars(basisType,surfIntVars,polyOrder) - ), - numSurf : length(bSurf), - - if sideStr="L" then (evPoint : -1) - elseif sideStr="R" then (evPoint : 1), - - /* Project full alpha expression evaluated at interior surface - onto surface basis and print to C variable alpha. */ - alpha_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,alpha_e)), - alphaCvar : eval_string(sconcat("alpha",sideStr)), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaCvar), - alphaSurf_e : doExpand(alphaNoZero_c, bSurf), - - return(alphaSurf_e) -)$ - -calc_surfAvgAlpha(bP,surfVar,alpha_e,evAtLower) := block( - [i,v,varsP,numP,surfIntVars,surfBasis,ignoreVars,alphaSurfAvg_c,alphaSurfAvg_e,evPoint], - /* Calculate the surface-averaged alpha. */ - - varsP : listofvars(bP), - numP : length(bP), - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - - if evAtLower then (evPoint:-1) else (evPoint:1), - - /* alpha coefficients are for an expansion in the full-dim phase basis. We - need to project onto the a basis on the surface with the right normalization - and dimensionality. */ - surfBasis : copylist(bP), - ignoreVars : listify(setdifference(setify(varsP),setify(surfIntVars))), - for i : 1 thru numP do ( - for v : 1 thru length(ignoreVars) do ( - if not freeof(ignoreVars[v],bP[i]) then ( surfBasis[i] : 0 ) - )), - alphaSurfAvg_c : calcInnerProdList(surfIntVars,1,surfBasis,subst(surfVar=evPoint,alpha_e)), - alphaSurfAvg_e : doExpand(alphaSurfAvg_c,surfBasis), - alphaSurfAvg_s : fullratsimp(innerProd(surfIntVars,1,alphaSurfAvg_e,1)/innerProd(surfIntVars,1,1,1)), - - return(alphaSurfAvg_s) -)$ - -calcAndWrite_surfAvgAlpha(fH,bP,surfDir,alpha_e,sideStr) := block([replaceList,evAtLower], - /* Given the phase-space velocity alpha, compute the average over the surface - perpendicular to the surfVar dimension, and at the lower/upper boundary if - sideStr=R/L. Write it out too.*/ - - surfVar : varsP[surfDir], /* Surface variable. */ - - if sideStr="R" then (evAtLower:true) else (evAtLower:false), - - alphaSurfAvg_s : calc_surfAvgAlpha(bP,surfVar,alpha_e,evAtLower), - - printf(fH, " // Surface-averaged phase velocity in this direction.~%"), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, - wvparL^2=wvparSqL, rdvpar2L^2=rdvpar2SqL, rdx2L^2=rdx2SqL, - wvparR^2=wvparSqR, rdvpar2R^2=rdvpar2SqR, rdx2R^2=rdx2SqR, m_^2=mSq, q_^2=qSq], - printf(fH, " double alphaSurfAvg~a = ~a; ~%~%", sideStr, float(subst(replaceList, alphaSurfAvg_s))), - flush_output(fH), - - return(alphaSurfAvg_s) -)$ - -calcAndWrite_upwindIncr_wSurfAvgAlpha(fH,bP,polyOrder,surfDir,sideStr,alphaSurf_e,isStep2) := block( - [varsP,numP,surfIntVars,fL_e,fR_e,fhatSurf_e,replaceList,fhatAlpha_c,incr_r,tMod,incrMod_r], - /* Given a surface expansion of the phase-space velocity, alpha, determine the upwinding - based on the surface average of alpha. Write the common increment to left/right cells - (the actual output from the C kernel should be this increment times some scaling factor). */ - - varsP : listofvars(bP), - numP : length(bP), - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - - /* Expand distribution function. */ - fL_e : doExpand1(fL,bP), fR_e : doExpand1(fR,bP), - - printf(fH, " if (alphaSurfAvg~a>0) { ~%", sideStr), - - fhatSurf_e : subst(surfVar=1, fL_e), - - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, - wvparL^2=wvparSqL, rdvpar2L^2=rdvpar2SqL, rdx2L^2=rdx2SqL, - wvparR^2=wvparSqR, rdvpar2R^2=rdvpar2SqR, rdx2R^2=rdx2SqR, m_^2=mSq, q_^2=qSq], - /* Write out the increment to the right cell. Omit a dxv factor we incorporate later. */ - fhatAlpha_c : calcInnerProdList(surfIntVars, alphaSurf_e, subst(surfVar=-1, bP), fhatSurf_e), - incrR_c : fullratsimp(fhatAlpha_c), - writeCExprsNoExpand1(incr, subst(replaceList, incrR_c)), - flush_output(fH), - - if surfVar=vpar and polyOrder=1 and (not isStep2) then ( - tMod : calcInnerProdList(surfIntVars, 1, subst(surfVar=-1, bP), fhatSurf_e), - incrModR_c : fullratsimp(tMod), - writeCExprsNoExpand1(incrEmMod, subst(replaceList, incrModR_c)) - ), - - printf(fH, " } else { ~%"), - - fhatSurf_e : subst(surfVar=-1, fR_e), - - if surfVar=vpar and polyOrder=1 and (not isStep2) then ( - tMod : calcInnerProdList(surfIntVars, 1, subst(surfVar=-1, bP), fhatSurf_e), - incrModR_c : fullratsimp(tMod), - writeCExprsNoExpand1(incrEmMod, subst(replaceList, incrModR_c)) - ), - - fhatAlpha_c : calcInnerProdList(surfIntVars, alphaSurf_e, subst(surfVar=-1, bP), fhatSurf_e), - incrR_c : fullratsimp(fhatAlpha_c), - - fhatAlpha_c : calcInnerProdList(surfIntVars, alphaSurf_e, subst(surfVar=1, bP), fhatSurf_e), - incrL_c : -fullratsimp(fhatAlpha_c), - - writeCExprsNoExpand1(incr, subst(replaceList, incrR_c)), - printf(fH, " }~%"), - flush_output(fH), - - return([incrL_c,incrR_c]) -)$ - -calcAndWrite_upwindIncr_wQuadNodeAlpha(fH,basisType,polyOrder,bP,surfDir,sideStr, - alphaSurf_e,alphaUpSurf_e,fLR,isStep2) := block( - [varsP,numP,pDim,surfIntVars,vdim,cdim,surf_cvars,surf_vvars,surfNodes, - numNodes,fL_e,fR_e,fOrdL_n,fOrdR_n,alphaOrd_n, - fHatSurf_e,replaceList,Ghat_c,evPoint], - /* Compute the common increment to left/right cells with upwinding based on - the quadrature-node values of the phase-space velocity alpha. Write them - out. The actual output should be these increments scaled by some - cell-length factor. */ - - varsP : listofvars(bP), - numP : length(bP), - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - pDim : length(varsP), - - vdim : 0, - if isInList(vpar,varsP) then vdim : vdim+1, - if isInList(mu,varsP) then vdim : vdim+1, - cdim : pDim-vdim, - - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), - basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) - ), - numNodes : length(surfNodes), - - /* Expand distribution function. */ - fL_e : doExpand1(fLR[1],bP), - fR_e : doExpand1(fLR[2],bP), - - /* Evaluate alpha at ordinates. - Note: alphaSurf_e is already a surface expansion. */ - alphaOrd_n : gcfac(float(evAtNodes(alphaUpSurf_e,surfNodes,surfIntVars))), - /* Determine upwinding at each surface quadrature node. */ - printf(fH, " double fUpOrd~a[~a] = {0.};~%", sideStr, numNodes), - for i : 1 thru numNodes do ( - printf(fH, " if (~a > 0.) {~%", float(expand(fullratsimp(alphaOrd_n[i]/abs(content(args(alphaOrd_n[i])[1])[1]))))), - printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_r(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[1]), - printf(fh, " } else { ~%"), - printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_l(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[2]), - printf(fh, " } ~%") - ), - printf(fH, "~%"), - flush_output(fH), - - /* Write coefficients of modal surface expansion fupwind. */ - printf(fh, " // Project tensor nodal quadrature basis back onto modal basis. ~%"), - printf(fH, " double fUp~a[~a] = {0.};~%", sideStr, length(bSurf)), - if polyOrder=1 then ( /* Force p=1 to use hybrid basis. */ - dirStr : "x", - if surfDir = cdim+1 then (dirStr : "vpar") elseif surfDir = cdim+2 then (dirStr : "mu"), - printf(fh, " ~a_~adir_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, dirStr, sideStr, sideStr) - ) else ( - printf(fh, " ~a_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, sideStr, sideStr) - ), - printf(fh, "~%"), - flush_output(fH), - fHatSurf_e : doExpand1(eval_string(sconcat("fUp",sideStr)), bSurf), - - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - - if (sideStr="L") then (evPoint : -1) - elseif (sideStr="R") then (evPoint : 1), - - Ghat_c : calcInnerProdList(surfIntVars, alphaSurf_e, bSurf, fHatSurf_e), - Ghat_e : doExpand(Ghat_c, bSurf), - printf(fH, " double Ghat~a[~a] = {0.}; ~%", sideStr, length(bSurf)), - writeCExprs1(eval_string(sconcat("Ghat",sideStr)), Ghat_c), - printf(fH, "~%"), - flush_output(fH), - /* Zero out components of Ghat which are empty. */ - GhatNoZero : makelistNoZeros1(Ghat_c, eval_string(sconcat("Ghat",sideStr))), - Ghat_e : doExpand(GhatNoZero, bSurf), - - incr_c : fullratsimp(calcInnerProdList(surfIntVars, -evPoint, subst(surfVar=evPoint, bP), Ghat_e)), - - return(incr_c) -)$ - -calcAndWrite_upwindIncr_cflFreq_wQuadNodeAlpha(fH,basisType,polyOrder,bP,surfDir,sideStr, - alphaSurf_e,alphaUpSurf_e,fLR,isStep2) := block( - [varsP,numP,surfVar,surfIntVars,pDim,vdim,cdim,surf_cvars,surf_vvars,surfNodes, - bSurf,basisStr,numNodes,fL_e,fR_e,alphaOrd_n,i, - dirStr,fHatSurf_e,evPoint,Ghat_c,Ghat_e,GhatNoZero,incr_c], - - varsP : listofvars(bP), - numP : length(bP), - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - pDim : length(varsP), - - vdim : 0, - if isInList(vpar,varsP) then vdim : vdim+1, - if isInList(mu,varsP) then vdim : vdim+1, - cdim : pDim-vdim, - - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisStr : sconcat("gkhyb_", cdim, "x", vdim, "v", "_p", polyOrder) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder), - basisStr : sconcat(basisFun, "_", cdim+vdim, "x", "_p", polyOrder) - ), - numNodes : length(surfNodes), - - /* Expand distribution function. */ - fL_e : doExpand1(fLR[1],bP), - fR_e : doExpand1(fLR[2],bP), - - /* Evaluate alpha at ordinates. - Note: alphaSurf_e is already a surface expansion. */ - alphaOrd_n : gcfac(float(evAtNodes(alphaUpSurf_e,surfNodes,surfIntVars))), - - /* Determine upwinding and cflFreq at each surface quadrature node. */ - printf(fH, " double fUpOrd~a[~a] = {0.};~%", sideStr, numNodes), - printf(fH, " double alpha~a_n = 0.;~%", sideStr), - printf(fH, "~%"), - for i : 1 thru numNodes do ( - printf(fH, " alpha~a_n = ~a;~%", sideStr, float(expand(fullratsimp(alphaOrd_n[i])))), - printf(fH, " if (alpha~a_n > 0.) {~%", sideStr), - printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_r(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[1]), - printf(fh, " } else { ~%"), - printf(fh, " fUpOrd~a[~a] = ~a_surfx~a_eval_quad_node_~a_l(~a); ~%", sideStr, i-1, basisStr, surfDir, i-1, fLR[2]), - printf(fh, " } ~%"), - /* The extra factor of bP[1] below remains unexplained. NRM might've - stumbled up one it by trial and error. It may also have been meant - to average all the quad node values, but that meaning is only correct - for pure p=1. */ - printf(fh, " cflFreq = fmax(cflFreq, fabs(alpha~a_n)); ~%", sideStr, sideStr) - ), - printf(fH, "~%"), - flush_output(fH), - - /* Write coefficients of modal surface expansion fupwind. */ - printf(fh, " // Project tensor nodal quadrature basis back onto modal basis. ~%"), - printf(fH, " double fUp~a[~a] = {0.};~%", sideStr, length(bSurf)), - if polyOrder=1 then ( /* Force p=1 to use hybrid basis. */ - dirStr : "x", - if surfDir = cdim+1 then (dirStr : "vpar") elseif surfDir = cdim+2 then (dirStr : "mu"), - printf(fh, " ~a_~adir_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, dirStr, sideStr, sideStr) - ) else ( - printf(fh, " ~a_upwind_quad_to_modal(fUpOrd~a, fUp~a); ~%", basisStr, sideStr, sideStr) - ), - printf(fh, "~%"), - flush_output(fH), - fHatSurf_e : doExpand1(eval_string(sconcat("fUp",sideStr)), bSurf), - - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - - if (sideStr="L") then (evPoint : -1) - elseif (sideStr="R") then (evPoint : 1), - - Ghat_c : calcInnerProdList(surfIntVars, alphaSurf_e, bSurf, fHatSurf_e), - Ghat_e : doExpand(Ghat_c, bSurf), - printf(fH, " double Ghat~a[~a] = {0.}; ~%", sideStr, length(bSurf)), - writeCExprs1(eval_string(sconcat("Ghat",sideStr)), Ghat_c), - printf(fH, "~%"), - flush_output(fH), - /* Zero out components of Ghat which are empty. */ - GhatNoZero : makelistNoZeros1(Ghat_c, eval_string(sconcat("Ghat",sideStr))), - Ghat_e : doExpand(GhatNoZero, bSurf), - - incr_c : fullratsimp(calcInnerProdList(surfIntVars, -evPoint, subst(surfVar=evPoint, bP), Ghat_e)), - - return(incr_c) -)$ - -calcAndWrite_quadCFLfreq_wPhaseAlpha(basisType,polyOrder,bP,surfDir,alpha_e) := block( - [i,varsP,numP,cdim,vdim,pDim,surfVar,surfIntVars,pOrderCFL,surf_cvars,surf_vvars,surfNodes, - numNodes,alphaSurfL_c,alphaSurfL_e,alphaSurfL_n,alphaSurfR_c,alphaSurfR_e,alphaSurfR_n], - /* Compute the CFL frequency from quadrature node contributions on the - surfaces in the dir dimension, given a phase-space volume expansion - of the speed (i.e. coming from doExpand(alpha,bP)). */ - - varsP : listofvars(bP), - numP : length(bP), - pDim : length(varsP), - surfVar : varsP[surfDir], /* Surface variable. */ - surfIntVars : delete(surfVar,varsP), /* Surface integral variables. */ - vdim : 0, - if isInList(vpar,varsP) then vdim : vdim+1, - if isInList(mu,varsP) then vdim : vdim+1, - cdim : pDim-vdim, - - /* Identify polyOrder in velocity space as p=2 for p=1 since we force p=1 to - mean gkhybrid basis. */ - pOrderCFL : polyOrder, - if polyOrder=1 and surfDir=cdim+1 then ( pOrderCFL : 2 ), - - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - /* Evaluate cfl by evaluating at all surface quadrature points. */ - /* Get quadrature nodes on surface. */ - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1) - ), - numNodes : length(surfNodes), - - /* Coefficients of alpha written out to the file above are phase-space volume - expansion coefficients. Need to evaluate at the surface and project onto - surface basis, before (expanding and) evaluating at surface nodes. */ - /* The extra factor of bP[1] below remains unexplained. NRM might've - stumbled up one it by trial and error. */ - alphaSurfL_n : gcfac(float(evAtNodes(subst(surfVar=-1,alpha_e)*bP[1],surfNodes,surfIntVars)*bP[1])), - printf(fh, " // Evaluate alpha at left surface quadrature points.~%"), - for i : 1 thru numNodes do ( - printf(fh, " alphaL = ~a; ~%", gcfac(float(alphaSurfL_n[i]))), - printf(fh, " cflFreq += -~a*(alphaL-fabs(alphaL)); ~%",float(0.5*(2*pOrderCFL+1))) - ), - - alphaSurfR_n : gcfac(float(evAtNodes(subst(surfVar=+1,alpha_e)*bP[1],surfNodes,surfIntVars)*bP[1])), - printf(fh, " // Evaluate alpha at right surface quadrature points.~%"), - for i : 1 thru numNodes do ( - printf(fh, " alphaR = ~a; ~%", gcfac(float(alphaSurfR_n[i]))), - printf(fh, " cflFreq += ~a*(alphaR+fabs(alphaR)); ~%",float(0.5*(2*pOrderCFL+1))) - ) -)$ - -/* - Utility functions for computing surface DG updates - for the generic case applicable to all our kinetic equations: - For a *continuous* phase space flux alpha, if sign(alpha) is a constant - we can use simple upwind fluxes. - F = alpha_surf*f^- (if sign(alpha_surf) = 1), - F = alpha_surf*f^+ (if sign(alpha_surf) = -1) - Otherwise, we project sign(alpha_surf) first evaluating sign(alpha_surf) - at quadrature points and then using a nodal-to-modal transformation do - F = alpha_surf ( 1/2*(f^+ + f^-) - 1/2*sgn_alpha_surf*(f^+ - f^-) - - In this notation alpha_surf is the expansion of the *continuous* phase space flux - on the given surface, f^+ is the distribution function evaluated just outside the surface - and f^- is the distribution function evaluated just inside the surface - +------+------+ - | | | - | f^-|f^+ | - | | | - +------+------+ - alpha_surf -*/ - -/* Determine the upwinded distribution function in gyrokinetics */ -calcAndWrite_GKfUpwind(file_handle,cdim,surfDir,surfVar,surfIntVars,bSurf,fl_e,fr_e,basisStr,sideStr,no_by) := block( - [fstrL, fstrR, fLNm, fRNm, fUpNm, sgn_alpha_surfNm, sgn_alphaUpNm, NSurf,fSurfl_c, fSurfr_c, fSurfl_e, fSurfr_e, - surfNodes,nodeVars,basisNodal,sgn_alphaNodal_e,bSurf_no_by,sgn_alphaHatModProj_e,sgn_alphaUp_e,fUp_c], - - /* Naming convention for subsequent distribution function evaluations - for a cell-based update. If performing the left surface update - we need fl(surfVar=+1) and fc(surfVar=-1) (f_lr and f_cl) and if we are performing - the right surface update we need fc(surfVar=+1) and fr(surfVar=-1) (f_cr and f_rl) */ - if (sideStr = "L") then ( - fstrL : "lr", - fstrR : "cl" - ) else ( - fstrL : "cr", - fstrR : "rl" - ), - fLNm : eval_string(sconcat("f_",fstrL)), - fRNm : eval_string(sconcat("f_",fstrR)), - fUpNm : eval_string(sconcat("fUp",sideStr)), - sgn_alpha_surfNm : eval_string(sconcat("sgn_alpha_surf",sideStr)), - sgn_alphaUpNm : eval_string(sconcat("sgn_alphaUp",sideStr)), - - NSurf : length(bSurf), - printf(file_handle, " double fUp~a[~a] = {0.};~%", sideStr, NSurf), - fSurfl_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=1, fl_e)), - fSurfr_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=-1, fr_e)), - fSurfl_e : doExpand1(fLNm, bSurf), - fSurfr_e : doExpand1(fRNm, bSurf), - - clst : [vmap_prime_l[0],vmap_prime_l[1],vmap_prime_c[0],vmap_prime_c[1], - vmap_prime_r[0],vmap_prime_r[1],vmap_prime_edge[0],vmap_prime_edge[1], - vmap_prime_skin[0],vmap_prime_skin[1]], - /* If sign(alpha_surf) is single signed - 1. f^- (if sign(alpha_surf) = 1), - 2. f^+ (if sign(alpha_surf) = -1) */ - printf(file_handle, " if (const_sgn_alpha~a[0] == 1) { ~%", sideStr), - printf(file_handle, " if (sgn_alpha_surf~a[0] == 1.0) { ~%", sideStr), - writeCExprsCollect1(fUpNm, fSurfl_c, clst), - printf(file_handle, " } else { ~%"), - writeCExprsCollect1(fUpNm, fSurfr_c, clst), - printf(file_handle, " } ~%"), - - /* Else sign(alpha_surf) is changing quadrature point to quadrature point - 1/2*(f^+ + f^-) - 1/2*sgn_alpha_surf*(f^+ - f^-) */ - printf(file_handle, " } else { ~%"), - printf(file_handle, " double f_~a[~a] = {0.};~%", fstrL, NSurf), - printf(file_handle, " double f_~a[~a] = {0.};~%", fstrR, NSurf), - if (polyOrder = 1) then ( /* Force p=1 to use hybrid basis. */ - /* if no toroidal field and p=1, use a further reduced quadrature evaluation - to exploit the larger sparsity in the x and z updates. - The x update is surfDir = 1 and the z update is surfDir = cdim */ - if (no_by and surfDir = 1) then ( - surfNodes : gaussOrd(1+1, 1), - nodeVars : [z], - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", 1, 1, nodeVars, surfNodes), - sgn_alphaNodal_e : doExpand1(sgn_alpha_surfNm,basisNodal), - bSurf_no_by : basisFromVars("gkhyb",nodeVars,polyOrder), - sgn_alphaHatModProj_e : fullratsimp(calcInnerProdList(nodeVars, 1, bSurf_no_by, sgn_alphaNodal_e)), - printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, length(bSurf_no_by)), - writeCExprs1(sgn_alphaUpNm, sgn_alphaHatModProj_e), - sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf_no_by) - ) - else if (no_by and surfDir = cdim) then ( - surfNodes : gaussOrdGkHyb(1+1, [x], [vpar]), - nodeVars : [x,vpar], - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", 1, 1, nodeVars, surfNodes), - sgn_alphaNodal_e : doExpand1(sgn_alpha_surfNm,basisNodal), - bSurf_no_by : basisFromVars("gkhyb",nodeVars,polyOrder), - sgn_alphaHatModProj_e : fullratsimp(calcInnerProdList(nodeVars, 1, bSurf_no_by, sgn_alphaNodal_e)), - printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, length(bSurf_no_by)), - writeCExprs1(sgn_alphaUpNm, sgn_alphaHatModProj_e), - sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf_no_by) - ) - else ( - dirStr : "x", - if (surfDir = cdim+1) then (dirStr : "vpar") elseif (surfDir = cdim+2) then (dirStr : "mu"), - printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, NSurf), - printf(file_handle, " ~a_~adir_upwind_quad_to_modal(~a, ~a); ~%", basisStr, dirStr, sgn_alpha_surfNm, sgn_alphaUpNm), - sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf) - ) - ) else ( - printf(file_handle, " double sgn_alphaUp~a[~a] = {0.};~%", sideStr, NSurf), - printf(file_handle, " ~a_upwind_quad_to_modal(~a, ~a); ~%", basisStr, sgn_alpha_surfNm, sgn_alphaUpNm), - sgn_alphaUp_e : doExpand1(sgn_alphaUpNm, bSurf) - ), - printf(file_handle, "~%"), - - writeCExprsCollect1(fLNm, fSurfl_c, clst), - printf(file_handle, "~%"), - flush_output(file_handle), - - writeCExprsCollect1(fRNm, fSurfr_c, clst), - printf(file_handle, "~%"), - flush_output(file_handle), - - fUp_c : calcInnerProdList(surfIntVars, 1, bSurf, 0.5*(fSurfl_e + fSurfr_e) - 0.5*sgn_alphaUp_e*(fSurfr_e - fSurfl_e)), - writeCExprsNoExpand1(fUpNm, gcfac(float(expand(fUp_c)))), - printf(file_handle, "~%"), - flush_output(file_handle), - - printf(file_handle, " } ~%") -)$ - -/* Determine the upwinded distribution function in gyrokinetics */ -calcAndWrite_sgn_alpha(file_handle,surfIntVars,surfNodes,numNodes,alphaSurf_e,sideStr) := block( - [alphaOrd_n], - /* Determine sign(alpha_surf) for upwinding at each surface quadrature node. */ - - /* Evaluate alpha at ordinates. - Note: alphaSurf_e is already a surface expansion. */ - alphaOrd_n : gcfac(float(evAtNodes(alphaSurf_e,surfNodes,surfIntVars))), - - printf(file_handle, " int const_sgn_alpha_surf = 1; ~%"), - printf(file_handle, " ~%"), - /* Write out first quadrature point - We are going to compare the signs of the quadrature points to see if the sign is constant */ - printf(file_handle, " if (~a > 0.) ~%", gcfac(float(expand(fullratsimp(alphaOrd_n[1]))))), - printf(file_handle, " sgn_alpha_surf~a[0] = 1.0; ~%", sideStr), - printf(file_handle, " else ~%"), - printf(file_handle, " sgn_alpha_surf~a[0] = -1.0; ~%", sideStr), - printf(file_handle, " ~%"), - /* Write out the other quadrature point evaluations and compare the signs point by point */ - for i : 2 thru numNodes do ( - printf(file_handle, " if (~a > 0.) ~%", gcfac(float(expand(fullratsimp(alphaOrd_n[i]))))), - printf(file_handle, " sgn_alpha_surf~a[~a] = 1.0; ~%", sideStr, i-1), - printf(file_handle, " else ~%"), - printf(file_handle, " sgn_alpha_surf~a[~a] = -1.0; ~%", sideStr, i-1), - printf(file_handle, " ~%"), - printf(file_handle, " if (sgn_alpha_surf~a[~a] == sgn_alpha_surf~a[~a]) ~%", sideStr, i-1, sideStr, i-2), - printf(file_handle, " const_sgn_alpha_surf = const_sgn_alpha_surf ? 1 : 0; ~%"), - printf(file_handle, " else ~%"), - printf(file_handle, " const_sgn_alpha_surf = 0; ~%"), - printf(file_handle, " ~%") - ) -)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac deleted file mode 100644 index 50c5cfcc..00000000 --- a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-conf_em.mac +++ /dev/null @@ -1,85 +0,0 @@ -load("modal-basis")$ -load("out-scripts")$ -load(stringproc)$ -load("scifac")$ -load("utilities_gyrokinetic")$ -load("nodal_operations/nodal_functions")$ -fpprec : 24$ - -buildGKFluxConfAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, - numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, - vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, - jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - if cdim = 1 then ( - surfConfigNodes : [1] - ) - else ( - surfConfigNodes : gaussOrd(polyOrder+1, cdim-1) - ), - numSurfNodes : length(surfNodes), - numSurfConfigNodes : length(surfConfigNodes), - numVelNodes : numSurfNodes/numSurfConfigNodes, - numMuNodes : 1, - if vdim > 1 then ( numMuNodes : 2), - numVparNodes : numVelNodes/numMuNodes, - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, - const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgs: surface DG geometry.~%"), - printf(fh, " // gkdgs: gyrokinetic surface DG geometry.~%"), - printf(fh, " // bmag: bmag represented on the surface.~%"), - printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), - printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") -)$ diff --git a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac b/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac deleted file mode 100644 index f856ffb8..00000000 --- a/maxima/g0/gk_collisionless/em/gk_collisionless_flux-surf-vpar_em.mac +++ /dev/null @@ -1,90 +0,0 @@ -load("modal-basis")$ -load("out-scripts")$ -load(stringproc)$ -load("scifac")$ -load("utilities_gyrokinetic")$ -fpprec : 24$ - -buildGKFluxVparAddEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, - numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, - bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, - hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - configNodes : gaussOrd(polyOrder+1, cdim), - numSurfNodes : length(surfNodes), - numConfigNodes : length(configNodes), - numVelNodes : numSurfNodes/numConfigNodes, - - /* if polyOrder = 1, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size in the - vparallel surfaces and/or we are more directly exploiting the sparsity of - alpha (e.g., in the x and z direction when no toroidal field, by=0) - and thus utilize fewer coefficients to reduce the number of operations */ - if (polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgv: volume DG geometry.~%"), - printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") -)$ diff --git a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac deleted file mode 100644 index 3ecb7cfd..00000000 --- a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-header_em.mac +++ /dev/null @@ -1,105 +0,0 @@ -/* Compute the header file for gyrokinetic collisionless equation object kernels. */ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -maxPolyOrder_Ser : 2$ -minCdim_Ser : 1$ -minVdim_Ser : 1$ -maxCdim_Ser : 3$ -maxVdim_Ser : 2$ - -/* Tensor order basis. */ -maxPolyOrder_Tensor : 2$ -minCdim_Tensor : 1$ -minVdim_Tensor : 1$ -maxCdim_Tensor : 0$ -maxVdim_Tensor : 0$ - -/* Number of velocity dimensions allowed for each - configuration-space dimension. */ -gkVdims : [[1,2], [2], [2]]$ - -/* ...... END OF USER INPUTS........ */ - -varsC : [x, y, z]$ -varsV : [vpar, mu]$ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -minVdim : [minVdim_Ser, minVdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ -maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ - -printPrototypes() := block([], - for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_vol_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const double *bmag, const double *phi, - const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, - const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_no_by_vol_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const double *bmag, const double *phi, - const double *dualcurlbhatoverB, const double *rtg33inv, const double* bioverJB, - const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - - for surfDir : 1 thru c+1 do ( - if surfDir<=c then ( - dirlabel : varsC[surfDir] - ) else ( - dirlabel : varsV[surfDir-c] - ), - - if surfDir<=c then ( - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, " - ) else ( - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, " - ), - - if surfDir<=c then ( - vprimeargs : "" - ) else ( - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, " - ), - - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_c, const double *vmap_prime_r, - const double *flux_surf_l, const double *flux_surf_r, - double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_em_boundary_surf~a_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap_prime_edge, const double *vmap_prime_skin, - const double *flux_surf_edge, const double *flux_surf_skin, - const int edge, double* GKYL_RESTRICT out); ~%", dirlabel, c, v, bName[bInd], polyOrder) - ), - printf(fh, "~%") - ) - ) - ) - ) -)$ - -fh : openw("~/max-out/gkyl_dg_gyrokinetic_kernels.h")$ -printf(fh, "#pragma once~%")$ -printf(fh, "~%")$ -printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ -printf(fh, "~%")$ -printf(fh, "EXTERN_C_BEG~%")$ -printf(fh, "~%")$ -printPrototypes()$ -printf(fh, "~%")$ -printf(fh, "EXTERN_C_END~%")$ -close(fh)$ diff --git a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac deleted file mode 100644 index 85a5baf4..00000000 --- a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-surf_em.mac +++ /dev/null @@ -1,83 +0,0 @@ -/* - Generate the surface kernels for gyrokinetics with general geometry. - Assumes surface alpha pre-computed so kernels are agnostic to different - forms of gyrokinetics (electrostatic vs. electromagnetic, etc.) - - The functions called in this file are in gkFuncs-surf.mac. -*/ -load("gk_collisionless/em/dg_gk-surf_em")$ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -minPolyOrder_Ser : 1$ -maxPolyOrder_Ser : 1$ -minCdim_Ser : 1$ -maxCdim_Ser : 3$ - -/* Tensor order basis. No need to generate p=1. */ -minPolyOrder_Tensor : 2$ -maxPolyOrder_Tensor : 0$ -minCdim_Tensor : 1$ -maxCdim_Tensor : 0$ - -/* Vdim possibilities for each of Cdim=[1,2,3]. */ -gkVdims : [[1,2], [2], [2]]$ - -/* ...... END OF USER INPUTS........ */ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ - -clabels : ["x","y","z"]$ -vlabels : ["vpar","mu"]$ - -/* Possible combinations of variable dependence of background magnetic field. - with [] = const. Note that we assume axisymmetry, which means B cannot depend on y. */ -bVarsList : [x,z]$ - -includeSurfHeaders(fhIn, bname, c, v, porder, dir) := block([], - printf(fhIn, "#include ~%"), - if porder = 1 then ( /* Force hybrid basis (p=2 in velocity space). */ - printf(fhIn, "#include ~%", c, v) - ) elseif porder > 1 then ( - printf(fhIn, "#include ~%", bname, c+v, porder) - ) -)$ - -/* Generate kernels of selected types. */ -for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - /* Advection in velocity space.*/ - fname : sconcat("~/max-out/dg_gyrokinetic_add_em_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), - disp(printf(false,"Creating surface file: ~a",fname)), - - fh : openw(fname), - includeSurfHeaders(fh, bName[bInd], c, v, polyOrder, c+1), - funcName : sconcat("dg_gyrokinetic_add_em_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - calcGKAddEMSurfUpdateInDir(c+1, fh, funcName, c, v, bName[bInd], polyOrder, bVarsList), - close(fh), - - /* Advection in velocity space in the skin cell along vpar (for zero-flux BCs).*/ - fname : sconcat("~/max-out/dg_gyrokinetic_add_em_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), - disp(printf(false,"Creating surface file: ~a",fname)), - - fh : openw(fname), - includeSurfHeaders(fh, bName[bInd], c, v, polyOrder, c+1), - funcName : sconcat("dg_gyrokinetic_add_em_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - calcGKAddEMBoundarySurfUpdateInDir(c+1, fh, funcName, c, v, bName[bInd], polyOrder, bVarsList), - close(fh) - ) - ) - ) -)$ diff --git a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac b/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac deleted file mode 100644 index e2766cb2..00000000 --- a/maxima/g0/gk_collisionless/em/ms-dg_gyrokinetic-vol_em.mac +++ /dev/null @@ -1,72 +0,0 @@ -/* - Generate the volume kernels for collisionless gyrokinetic terms. - - The functions called in this file are in gkFuncs-vol.mac. -*/ -load("gk_collisionless/em/dg_gk-vol_em")$ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -minPolyOrder_Ser : 1$ -maxPolyOrder_Ser : 1$ -minCdim_Ser : 1$ -maxCdim_Ser : 3$ - -/* Tensor order basis. No need to generate p=1. */ -minPolyOrder_Tensor : 2$ -maxPolyOrder_Tensor : 2$ -minCdim_Tensor : 1$ -maxCdim_Tensor : 0$ - -/* Vdim possibilities for each of Cdim=[1,2,3]. */ -gkVdims : [[1,2], [2], [2]]$ - -/* ...... END OF USER INPUTS........ */ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ - -/* Possible combinations of variable dependence of background magnetic field. - with [] = const. Note that we assume axisymmetry, which means B cannot depend on y. */ -bVarsList : [x,z]$ - -/* Generate kernels of selected types. */ -for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - fname : sconcat("~/max-out/dg_gyrokinetic_add_em_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file: ~a",fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("dg_gyrokinetic_add_em_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKAddEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), - close(fh) - - /* if cdim > 1, also generate a set of kernels for the case where there is no toroidal field (by = 0) */ - /* if (c > 1) then ( - fname : sconcat("~/max-out/dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file (no by): ~a",fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, true), - close(fh) - ) */ - ) - ) - ) -)$ diff --git a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac deleted file mode 100644 index f51e3991..00000000 --- a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux-header_em.mac +++ /dev/null @@ -1,122 +0,0 @@ -/* Compute the header file for gyrokinetic collisionless flux kernels. */ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -maxPolyOrder_Ser : 2$ -minCdim_Ser : 1$ -minVdim_Ser : 1$ -maxCdim_Ser : 3$ -maxVdim_Ser : 2$ - -/* Tensor order basis. */ -maxPolyOrder_Tensor : 2$ -minCdim_Tensor : 1$ -minVdim_Tensor : 1$ -maxCdim_Tensor : 0$ -maxVdim_Tensor : 0$ - -/* Number of velocity dimensions allowed for each - configuration-space dimension. */ -gkVdims : [[1,2], [2], [2]]$ - -/* ...... END OF USER INPUTS........ */ - -varsC : [x, y, z]$ -varsV : [vpar, mu]$ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -minVdim : [minVdim_Ser, minVdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ -maxVdim : [maxVdim_Ser, maxVdim_Tensor]$ - -/* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension. */ -byOpt : [[false], [false, true], [false, true]]$ -byStr : ["", "no_by_"]$ - -/* Options for writing kernels used at multiblock boundaries. One for each - dimension. */ -mb_bcOpt : [[false,true],[false,true],[false,true]]$ -mb_bcStr : ["", "multib_boundary_"]$ - -printPrototypes() := block([], - for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - - for byI : 1 thru length(byOpt[c]) do ( - no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_em_~a~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_em_~a~aedge_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ) - ), - - dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_em_~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ), - - printf(fh, "~%") - ) - ) - ) - ) -)$ - -fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels_add_em.h")$ -printf(fh, "#pragma once~%")$ -printf(fh, "~%")$ -printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ -printf(fh, "~%")$ -printf(fh, "EXTERN_C_BEG~%")$ -printf(fh, "~%")$ -printPrototypes()$ -printf(fh, "~%")$ -printf(fh, "EXTERN_C_END~%")$ -close(fh)$ diff --git a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac b/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac deleted file mode 100644 index 4844eeb9..00000000 --- a/maxima/g0/gk_collisionless/em/ms-gk_collisionless_flux_em.mac +++ /dev/null @@ -1,105 +0,0 @@ -/* - Generate the kernel for surface expansions of the phase space characteristics. - - The functions called in this file are in gkFuncs-alpha-surf.mac. -*/ -load("gk_collisionless/em/gk_collisionless_flux-surf-conf_em")$ -load("gk_collisionless/em/gk_collisionless_flux-surf-vpar_em")$ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -minPolyOrder_Ser : 1$ -maxPolyOrder_Ser : 1$ -minCdim_Ser : 1$ -maxCdim_Ser : 3$ - -/* Tensor order basis. No need to generate p=1. */ -minPolyOrder_Tensor : 2$ -maxPolyOrder_Tensor : 2$ -minCdim_Tensor : 1$ -maxCdim_Tensor : 0$ - -/* ...... END OF USER INPUTS........ */ - -/* Vdim possibilities for each of Cdim=[1,2,3]. */ -gkVdims : [[1,2], [2], [2]]$ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ - -clabels : ["x","y","z"]$ -vlabels : ["vpar","mu"]$ - -/* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension. */ -byOpt : [[false], [false, true], [false, true]]$ -byStr : ["", "no_by_"]$ - -/* Options for writing kernels used at multiblock boundaries. One for each - dimension. */ -mb_bcOpt : [[false,true],[false,true],[false,true]]$ -mb_bcStr : ["", "multib_boundary_"]$ - -/* Generate kernels of selected types. */ -for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - for byI : 1 thru length(byOpt[c]) do ( - no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - /* Surface flux in direction dir in configuration space.*/ - for dir : 1 thru c do ( - - fname : sconcat("~/max-out/gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfAddEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), - close(fh), - - fname : sconcat("~/max-out/gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_add_em_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfAddEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), - close(fh) - ) - ), - - /* Surface flux in vparallel direction.*/ - fname : sconcat("~/max-out/gk_collisionless_flux_add_em_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_add_em_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxVparAddEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false), - close(fh) - ) - ) - ) - ) -)$ diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 34e06ea7..5ad7004d 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -297,3 +297,305 @@ buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, "} ~%") )$ + +AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, + numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, + vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, + jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + if cdim = 1 then ( + surfConfigNodes : [1] + ) + else ( + surfConfigNodes : gaussOrd(polyOrder+1, cdim-1) + ), + numSurfNodes : length(surfNodes), + numSurfConfigNodes : length(surfConfigNodes), + numVelNodes : numSurfNodes/numSurfConfigNodes, + numMuNodes : 1, + if vdim > 1 then ( numMuNodes : 2), + numVparNodes : numVelNodes/numMuNodes, + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, + const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgs: surface DG geometry.~%"), + printf(fh, " // gkdgs: gyrokinetic surface DG geometry.~%"), + printf(fh, " // bmag: bmag represented on the surface.~%"), + printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), + printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmagSurf_e : doExpand1(bmag, bmagBasis), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + if edge = true then ( + evPoint : 1 + ) else ( + evPoint : -1 + ), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmagSurf_e ), + hamil_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,hamil_e)), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bSurf, + + /* fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + JfL_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=1,JfL_e)), + JfR_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=-1,JfR_e)), + JfL_e : JfL_c . bSurf, + JfR_e : JfR_c . bSurf, + + if (mb_bound = true) then ( + /* Rescale ghost cell by ratio of the Jacobians at multiblock boundaries. */ + + if (edge = true) then ( + /* Upper boundary. */ + jacobgeo_rat_surfR_e : doExpand1(jacobgeo_rat_surfR, bSurfC), + + JfR_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfR_e, bSurf, JfR_e), + printf(fh, " double JRatfR[~a] = {0.}; ~%", length(bSurf)), + writeCExprsNoExpand1(JRatfR, fullratsimp(JfR_c)), + printf(fh, "~%"), + JfR_c : makelistNoZeros1(JfR_c, JRatfR), + JfR_e : doExpand(JfR_c, bSurf) + ) else ( + /* Lower boundary. */ + jacobgeo_rat_surfL_e : doExpand1(jacobgeo_rat_surfL, bSurfC), + + JfL_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfL_e, bSurf, JfL_e), + printf(fh, " double JRatfL[~a] = {0.}; ~%", length(bSurf)), + writeCExprsNoExpand1(JRatfL, fullratsimp(JfL_c)), + printf(fh, "~%"), + JfL_c : makelistNoZeros1(JfL_c, JRatfL), + JfL_e : doExpand(JfL_c, bSurf) + ) + ), + + JfL_nodes : gcfac(float(expand(evAtNodes(JfL_e,surfNodes,surfIntVars)))), + JfR_nodes : gcfac(float(expand(evAtNodes(JfR_e,surfNodes,surfIntVars)))), + + vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), + + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_nodes : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars))/vmap_prime_nodes + ) + else ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ) + ), + + mvpar_nodes : [], + for i : 1 thru numVparNodes do ( + mvpar_nodes : append(mvpar_nodes, [dH_dz_nodes[vpardim][i]]) + ), + + if surfDir = cdim then( + di3 : true + ) + else ( + di3 : false + ), + + /* Expand Aparallel. */ + apar_e : doExpand1(apar,bC), + /* Eval Aparallel at nodes. */ + apar_nodes : float(evAtNodes(apar_e,surfNodes,surfIntVars)), + /* Compute gradient of Aparallel */ + dA_dx_nodes : makelist(0, i, 1, cdim), + for i : 1 thru cdim do ( + dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ), + /* It will be used to compute the contribution as curl(Apar * bhat) = nabla Aparallel cross bhat + Aparallel * curl(bhat) */ + + /* Now calculate flux at all quadrature nodes */ + /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + printf(fh, " double bmag_quad = 0.0; ~%"), + printf(fh, " double Jc_quad = 0.0; ~%"), + printf(fh, " double B3_quad = 0.0; ~%"), + printf(fh, " double normcurlbhat_quad = 0.0; ~%"), + printf(fh, " double area_elem_quad = 0.0; ~%"), + printf(fh, " double bhat_quad[3] = {0.0}; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + + printf(fh, " double mvpar_quad[3] = {0.0}; ~%"), + for i : 1 thru numVparNodes do ( + printf(fh, " mvpar_quad[~a] = ~a; ~%", i-1, mvpar_nodes[i]) + ), + + printf(fh, " double mvparsq_quad[3] = {0.0}; ~%"), + for i : 1 thru numVparNodes do ( + printf(fh, " mvparsq_quad[~a] = mvpar_quad[~a]*mvpar_quad[~a]/m_; ~%", i-1, i-1,i-1) + ), + printf(fh, "~%"), + + for i : 1 thru numSurfConfigNodes do ( + printf(fh, " bmag_quad = gkdgs[~a].bmag; ~%", i-1), + printf(fh, " Jc_quad = gkdgs[~a].Jc; ~%", i-1), + printf(fh, " B3_quad = gkdgs[~a].B3; ~%", i-1), + printf(fh, " normcurlbhat_quad = gkdgs[~a].normcurlbhat; ~%", i-1), + printf(fh, " bhat_quad[0] = gkdgs[~a].bhat.x[0]; ~%", i-1), + printf(fh, " bhat_quad[1] = gkdgs[~a].bhat.x[1]; ~%", i-1), + printf(fh, " bhat_quad[2] = gkdgs[~a].bhat.x[2]; ~%", i-1), + printf(fh, " area_elem_quad = dgs[~a].area_elem; ~%", i-1), + printf(fh, "~%"), + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + vparindex : mod(j-1, numVparNodes) + 1, + vpar0index : mod(j-1, numVparNodes), + printf(fh, "~%"), + printf(fh, " alpha_quad = 0.0; ~%"), + + if no_by = false then ( + /*printf(fh, " alpha_quad += mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) ;~%", vpar0index),*/ + if cdim = 3 then ( + if surfDir = 1 then( + /* Aparallel curl b contribution */ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), + /* grad(Aparallel) x b contribution*/ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) + ), + if surfDir = 2 then( + /* Aparallel curl b contribution */ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), + /* grad(Aparallel) x b contribution*/ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) + ), + if surfDir = 3 then( + /* Aparallel curl b contribution */ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), + /* grad(Aparallel) x b contribution*/ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + ) + ), + if cdim = 2 then ( + if surfDir = 1 then( + /* Aparallel curl b contribution */ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), + /* grad(Aparallel) x b contribution*/ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) + ), + if surfDir = 2 then( + /* Aparallel curl b contribution */ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), + /* grad(Aparallel) x b contribution*/ + printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) + ) + ), + if cdim = 1 then ( + /* B0 */ + printf(fh, " alpha_quad = 0.0; ~%", vpar0index) + ) + ), + + printf(fh, "~%"), + /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), + printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), + printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), + printf(fh, " flux_surf_nodal[~a] += alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ), + printf(fh, "~%") + ), + + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + printf(fh, "~%"), + printf(fh, " return cfl*~a; ~%", float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%"), + flush_output(fh), + printf(fh, "} ~%") + +)$ diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index a172abb2..516acb78 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -240,3 +240,420 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, "} ~%") )$ + + +AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, + numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, + bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, + hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + configNodes : gaussOrd(polyOrder+1, cdim), + numSurfNodes : length(surfNodes), + numConfigNodes : length(configNodes), + numVelNodes : numSurfNodes/numConfigNodes, + + /* if polyOrder = 1, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size in the + vparallel surfaces and/or we are more directly exploiting the sparsity of + alpha (e.g., in the x and z direction when no toroidal field, by=0) + and thus utilize fewer coefficients to reduce the number of operations */ + if (polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgv: volume DG geometry.~%"), + printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmag_e : doExpand1(bmag, bmagBasis), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + if edge = true then ( + evPoint : 1 + ) else ( + evPoint : -1 + ), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ + + /* Expand Apar */ + apar_e : doExpand1(apar, bC), + /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ + apar_c : calcInnerProdList(varsP, 1, bP, apar_e), + apar_e : apar_c . bP, + apar_nodes : makelist(0, i, 1, cdim), + for i : 1 thru cdim do ( + apar_nodes[i] : float(evAtNodes(apar_e,surfNodes,surfIntVars)) + ), + /* Compute gradient of Aparallel */ + dA_dx_nodes : makelist(0, i, 1, cdim), + for i : 1 thru cdim do ( + dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ), + + /*fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), + JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), + + JfL_e : subst(surfVar=1,JfL_e), + JfR_e : subst(surfVar=-1,JfR_e), + + JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), + JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), + + vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), + + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_nodes : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), + dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) + ) + else ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ) + ), + + /* Now calculate apha at all quadrature nodes */ + /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + printf(fh, " double bmag_quad = 0.0; ~%"), + printf(fh, " double B3_quad = 0.0; ~%"), + printf(fh, " double Jc_quad = 0.0; ~%"), + printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), + printf(fh, " double m_bmag_inv = 0.0; ~%"), + printf(fh, " double mvpar_over_q = 0.0; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + printf(fh, "~%"), + + for i : 1 thru numConfigNodes do ( + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + + printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), + /* + We develop the component grad(Apar) x b as + e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| + which gives + coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 + coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 + coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 + with + coeff = Jc/sqrt(g_33) + */ + printf(fh, " g_13 = 1.0; ~%"), /* need to pass them */ + printf(fh, " g_23 = 1.0; ~%"), + printf(fh, " g_33 = 1.0; ~%"), + printf(fh, " mag_e_3 = 1.0; ~%"), /* I need |e_3|=sqrt(g_33) here */ + + printf(fh, "~%"), + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + printf(fh, "~%"), + printf(fh, " mvpar_over_q = (~a)/q_; ~%", dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + + printf(fh, " alpha_quad = 0.0; ~%"), + if cdim = 3 then ( + /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + for k : 1 thru cdim do ( + /* Apar * curl(b) */ + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[k][j1index], k-1) + ), + /* grad(Apar) x b */ + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]), + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]), + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + ), + if cdim = 2 then ( + /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* Apar * curl(b) */ + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 0), + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[2][j1index], 2), + /* grad(Apar) x b */ + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index]), + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][j1index]) + ), + if cdim = 1 then ( + /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* Apar * curl(b) */ + printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 2) + /* grad(Apar) x b */ + /* none */ + ), + + printf(fh, "~%"), + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), + printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), + printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), + printf(fh, " flux_surf_nodal[~a] += alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + ), + printf(fh, "~%") + ), + + printf(fh, "~%"), + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + if polyOrder=1 then ( pOrderCFL : 2 ), + printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), + vprimeStr : "/vmap_prime_min", + printf(fh, "~%"), + printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%"), + flush_output(fh), + printf(fh, "} ~%") + +)$ + +AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge) := block( + [pDim,varsC,bC,varsP,bP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfNodes,configNodes,numSurfNodes,numConfigNodes, + numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdSurfVar2, + JfL_e,JfR_e,JfL_nodes,JfR_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1) + ), + configNodes : gaussOrd(polyOrder+1, cdim), + numSurfNodes : length(surfNodes), + numConfigNodes : length(configNodes), + numVelNodes : numSurfNodes/numConfigNodes, + + /* if polyOrder = 1, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size in the + vparallel surfaces and/or we are more directly exploiting the sparsity of + alpha (e.g., in the x and z direction when no toroidal field, by=0) + and thus utilize fewer coefficients to reduce the number of operations */ + if (polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apardot, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgv: volume DG geometry.~%"), + printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // apardot: time derivative of the parallel component of vector potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + printf(fh, "~%"), + flush_output(fh), + + /* Expand Apardot */ + apardot_e : doExpand1(apardot, bC), + /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ + apardot_c : calcInnerProdList(varsP, 1, bP, apardot_e), + apardot_e : apardot_c . bP, + apardot_nodes : float(evAtNodes(apardot_e,surfNodes,surfIntVars)), + + /*fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + + JfL_e : subst(surfVar=1,JfL_e), + JfR_e : subst(surfVar=-1,JfR_e), + + JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), + JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), + + /* Now calculate alpha at all quadrature nodes */ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + printf(fh, "~%"), + + for i : 1 thru numConfigNodes do ( + printf(fh, "~%"), + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + printf(fh, "~%"), + + /* Compute the contribution of Apardot */ + printf(fh, " alpha_quad = -q_/m_*(~a); ~%", apardot_nodes[j1index]), + + printf(fh, "~%"), + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), + printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), + printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), + printf(fh, " flux_surf_nodal[~a] += alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + ), + printf(fh, "~%") + ), + + printf(fh, "~%"), + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + if polyOrder=1 then ( pOrderCFL : 2 ), + printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), + vprimeStr : "/vmap_prime_min", + printf(fh, "~%"), + printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%"), + flush_output(fh), + printf(fh, "} ~%") +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 08e41563..a624bdde 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -86,6 +86,27 @@ printPrototypes() := block([], ) ) ) + ), + /* EM terms */ + for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apar_vol_~ax~av_~a_p~a(const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const double *bmag, const double *jacobtot_inv, + const double *b_i, const double *phi, const double *apar, + const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apardot_vol_~ax~av_~a_p~a(const double q_, const double m_, + const double *apardot, const double *fin, double* GKYL_RESTRICT out) ; ~%", c, v, bName[bInd], polyOrder), + printf(fh, "~%") + ) + ) + ) ) )$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index ef0b8a40..37d36b83 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -54,6 +54,23 @@ for bInd : 1 thru length(bName) do ( buildGKVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), close(fh), + /* Add em kernels */ + fname : sconcat("~/max-out/dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating volume file (add em): ~a",fname)), + fh : openw(fname), + printf(fh, "#include ~%"), + funcName : sconcat("dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + addAparGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), + close(fh), + + fname : sconcat("~/max-out/dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating volume file (add em): ~a",fname)), + fh : openw(fname), + printf(fh, "#include ~%"), + funcName : sconcat("dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + addApardotGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), + close(fh), + /* if cdim > 1, also generate a set of kernels for the case where there is no toroidal field (by = 0) */ if (c > 1) then ( fname : sconcat("~/max-out/dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index ebef045a..a01ef010 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -103,6 +103,89 @@ printPrototypes() := block([], ) ) ) + ), + + /* EM terms */ + for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ) + ), + + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ), + + printf(fh, "~%") + ) + ) ) )$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 25581b85..4adad02e 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -84,7 +84,30 @@ for bInd : 1 thru length(bName) do ( funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), - close(fh) + close(fh), + + /* EM terms */ + if (no_by = false) then ( + fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), + close(fh), + + fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), + close(fh) + ) ) ), @@ -97,7 +120,30 @@ for bInd : 1 thru length(bName) do ( funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxVparESKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false), - close(fh) + close(fh), + + if (no_by = false) then ( + /* EM terms */ + fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar file: ~a",fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddAparGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), + close(fh), + + fname : sconcat("~/max-out/gk_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar file: ~a",fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), + close(fh) + ) ) ) ) From 78e8603c782f22137ab6fdf3b1b18b4237d6baeb Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 6 Nov 2025 09:13:42 -0500 Subject: [PATCH 07/54] The scripts are still containing commented parts to keep the possibility of generating separated EM/ES kernels. This will be cleaned once the design in Gkeyll is fully decided. --- .../gk_collisionless_flux-surf-conf.mac | 393 ++++++++++++++++-- .../gk_collisionless_flux-surf-vpar.mac | 338 ++++++++++++++- .../ms-gk_collisionless_flux-header.mac | 12 +- .../ms-gk_collisionless_flux.mac | 38 +- 4 files changed, 705 insertions(+), 76 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 5ad7004d..f336e4ae 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -298,10 +298,12 @@ buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no )$ -AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( + +buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, - numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, + numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,apar_e, + bmagSurf_e,vmap_e,vmapSq_e, vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL @@ -366,6 +368,7 @@ AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // apar: parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -413,7 +416,7 @@ AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bSurf, + hamil_e : doExpand(hamilNoZero_c, bSurf), /* fl and fr */ JfL_e : doExpand1(JfL, bP), @@ -480,6 +483,12 @@ AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, /* Expand Aparallel. */ apar_e : doExpand1(apar,bC), + apar_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,apar_e)), + /* printf(fh, " double apar[~a] = {0.}; ~%", numP), */ + aparCvar : eval_string(sconcat("apar")), + apar_c : makelistNoZeros1(apar_c, aparCvar), + /* Expand projected Apar on basis. */ + apar_e : doExpand(apar_c, bSurf), /* Eval Aparallel at nodes. */ apar_nodes : float(evAtNodes(apar_e,surfNodes,surfIntVars)), /* Compute gradient of Aparallel */ @@ -533,47 +542,361 @@ AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, vparindex : mod(j-1, numVparNodes) + 1, vpar0index : mod(j-1, numVparNodes), printf(fh, "~%"), - printf(fh, " alpha_quad = 0.0; ~%"), - if no_by = false then ( + /* Electrostatic term */ + if no_by = true then ( + if di3 = true then ( + printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) + ) + else ( + printf(fh, " alpha_quad = 0.0; ~%") + ) + ) else ( /*printf(fh, " alpha_quad += mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) ;~%", vpar0index),*/ if cdim = 3 then ( - if surfDir = 1 then( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), - /* grad(Aparallel) x b contribution*/ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) - ), - if surfDir = 2 then( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), - /* grad(Aparallel) x b contribution*/ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) - ), - if surfDir = 3 then( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), - /* grad(Aparallel) x b contribution*/ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) - ) + if surfDir = 1 then( + printf(fh, " alpha_quad = (mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * (bhat_quad[1]*(~a) - bhat_quad[2]*(~a)))*area_elem_quad/Jc_quad; ~%", vpar0index, dH_dz_nodes[3][j1index], dH_dz_nodes[2][j1index]) + ), + if surfDir = 2 then( + printf(fh, " alpha_quad = (mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * (bhat_quad[2]*(~a) - bhat_quad[0]*(~a)))*area_elem_quad/Jc_quad; ~%", vpar0index, dH_dz_nodes[1][j1index], dH_dz_nodes[3][j1index]) + ), + if surfDir = 3 then( + printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad) + mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * (bhat_quad[0]*(~a) - bhat_quad[1]*(~a)))*area_elem_quad/Jc_quad; ~%", vpar0index, vpar0index, dH_dz_nodes[2][j1index], dH_dz_nodes[1][j1index]) + ) ), if cdim = 2 then ( - if surfDir = 1 then( + if surfDir = 1 then( + printf(fh, " alpha_quad = (mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * bhat_quad[1]*(~a))*area_elem_quad/Jc_quad; ~%", vpar0index, dH_dz_nodes[2][j1index]) + ), + if surfDir = 2 then( + printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad) + mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * -bhat_quad[1]*(~a))*area_elem_quad/Jc_quad;~%", vpar0index, vpar0index, dH_dz_nodes[1][j1index]) + ) + ), + if cdim = 1 then ( + printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) + ), + + if em = true then ( + /* Electromagnetic Apar contribution curl(Apar b) = grad(Apar) x b + Apar curl(b)*/ + /* No contribution for cdim = 1 */ + if cdim > 1 then ( /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), - /* grad(Aparallel) x b contribution*/ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]) ), - if surfDir = 2 then( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]), - /* grad(Aparallel) x b contribution*/ - printf(fh, " alpha_quad += mvpar_quad[~a]/bmag_quad * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) + /* grad(Aparallel) x b contribution*/ + if cdim = 3 then ( + if surfDir = 1 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) + ), + if surfDir = 2 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) + ), + if surfDir = 3 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + ) + ), + if cdim = 2 then ( + if surfDir = 1 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) + ), + if surfDir = 2 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) + ) ) + ) + ), + + printf(fh, "~%"), + /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), + printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), + printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ), + printf(fh, "~%") + ), + + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + printf(fh, "~%"), + printf(fh, " return cfl*~a; ~%", float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%"), + flush_output(fh), + printf(fh, "} ~%") + +)$ + +AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge, mb_bound) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, + numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, + vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, + jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + if cdim = 1 then ( + surfConfigNodes : [1] + ) + else ( + surfConfigNodes : gaussOrd(polyOrder+1, cdim-1) + ), + numSurfNodes : length(surfNodes), + numSurfConfigNodes : length(surfConfigNodes), + numVelNodes : numSurfNodes/numSurfConfigNodes, + numMuNodes : 1, + if vdim > 1 then ( numMuNodes : 2), + numVparNodes : numVelNodes/numMuNodes, + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, + const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgs: surface DG geometry.~%"), + printf(fh, " // gkdgs: gyrokinetic surface DG geometry.~%"), + printf(fh, " // bmag: bmag represented on the surface.~%"), + printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), + printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmagSurf_e : doExpand1(bmag, bmagBasis), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + if edge = true then ( + evPoint : 1 + ) else ( + evPoint : -1 + ), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmagSurf_e ), + hamil_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,hamil_e)), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : doExpand(hamilNoZero_c, bSurf), + + /* fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + JfL_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=1,JfL_e)), + JfR_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=-1,JfR_e)), + JfL_e : JfL_c . bSurf, + JfR_e : JfR_c . bSurf, + + if (mb_bound = true) then ( + /* Rescale ghost cell by ratio of the Jacobians at multiblock boundaries. */ + + if (edge = true) then ( + /* Upper boundary. */ + jacobgeo_rat_surfR_e : doExpand1(jacobgeo_rat_surfR, bSurfC), + + JfR_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfR_e, bSurf, JfR_e), + printf(fh, " double JRatfR[~a] = {0.}; ~%", length(bSurf)), + writeCExprsNoExpand1(JRatfR, fullratsimp(JfR_c)), + printf(fh, "~%"), + JfR_c : makelistNoZeros1(JfR_c, JRatfR), + JfR_e : doExpand(JfR_c, bSurf) + ) else ( + /* Lower boundary. */ + jacobgeo_rat_surfL_e : doExpand1(jacobgeo_rat_surfL, bSurfC), + + JfL_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfL_e, bSurf, JfL_e), + printf(fh, " double JRatfL[~a] = {0.}; ~%", length(bSurf)), + writeCExprsNoExpand1(JRatfL, fullratsimp(JfL_c)), + printf(fh, "~%"), + JfL_c : makelistNoZeros1(JfL_c, JRatfL), + JfL_e : doExpand(JfL_c, bSurf) + ) + ), + + JfL_nodes : gcfac(float(expand(evAtNodes(JfL_e,surfNodes,surfIntVars)))), + JfR_nodes : gcfac(float(expand(evAtNodes(JfR_e,surfNodes,surfIntVars)))), + + vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), + + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_nodes : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars))/vmap_prime_nodes + ) + else ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ) + ), + + mvpar_nodes : [], + for i : 1 thru numVparNodes do ( + mvpar_nodes : append(mvpar_nodes, [dH_dz_nodes[vpardim][i]]) + ), + + if surfDir = cdim then( + di3 : true + ) + else ( + di3 : false + ), + + /* Expand Aparallel. */ + apar_e : doExpand1(apar,bC), + apar_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,apar_e)), + /* printf(fh, " double apar[~a] = {0.}; ~%", numP), */ + aparCvar : eval_string(sconcat("apar")), + apar_c : makelistNoZeros1(apar_c, aparCvar), + /* Expand projected Apar on basis. */ + apar_e : doExpand(apar_c, bSurf), + /* Eval Aparallel at nodes. */ + apar_nodes : float(evAtNodes(apar_e,surfNodes,surfIntVars)), + /* Compute gradient of Aparallel */ + dA_dx_nodes : makelist(0, i, 1, cdim), + for i : 1 thru cdim do ( + dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ), + /* It will be used to compute the contribution as curl(Apar * bhat) = nabla Aparallel cross bhat + Aparallel * curl(bhat) */ + + /* Now calculate flux at all quadrature nodes */ + /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + printf(fh, " double bmag_quad = 0.0; ~%"), + printf(fh, " double Jc_quad = 0.0; ~%"), + printf(fh, " double B3_quad = 0.0; ~%"), + printf(fh, " double normcurlbhat_quad = 0.0; ~%"), + printf(fh, " double area_elem_quad = 0.0; ~%"), + printf(fh, " double bhat_quad[3] = {0.0}; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + + printf(fh, " double mvpar_quad[3] = {0.0}; ~%"), + for i : 1 thru numVparNodes do ( + printf(fh, " mvpar_quad[~a] = ~a; ~%", i-1, mvpar_nodes[i]) + ), + + printf(fh, " double mvparsq_quad[3] = {0.0}; ~%"), + for i : 1 thru numVparNodes do ( + printf(fh, " mvparsq_quad[~a] = mvpar_quad[~a]*mvpar_quad[~a]/m_; ~%", i-1, i-1,i-1) + ), + printf(fh, "~%"), + + for i : 1 thru numSurfConfigNodes do ( + printf(fh, " bmag_quad = gkdgs[~a].bmag; ~%", i-1), + printf(fh, " Jc_quad = gkdgs[~a].Jc; ~%", i-1), + printf(fh, " B3_quad = gkdgs[~a].B3; ~%", i-1), + printf(fh, " normcurlbhat_quad = gkdgs[~a].normcurlbhat; ~%", i-1), + printf(fh, " bhat_quad[0] = gkdgs[~a].bhat.x[0]; ~%", i-1), + printf(fh, " bhat_quad[1] = gkdgs[~a].bhat.x[1]; ~%", i-1), + printf(fh, " bhat_quad[2] = gkdgs[~a].bhat.x[2]; ~%", i-1), + printf(fh, " area_elem_quad = dgs[~a].area_elem; ~%", i-1), + printf(fh, "~%"), + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + vparindex : mod(j-1, numVparNodes) + 1, + vpar0index : mod(j-1, numVparNodes), + printf(fh, "~%"), + printf(fh, " alpha_quad = 0.0; ~%"), + + if cdim = 1 then ( + /* No contribution */ + printf(fh, " alpha_quad = 0.0; ~%", vpar0index) + ) else ( + /* Aparallel curl b contribution */ + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]) + ), + /* grad(Aparallel) x b contribution*/ + if cdim = 3 then ( + if surfDir = 1 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) ), - if cdim = 1 then ( - /* B0 */ - printf(fh, " alpha_quad = 0.0; ~%", vpar0index) + if surfDir = 2 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) + ), + if surfDir = 3 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + ) + ), + if cdim = 2 then ( + if surfDir = 1 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) + ), + if surfDir = 2 then( + printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) ) ), diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 516acb78..01969b2f 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -242,6 +242,307 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no )$ +buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge) := block( + [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, + surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, + numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, + bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, + hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + ], + + kill(varsC,varsP,bC,bP), + pDim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + numC : length(bC), numP : length(bP), + + surfVar : varsP[surfDir], /* Surface variable. */ + varLabel : makelist(string(varsP[d]),d,1,pDim), + dirLabel : varLabel[surfDir], + + surfIntVars : delete(surfVar,varsP), + surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), + surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), + + surfIntVarsC : delete(surfVar,varsC), + bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), + + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), + nodeVars : surfIntVars, + bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), + basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) + ) else ( + surfNodes : gaussOrd(polyOrder+1, pDim-1), + nodeVars : surfIntVars, + bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) + ), + configNodes : gaussOrd(polyOrder+1, cdim), + numSurfNodes : length(surfNodes), + numConfigNodes : length(configNodes), + numVelNodes : numSurfNodes/numConfigNodes, + + /* if polyOrder = 1, we need to be careful about + indexing input arrays since the surface hybrid basis has a different size in the + vparallel surfaces and/or we are more directly exploiting the sparsity of + alpha (e.g., in the x and z direction when no toroidal field, by=0) + and thus utilize fewer coefficients to reduce the number of operations */ + if (polyOrder = 1) then ( + tempVars : delete(x,varsP), + tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), + NSurfIndexing : length(tempBasis), + numNodesIndexing : length(tempBasis) + ) else ( + NSurfIndexing : NSurf, + numNodesIndexing : numNodes + ), + + print("Working on ", funcNm), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + printf(fh, " // w[NDIM]: cell-center.~%"), + printf(fh, " // dxv[NDIM]: cell length.~%"), + printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), + printf(fh, " // vmap: velocity space mapping.~%"), + printf(fh, " // vmapSq: velocity space mapping squared.~%"), + printf(fh, " // q_,m_: species charge and mass.~%"), + printf(fh, " // dgv: volume DG geometry.~%"), + printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), + printf(fh, " // bmag: magnetic field amplitude.~%"), + printf(fh, " // phi: electrostatic potential.~%"), + printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), + printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), + printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), + printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), + printf(fh, "~%"), + + /* Declare cell-center variables and variables multiplying gradients. */ + for d : 1 thru cdim+1 do ( + printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) + ), + printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), + + /* Axisymmetric basis (independent of y). */ + bmagBasis : getAxisymmetricConfBasis(bC), + + /* Expand input fields for Hamiltonian calculation */ + phi_e : doExpand1(phi,bC), + bmag_e : doExpand1(bmag, bmagBasis), + + /* Velocity mapping fields. */ + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Redefine vmap_prime to exploit the relationship between it and vmap. */ + /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), + + if edge = true then ( + evPoint : 1 + ) else ( + evPoint : -1 + ), + + /* Finally write out the hamiltonian*/ + hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], + if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), + hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), + printf(fh, " double hamil[~a] = {0.}; ~%", numP), + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + hamilCvar : eval_string(sconcat("hamil")), + writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), + printf(fh, "~%"), + flush_output(fh), + hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), + /* Expand projected Hamiltonian on basis. */ + hamil_e : hamilNoZero_c . bP, + /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ + + /* Expand Apar */ + apar_e : doExpand1(apar, bC), + /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ + apar_c : calcInnerProdList(varsP, 1, bP, apar_e), + apar_e : apar_c . bP, + apar_nodes : makelist(0, i, 1, cdim), + for i : 1 thru cdim do ( + apar_nodes[i] : float(evAtNodes(apar_e,surfNodes,surfIntVars)) + ), + /* Compute gradient of Aparallel */ + dA_dx_nodes : makelist(0, i, 1, cdim), + for i : 1 thru cdim do ( + dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ), + + /*fl and fr */ + JfL_e : doExpand1(JfL, bP), + JfR_e : doExpand1(JfR, bP), + JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), + JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), + + JfL_e : subst(surfVar=1,JfL_e), + JfR_e : subst(surfVar=-1,JfR_e), + + JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), + JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), + + vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), + + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_nodes : makelist(0, i, 1, pDim), + for i : 1 thru vpardim do ( + if i = vpardim then ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), + dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) + ) + else ( + dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + ) + ), + + /* Now calculate apha at all quadrature nodes */ + /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ + printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + printf(fh, " double cfl = 0.0; ~%"), + printf(fh, " double bmag_quad = 0.0; ~%"), + printf(fh, " double B3_quad = 0.0; ~%"), + printf(fh, " double Jc_quad = 0.0; ~%"), + printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), + printf(fh, " double m_bmag_inv = 0.0; ~%"), + printf(fh, " double mvpar_over_q = 0.0; ~%"), + + printf(fh, " double alpha_quad = 0.0; ~%"), + printf(fh, " double JfL_quad = 0.0; ~%"), + printf(fh, " double JfR_quad = 0.0; ~%"), + printf(fh, " double Jfavg_quad = 0.0; ~%"), + printf(fh, " double Jfjump_quad = 0.0; ~%"), + printf(fh, " double g_13 = 0.0; ~%"), + printf(fh, " double g_23 = 0.0; ~%"), + printf(fh, " double g_33 = 0.0; ~%"), + printf(fh, " double mag_e_3 = 0.0; ~%"), + printf(fh, "~%"), + + for i : 1 thru numConfigNodes do ( + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + + printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), + /* + We develop the component grad(Apar) x b as + e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| + which gives + coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 + coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 + coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 + with + coeff = Jc/sqrt(g_33) + */ + printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), + printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), + printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), + printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1), + + for j : 1 thru numVelNodes do ( + j0index : j-1+(i-1)*numVelNodes, + j1index : j+(i-1)*numVelNodes, + printf(fh, "~%"), + /* printf(fh, " mvpar_over_q = (~a)/q_; ~%", dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), */ + + if no_by = true then ( + /* Start ES term */ + printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) + ), + if no_by = false then ( + /* Start ES term */ + printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), + if cdim = 3 then ( + /* Finish ES term */ + for k : 1 thru cdim do ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + printf(fh, ";~%"), + if em = true then ( + /* EM term curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + for k : 1 thru cdim do ( + /* Apar * curl(b) */ + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[k][j1index], k-1) + ), + /* grad(Apar) x b */ + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + ) + ), + if cdim = 2 then ( + /* Finish ES term */ + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, ";~%"), + if em = true then ( + /* EM term curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* Apar * curl(b) */ + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 0), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[2][j1index], 2), + /* grad(Apar) x b */ + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][j1index]) + ) + ), + if cdim = 1 then ( + /* Finish ES term */ + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, ";~%"), + if em = true then ( + /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* Apar * curl(b) */ + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 2) + /* grad(Apar) x b */ + /* none */ + ) + ) + ), + + printf(fh, "~%"), + printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), + printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), + printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), + printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), + printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + ), + printf(fh, "~%") + ), + + printf(fh, "~%"), + /*Calculate the cfl*/ + pOrderCFL : polyOrder, + if polyOrder=1 then ( pOrderCFL : 2 ), + printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), + vprimeStr : "/vmap_prime_min", + printf(fh, "~%"), + printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), + + printf(fh, "~%"), + flush_output(fh), + printf(fh, "} ~%") + +)$ + + AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, @@ -426,6 +727,10 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, printf(fh, " double JfR_quad = 0.0; ~%"), printf(fh, " double Jfavg_quad = 0.0; ~%"), printf(fh, " double Jfjump_quad = 0.0; ~%"), + printf(fh, " double g_13 = 0.0; ~%"), + printf(fh, " double g_23 = 0.0; ~%"), + printf(fh, " double g_33 = 0.0; ~%"), + printf(fh, " double mag_e_3 = 0.0; ~%"), printf(fh, "~%"), for i : 1 thru numConfigNodes do ( @@ -447,12 +752,11 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, with coeff = Jc/sqrt(g_33) */ - printf(fh, " g_13 = 1.0; ~%"), /* need to pass them */ - printf(fh, " g_23 = 1.0; ~%"), - printf(fh, " g_33 = 1.0; ~%"), - printf(fh, " mag_e_3 = 1.0; ~%"), /* I need |e_3|=sqrt(g_33) here */ + printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), + printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), + printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), + printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1), - printf(fh, "~%"), for j : 1 thru numVelNodes do ( j0index : j-1+(i-1)*numVelNodes, j1index : j+(i-1)*numVelNodes, @@ -464,26 +768,26 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ for k : 1 thru cdim do ( /* Apar * curl(b) */ - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[k][j1index], k-1) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[k][j1index], k-1) ), /* grad(Apar) x b */ - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]), - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]), - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) ), if cdim = 2 then ( /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ /* Apar * curl(b) */ - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 0), - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[2][j1index], 2), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 0), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[2][j1index], 2), /* grad(Apar) x b */ - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index]), - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][j1index]) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][j1index]) ), if cdim = 1 then ( /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ /* Apar * curl(b) */ - printf(fh, "alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 2) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 2) /* grad(Apar) x b */ /* none */ ), @@ -565,7 +869,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde const double *vmap_prime_l, const double *vmap_prime_r, const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apardot, const double *JfL, const double *JfR, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), @@ -577,7 +881,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), printf(fh, " // bmag: magnetic field amplitude.~%"), printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apardot: time derivative of the parallel component of vector potential.~%"), + printf(fh, " // apar: parallel component of vector potential (here it will be apardot).~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -596,7 +900,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde flush_output(fh), /* Expand Apardot */ - apardot_e : doExpand1(apardot, bC), + apardot_e : doExpand1(apar, bC), /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ apardot_c : calcInnerProdList(varsP, 1, bP, apardot_e), apardot_e : apardot_c . bP, diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index a01ef010..f37bc501 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -130,7 +130,7 @@ printPrototypes() := block([], const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_~aedge_surf~a_~ax~av_~a_p~a( @@ -139,7 +139,7 @@ printPrototypes() := block([], const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_~asurf~a_~ax~av_~a_p~a( @@ -148,7 +148,7 @@ printPrototypes() := block([], const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, + const double *phi, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_~aedge_surf~a_~ax~av_~a_p~a( @@ -157,7 +157,7 @@ printPrototypes() := block([], const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, + const double *phi, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ) ), @@ -171,7 +171,7 @@ printPrototypes() := block([], ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a - const double *bmag, const double *phi, const double *JfL, const double *JfR, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_surf~a_~ax~av_~a_p~a( @@ -179,7 +179,7 @@ printPrototypes() := block([], ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a - const double *bmag, const double *phi, const double *JfL, const double *JfR, + const double *bmag, const double *phi, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ), diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 4adad02e..63822105 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -45,6 +45,8 @@ byStr : ["", "no_by_"]$ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ +em : false$ /* Include EM terms if true */ + /* Generate kernels of selected types. */ for bInd : 1 thru length(bName) do ( for c : minCdim[bInd] thru maxCdim[bInd] do ( @@ -71,9 +73,9 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), - + em : true, funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), close(fh), fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), @@ -81,33 +83,33 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), - + em : true, funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), - close(fh), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, true, mb_bound), + close(fh) /* EM terms */ - if (no_by = false) then ( - fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + /* if (no_by = false) then ( + fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), + funcName : sconcat("gk_collisionless_flux_add_apar_",mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, false, mb_bound), close(fh), - fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux edge surf~a ~a file: ~a",clabels[dir],mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_add_apar_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), + funcName : sconcat("gk_collisionless_flux_add_apar_",mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, true, mb_bound), close(fh) - ) + ) */ ) ), @@ -117,14 +119,14 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), - + em : true, funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxVparESKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false), + buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false), close(fh), if (no_by = false) then ( /* EM terms */ - fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + /* fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar file: ~a",fname)), fh : openw(fname), @@ -132,7 +134,7 @@ for bInd : 1 thru length(bName) do ( funcName : sconcat("gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), AddAparGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), - close(fh), + close(fh), */ fname : sconcat("~/max-out/gk_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar file: ~a",fname)), From 6ecbf540120aea36725e1ead4895b9682559a7d5 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 6 Nov 2025 15:16:25 -0500 Subject: [PATCH 08/54] clean and make the script write es and em kernels for fluxes --- .../ms-gk_collisionless_flux-header.mac | 200 ++++++++---------- .../ms-gk_collisionless_flux.mac | 114 ++++++---- 2 files changed, 157 insertions(+), 157 deletions(-) diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index f37bc501..33389307 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -43,69 +43,76 @@ byStr : ["", "no_by_"]$ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ +emStr : ["es", "em"]$ + printPrototypes() := block([], - for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( + for emI : 1 thru 2 do ( + em_label : emStr[emI], + + for bInd : 1 thru length(bName) do ( + + for c : minCdim[bInd] thru maxCdim[bInd] do ( + + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + + for byI : 1 thru length(byOpt[c]) do ( + no_by : byOpt[c][byI], + no_byStr : byStr[byI], + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_~a_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_~a_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ) + ), + + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", + printf(fh, "GKYL_CU_DH double gk_~a_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - for byI : 1 thru length(byOpt[c]) do ( - no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ) - ), - - dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ), - - printf(fh, "~%") - ) - ) + printf(fh, "~%") + ) + ) + ) + ) ) ), - /* EM terms */ + /* EM add apardot vpar surface term */ for bInd : 1 thru length(bName) do ( for c : minCdim[bInd] thru maxCdim[bInd] do ( for gkV : 1 thru length(gkVdims[c]) do ( @@ -115,66 +122,11 @@ printPrototypes() := block([], if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ for polyOrder : 1 thru maxPolyOrderB do ( - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_~aedge_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_~aedge_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) - ) - ), - dirlabel : varsV[1], extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apar_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_collisionless_flux_add_apardot_surf~a_~ax~av_~a_p~a( + printf(fh, "GKYL_CU_DH double gk_em_collisionless_flux_add_apardot_surf~a_~ax~av_~a_p~a( const double *w, const double *dxv, ~a const double *vmap, const double *vmapSq, const double q_, const double m_, @@ -186,7 +138,25 @@ printPrototypes() := block([], printf(fh, "~%") ) ) - ) + ), + +printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, + const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf);~%"), + +printf(fh,"~%"), + +printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surfvpar_return_zero( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf);~%") )$ fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels.h")$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 63822105..99c027f3 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -68,81 +68,82 @@ for bInd : 1 thru length(bName) do ( /* Surface flux in direction dir in configuration space.*/ for dir : 1 thru c do ( - fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + /* ES kernels */ + fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + em : false, + funcName : sconcat("gk_es_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), + close(fh), + + fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + em : false, + funcName : sconcat("gk_es_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, true, mb_bound), + close(fh), + + /* EM kernels */ + fname : sconcat("~/max-out/gk_em_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), em : true, - funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_em_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), close(fh), - fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/gk_em_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), em : true, - funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_em_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, true, mb_bound), close(fh) - - /* EM terms */ - /* if (no_by = false) then ( - fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_add_apar_",mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, false, mb_bound), - close(fh), - - fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_",mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux edge surf~a ~a file: ~a",clabels[dir],mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_add_apar_",mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddAparGKEMFluxConfKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, true, mb_bound), - close(fh) - ) */ ) ), /* Surface flux in vparallel direction.*/ - fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + /* ES */ + fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + em : false, + funcName : sconcat("gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false), + close(fh), + + /* EM */ + fname : sconcat("~/max-out/gk_em_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), em : true, - funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_em_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false), close(fh), if (no_by = false) then ( - /* EM terms */ - /* fname : sconcat("~/max-out/gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar file: ~a",fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_collisionless_flux_add_apar_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddAparGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), - close(fh), */ - - fname : sconcat("~/max-out/gk_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + /* Add apardot EM terms */ + fname : sconcat("~/max-out/gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar file: ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), close(fh) ) @@ -151,3 +152,32 @@ for bInd : 1 thru length(bName) do ( ) ) )$ +fname : "~/max-out/gk_collisionless_flux_surf_return_zero.h"$ +fh : openw(fname)$ +printf(fh, "#include ~%")$ */ +printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, + /* const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) + { + return 0.0; + }~%")$ +close(fh)$ + +fname : "~/max-out/gk_collisionless_flux_surfvpar_return_zero.h"$ +fh : openw(fname)$ +printf(fh, "#include ~%")$ +printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surfvpar_return_zero( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) + { + return 0.0; + }~%")$ +close(fh)$ From eff6a16d908d536738df5b6ff82a8c0b2bc2afb1 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 6 Nov 2025 19:35:29 -0500 Subject: [PATCH 09/54] =?UTF-8?q?Ensure=20that=20all=20local=20variables?= =?UTF-8?q?=20are=20put=20in=20the=20bracket=20scope=20of=20the=20block=20?= =?UTF-8?q?instance.=20This=20did=20not=20change=20a=20iota=20of=20the=20o?= =?UTF-8?q?utput=20kernels=20but=20better=20be=20safe=20than=20sorry.=20Th?= =?UTF-8?q?ere=20is=20an=20error=20in=20the=20addapardot=20volume=20kernel?= =?UTF-8?q?=20I=20think=20because=20my=20first=20tests=20explode=20when=20?= =?UTF-8?q?I=20include=20it,=20will=20work=20on=20that=20tomorrow=20?= =?UTF-8?q?=F0=9F=A4=93=20have=20a=20good=20night=20folks=20=F0=9F=98=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- maxima/g0/gk_collisionless/dg_gk-surf.mac | 5 +++-- maxima/g0/gk_collisionless/dg_gk-vol.mac | 15 ++++++++++++--- .../gk_collisionless_flux-surf-conf.mac | 9 ++++++--- .../gk_collisionless_flux-surf-vpar.mac | 9 +++++---- 4 files changed, 26 insertions(+), 12 deletions(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-surf.mac b/maxima/g0/gk_collisionless/dg_gk-surf.mac index 77901135..d8d97ea6 100644 --- a/maxima/g0/gk_collisionless/dg_gk-surf.mac +++ b/maxima/g0/gk_collisionless/dg_gk-surf.mac @@ -26,7 +26,7 @@ calcGKSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, vars BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, hamil_e,alphaSurfL_e,alphaSurfR_e, fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - fnodal_l_e, fnodal_r_e, fmodproj_e], + fnodal_l_e,fnodal_r_e,fmodproj_e,numC,vmap_prime_fac_l,vmap_prime_fac_c,vmap_prime_fac_r,vmap_prime_e,basisNodal,i], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, @@ -143,7 +143,8 @@ calcGKBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrd rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, - fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], + fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, + numC,vmap_prime_fac_edge,vmap_prime_fac_skin,vmap_prime_e,basisNodal,i,fnodal_l_e,fnodal_r_e,fmodproj_e], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 62df8500..22d1a5f5 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -14,7 +14,11 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, + dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, + replaceList,dvparSimp,phi_e,bmag_e,dualcurlbhatoverB_x_e,dualcurlbhatoverB_y_e,dualcurlbhatoverB_z_e, + rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,dualcurlbhatoverB_list,bioverJB_list, + vmapSq_e,vmap_prime_e,hamilCvar,hamilNoZero_c,hamil_c,vpardim,i,k,curvdriftdir,clst], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, @@ -262,7 +266,10 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, + replaceList,dvparSimp,phi_e,bmag_e,rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,bioverJB_list, + vmapSq_e,vmap_prime_e,hamil_c,hamilCvar,hamilNoZero_c,vpardim,i,k,Apar_e, + dBperpoverB_x,dBperpoverB_y,dBperpoverB_z,dBperpoverB_list,curvdriftdir,clst], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, @@ -485,7 +492,9 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, + alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, + vmapSq_e,vmap_prime_e,apardot_e,clst], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index f336e4ae..c00be4c2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -12,7 +12,8 @@ buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, + surfIntVarsC,bSurfC,hamilCvar ], kill(varsC,varsP,bC,bP), @@ -306,7 +307,8 @@ buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no bmagSurf_e,vmap_e,vmapSq_e, vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, + surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_nodes,dA_dx_nodes ], kill(varsC,varsP,bC,bP), @@ -635,7 +637,8 @@ AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, + surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_e,apar_nodes,dA_dx_nodes,apar_c ], kill(varsC,varsP,bC,bP), diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 01969b2f..55ee4cdb 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -11,7 +11,7 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,k ], kill(varsC,varsP,bC,bP), @@ -248,7 +248,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,apar_e,apar_c,apar_nodes,dA_dx_nodes,k ], kill(varsC,varsP,bC,bP), @@ -549,7 +549,7 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_c,apar_nodes,dA_dx_nodes,k ], kill(varsC,varsP,bC,bP), @@ -822,7 +822,8 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde [pDim,varsC,bC,varsP,bP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,configNodes,numSurfNodes,numConfigNodes, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdSurfVar2, - JfL_e,JfR_e,JfL_nodes,JfR_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr + JfL_e,JfR_e,JfL_nodes,JfR_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr, + numC,numP,vSub,NSurf,numNodes,apardot_e,apardot_c,apardot_nodes ], kill(varsC,varsP,bC,bP), From ee37a0c75e6374e785e7ac9e123d5d302112681d Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 7 Nov 2025 11:23:36 -0500 Subject: [PATCH 10/54] fix an error were apardot was expanded on bP instead of bC --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 22d1a5f5..7c471e28 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -520,7 +520,7 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no Jf_e : doExpand1(fin,bP), /* Expand Apardot */ - apardot_e : doExpand1(apardot,bP), + apardot_e : doExpand1(apardot,bC), /* Note: only a vpar contribution. */ dir : cdim+1, From ef2671c120068b5d655fe00e7ad1563a179d3c90 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 7 Nov 2025 11:43:49 -0500 Subject: [PATCH 11/54] Fix the apardot volume contribution, a 1/vmap was missing. --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 7c471e28..6a4efa89 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -505,7 +505,7 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no varLabel : makelist(string(varsP[d]),d,1,pDim), print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double q_, const double m_, const double *apardot, + printf(fh, "GKYL_CU_DH double ~a(const double *vmap, const double q_, const double m_, const double *apardot, const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), printf(fh, " // q_,m_: species charge and mass.~%"), printf(fh, " // apardot: time derivative of parallel component of magnetic vector potential.~%"), @@ -513,8 +513,13 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no printf(fh, " // out: output increment.~%"), printf(fh, "~%"), + rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + + /* Velocity mapping fields. */ [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), /*Expand Jf*/ Jf_e : doExpand1(fin,bP), @@ -528,6 +533,14 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no alpha_e : -q_/m_ * apardot_e, + vpardim : pDim-1, + if dir < vpardim then ( + alpha_e : alpha_e*rdx2vec[dir] + ) + else if dir = vpardim then ( + alpha_e : alpha_e/vmap_prime_e[1] + ), + /* Project alpha on basis and write to array. */ printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), From 7faac8e366089b13e3c88ecd2e497c7ead285a5c Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 7 Nov 2025 11:44:26 -0500 Subject: [PATCH 12/54] remove dot operator with doExpand and fix a wrong expansion of Apar and Apardot on bP instead of bC. --- .../gk_collisionless_flux-surf-vpar.mac | 21 ++++++------------- 1 file changed, 6 insertions(+), 15 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 55ee4cdb..75238cca 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -127,7 +127,7 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, + hamil_e : doExpand(hamilNoZero_c,bP), /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ /*fl and fr */ @@ -248,7 +248,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,apar_e,apar_c,apar_nodes,dA_dx_nodes,k + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,apar_e,apar_nodes,dA_dx_nodes,k ], kill(varsC,varsP,bC,bP), @@ -365,14 +365,11 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, + hamil_e : doExpand(hamilNoZero_c,bP), /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ /* Expand Apar */ apar_e : doExpand1(apar, bC), - /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ - apar_c : calcInnerProdList(varsP, 1, bP, apar_e), - apar_e : apar_c . bP, apar_nodes : makelist(0, i, 1, cdim), for i : 1 thru cdim do ( apar_nodes[i] : float(evAtNodes(apar_e,surfNodes,surfIntVars)) @@ -549,7 +546,7 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_c,apar_nodes,dA_dx_nodes,k + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_nodes,dA_dx_nodes,k ], kill(varsC,varsP,bC,bP), @@ -670,10 +667,7 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ /* Expand Apar */ - apar_e : doExpand1(apar, bC), - /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ - apar_c : calcInnerProdList(varsP, 1, bP, apar_e), - apar_e : apar_c . bP, + apar_e : doExpand1(apar, bC), apar_nodes : makelist(0, i, 1, cdim), for i : 1 thru cdim do ( apar_nodes[i] : float(evAtNodes(apar_e,surfNodes,surfIntVars)) @@ -823,7 +817,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde surfNodes,configNodes,numSurfNodes,numConfigNodes, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdSurfVar2, JfL_e,JfR_e,JfL_nodes,JfR_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr, - numC,numP,vSub,NSurf,numNodes,apardot_e,apardot_c,apardot_nodes + numC,numP,vSub,NSurf,numNodes,apardot_e,apardot_nodes ], kill(varsC,varsP,bC,bP), @@ -902,9 +896,6 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde /* Expand Apardot */ apardot_e : doExpand1(apar, bC), - /* I don't know if this is necessary but let's copy the Hamiltonian treatment */ - apardot_c : calcInnerProdList(varsP, 1, bP, apardot_e), - apardot_e : apardot_c . bP, apardot_nodes : float(evAtNodes(apardot_e,surfNodes,surfIntVars)), /*fl and fr */ From 3ed347a2771e18eda5a4075d9f2800eb5d8a8798 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 7 Nov 2025 11:44:45 -0500 Subject: [PATCH 13/54] update kernel signature of add_aprdot to include vmap. --- maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index a624bdde..f579b863 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -94,15 +94,15 @@ printPrototypes() := block([], v : gkVdims[c][gkV], maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ for polyOrder : 1 thru maxPolyOrderB do ( printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apar_vol_~ax~av_~a_p~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, const double q_, const double m_, const double *bmag, const double *jacobtot_inv, const double *b_i, const double *phi, const double *apar, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apardot_vol_~ax~av_~a_p~a(const double q_, const double m_, - const double *apardot, const double *fin, double* GKYL_RESTRICT out) ; ~%", c, v, bName[bInd], polyOrder), + printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apardot_vol_~ax~av_~a_p~a(const double *vmap, const double q_, const double m_, + const double *apardot, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), printf(fh, "~%") ) ) @@ -110,7 +110,7 @@ printPrototypes() := block([], ) )$ -fh : openw("~/max-out/gkyl_dg_gyrokinetic_kernels.h")$ +fh : openw("/Users/ahoffman/gkeyll_dev/gkeyll/gyrokinetic/ker/dg_gyrokinetic/gkyl_dg_gyrokinetic_kernels.h")$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ From 99d2daf0a99e023b5cb3a227020f837d121d6d5f Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 11 Nov 2025 15:45:21 -0500 Subject: [PATCH 14/54] correct a 1/J factor and define the apar and apardot quantities in conf space. --- .../gk_collisionless_flux-surf-vpar.mac | 87 ++++++++++--------- 1 file changed, 44 insertions(+), 43 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 75238cca..eff9836e 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -370,14 +370,11 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no /* Expand Apar */ apar_e : doExpand1(apar, bC), - apar_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - apar_nodes[i] : float(evAtNodes(apar_e,surfNodes,surfIntVars)) - ), + apar_nodes : float(evAtNodes(apar_e,configNodes,surf_cvars)), /* Compute gradient of Aparallel */ dA_dx_nodes : makelist(0, i, 1, cdim), for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsC[i]),configNodes,surf_cvars)) ), /*fl and fr */ @@ -430,12 +427,15 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, "~%"), for i : 1 thru numConfigNodes do ( - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + i0index : i-1, + i1index : i, + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i0index), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i0index), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i0index), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i0index), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i0index), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i0index), + printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), /* @@ -476,12 +476,12 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no /* EM term curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ for k : 1 thru cdim do ( /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[k][j1index], k-1) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[i1index], k-1) ), /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index], dA_dx_nodes[3][i1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][i1index], dA_dx_nodes[1][i1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][i1index], dA_dx_nodes[2][i1index]) ) ), if cdim = 2 then ( @@ -492,11 +492,11 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no if em = true then ( /* EM term curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 0), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[2][j1index], 2), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 0), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[i1index], 2), /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][j1index]) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][i1index]) ) ), if cdim = 1 then ( @@ -506,7 +506,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no if em = true then ( /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 2) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 2) /* grad(Apar) x b */ /* none */ ) @@ -668,14 +668,11 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, /* Expand Apar */ apar_e : doExpand1(apar, bC), - apar_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - apar_nodes[i] : float(evAtNodes(apar_e,surfNodes,surfIntVars)) - ), + apar_nodes : float(evAtNodes(apar_e,configNodes,surf_cvars)), /* Compute gradient of Aparallel */ dA_dx_nodes : makelist(0, i, 1, cdim), for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) + dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsC[i]),configNodes,surf_cvars)) ), /*fl and fr */ @@ -728,12 +725,14 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, printf(fh, "~%"), for i : 1 thru numConfigNodes do ( - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + i0index : i-1, + i1index : i, + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i0index), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i0index), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i0index), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i0index), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i0index), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i0index), printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), /* @@ -759,29 +758,29 @@ AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, printf(fh, " alpha_quad = 0.0; ~%"), if cdim = 3 then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ for k : 1 thru cdim do ( /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[k][j1index], k-1) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[i1index], k-1) ), /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index], dA_dx_nodes[3][i1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][i1index], dA_dx_nodes[1][i1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][i1index], dA_dx_nodes[2][i1index]) ), if cdim = 2 then ( /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 0), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[2][j1index], 2), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 0), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[i1index], 2), /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][j1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * Jc_quad/mag_e_3 * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][j1index]) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index]), + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][i1index]) ), if cdim = 1 then ( /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[1][j1index], 2) + printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 2) /* grad(Apar) x b */ /* none */ ), @@ -896,7 +895,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde /* Expand Apardot */ apardot_e : doExpand1(apar, bC), - apardot_nodes : float(evAtNodes(apardot_e,surfNodes,surfIntVars)), + apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)), /*fl and fr */ JfL_e : doExpand1(JfL, bP), @@ -920,6 +919,8 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde printf(fh, "~%"), for i : 1 thru numConfigNodes do ( + i0index : i-1, + i1index : i, printf(fh, "~%"), for j : 1 thru numVelNodes do ( j0index : j-1+(i-1)*numVelNodes, @@ -927,7 +928,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde printf(fh, "~%"), /* Compute the contribution of Apardot */ - printf(fh, " alpha_quad = -q_/m_*(~a); ~%", apardot_nodes[j1index]), + printf(fh, " alpha_quad = -q_/m_*(~a); ~%", apardot_nodes[i1index]), printf(fh, "~%"), printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), From 5a223333197fccdf11f40fdd01d06860f5ab91b5 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Wed, 3 Dec 2025 13:51:33 -0500 Subject: [PATCH 15/54] clean unused routines --- .../gk_collisionless_flux-surf-conf.mac | 297 +----------------- .../gk_collisionless_flux-surf-vpar.mac | 272 ---------------- 2 files changed, 1 insertion(+), 568 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index c00be4c2..d1724ee7 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -629,299 +629,4 @@ buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), printf(fh, "} ~%") -)$ - -AddAparGKEMFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge, mb_bound) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, - numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, - vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, - jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, - surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_e,apar_nodes,dA_dx_nodes,apar_c - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - if cdim = 1 then ( - surfConfigNodes : [1] - ) - else ( - surfConfigNodes : gaussOrd(polyOrder+1, cdim-1) - ), - numSurfNodes : length(surfNodes), - numSurfConfigNodes : length(surfConfigNodes), - numVelNodes : numSurfNodes/numSurfConfigNodes, - numMuNodes : 1, - if vdim > 1 then ( numMuNodes : 2), - numVparNodes : numVelNodes/numMuNodes, - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, - const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgs: surface DG geometry.~%"), - printf(fh, " // gkdgs: gyrokinetic surface DG geometry.~%"), - printf(fh, " // bmag: bmag represented on the surface.~%"), - printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), - printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmagSurf_e : doExpand1(bmag, bmagBasis), - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - if edge = true then ( - evPoint : 1 - ) else ( - evPoint : -1 - ), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmagSurf_e ), - hamil_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,hamil_e)), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : doExpand(hamilNoZero_c, bSurf), - - /* fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - JfL_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=1,JfL_e)), - JfR_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=-1,JfR_e)), - JfL_e : JfL_c . bSurf, - JfR_e : JfR_c . bSurf, - - if (mb_bound = true) then ( - /* Rescale ghost cell by ratio of the Jacobians at multiblock boundaries. */ - - if (edge = true) then ( - /* Upper boundary. */ - jacobgeo_rat_surfR_e : doExpand1(jacobgeo_rat_surfR, bSurfC), - - JfR_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfR_e, bSurf, JfR_e), - printf(fh, " double JRatfR[~a] = {0.}; ~%", length(bSurf)), - writeCExprsNoExpand1(JRatfR, fullratsimp(JfR_c)), - printf(fh, "~%"), - JfR_c : makelistNoZeros1(JfR_c, JRatfR), - JfR_e : doExpand(JfR_c, bSurf) - ) else ( - /* Lower boundary. */ - jacobgeo_rat_surfL_e : doExpand1(jacobgeo_rat_surfL, bSurfC), - - JfL_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfL_e, bSurf, JfL_e), - printf(fh, " double JRatfL[~a] = {0.}; ~%", length(bSurf)), - writeCExprsNoExpand1(JRatfL, fullratsimp(JfL_c)), - printf(fh, "~%"), - JfL_c : makelistNoZeros1(JfL_c, JRatfL), - JfL_e : doExpand(JfL_c, bSurf) - ) - ), - - JfL_nodes : gcfac(float(expand(evAtNodes(JfL_e,surfNodes,surfIntVars)))), - JfR_nodes : gcfac(float(expand(evAtNodes(JfR_e,surfNodes,surfIntVars)))), - - vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), - - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_nodes : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars))/vmap_prime_nodes - ) - else ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ) - ), - - mvpar_nodes : [], - for i : 1 thru numVparNodes do ( - mvpar_nodes : append(mvpar_nodes, [dH_dz_nodes[vpardim][i]]) - ), - - if surfDir = cdim then( - di3 : true - ) - else ( - di3 : false - ), - - /* Expand Aparallel. */ - apar_e : doExpand1(apar,bC), - apar_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,apar_e)), - /* printf(fh, " double apar[~a] = {0.}; ~%", numP), */ - aparCvar : eval_string(sconcat("apar")), - apar_c : makelistNoZeros1(apar_c, aparCvar), - /* Expand projected Apar on basis. */ - apar_e : doExpand(apar_c, bSurf), - /* Eval Aparallel at nodes. */ - apar_nodes : float(evAtNodes(apar_e,surfNodes,surfIntVars)), - /* Compute gradient of Aparallel */ - dA_dx_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ), - /* It will be used to compute the contribution as curl(Apar * bhat) = nabla Aparallel cross bhat + Aparallel * curl(bhat) */ - - /* Now calculate flux at all quadrature nodes */ - /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - printf(fh, " double bmag_quad = 0.0; ~%"), - printf(fh, " double Jc_quad = 0.0; ~%"), - printf(fh, " double B3_quad = 0.0; ~%"), - printf(fh, " double normcurlbhat_quad = 0.0; ~%"), - printf(fh, " double area_elem_quad = 0.0; ~%"), - printf(fh, " double bhat_quad[3] = {0.0}; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - - printf(fh, " double mvpar_quad[3] = {0.0}; ~%"), - for i : 1 thru numVparNodes do ( - printf(fh, " mvpar_quad[~a] = ~a; ~%", i-1, mvpar_nodes[i]) - ), - - printf(fh, " double mvparsq_quad[3] = {0.0}; ~%"), - for i : 1 thru numVparNodes do ( - printf(fh, " mvparsq_quad[~a] = mvpar_quad[~a]*mvpar_quad[~a]/m_; ~%", i-1, i-1,i-1) - ), - printf(fh, "~%"), - - for i : 1 thru numSurfConfigNodes do ( - printf(fh, " bmag_quad = gkdgs[~a].bmag; ~%", i-1), - printf(fh, " Jc_quad = gkdgs[~a].Jc; ~%", i-1), - printf(fh, " B3_quad = gkdgs[~a].B3; ~%", i-1), - printf(fh, " normcurlbhat_quad = gkdgs[~a].normcurlbhat; ~%", i-1), - printf(fh, " bhat_quad[0] = gkdgs[~a].bhat.x[0]; ~%", i-1), - printf(fh, " bhat_quad[1] = gkdgs[~a].bhat.x[1]; ~%", i-1), - printf(fh, " bhat_quad[2] = gkdgs[~a].bhat.x[2]; ~%", i-1), - printf(fh, " area_elem_quad = dgs[~a].area_elem; ~%", i-1), - printf(fh, "~%"), - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - vparindex : mod(j-1, numVparNodes) + 1, - vpar0index : mod(j-1, numVparNodes), - printf(fh, "~%"), - printf(fh, " alpha_quad = 0.0; ~%"), - - if cdim = 1 then ( - /* No contribution */ - printf(fh, " alpha_quad = 0.0; ~%", vpar0index) - ) else ( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]) - ), - /* grad(Aparallel) x b contribution*/ - if cdim = 3 then ( - if surfDir = 1 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) - ), - if surfDir = 3 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) - ) - ), - if cdim = 2 then ( - if surfDir = 1 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) - ) - ), - - printf(fh, "~%"), - /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), - printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), - printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), - printf(fh, " flux_surf_nodal[~a] += alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ), - printf(fh, "~%") - ), - - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - printf(fh, "~%"), - printf(fh, " return cfl*~a; ~%", float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%"), - flush_output(fh), - printf(fh, "} ~%") - -)$ +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index eff9836e..1382e8ca 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -539,278 +539,6 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no )$ - -AddAparGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, - numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, - bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, - hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_nodes,dA_dx_nodes,k - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - configNodes : gaussOrd(polyOrder+1, cdim), - numSurfNodes : length(surfNodes), - numConfigNodes : length(configNodes), - numVelNodes : numSurfNodes/numConfigNodes, - - /* if polyOrder = 1, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size in the - vparallel surfaces and/or we are more directly exploiting the sparsity of - alpha (e.g., in the x and z direction when no toroidal field, by=0) - and thus utilize fewer coefficients to reduce the number of operations */ - if (polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgv: volume DG geometry.~%"), - printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmag_e : doExpand1(bmag, bmagBasis), - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - if edge = true then ( - evPoint : 1 - ) else ( - evPoint : -1 - ), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ - - /* Expand Apar */ - apar_e : doExpand1(apar, bC), - apar_nodes : float(evAtNodes(apar_e,configNodes,surf_cvars)), - /* Compute gradient of Aparallel */ - dA_dx_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsC[i]),configNodes,surf_cvars)) - ), - - /*fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), - JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), - - JfL_e : subst(surfVar=1,JfL_e), - JfR_e : subst(surfVar=-1,JfR_e), - - JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), - JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), - - vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), - - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_nodes : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), - dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) - ) - else ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ) - ), - - /* Now calculate apha at all quadrature nodes */ - /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - printf(fh, " double bmag_quad = 0.0; ~%"), - printf(fh, " double B3_quad = 0.0; ~%"), - printf(fh, " double Jc_quad = 0.0; ~%"), - printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), - printf(fh, " double m_bmag_inv = 0.0; ~%"), - printf(fh, " double mvpar_over_q = 0.0; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - printf(fh, " double g_13 = 0.0; ~%"), - printf(fh, " double g_23 = 0.0; ~%"), - printf(fh, " double g_33 = 0.0; ~%"), - printf(fh, " double mag_e_3 = 0.0; ~%"), - printf(fh, "~%"), - - for i : 1 thru numConfigNodes do ( - i0index : i-1, - i1index : i, - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i0index), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i0index), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i0index), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i0index), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i0index), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i0index), - - printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), - /* - We develop the component grad(Apar) x b as - e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| - which gives - coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 - coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 - coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 - with - coeff = Jc/sqrt(g_33) - */ - printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), - printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), - printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), - printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1), - - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - printf(fh, "~%"), - printf(fh, " mvpar_over_q = (~a)/q_; ~%", dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - - printf(fh, " alpha_quad = 0.0; ~%"), - if cdim = 3 then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - for k : 1 thru cdim do ( - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[i1index], k-1) - ), - /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index], dA_dx_nodes[3][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][i1index], dA_dx_nodes[1][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][i1index], dA_dx_nodes[2][i1index]) - ), - if cdim = 2 then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 0), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[i1index], 2), - /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][i1index]) - ), - if cdim = 1 then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 2) - /* grad(Apar) x b */ - /* none */ - ), - - printf(fh, "~%"), - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), - printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), - printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - printf(fh, " flux_surf_nodal[~a] += alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ), - printf(fh, "~%") - ), - - printf(fh, "~%"), - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - if polyOrder=1 then ( pOrderCFL : 2 ), - printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), - vprimeStr : "/vmap_prime_min", - printf(fh, "~%"), - printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%"), - flush_output(fh), - printf(fh, "} ~%") - -)$ - AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge) := block( [pDim,varsC,bC,varsP,bP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,configNodes,numSurfNodes,numConfigNodes, From 9bce6d880554c65ff3ad0a24cbbe403d491b4f5f Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 10 Feb 2026 14:06:04 -0500 Subject: [PATCH 16/54] conserve former naming for electrostatic limit and add 'em_' prefix for electromagnetic routines. --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 18 ++----- .../gk_collisionless_flux-surf-vpar.mac | 50 ++++++++++--------- .../ms-gk_collisionless_flux-header.mac | 50 +++++++++---------- .../ms-gk_collisionless_flux.mac | 43 +++------------- 4 files changed, 63 insertions(+), 98 deletions(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 6a4efa89..40ad42d3 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -491,7 +491,7 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, + hamil_e,pbAuxFlds,alphaSum_e,vd,vpardir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, vmapSq_e,vmap_prime_e,apardot_e,clst], @@ -528,18 +528,10 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no apardot_e : doExpand1(apardot,bC), /* Note: only a vpar contribution. */ - dir : cdim+1, - dirLabel : varLabel[dir], - - alpha_e : -q_/m_ * apardot_e, + vpardir : cdim+1, + dirLabel : varLabel[vpardir], - vpardim : pDim-1, - if dir < vpardim then ( - alpha_e : alpha_e*rdx2vec[dir] - ) - else if dir = vpardim then ( - alpha_e : alpha_e/vmap_prime_e[1] - ), + alpha_e : -q_/m_ * apardot_e /vmap_prime_e[1], /* Project alpha on basis and write to array. */ printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), @@ -556,7 +548,7 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no alphaJf_e : alpha_e*Jf_e, printf(fh, "~%"), - volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), + volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[vpardir]), alphaJf_e)), writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), flush_output(fh), printf(fh, "~%"), diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 1382e8ca..4f45f71d 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -412,18 +412,19 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, " double B3_quad = 0.0; ~%"), printf(fh, " double Jc_quad = 0.0; ~%"), printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), - printf(fh, " double m_bmag_inv = 0.0; ~%"), - printf(fh, " double mvpar_over_q = 0.0; ~%"), - printf(fh, " double alpha_quad = 0.0; ~%"), printf(fh, " double JfL_quad = 0.0; ~%"), printf(fh, " double JfR_quad = 0.0; ~%"), printf(fh, " double Jfavg_quad = 0.0; ~%"), printf(fh, " double Jfjump_quad = 0.0; ~%"), - printf(fh, " double g_13 = 0.0; ~%"), - printf(fh, " double g_23 = 0.0; ~%"), - printf(fh, " double g_33 = 0.0; ~%"), - printf(fh, " double mag_e_3 = 0.0; ~%"), + if em = true then ( + printf(fh, " double m_bmag_inv = 0.0; ~%"), + printf(fh, " double mvpar_over_q = 0.0; ~%"), + printf(fh, " double g_13 = 0.0; ~%"), + printf(fh, " double g_23 = 0.0; ~%"), + printf(fh, " double g_33 = 0.0; ~%"), + printf(fh, " double mag_e_3 = 0.0; ~%") + ), printf(fh, "~%"), for i : 1 thru numConfigNodes do ( @@ -436,22 +437,23 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i0index), printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i0index), - - printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), - /* - We develop the component grad(Apar) x b as - e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| - which gives - coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 - coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 - coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 - with - coeff = Jc/sqrt(g_33) - */ - printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), - printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), - printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), - printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1), + if em = true then ( + printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), + /* + We develop the component grad(Apar) x b as + e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| + which gives + coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 + coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 + coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 + with + coeff = Jc/sqrt(g_33) + */ + printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), + printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), + printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), + printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1) + ), for j : 1 thru numVelNodes do ( j0index : j-1+(i-1)*numVelNodes, @@ -504,7 +506,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), printf(fh, ";~%"), if em = true then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ /* Apar * curl(b) */ printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 2) /* grad(Apar) x b */ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index 33389307..ddaec100 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -43,7 +43,7 @@ byStr : ["", "no_by_"]$ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -emStr : ["es", "em"]$ +emStr : ["", "em_"]$ printPrototypes() := block([], for emI : 1 thru 2 do ( @@ -73,36 +73,36 @@ printPrototypes() := block([], extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", vprimeargs : "", - printf(fh, "GKYL_CU_DH double gk_~a_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), - - printf(fh, "GKYL_CU_DH double gk_~a_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) ) ), dirlabel : varsV[1], extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - printf(fh, "GKYL_CU_DH double gk_~a_collisionless_flux_~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), printf(fh, "~%") ) diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 99c027f3..2a3bb836 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -69,23 +69,23 @@ for bInd : 1 thru length(bName) do ( for dir : 1 thru c do ( /* ES kernels */ - fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), em : false, - funcName : sconcat("gk_es_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), close(fh), - fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), em : false, - funcName : sconcat("gk_es_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, true, mb_bound), close(fh), @@ -114,13 +114,13 @@ for bInd : 1 thru length(bName) do ( /* Surface flux in vparallel direction.*/ /* ES */ - fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), em : false, - funcName : sconcat("gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false), close(fh), @@ -151,33 +151,4 @@ for bInd : 1 thru length(bName) do ( ) ) ) -)$ -fname : "~/max-out/gk_collisionless_flux_surf_return_zero.h"$ -fh : openw(fname)$ -printf(fh, "#include ~%")$ */ -printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, - /* const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) - { - return 0.0; - }~%")$ -close(fh)$ - -fname : "~/max-out/gk_collisionless_flux_surfvpar_return_zero.h"$ -fh : openw(fname)$ -printf(fh, "#include ~%")$ -printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surfvpar_return_zero( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) - { - return 0.0; - }~%")$ -close(fh)$ +)$ \ No newline at end of file From b4dea0153fd2fc82e0c5821be07e4fcec265a92e Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 10 Feb 2026 14:11:06 -0500 Subject: [PATCH 17/54] add a configurable output directory variable --- .../ms-gk_collisionless_flux.mac | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 2a3bb836..8a2b5139 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -8,6 +8,9 @@ load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ /* ...... USER INPUTS........ */ +/* Output directory for generated files. */ +outputDir : "~/max-out/"$ + /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -69,7 +72,7 @@ for bInd : 1 thru length(bName) do ( for dir : 1 thru c do ( /* ES kernels */ - fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), @@ -79,7 +82,7 @@ for bInd : 1 thru length(bName) do ( buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), close(fh), - fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), @@ -90,7 +93,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* EM kernels */ - fname : sconcat("~/max-out/gk_em_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_em_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), @@ -100,7 +103,7 @@ for bInd : 1 thru length(bName) do ( buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), close(fh), - fname : sconcat("~/max-out/gk_em_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_em_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), fh : openw(fname), @@ -114,7 +117,7 @@ for bInd : 1 thru length(bName) do ( /* Surface flux in vparallel direction.*/ /* ES */ - fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), @@ -125,7 +128,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* EM */ - fname : sconcat("~/max-out/gk_em_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_em_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), @@ -137,7 +140,7 @@ for bInd : 1 thru length(bName) do ( if (no_by = false) then ( /* Add apardot EM terms */ - fname : sconcat("~/max-out/gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar file: ~a",fname)), fh : openw(fname), From ab0ea6dcc0753d7353e5a22a73795fad4ec3c252 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 10 Feb 2026 14:14:48 -0500 Subject: [PATCH 18/54] add configurable output directory variable --- .../g0/gk_collisionless/ms-dg_gyrokinetic-header.mac | 5 ++++- maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac | 11 +++++++---- maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac | 11 +++++++---- .../ms-gk_collisionless_flux-header.mac | 5 ++++- 4 files changed, 22 insertions(+), 10 deletions(-) diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index f579b863..5ae1d154 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -2,6 +2,9 @@ /* ...... USER INPUTS........ */ +/* Output file path for the header file. */ +headerOutputPath : "~/max-out/gkyl_dg_gyrokinetic_kernels.h"$ + /* Serendipity basis. */ maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ @@ -110,7 +113,7 @@ printPrototypes() := block([], ) )$ -fh : openw("/Users/ahoffman/gkeyll_dev/gkeyll/gyrokinetic/ker/dg_gyrokinetic/gkyl_dg_gyrokinetic_kernels.h")$ +fh : openw(headerOutputPath)$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac index 18f5db41..f8dc8b49 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac @@ -9,6 +9,9 @@ load("gk_collisionless/dg_gk-surf")$ /* ...... USER INPUTS........ */ +/* Output directory for generated files. */ +outputDir : "~/max-out/"$ + /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -60,7 +63,7 @@ for bInd : 1 thru length(bName) do ( for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( for dir : 1 thru c do ( /* Advection in configuration space.*/ - fname : sconcat("~/max-out/dg_gyrokinetic_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -70,7 +73,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Advection in configuration space in the skin cell (for boundary flux operations) .*/ - fname : sconcat("~/max-out/dg_gyrokinetic_boundary_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_boundary_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -81,7 +84,7 @@ for bInd : 1 thru length(bName) do ( ), /* Advection in velocity space.*/ - fname : sconcat("~/max-out/dg_gyrokinetic_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -91,7 +94,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Advection in velocity space in the skin cell along vpar (for zero-flux BCs).*/ - fname : sconcat("~/max-out/dg_gyrokinetic_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index 37d36b83..31c80e31 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -7,6 +7,9 @@ load("gk_collisionless/dg_gk-vol")$ /* ...... USER INPUTS........ */ +/* Output directory for generated files. */ +outputDir : "~/max-out/"$ + /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -44,7 +47,7 @@ for bInd : 1 thru length(bName) do ( maxPolyOrderB : maxPolyOrder[bInd], if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - fname : sconcat("~/max-out/dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file: ~a",fname)), fh : openw(fname), @@ -55,7 +58,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Add em kernels */ - fname : sconcat("~/max-out/dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file (add em): ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), @@ -63,7 +66,7 @@ for bInd : 1 thru length(bName) do ( addAparGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), close(fh), - fname : sconcat("~/max-out/dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file (add em): ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), @@ -73,7 +76,7 @@ for bInd : 1 thru length(bName) do ( /* if cdim > 1, also generate a set of kernels for the case where there is no toroidal field (by = 0) */ if (c > 1) then ( - fname : sconcat("~/max-out/dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file (no by): ~a",fname)), fh : openw(fname), diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index ddaec100..3cf849b1 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -2,6 +2,9 @@ /* ...... USER INPUTS........ */ +/* Output directory for generated files. */ +outputDir : "~/max-out/"$ + /* Serendipity basis. */ maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ @@ -159,7 +162,7 @@ printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surfvpar_return_zero( double* GKYL_RESTRICT flux_surf);~%") )$ -fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels.h")$ +fh : openw(sconcat(outputDir,"gkyl_gk_collisionless_flux_kernels.h"))$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ From c4df9f7f5bc530b792534bb4d79bcfa766f65778 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 10 Feb 2026 14:30:43 -0500 Subject: [PATCH 19/54] remove unused lines --- .../gk_collisionless/ms-gk_collisionless_flux-header.mac | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index 3cf849b1..83d6f3d9 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -4,7 +4,6 @@ /* Output directory for generated files. */ outputDir : "~/max-out/"$ - /* Serendipity basis. */ maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ @@ -78,21 +77,19 @@ printPrototypes() := block([], printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~a~asurf~a_~ax~av_~a_p~a( const double *w, const double *dxv, - ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, extraargs), printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( const double *w, const double *dxv, - ~a const double *vmap, const double *vmapSq, const double q_, const double m_, ~a const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, extraargs) ) ), From a51a16ca1a9ca4bb3ff41e4d482ba8524d1fda60 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 10 Feb 2026 17:32:54 -0500 Subject: [PATCH 20/54] caught a typo but it's just in a comment -_- --- maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 4f45f71d..c5c126f3 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -157,7 +157,7 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no ) ), - /* Now calculate apha at all quadrature nodes */ + /* Now calculate alpha at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), printf(fh, " double cfl = 0.0; ~%"), From 064ca5474e17a81999979bba9216205427bf04c6 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 12 Feb 2026 15:37:24 -0500 Subject: [PATCH 21/54] Improve the em flux kernel generation scripts to be less redundant and correct a few typos in comments --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 4 +- .../gk_collisionless_flux-surf-vpar.mac | 6 +- .../ms-dg_gyrokinetic-header.mac | 6 +- .../ms-gk_collisionless_flux-header.mac | 96 +++++------ .../ms-gk_collisionless_flux.mac | 163 +++++++++--------- 5 files changed, 129 insertions(+), 146 deletions(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 40ad42d3..d3b28e2a 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -431,10 +431,10 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by curvdriftdir : 3 ), - if dir < vpardim then ( + if dir < vpardim then ( /* This is \rot(Apar b) dHdvpar \cdot \grad\psi from Rdot \cdot \grad\psi volume integrated */ alpha_e : alpha_e + dBperpoverB_list[curvdriftdir]/m_ * mvpar_e ), - if dir = vpardim then ( + if dir = vpardim then ( /* This is \rot(Apar b) \cdot \grad H from vpardot dpsi/dvpar volume integrated */ if cdim = 3 then ( for k : 1 thru cdim do ( alpha_e : alpha_e - dBperpoverB_list[k]/m_ * dH_dz_e[k] diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index c5c126f3..08d17205 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -404,7 +404,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no ) ), - /* Now calculate apha at all quadrature nodes */ + /* Now calculate alpha at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), printf(fh, " double cfl = 0.0; ~%"), @@ -475,7 +475,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no ), printf(fh, ";~%"), if em = true then ( - /* EM term curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* EM term curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ for k : 1 thru cdim do ( /* Apar * curl(b) */ printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[i1index], k-1) @@ -492,7 +492,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), printf(fh, ";~%"), if em = true then ( - /* EM term curl(Apar*b) = Apar * curl(b) grad(Apar) x b */ + /* EM term curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ /* Apar * curl(b) */ printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 0), printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[i1index], 2), diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 5ae1d154..de6ccedd 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -2,8 +2,8 @@ /* ...... USER INPUTS........ */ -/* Output file path for the header file. */ -headerOutputPath : "~/max-out/gkyl_dg_gyrokinetic_kernels.h"$ +/* Output directory for generated files. */ +outputDir : "~/max-out/"$ /* Serendipity basis. */ maxPolyOrder_Ser : 2$ @@ -113,7 +113,7 @@ printPrototypes() := block([], ) )$ -fh : openw(headerOutputPath)$ +fh : openw(sconcat(outputDir, "gkyl_dg_gyrokinetic_kernels.h"))$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index 83d6f3d9..d9b23ffb 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -4,6 +4,7 @@ /* Output directory for generated files. */ outputDir : "~/max-out/"$ + /* Serendipity basis. */ maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ @@ -72,37 +73,36 @@ printPrototypes() := block([], for surfDir : 1 thru c do ( dirlabel : varsC[surfDir], - extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", - vprimeargs : "", - - printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~a~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, extraargs), - - printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, extraargs) + + funcName : sconcat("gk_",em_label,"collisionless_flux_",no_byStr,mb_boundStr,"surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", funcName), + + funcName : sconcat("gk_",em_label,"collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", funcName) ) ), dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - printf(fh, "GKYL_CU_DH double gk_~acollisionless_flux_~asurf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", em_label, no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + funcName : sconcat("gk_",em_label,"collisionless_flux_",no_byStr,"surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", funcName), printf(fh, "~%") ) @@ -123,16 +123,14 @@ printPrototypes() := block([], for polyOrder : 1 thru maxPolyOrderB do ( dirlabel : varsV[1], - extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", - vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", - - printf(fh, "GKYL_CU_DH double gk_em_collisionless_flux_add_apardot_surf~a_~ax~av_~a_p~a( - const double *w, const double *dxv, - ~a - const double *vmap, const double *vmapSq, const double q_, const double m_, - ~a - const double *bmag, const double *phi, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + funcName : sconcat("gk_em_collisionless_flux_add_apardot_surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apardot, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", funcName) ), printf(fh, "~%") @@ -140,23 +138,13 @@ printPrototypes() := block([], ) ), -printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, - const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf);~%"), - -printf(fh,"~%"), - -printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surfvpar_return_zero( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf);~%") + printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf);~%") )$ fh : openw(sconcat(outputDir,"gkyl_gk_collisionless_flux_kernels.h"))$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 8a2b5139..53e6dbc8 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -43,115 +43,110 @@ vlabels : ["vpar","mu"]$ byOpt : [[false], [false, true], [false, true]]$ byStr : ["", "no_by_"]$ +/* Options for writing electromagnetic and electrostatic kernels. */ +emBool : [false, true]$ +emOpt : ["", "em_"]$ + /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -em : false$ /* Include EM terms if true */ +/* Options for writing kernels at surface and edge surfaces. */ +edgeBool : [false, true]$ +edgeOpt : ["surf", "edge_surf"]$ /* Generate kernels of selected types. */ for bInd : 1 thru length(bName) do ( + bStr : bName[bInd], + /* Loop over configuration space dimensions. */ for c : minCdim[bInd] thru maxCdim[bInd] do ( + /* Loop over velocity space dimensions. */ for gkV : 1 thru length(gkVdims[c]) do ( v : gkVdims[c][gkV], - maxPolyOrderB : maxPolyOrder[bInd], if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - + /* Loop over polynomial order. */ for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( + + /* With/without toroidal field loop. */ for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], no_byStr : byStr[byI], - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - /* Surface flux in direction dir in configuration space.*/ - for dir : 1 thru c do ( - - /* ES kernels */ - fname : sconcat(outputDir,"gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - em : false, - funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), - close(fh), - - fname : sconcat(outputDir,"gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - + /* Electrostatic/electromagnetic loop. */ + for emI : 1 thru length(emOpt) do ( + em : emBool[emI], + emStr : emOpt[emI], + + /* Singleblock/multiblock loop. */ + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + /* Configuration space surface direction loop. */ + for dir : 1 thru c do ( + dirStr : clabels[dir], + + /* Surface/edge surface loop. */ + for edgeI : 1 thru length(edgeBool) do ( + edge : edgeBool[edgeI], + edgeStr : edgeOpt[edgeI], + + fname : sconcat(outputDir,"gk_",emStr,"collisionless_flux_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), + fh : openw(fname), + printf(fh, "#include ~%"), + funcName : sconcat("gk_",emStr,"collisionless_flux_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound), + close(fh) + ) + ), + + /* Surface flux in vparallel direction (no edge).*/ + dirStr : vlabels[1], + edge : false, + edgeStr : edgeOpt[1], + + fname : sconcat(outputDir,"gk_",emStr,"collisionless_flux_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), - em : false, - funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, true, mb_bound), + funcName : sconcat("gk_",emStr,"collisionless_flux_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge), close(fh), - /* EM kernels */ - fname : sconcat(outputDir,"gk_em_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - em : true, - funcName : sconcat("gk_em_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, mb_bound), - close(fh), - - fname : sconcat(outputDir,"gk_em_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - em : true, - funcName : sconcat("gk_em_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, true, mb_bound), - close(fh) + if (em and no_by = false) then ( + /* Add apardot EM terms */ + fname : sconcat(outputDir,"gk_",emStr,"collisionless_flux_add_apardot_surf",dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar file: ~a",fname)), + fh : openw(fname), + printf(fh, "#include ~%"), + funcName : sconcat("gk_",emStr,"collisionless_flux_add_apardot_surf",dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, false), + close(fh) + ) ) - ), - - /* Surface flux in vparallel direction.*/ - /* ES */ - fname : sconcat(outputDir,"gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - em : false, - funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false), - close(fh), - - /* EM */ - fname : sconcat(outputDir,"gk_em_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - em : true, - funcName : sconcat("gk_em_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false), - close(fh), - - if (no_by = false) then ( - /* Add apardot EM terms */ - fname : sconcat(outputDir,"gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar file: ~a",fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), - close(fh) ) ) ) ) ) -)$ \ No newline at end of file +)$ + +/* Generate the return zero kernel */ +fname : sconcat(outputDir,"gk_collisionless_flux_surf_return_zero.c")$ +disp(printf(false,"Creating return zero kernel file: ~a",fname))$ +fh : openw(fname)$ +printf(fh, "#include ~%")$ +printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surf_return_zero(~%")$ +printf(fh, " const double *w, const double *dxv,~%")$ +printf(fh, " const double *vmap, const double *vmapSq, const double q_, const double m_,~%")$ +printf(fh, " const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ~%")$ +printf(fh, " const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, ~%")$ +printf(fh, " const double *phi, const double *apar,~%")$ +printf(fh, " const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%")$ +printf(fh, "{ ~%")$ +printf(fh, " return 0.0; ~%")$ +printf(fh, "}~%")$ +close(fh)$ From 25399c6a4fb4bcfb5e0bd6d828ab16769d71b395 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 17 Feb 2026 11:56:48 -0500 Subject: [PATCH 22/54] kernels related to the get_em_back_full_upwind branch in Gkeyll --- .../gk_collisionless_flux-surf-conf.mac | 14 ++- .../gk_collisionless_flux-surf-vpar.mac | 40 +++++--- .../ms-dg_gyrokinetic-vol.mac | 1 - .../ms-dg_gyrokinetic-vol_apardot.mac | 57 +++++++++++ .../ms-gk_collisionless_flux-header.mac | 74 +++++---------- .../ms-gk_collisionless_flux.mac | 38 +++++--- .../ms-gk_collisionless_flux_apardot.mac | 94 +++++++++++++++++++ maxima/g0/gk_collisionless/verify_no_leak.mac | 21 +++++ 8 files changed, 260 insertions(+), 79 deletions(-) create mode 100644 maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac create mode 100644 maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac create mode 100644 maxima/g0/gk_collisionless/verify_no_leak.mac diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index d1724ee7..211c47bb 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -300,7 +300,7 @@ buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no )$ -buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound) := block( +buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound, scheme) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,apar_e, @@ -357,7 +357,7 @@ buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, + const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), @@ -371,6 +371,7 @@ buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), printf(fh, " // phi: electrostatic potential.~%"), printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // apardot: time derivative of parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -609,13 +610,18 @@ buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no ), printf(fh, "~%"), - /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + if scheme = "upwind" then ( + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ) else if scheme = "central" then ( + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) + ) else if scheme = "downwind" then ( + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ) ), printf(fh, "~%") ), diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 08d17205..6b5b62c7 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -242,13 +242,14 @@ buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no )$ -buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge) := block( +buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, add_apardot, scheme) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,apar_e,apar_nodes,dA_dx_nodes,k + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,apar_e,apar_nodes,dA_dx_nodes,k, + apardot_e,apardot_nodes ], kill(varsC,varsP,bC,bP), @@ -300,12 +301,12 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), @@ -317,6 +318,7 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no printf(fh, " // bmag: magnetic field amplitude.~%"), printf(fh, " // phi: electrostatic potential.~%"), printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // apardot: time derivative of parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -515,13 +517,26 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no ) ), + /* Add apardot contribution if requested */ + if add_apardot = true then ( + apardot_e : doExpand1(apardot, bC), + apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)) + printf(fh, " alpha_quad += -q_/m_*(~a); ~%", apardot_nodes[i1index]) + ), + printf(fh, "~%"), printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + if scheme = "upwind" then ( + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) + ) else if scheme = "central" then ( + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) + ) else if scheme = "downwind" then ( + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ) ), printf(fh, "~%") ), @@ -593,7 +608,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde const double *vmap_prime_l, const double *vmap_prime_r, const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), @@ -605,7 +620,8 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), printf(fh, " // bmag: magnetic field amplitude.~%"), printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential (here it will be apardot).~%"), + printf(fh, " // apar: parallel component of vector potential.~%"), + printf(fh, " // apardot: derivative of apar with respect to vpar.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -624,7 +640,7 @@ AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrde flush_output(fh), /* Expand Apardot */ - apardot_e : doExpand1(apar, bC), + apardot_e : doExpand1(apardot, bC), apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)), /*fl and fr */ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index 31c80e31..965586ee 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -52,7 +52,6 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), close(fh), diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac new file mode 100644 index 00000000..5b578b88 --- /dev/null +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac @@ -0,0 +1,57 @@ +/* + Generate the volume kernels for collisionless gyrokinetic terms. + + The functions called in this file are in gkFuncs-vol.mac. +*/ +load("gk_collisionless/dg_gk-vol")$ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +minPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 1$ +minCdim_Ser : 1$ +maxCdim_Ser : 3$ + +/* Tensor order basis. No need to generate p=1. */ +minPolyOrder_Tensor : 2$ +maxPolyOrder_Tensor : 2$ +minCdim_Tensor : 1$ +maxCdim_Tensor : 0$ + +/* Vdim possibilities for each of Cdim=[1,2,3]. */ +gkVdims : [[1,2], [2], [2]]$ + +/* ...... END OF USER INPUTS........ */ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ + +/* Possible combinations of variable dependence of background magnetic field. + with [] = const. Note that we assume axisymmetry, which means B cannot depend on y. */ +bVarsList : [x,z]$ + +/* Generate kernels of selected types. */ +for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( + fname : sconcat("/Users/ahoffman/gkeyll_dev/gkeyll/gyrokinetic/ker/dg_gyrokinetic/dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating volume file (add em): ~a",fname)), + fh : openw(fname), + printf(fh, "#include ~%"), + funcName : sconcat("dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + addApardotGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), + close(fh) + ) + ) + ) +)$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index d9b23ffb..7b35759d 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -6,7 +6,7 @@ outputDir : "~/max-out/"$ /* Serendipity basis. */ -maxPolyOrder_Ser : 2$ +maxPolyOrder_Ser : 1$ minCdim_Ser : 1$ minVdim_Ser : 1$ maxCdim_Ser : 3$ @@ -46,10 +46,14 @@ byStr : ["", "no_by_"]$ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -emStr : ["", "em_"]$ +emStr : ["", "em_", "em_star_"]$ + +/* Options for writing kernels at surface and edge surfaces. */ +edgeBool : [false, true]$ +edgeOpt : ["surf", "edge_surf"]$ printPrototypes() := block([], - for emI : 1 thru 2 do ( + for emI : 1 thru 3 do ( em_label : emStr[emI], for bInd : 1 thru length(bName) do ( @@ -73,35 +77,33 @@ printPrototypes() := block([], for surfDir : 1 thru c do ( dirlabel : varsC[surfDir], - - funcName : sconcat("gk_",em_label,"collisionless_flux_",no_byStr,mb_boundStr,"surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName), - funcName : sconcat("gk_",em_label,"collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName) + for edgeI : 1 thru 2 do ( + edge : edgeBool[edgeI], + edgeStr : edgeOpt[edgeI], + + funcName : sconcat("gk_collisionless_flux_",em_label,no_byStr,mb_boundStr,edgeStr,dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), + printf(fh, "GKYL_CU_DH double ~a( + const double *w, const double *dxv, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", funcName) + ) ) ), dirlabel : varsV[1], - funcName : sconcat("gk_",em_label,"collisionless_flux_",no_byStr,"surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), + edgeStr : edgeOpt[1], + edge : false, + funcName : sconcat("gk_collisionless_flux_",em_label,no_byStr,edgeStr,dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), printf(fh, "GKYL_CU_DH double ~a( const double *w, const double *dxv, const double *vmap_prime_l, const double *vmap_prime_r, const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *JfL, const double *JfR, + const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf); ~%", funcName), printf(fh, "~%") @@ -112,38 +114,12 @@ printPrototypes() := block([], ) ), - /* EM add apardot vpar surface term */ - for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - - dirlabel : varsV[1], - funcName : sconcat("gk_em_collisionless_flux_add_apardot_surf",dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName) - ), - - printf(fh, "~%") - ) - ) - ), - printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( const double *w, const double *dxv, const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *JfL, const double *JfR, + const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf);~%") )$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 53e6dbc8..e3d86b4e 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -93,13 +93,23 @@ for bInd : 1 thru length(bName) do ( edge : edgeBool[edgeI], edgeStr : edgeOpt[edgeI], - fname : sconcat(outputDir,"gk_",emStr,"collisionless_flux_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_",emStr,"collisionless_flux_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound), - close(fh) + funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), + close(fh), + + if (em) then ( + fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), + fh : openw(fname), + printf(fh, "#include ~%"), + funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), + close(fh) + ) ) ), @@ -107,23 +117,25 @@ for bInd : 1 thru length(bName) do ( dirStr : vlabels[1], edge : false, edgeStr : edgeOpt[1], + add_apardot : em, /* Add apardot term if EM. */ - fname : sconcat(outputDir,"gk_",emStr,"collisionless_flux_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_",emStr,"collisionless_flux_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge), + funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), close(fh), - if (em and no_by = false) then ( - /* Add apardot EM terms */ - fname : sconcat(outputDir,"gk_",emStr,"collisionless_flux_add_apardot_surf",dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), + if (em) then ( + /* Add EM terms but not Apardot (star term) */ + add_apardot : false, + fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar file: ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_",emStr,"collisionless_flux_add_apardot_surf",dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, false), + funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), + buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), close(fh) ) ) @@ -144,7 +156,7 @@ printf(fh, " const double *w, const double *dxv,~%")$ printf(fh, " const double *vmap, const double *vmapSq, const double q_, const double m_,~%")$ printf(fh, " const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ~%")$ printf(fh, " const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, ~%")$ -printf(fh, " const double *phi, const double *apar,~%")$ +printf(fh, " const double *phi, const double *apar, const double *apardot, ~%")$ printf(fh, " const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%")$ printf(fh, "{ ~%")$ printf(fh, " return 0.0; ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac new file mode 100644 index 00000000..402952f7 --- /dev/null +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac @@ -0,0 +1,94 @@ +/* + Generate the kernel for surface expansions of the phase space characteristics. + + The functions called in this file are in gkFuncs-alpha-surf.mac. +*/ +load("gk_collisionless/gk_collisionless_flux-surf-conf")$ +load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ + +/* ...... USER INPUTS........ */ + +/* Serendipity basis. */ +minPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 1$ +minCdim_Ser : 1$ +maxCdim_Ser : 3$ + +/* Tensor order basis. No need to generate p=1. */ +minPolyOrder_Tensor : 2$ +maxPolyOrder_Tensor : 2$ +minCdim_Tensor : 1$ +maxCdim_Tensor : 0$ + +/* ...... END OF USER INPUTS........ */ + +/* Vdim possibilities for each of Cdim=[1,2,3]. */ +gkVdims : [[1,2], [2], [2]]$ + +/* To generate other bases, just add corresponding column to arrays below. */ +bName : ["ser", "tensor"]$ +minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ +maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ +minCdim : [minCdim_Ser, minCdim_Tensor]$ +maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ + +clabels : ["x","y","z"]$ +vlabels : ["vpar","mu"]$ + +/* Options for writing kernels with and without toroidal field (b_y=0), one per + dimension. */ +byOpt : [[false], [false, true], [false, true]]$ +byStr : ["", "no_by_"]$ + +/* Options for writing kernels used at multiblock boundaries. One for each + dimension. */ +mb_bcOpt : [[false,true],[false,true],[false,true]]$ +mb_bcStr : ["", "multib_boundary_"]$ + +em : false$ /* Include EM terms if true */ + +/* Generate kernels of selected types. */ +for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ + + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( + for byI : 1 thru length(byOpt[c]) do ( + no_by : byOpt[c][byI], + no_byStr : byStr[byI], + + /* Surface flux in vparallel direction.*/ + /* ES */ + /* fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + em : false, + funcName : sconcat("gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, false), + close(fh), */ + + /* EM */ + if (no_by = false) then ( + /* Add apardot EM terms */ + fname : sconcat("/Users/ahoffman/gkeyll_dev/gkeyll/gyrokinetic/ker/gk_collisionless_flux/gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar file: ~a",fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), + close(fh) + ) + ) + ) + ) + ) +)$ + diff --git a/maxima/g0/gk_collisionless/verify_no_leak.mac b/maxima/g0/gk_collisionless/verify_no_leak.mac new file mode 100644 index 00000000..90621efd --- /dev/null +++ b/maxima/g0/gk_collisionless/verify_no_leak.mac @@ -0,0 +1,21 @@ +kill(all)$ +/* load("dg_gk-vol.mac")$ */ +/* load("nodal_operations/node_locations")$ */ +/* load(stringproc)$ */ +/* fpprec : 24$ */ +/* load("eigen")$ */ + +/* values()$ */ +/* print(values)$ */ + +load("modal-basis")$ + +vars : [z,v,m]$ +n : 1$ +basis : makeSerendipBasis(vars, n)$ + +print("Serendipity basis:")$ +for i : 1 thru length(basis) do ( + printf(true, " basis[~a] = ~a~%", i, basis[i]) +)$ + From 2d170beb427cb77e586ef6d834945dc142ad665e Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 17 Feb 2026 14:33:49 -0500 Subject: [PATCH 23/54] remove unused scripts --- .../gk_collisionless_flux-surf-vpar.mac | 384 +----------------- .../ms-dg_gyrokinetic-vol_apardot.mac | 57 --- .../ms-gk_collisionless_flux_apardot.mac | 94 ----- 3 files changed, 1 insertion(+), 534 deletions(-) delete mode 100644 maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac delete mode 100644 maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 6b5b62c7..e025f622 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -5,243 +5,6 @@ load("scifac")$ load("utilities_gyrokinetic")$ fpprec : 24$ -buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, - numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, - bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, - hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,k - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim, vdim-1, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - configNodes : gaussOrd(polyOrder+1, cdim), - numSurfNodes : length(surfNodes), - numConfigNodes : length(configNodes), - numVelNodes : numSurfNodes/numConfigNodes, - - /* if polyOrder = 1, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size in the - vparallel surfaces and/or we are more directly exploiting the sparsity of - alpha (e.g., in the x and z direction when no toroidal field, by=0) - and thus utilize fewer coefficients to reduce the number of operations */ - if (polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgv: volume DG geometry.~%"), - printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmag_e : doExpand1(bmag, bmagBasis), - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - if edge = true then ( - evPoint : 1 - ) else ( - evPoint : -1 - ), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : doExpand(hamilNoZero_c,bP), - /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ - - /*fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - JfL_c : calcInnerProdList(varsP, 1, bP, JfL_e), - JfR_c : calcInnerProdList(varsP, 1, bP, JfR_e), - - JfL_e : subst(surfVar=1,JfL_e), - JfR_e : subst(surfVar=-1,JfR_e), - - JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), - JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), - - vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), - - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_nodes : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars)), - dH_dz_nodes[i] : subst(surfVar=evPoint, dH_dz_nodes[i]) - ) - else ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ) - ), - - /* Now calculate alpha at all quadrature nodes */ - /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - printf(fh, " double bmag_quad = 0.0; ~%"), - printf(fh, " double B3_quad = 0.0; ~%"), - printf(fh, " double Jc_quad = 0.0; ~%"), - printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - printf(fh, "~%"), - - for i : 1 thru numConfigNodes do ( - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), - printf(fh, "~%"), - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - printf(fh, "~%"), - if no_by = true then ( - printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) - ), - if no_by = false then ( - printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), - if cdim = 3 then ( - for k : 1 thru cdim do ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ) - ), - if cdim = 2 then ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - if cdim = 1 then ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - printf(fh, ";~%") - ), - - printf(fh, "~%"), - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), - printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), - printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ), - printf(fh, "~%") - ), - - /* Do the quad nodal to modal ops directly here*/ - /*printf(fh, "~%"), - printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), - fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), - - for i : 1 thru length(fmodproj_e) do ( - printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) - ), - - printf(fh, "~%"),*/ - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - if polyOrder=1 then ( pOrderCFL : 2 ), - printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), - vprimeStr : "/vmap_prime_min", - printf(fh, "~%"), - printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%"), - flush_output(fh), - printf(fh, "} ~%") - -)$ - - buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, add_apardot, scheme) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, @@ -554,149 +317,4 @@ buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no flush_output(fh), printf(fh, "} ~%") -)$ - -AddApardotGKEMFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, edge) := block( - [pDim,varsC,bC,varsP,bP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfNodes,configNodes,numSurfNodes,numConfigNodes, - numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdSurfVar2, - JfL_e,JfR_e,JfL_nodes,JfR_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr, - numC,numP,vSub,NSurf,numNodes,apardot_e,apardot_nodes - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1) - ), - configNodes : gaussOrd(polyOrder+1, cdim), - numSurfNodes : length(surfNodes), - numConfigNodes : length(configNodes), - numVelNodes : numSurfNodes/numConfigNodes, - - /* if polyOrder = 1, we need to be careful about - indexing input arrays since the surface hybrid basis has a different size in the - vparallel surfaces and/or we are more directly exploiting the sparsity of - alpha (e.g., in the x and z direction when no toroidal field, by=0) - and thus utilize fewer coefficients to reduce the number of operations */ - if (polyOrder = 1) then ( - tempVars : delete(x,varsP), - tempBasis : basisFromVars("gkhyb",tempVars,polyOrder), - NSurfIndexing : length(tempBasis), - numNodesIndexing : length(tempBasis) - ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes - ), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgv: volume DG geometry.~%"), - printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // apardot: derivative of apar with respect to vpar.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - printf(fh, "~%"), - flush_output(fh), - - /* Expand Apardot */ - apardot_e : doExpand1(apardot, bC), - apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)), - - /*fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - - JfL_e : subst(surfVar=1,JfL_e), - JfR_e : subst(surfVar=-1,JfR_e), - - JfL_nodes : float(evAtNodes(JfL_e,surfNodes,surfIntVars)), - JfR_nodes : float(evAtNodes(JfR_e,surfNodes,surfIntVars)), - - /* Now calculate alpha at all quadrature nodes */ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - printf(fh, "~%"), - - for i : 1 thru numConfigNodes do ( - i0index : i-1, - i1index : i, - printf(fh, "~%"), - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - printf(fh, "~%"), - - /* Compute the contribution of Apardot */ - printf(fh, " alpha_quad = -q_/m_*(~a); ~%", apardot_nodes[i1index]), - - printf(fh, "~%"), - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)) ;~%", j0index), - printf(fh, " JfL_quad = (~a)/~a;~%", JfL_nodes[j1index], vmap_prime_l[surfDir-cdim-1]), - printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - printf(fh, " flux_surf_nodal[~a] += alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ), - printf(fh, "~%") - ), - - printf(fh, "~%"), - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - if polyOrder=1 then ( pOrderCFL : 2 ), - printf(fh, " double vmap_prime_min = fmin(fabs(~a),fabs(~a));~%",vmap_prime_l[surfDir-cdim-1],vmap_prime_r[surfDir-cdim-1]), - vprimeStr : "/vmap_prime_min", - printf(fh, "~%"), - printf(fh, " return cfl~a*~a; ~%", vprimeStr, float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%"), - flush_output(fh), - printf(fh, "} ~%") -)$ +)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac deleted file mode 100644 index 5b578b88..00000000 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol_apardot.mac +++ /dev/null @@ -1,57 +0,0 @@ -/* - Generate the volume kernels for collisionless gyrokinetic terms. - - The functions called in this file are in gkFuncs-vol.mac. -*/ -load("gk_collisionless/dg_gk-vol")$ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -minPolyOrder_Ser : 1$ -maxPolyOrder_Ser : 1$ -minCdim_Ser : 1$ -maxCdim_Ser : 3$ - -/* Tensor order basis. No need to generate p=1. */ -minPolyOrder_Tensor : 2$ -maxPolyOrder_Tensor : 2$ -minCdim_Tensor : 1$ -maxCdim_Tensor : 0$ - -/* Vdim possibilities for each of Cdim=[1,2,3]. */ -gkVdims : [[1,2], [2], [2]]$ - -/* ...... END OF USER INPUTS........ */ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ - -/* Possible combinations of variable dependence of background magnetic field. - with [] = const. Note that we assume axisymmetry, which means B cannot depend on y. */ -bVarsList : [x,z]$ - -/* Generate kernels of selected types. */ -for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - fname : sconcat("/Users/ahoffman/gkeyll_dev/gkeyll/gyrokinetic/ker/dg_gyrokinetic/dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file (add em): ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - addApardotGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), - close(fh) - ) - ) - ) -)$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac deleted file mode 100644 index 402952f7..00000000 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux_apardot.mac +++ /dev/null @@ -1,94 +0,0 @@ -/* - Generate the kernel for surface expansions of the phase space characteristics. - - The functions called in this file are in gkFuncs-alpha-surf.mac. -*/ -load("gk_collisionless/gk_collisionless_flux-surf-conf")$ -load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ - -/* ...... USER INPUTS........ */ - -/* Serendipity basis. */ -minPolyOrder_Ser : 1$ -maxPolyOrder_Ser : 1$ -minCdim_Ser : 1$ -maxCdim_Ser : 3$ - -/* Tensor order basis. No need to generate p=1. */ -minPolyOrder_Tensor : 2$ -maxPolyOrder_Tensor : 2$ -minCdim_Tensor : 1$ -maxCdim_Tensor : 0$ - -/* ...... END OF USER INPUTS........ */ - -/* Vdim possibilities for each of Cdim=[1,2,3]. */ -gkVdims : [[1,2], [2], [2]]$ - -/* To generate other bases, just add corresponding column to arrays below. */ -bName : ["ser", "tensor"]$ -minPolyOrder : [minPolyOrder_Ser, minPolyOrder_Tensor]$ -maxPolyOrder : [maxPolyOrder_Ser, maxPolyOrder_Tensor]$ -minCdim : [minCdim_Ser, minCdim_Tensor]$ -maxCdim : [maxCdim_Ser, maxCdim_Tensor]$ - -clabels : ["x","y","z"]$ -vlabels : ["vpar","mu"]$ - -/* Options for writing kernels with and without toroidal field (b_y=0), one per - dimension. */ -byOpt : [[false], [false, true], [false, true]]$ -byStr : ["", "no_by_"]$ - -/* Options for writing kernels used at multiblock boundaries. One for each - dimension. */ -mb_bcOpt : [[false,true],[false,true],[false,true]]$ -mb_bcStr : ["", "multib_boundary_"]$ - -em : false$ /* Include EM terms if true */ - -/* Generate kernels of selected types. */ -for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - for byI : 1 thru length(byOpt[c]) do ( - no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - /* Surface flux in vparallel direction.*/ - /* ES */ - /* fname : sconcat("~/max-out/gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - em : false, - funcName : sconcat("gk_es_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, em, false, false), - close(fh), */ - - /* EM */ - if (no_by = false) then ( - /* Add apardot EM terms */ - fname : sconcat("/Users/ahoffman/gkeyll_dev/gkeyll/gyrokinetic/ker/gk_collisionless_flux/gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar file: ~a",fname)), - - fh : openw(fname), - printf(fh, "#include ~%"), - - funcName : sconcat("gk_em_collisionless_flux_add_apardot_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - AddApardotGKEMFluxVparKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, false), - close(fh) - ) - ) - ) - ) - ) -)$ - From dea3b488649b4901a0c260dba17eca661cbf7f35 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 17 Feb 2026 14:34:35 -0500 Subject: [PATCH 24/54] remove unused function --- .../gk_collisionless_flux-surf-conf.mac | 294 ------------------ 1 file changed, 294 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 211c47bb..66e91d8c 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -6,300 +6,6 @@ load("utilities_gyrokinetic")$ load("nodal_operations/nodal_functions")$ fpprec : 24$ -buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( - [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, - surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, - numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, - vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, - jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, - surfIntVarsC,bSurfC,hamilCvar - ], - - kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - surfVar : varsP[surfDir], /* Surface variable. */ - varLabel : makelist(string(varsP[d]),d,1,pDim), - dirLabel : varLabel[surfDir], - - surfIntVars : delete(surfVar,varsP), - surf_cvars : delete(surfVar, makelist(varsP[i],i,1,cdim)), - surf_vvars : delete(surfVar, makelist(varsP[cdim+i],i,1,vdim)), - - surfIntVarsC : delete(surfVar,varsC), - bSurfC : basisFromVars(basisFun,surfIntVarsC,polyOrder), - - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - surfNodes : gaussOrdGkHyb(1+1, surf_cvars, surf_vvars), - nodeVars : surfIntVars, - bSurf : basisFromVars("gkhyb",surfIntVars,polyOrder), - basisNodal : getVarsNodalBasisWithNodesHyb("gkhyb", cdim-1, vdim, surfIntVars, surfNodes) - ) else ( - surfNodes : gaussOrd(polyOrder+1, pDim-1), - nodeVars : surfIntVars, - bSurf : basisFromVars(basisFun,surfIntVars,polyOrder) - ), - if cdim = 1 then ( - surfConfigNodes : [1] - ) - else ( - surfConfigNodes : gaussOrd(polyOrder+1, cdim-1) - ), - numSurfNodes : length(surfNodes), - numSurfConfigNodes : length(surfConfigNodes), - numVelNodes : numSurfNodes/numSurfConfigNodes, - numMuNodes : 1, - if vdim > 1 then ( numMuNodes : 2), - numVparNodes : numVelNodes/numMuNodes, - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, - const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // dgs: surface DG geometry.~%"), - printf(fh, " // gkdgs: gyrokinetic surface DG geometry.~%"), - printf(fh, " // bmag: bmag represented on the surface.~%"), - printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), - printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), - printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), - printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), - printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), - printf(fh, " // Note: Each cell owns their *lower* edge surface evaluation.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru cdim+1 do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), - rdSurfVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmagSurf_e : doExpand1(bmag, bmagBasis), - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - /*vmap_prime_e : makelist((2/dxv[cdim+d-1])*diff(vmap_e[d],varsP[cdim+d]),d,1,vdim),*/ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - if edge = true then ( - evPoint : 1 - ) else ( - evPoint : -1 - ), - - /* Finally write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmagSurf_e ), - hamil_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,hamil_e)), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bSurf, - - /* fl and fr */ - JfL_e : doExpand1(JfL, bP), - JfR_e : doExpand1(JfR, bP), - JfL_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=1,JfL_e)), - JfR_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=-1,JfR_e)), - JfL_e : JfL_c . bSurf, - JfR_e : JfR_c . bSurf, - - if (mb_bound = true) then ( - /* Rescale ghost cell by ratio of the Jacobians at multiblock boundaries. */ - - if (edge = true) then ( - /* Upper boundary. */ - jacobgeo_rat_surfR_e : doExpand1(jacobgeo_rat_surfR, bSurfC), - - JfR_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfR_e, bSurf, JfR_e), - printf(fh, " double JRatfR[~a] = {0.}; ~%", length(bSurf)), - writeCExprsNoExpand1(JRatfR, fullratsimp(JfR_c)), - printf(fh, "~%"), - JfR_c : makelistNoZeros1(JfR_c, JRatfR), - JfR_e : doExpand(JfR_c, bSurf) - ) else ( - /* Lower boundary. */ - jacobgeo_rat_surfL_e : doExpand1(jacobgeo_rat_surfL, bSurfC), - - JfL_c : calcInnerProdList(surfIntVars, jacobgeo_rat_surfL_e, bSurf, JfL_e), - printf(fh, " double JRatfL[~a] = {0.}; ~%", length(bSurf)), - writeCExprsNoExpand1(JRatfL, fullratsimp(JfL_c)), - printf(fh, "~%"), - JfL_c : makelistNoZeros1(JfL_c, JRatfL), - JfL_e : doExpand(JfL_c, bSurf) - ) - ), - - JfL_nodes : gcfac(float(expand(evAtNodes(JfL_e,surfNodes,surfIntVars)))), - JfR_nodes : gcfac(float(expand(evAtNodes(JfR_e,surfNodes,surfIntVars)))), - - vmap_prime_nodes : float(evAtNodes(vmap_prime_e[1],surfNodes,surfIntVars)), - - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_nodes : makelist(0, i, 1, pDim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e,varsP[i]),surfNodes,surfIntVars))/vmap_prime_nodes - ) - else ( - dH_dz_nodes[i] : float(evAtNodes(diff(hamil_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ) - ), - - mvpar_nodes : [], - for i : 1 thru numVparNodes do ( - mvpar_nodes : append(mvpar_nodes, [dH_dz_nodes[vpardim][i]]) - ), - - if surfDir = cdim then( - di3 : true - ) - else ( - di3 : false - ), - - /* Now calculate flux at all quadrature nodes */ - /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ - printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), - printf(fh, " double cfl = 0.0; ~%"), - printf(fh, " double bmag_quad = 0.0; ~%"), - printf(fh, " double Jc_quad = 0.0; ~%"), - printf(fh, " double B3_quad = 0.0; ~%"), - printf(fh, " double normcurlbhat_quad = 0.0; ~%"), - printf(fh, " double area_elem_quad = 0.0; ~%"), - printf(fh, " double bhat_quad[3] = {0.0}; ~%"), - - printf(fh, " double alpha_quad = 0.0; ~%"), - printf(fh, " double JfL_quad = 0.0; ~%"), - printf(fh, " double JfR_quad = 0.0; ~%"), - printf(fh, " double Jfavg_quad = 0.0; ~%"), - printf(fh, " double Jfjump_quad = 0.0; ~%"), - - printf(fh, " double mvpar_quad[3] = {0.0}; ~%"), - for i : 1 thru numVparNodes do ( - printf(fh, " mvpar_quad[~a] = ~a; ~%", i-1, mvpar_nodes[i]) - ), - - printf(fh, " double mvparsq_quad[3] = {0.0}; ~%"), - for i : 1 thru numVparNodes do ( - printf(fh, " mvparsq_quad[~a] = mvpar_quad[~a]*mvpar_quad[~a]/m_; ~%", i-1, i-1,i-1) - ), - printf(fh, "~%"), - - for i : 1 thru numSurfConfigNodes do ( - printf(fh, " bmag_quad = gkdgs[~a].bmag; ~%", i-1), - printf(fh, " Jc_quad = gkdgs[~a].Jc; ~%", i-1), - printf(fh, " B3_quad = gkdgs[~a].B3; ~%", i-1), - printf(fh, " normcurlbhat_quad = gkdgs[~a].normcurlbhat; ~%", i-1), - printf(fh, " bhat_quad[0] = gkdgs[~a].bhat.x[0]; ~%", i-1), - printf(fh, " bhat_quad[1] = gkdgs[~a].bhat.x[1]; ~%", i-1), - printf(fh, " bhat_quad[2] = gkdgs[~a].bhat.x[2]; ~%", i-1), - printf(fh, " area_elem_quad = dgs[~a].area_elem; ~%", i-1), - printf(fh, "~%"), - for j : 1 thru numVelNodes do ( - j0index : j-1+(i-1)*numVelNodes, - j1index : j+(i-1)*numVelNodes, - vparindex : mod(j-1, numVparNodes) + 1, - vpar0index : mod(j-1, numVparNodes), - printf(fh, "~%"), - if no_by = true then ( - if di3 = true then ( - printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) - ) - else ( - printf(fh, " alpha_quad = 0.0; ~%") - ) - ), - if no_by = false then ( - /*printf(fh, " alpha_quad += mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) ;~%", vpar0index),*/ - if cdim = 3 then ( - if surfDir = 1 then( - printf(fh, " alpha_quad = (mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * (bhat_quad[1]*(~a) - bhat_quad[2]*(~a)))*area_elem_quad/Jc_quad; ~%", vpar0index, dH_dz_nodes[3][j1index], dH_dz_nodes[2][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad = (mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * (bhat_quad[2]*(~a) - bhat_quad[0]*(~a)))*area_elem_quad/Jc_quad; ~%", vpar0index, dH_dz_nodes[1][j1index], dH_dz_nodes[3][j1index]) - ), - if surfDir = 3 then( - printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad) + mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * (bhat_quad[0]*(~a) - bhat_quad[1]*(~a)))*area_elem_quad/Jc_quad; ~%", vpar0index, vpar0index, dH_dz_nodes[2][j1index], dH_dz_nodes[1][j1index]) - ) - ), - if cdim = 2 then ( - if surfDir = 1 then( - printf(fh, " alpha_quad = (mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * bhat_quad[1]*(~a))*area_elem_quad/Jc_quad; ~%", vpar0index, dH_dz_nodes[2][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad) + mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) + 1/(q_*bmag_quad*area_elem_quad) * -bhat_quad[1]*(~a))*area_elem_quad/Jc_quad;~%", vpar0index, vpar0index, dH_dz_nodes[1][j1index]) - ) - ), - if cdim = 1 then ( - printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) - ) - ), - - printf(fh, "~%"), - /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ - printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), - printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), - printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), - printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), - printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ), - printf(fh, "~%") - ), - - /* Do the quad nodal to modal ops directly here*/ - /*printf(fh, "~%"), - printf(fh, " double *fmodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), - flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), - fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), - - for i : 1 thru length(fmodproj_e) do ( - printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) - ), - - printf(fh, "~%"),*/ - - /*Calculate the cfl*/ - pOrderCFL : polyOrder, - printf(fh, "~%"), - printf(fh, " return cfl*~a; ~%", float(0.5*(2*pOrderCFL+1)*rdSurfVar2)), - - printf(fh, "~%"), - flush_output(fh), - printf(fh, "} ~%") - -)$ - - buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound, scheme) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, From 8631b9a6dce2d09e9f1892be3f936a50aca97a44 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 17 Feb 2026 14:36:31 -0500 Subject: [PATCH 25/54] remove the EM in the surface flux routines since it's the only one now. --- .../gk_collisionless/gk_collisionless_flux-surf-conf.mac | 2 +- .../gk_collisionless/gk_collisionless_flux-surf-vpar.mac | 2 +- maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac | 8 ++++---- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 66e91d8c..8556e00a 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -6,7 +6,7 @@ load("utilities_gyrokinetic")$ load("nodal_operations/nodal_functions")$ fpprec : 24$ -buildGKFluxConfEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound, scheme) := block( +buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound, scheme) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,apar_e, diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index e025f622..74c5a8e2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -5,7 +5,7 @@ load("scifac")$ load("utilities_gyrokinetic")$ fpprec : 24$ -buildGKFluxVparEMKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, add_apardot, scheme) := block( +buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, add_apardot, scheme) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index e3d86b4e..70096198 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -98,7 +98,7 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), + buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), close(fh), if (em) then ( @@ -107,7 +107,7 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfEMKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), + buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), close(fh) ) ) @@ -124,7 +124,7 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), + buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), close(fh), if (em) then ( @@ -135,7 +135,7 @@ for bInd : 1 thru length(bName) do ( fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparEMKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), + buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), close(fh) ) ) From bf20d444af4726442cf044deef8a55852348f059 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 17 Feb 2026 14:42:54 -0500 Subject: [PATCH 26/54] add error detection for the advection scheme --- .../g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac | 3 +++ .../g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac | 5 ++++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 8556e00a..9ace3df7 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -327,6 +327,9 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) ) else if scheme = "downwind" then ( printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ) else ( + /* Stop the script if an invalid scheme is provided. */ + error("Invalid flux scheme provided. Options are: upwind, central, downwind.") ) ), printf(fh, "~%") diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 74c5a8e2..1e183c4d 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -283,7 +283,7 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b /* Add apardot contribution if requested */ if add_apardot = true then ( apardot_e : doExpand1(apardot, bC), - apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)) + apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)), printf(fh, " alpha_quad += -q_/m_*(~a); ~%", apardot_nodes[i1index]) ), @@ -299,6 +299,9 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) ) else if scheme = "downwind" then ( printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) + ) else ( + /* Stop the script if an invalid scheme is provided. */ + error("Invalid flux scheme provided. Options are: upwind, central, downwind.") ) ), printf(fh, "~%") From 03fdd36fddb3e4d62c85821eb24d452812a898ef Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 19 Feb 2026 08:57:03 -0500 Subject: [PATCH 27/54] remove unused variables and streamline error handling for p>1 --- .../g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 1e183c4d..8bcccdd0 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -11,7 +11,7 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,NSurf,numNodes,apar_e,apar_nodes,dA_dx_nodes,k, + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_nodes,dA_dx_nodes,k, apardot_e,apardot_nodes ], @@ -58,8 +58,7 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b NSurfIndexing : length(tempBasis), numNodesIndexing : length(tempBasis) ) else ( - NSurfIndexing : NSurf, - numNodesIndexing : numNodes + error("Only p=1 is currently supported for the surfvpar kernels.") ), print("Working on ", funcNm), From 0d518e156c704b41b448d87ec19ea8ed16559df5 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 19 Feb 2026 10:22:33 -0500 Subject: [PATCH 28/54] add apar_c to local variable list --- maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index 9ace3df7..eae64208 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -14,7 +14,7 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, - surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_nodes,dA_dx_nodes + surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_nodes,apar_c,dA_dx_nodes ], kill(varsC,varsP,bC,bP), From 79fa5a5ffee81e61c74ef35994a8c346bc2471d6 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Mon, 23 Feb 2026 09:21:40 -0500 Subject: [PATCH 29/54] Refactor a major part of the volume and conf flux kernels. We reuse as much as possible the precomputed geometric quantities like normcurlbhat_quad for surface flux and bioverJB_list for the volume computation. A comment in each script is added to point out the terms responsible to oscillations observed in the 3x2v Alfven testcase. The volume term builds an oscillation in n_e along y at longer time whereas the surface flux term creates a discontinuity in n_e along y at the first frame of the regression test. It is still unknown if these terms are the source of the 3x2v alfven issue or if they are triggered unphysically from other part of the code like the Helmholtz solver. --- maxima/g0/gk_collisionless/dg_gk-vol.mac | 266 +++++++++++------- .../gk_collisionless_flux-surf-conf.mac | 6 +- 2 files changed, 175 insertions(+), 97 deletions(-) diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index d3b28e2a..93e42e7c 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -11,8 +11,8 @@ load("utilities")$ fpprec : 24$ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, + [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, @@ -21,12 +21,12 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := vmapSq_e,vmap_prime_e,hamilCvar,hamilNoZero_c,hamil_c,vpardim,i,k,curvdriftdir,clst], kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, + pdim : cdim+vdim, [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), numC : length(bC), numP : length(bP), - varLabel : makelist(string(varsP[d]),d,1,pDim), + varLabel : makelist(string(varsP[d]),d,1,pdim), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, @@ -45,19 +45,19 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "~%"), /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pDim do ( + for d : 1 thru pdim do ( printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) ), printf(fh, "~%"), rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), printf(fh, "~%"), replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), + dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pdim), [dvparSq=4/rdvpar2Sq]), /* Create pointers to the components of b_i. */ @@ -114,9 +114,9 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := Jf_e : doExpand1(fin,bP), /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_e : makelist(0, i, 1, pDim), + vpardim : pdim-1, + if vdim = 1 then ( vpardim : pdim ), + dH_dz_e : makelist(0, i, 1, pdim), for i : 1 thru vpardim do ( if i = vpardim then ( dH_dz_e[i] : diff(hamil_e,varsP[i]) @@ -159,21 +159,25 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := dirVar : varsP[dir], /* Variable in current direction. */ if dir = cdim then ( - alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ + alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ /* Contribution from B_0 . dH/dvpar . ∇ψ in z*/ ) else if dir = vpardim then ( - alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ + alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ /* Contribution from B_0 . ∇H . dψ/dvpar in z */ ) else ( - alpha_e : 0 + alpha_e : 0 /* all other B_0 contributions are 0 since B_0_x,y = 0 */ ), if no_by = false then ( + + /* Add curvature drift terms (m vpar/q * ∇ x b)/mB = (m vpar * (∇ x b)/B)/qm */ if cdim = 3 then ( + /* Sum each directions */ curvdriftdir : dir ), if cdim = 2 then ( + /* Select only x and z */ if dir = 1 then ( curvdriftdir : dir ), @@ -182,12 +186,28 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := ) ), if cdim = 1 then ( + /* Select z */ curvdriftdir : 3 ), - if dir < vpardim then ( - alpha_e : alpha_e + dualcurlbhatoverB_list[curvdriftdir]*dH_dz_e[vpardim]/vmap_prime_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/m_/q_ + /* Config space contributions ( curv drift * dH/dvpar . ∇ψ ) */ + alpha_e : alpha_e + mvpar_e*dualcurlbhatoverB_list[curvdriftdir] * dH_dz_e[vpardim]/vmap_prime_e[1] / (q_*m_) + ) else ( + /* Vpar contribution ( curv drift . ∇H * dψ/dvpar )*/ + if cdim = 3 then ( + for k : 1 thru cdim do ( + alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[k]*dH_dz_e[k]/(q_*m_) + ) + ), + if cdim = 2 then ( + alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[1] * dH_dz_e[1]/(q_*m_) - mvpar_e*dualcurlbhatoverB_list[3] * dH_dz_e[2]/(q_*m_) + ), + if cdim = 1 then ( + alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[3] * dH_dz_e[1]/(q_*m_) + ) ), + + /* Add b x ∇H / qB term (only in configuration space) */ if cdim = 3 then ( if dir = 1 then ( alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[3] - bioverJB_list[3]*dH_dz_e[2]) @@ -206,27 +226,13 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := if dir = 2 then ( alpha_e : alpha_e - 1/q_ * (bioverJB_list[2]*dH_dz_e[1]) ) - ), - if dir = vpardim then ( - if cdim = 3 then ( - for k : 1 thru cdim do ( - alpha_e : alpha_e - dualcurlbhatoverB_list[k]*dH_dz_e[k]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - ) - ), - if cdim = 2 then ( - alpha_e : alpha_e - dualcurlbhatoverB_list[1]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - dualcurlbhatoverB_list[3]*dH_dz_e[2]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - ), - if cdim = 1 then ( - alpha_e : alpha_e - dualcurlbhatoverB_list[3]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - ) ) - ), if dir < vpardim then ( alpha_e : alpha_e*rdx2vec[dir] ) - else if dir = vpardim then ( + else ( alpha_e : alpha_e/vmap_prime_e[1] ), @@ -239,7 +245,7 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := alpha_c : subst(dvparSimp, alpha_c), alphaLabel : eval_string(sconcat(alpha, dirLabel)), clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], writeCExprsCollect1(alphaLabel, alpha_c, clst), printf(fh, "~%"), flush_output(fh), @@ -263,25 +269,28 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := )$ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, + replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e,dim_idx_list, xidx, yidx, zidx, vidx, replaceList,dvparSimp,phi_e,bmag_e,rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,bioverJB_list, - vmapSq_e,vmap_prime_e,hamil_c,hamilCvar,hamilNoZero_c,vpardim,i,k,Apar_e, - dBperpoverB_x,dBperpoverB_y,dBperpoverB_z,dBperpoverB_list,curvdriftdir,clst], + dualcurlbhatoverB_x_e,dualcurlbhatoverB_y_e,dualcurlbhatoverB_z_e, dH_dx, dH_dy, dH_dz, dH_dvpar, gradH_vec, + vmapSq_e,vmap_prime_e,hamil_c,hamilCvar,hamilNoZero_c,vpardim,i,k,Apar_e, dA_dx, dA_dy, dA_dz, gradA_vec, + rotAbovermB_x,rotAbovermB_y,rotAbovermB_z,rotAbovermB_list, gradAxbhatoverB_x,gradAxbhatoverB_y,gradAxbhatoverB_z,gradAxbhatoverB_vec, + curvdriftdir,clst], kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, + pdim : cdim+vdim, [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), numC : length(bC), numP : length(bP), - varLabel : makelist(string(varsP[d]),d,1,pDim), + varLabel : makelist(string(varsP[d]),d,1,pdim), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, - const double q_, const double m_, const double *bmag, const double *jacobtot_inv, + const double q_, const double m_, const double *bmag, const double *jacobtot_inv, const double *dualcurlbhatoverB, const double *bioverJB, const double *b_i, const double *phi, const double *apar, const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), @@ -290,6 +299,8 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by printf(fh, " // q_,m_: species charge and mass.~%"), printf(fh, " // bmag: magnetic field amplitude.~%"), printf(fh, " // jacobtot_inv: reciprocal of the conf-space jacobian time the guiding center coordinate Jacobian.~%"), + printf(fh, " // dualcurlbhatoverB: dual curl of bhat over B.~%"), + printf(fh, " // bioverJB: b_i over J times B.~%"), printf(fh, " // b_i: covariant components of the field aligned unit vector.~%"), printf(fh, " // apar: parallel component of magnetic vector potential.~%"), printf(fh, " // phi: electrostatic potential .~%"), @@ -298,33 +309,57 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by printf(fh, "~%"), /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pDim do ( + for d : 1 thru pdim do ( printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) ), printf(fh, "~%"), rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ - printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), - printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), + /* printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), */ + /* printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), */ printf(fh, "~%"), - replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), + replaceList : [rdx^2=dx2Sq, rdy^2=dy2Sq, rdz^2=dx2Sq, rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], + dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pdim), [dvparSq=4/rdvpar2Sq]), + /* Store indices of the coordinate directions. */ + if cdim = 3 then ( + xidx : 1, yidx : 2, zidx : 3, vidx : 4 + ) else if cdim = 2 then ( + xidx : 1, zidx : 2, vidx : 3 + ) else if cdim = 1 then ( + zidx : 1, vidx : 2 + ), + + /* Create pointers to the components of b_i. */ allVarLabelsC : ["x","y","z"], for d : 1 thru 3 do ( printf(fh, " const double *b_~a = &b_i[~a];~%", allVarLabelsC[d], numC*(d-1)) ), printf(fh, "~%"), + for d : 1 thru 3 do ( + printf(fh, " const double *bioverJB_~a = &bioverJB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) + ), + printf(fh, "~%"), + + /* Create pointers to the components of dualcurlbhatoverB. */ + for d : 1 thru 3 do ( + printf(fh, " const double *dualcurlbhatoverB_~a = &dualcurlbhatoverB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) + ), + printf(fh, "~%"), + /* Axisymmetric basis (independent of y). */ bmagBasis : getAxisymmetricConfBasis(bC), /* Expand input fields for Hamiltonian calculation */ phi_e : doExpand1(phi,bC), bmag_e : doExpand1(bmag, bmagBasis), rtg33inv_e : doExpand1(rtg33inv, bmagBasis), + dualcurlbhatoverB_x_e : doExpand1(dualcurlbhatoverB_x, bmagBasis), + dualcurlbhatoverB_y_e : doExpand1(dualcurlbhatoverB_y, bmagBasis), + dualcurlbhatoverB_z_e : doExpand1(dualcurlbhatoverB_z, bmagBasis), bioverJB_x_e : doExpand1(bioverJB_x, bmagBasis), bioverJB_y_e : doExpand1(bioverJB_y, bmagBasis), bioverJB_z_e : doExpand1(bioverJB_z, bmagBasis), @@ -334,6 +369,7 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by b_z_e : doExpand1(b_z, bmagBasis), jacobTotInv_e : doExpand1(jacobtot_inv, bmagBasis), + dualcurlbhatoverB_list : [dualcurlbhatoverB_x_e, dualcurlbhatoverB_y_e, dualcurlbhatoverB_z_e], bioverJB_list : [bioverJB_x_e, bioverJB_y_e, bioverJB_z_e], /* Velocity mapping fields. */ @@ -342,12 +378,12 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by /* Redefine vmap_prime to exploit the relationship between it and vmap. */ vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - /* Finally write out the hamiltonian*/ + /* Write out the hamiltonian*/ hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, m_^2=mSq, q_^2=qSq], + replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, rdy2^2=rdy2Sq, rdz2^2=rdz2Sq, m_^2=mSq, q_^2=qSq], hamilCvar : eval_string(sconcat("hamil")), writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), printf(fh, "~%"), @@ -360,9 +396,9 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by Jf_e : doExpand1(fin,bP), /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pDim-1, - if vdim = 1 then ( vpardim : pDim ), - dH_dz_e : makelist(0, i, 1, pDim), + vpardim : pdim-1, + if vdim = 1 then ( vpardim : pdim ), + dH_dz_e : makelist(0, i, 1, pdim), for i : 1 thru vpardim do ( if i = vpardim then ( dH_dz_e[i] : diff(hamil_e,varsP[i]) @@ -371,6 +407,23 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by dH_dz_e[i] : diff(hamil_e*rdx2vec[i],varsP[i]) ) ), + dH_dvpar : diff(hamil_e,varsP[vpardim])/vmap_prime_e[1], /* We do not multply by rdv2vec because it is inside vmap_prime */ + if cdim = 3 then ( + dH_dx : diff(hamil_e*rdx2vec[xidx],varsP[xidx]), + dH_dy : diff(hamil_e*rdx2vec[yidx],varsP[yidx]), + dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), + gradH_vec : [dH_dx, dH_dy, dH_dz, dH_dvpar] + ) else if cdim = 2 then ( + dH_dx : diff(hamil_e*rdx2vec[xidx],varsP[xidx]), + dH_dy : 0, + dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), + gradH_vec : [dH_dx, dH_dz, dH_dvpar] + ) else if cdim = 1 then ( + dH_dx : 0, + dH_dy : 0, + dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), + gradH_vec : [dH_dz, dH_dvpar] + ), /*Make sure to avoid having hamil[i]^2 or vmap[i]^2 in expressions*/ replaceListVpar : [vmap[1]^2=vmap2], @@ -395,14 +448,55 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by printf(fh, "~%"), /* Expand Apar.*/ + /* Apar_e : subst(y=0, doExpand1(apar,bC)), */ Apar_e : doExpand1(apar,bC), /* Expand dBperp/Bmag. */ - dBperpoverB_x : (rdy2*diff(Apar_e*b_z_e,y) - rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e, - dBperpoverB_y : (rdz2*diff(Apar_e*b_x_e,z) - rdx2*diff(Apar_e*b_z_e,x))*jacobTotInv_e, - dBperpoverB_z : (rdx2*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y))*jacobTotInv_e, - dBperpoverB_list : [dBperpoverB_x, dBperpoverB_y, dBperpoverB_z], + /* Direct method ∇ x (Apar bhat) */ + rotAbovermB_x : (rdy2*diff(Apar_e*b_z_e,y) - rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e/m_, + rotAbovermB_y : (rdz2*diff(Apar_e*b_x_e,z) - rdx2*diff(Apar_e*b_z_e,x))*jacobTotInv_e/m_, + rotAbovermB_z : (rdx2*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y))*jacobTotInv_e/m_, + rotAbovermB_list : [rotAbovermB_x, rotAbovermB_y, rotAbovermB_z], + + /* Product rule method Apar ∇ x bhat + ∇Apar x bhat. */ + /* Calculate ∇Apar in a list */ + if cdim = 3 then ( + dA_dx : diff(Apar_e*rdx2vec[xidx],varsC[xidx]), + dA_dy : diff(Apar_e*rdx2vec[yidx],varsC[yidx]), + dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), + gradA_vec : [dA_dx, dA_dy, dA_dz] + ) else if cdim = 2 then ( + dA_dx : diff(Apar_e*rdx2vec[xidx],varsC[xidx]), + dA_dy : 0, + dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), + gradA_vec : [dA_dx, dA_dz] + ) else if cdim = 1 then ( + dA_dx : 0, + dA_dy : 0, + dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), + gradA_vec : [dA_dz] + ), + /* Use bioverJB to calculate ∇Apar x b / B in a list */ + if cdim = 3 then ( + gradAxbhatoverB_x : gradA_vec[yidx]*bioverJB_list[3] - gradA_vec[zidx]*bioverJB_list[2], + gradAxbhatoverB_y : gradA_vec[zidx]*bioverJB_list[1] - gradA_vec[xidx]*bioverJB_list[3], + gradAxbhatoverB_z : gradA_vec[xidx]*bioverJB_list[2] - gradA_vec[yidx]*bioverJB_list[1], + gradAxbhatoverB_vec : [gradAxbhatoverB_x, gradAxbhatoverB_y, gradAxbhatoverB_z] + ) else if cdim = 2 then ( + gradAxbhatoverB_x : -gradA_vec[zidx]*bioverJB_list[2], + gradAxbhatoverB_y : 0, + gradAxbhatoverB_z : +gradA_vec[xidx]*bioverJB_list[2], + gradAxbhatoverB_vec : [gradAxbhatoverB_x, gradAxbhatoverB_z] + ) else if cdim = 1 then ( + gradAxbhatoverB_x : 0, + gradAxbhatoverB_y : 0, + gradAxbhatoverB_z : 0, + gradAxbhatoverB_vec : [gradAxbhatoverB_z] + ), + + dim_idx_list : [3, 1, 2], + /* Note: no contribution from mu. */ for dir : 1 thru cdim+1 do ( @@ -416,46 +510,28 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by alpha_e : 0, if no_by = false then ( - if cdim = 3 then ( - curvdriftdir : dir - ), - if cdim = 2 then ( - if dir = 1 then ( - curvdriftdir : dir + if dir < vpardim then ( /* Config space contributions ( curv drift * dH/dvpar . ∇ψ ) */ + list_idx : dim_idx_list[dir], + /* This is [Apar . (∇ x b)/B + ∇Apar x b/B]/m dH/dvpar . ∇ψ */ + alpha_e : alpha_e + 1/m_ * Apar_e * dualcurlbhatoverB_list[list_idx] * gradH_vec[vpardim], + /* This term is responsible of y oscillations in the Alfven 3x2v regression test. */ + /* The oscillation builds up at longer time (not observable at frame 1). */ + alpha_e : alpha_e + 1/m_ * gradAxbhatoverB_vec[dir] * gradH_vec[vpardim], + /* basis function gradient ∇ψ factor */ + alpha_e : alpha_e*rdx2vec[dir] + ) else ( /* Vpar contribution ( curv drift . ∇H * dψ/dvpar )*/ + for k : 1 thru cdim do ( + list_idx : dim_idx_list[k], + /* this is [Apar . (∇ x b)/B]/m . ∇H * dψ/dvpar */ + alpha_e : alpha_e - 1/m_ * (Apar_e * dualcurlbhatoverB_list[list_idx]) * gradH_vec[k], + /* this is [∇Apar x b/B]/m . ∇H * dψ/dvpar */ + alpha_e : alpha_e - 1/m_ * gradAxbhatoverB_vec[k] * gradH_vec[k] ), - if dir = 2 then ( - curvdriftdir : 3 - ) - ), - if cdim = 1 then ( - curvdriftdir : 3 - ), - - if dir < vpardim then ( /* This is \rot(Apar b) dHdvpar \cdot \grad\psi from Rdot \cdot \grad\psi volume integrated */ - alpha_e : alpha_e + dBperpoverB_list[curvdriftdir]/m_ * mvpar_e - ), - if dir = vpardim then ( /* This is \rot(Apar b) \cdot \grad H from vpardot dpsi/dvpar volume integrated */ - if cdim = 3 then ( - for k : 1 thru cdim do ( - alpha_e : alpha_e - dBperpoverB_list[k]/m_ * dH_dz_e[k] - ) - ), - if cdim = 2 then ( - alpha_e : alpha_e - dBperpoverB_list[1]/m_ * dH_dz_e[1] - dBperpoverB_list[3]/m_ * dH_dz_e[2] - ), - if cdim = 1 then ( - alpha_e : alpha_e - dBperpoverB_list[3]/m_ * dH_dz_e[1] - ) + /* basis function gradient dψ/dvpar factor */ + alpha_e : alpha_e/vmap_prime_e[1] ) ), - if dir < vpardim then ( - alpha_e : alpha_e*rdx2vec[dir] - ) - else if dir = vpardim then ( - alpha_e : alpha_e/vmap_prime_e[1] - ), - /* Project alpha on basis and write to array. */ printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), @@ -465,7 +541,7 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by alpha_c : subst(dvparSimp, alpha_c), alphaLabel : eval_string(sconcat(alpha, dirLabel)), clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], writeCExprsCollect1(alphaLabel, alpha_c, clst), printf(fh, "~%"), flush_output(fh), @@ -489,7 +565,7 @@ addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by )$ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,vpardir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, @@ -497,12 +573,12 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no vmapSq_e,vmap_prime_e,apardot_e,clst], kill(varsC,varsP,bC,bP), - pDim : cdim+vdim, + pdim : cdim+vdim, [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), numC : length(bC), numP : length(bP), - varLabel : makelist(string(varsP[d]),d,1,pDim), + varLabel : makelist(string(varsP[d]),d,1,pdim), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a(const double *vmap, const double q_, const double m_, const double *apardot, @@ -514,7 +590,7 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no printf(fh, "~%"), rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), /* Velocity mapping fields. */ @@ -538,7 +614,7 @@ addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), alphaLabel : eval_string(sconcat(alpha, dirLabel)), clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], writeCExprsCollect1(alphaLabel, alpha_c, clst), printf(fh, "~%"), flush_output(fh), diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index eae64208..dcc33e8e 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -205,7 +205,7 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b for i : 1 thru cdim do ( dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) ), - /* It will be used to compute the contribution as curl(Apar * bhat) = nabla Aparallel cross bhat + Aparallel * curl(bhat) */ + /* It will be used to compute the contribution as ∇ x (A b) = ∇A x b + A ∇ x b */ /* Now calculate flux at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ @@ -295,7 +295,9 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b /* grad(Aparallel) x b contribution*/ if cdim = 3 then ( if surfDir = 1 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) + /* This term is responsible of y oscillations in the Alfven 3x2v regression test. */ + /* The oscillation appears at short time (observable frame 1). */ + printf(fh, " alpha_quad += 0*mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) ), if surfDir = 2 then( printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) From 984a83c528d55d0767240d0cdeafcf696eb0aebb Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Mon, 23 Feb 2026 09:27:47 -0500 Subject: [PATCH 30/54] update scripts to be compatible with latest commit. --- .../gk_collisionless/ms-dg_gyrokinetic-header.mac | 2 +- .../gk_collisionless/ms-gk_collisionless_flux.mac | 13 +++++++++---- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index de6ccedd..06c9a6de 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -101,7 +101,7 @@ printPrototypes() := block([], for polyOrder : 1 thru maxPolyOrderB do ( printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apar_vol_~ax~av_~a_p~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, const double q_, const double m_, - const double *bmag, const double *jacobtot_inv, + const double *bmag, const double *jacobtot_inv, const double *dualcurlbhatoverB, const double *bioverJB, const double *b_i, const double *phi, const double *apar, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apardot_vol_~ax~av_~a_p~a(const double *vmap, const double q_, const double m_, diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 70096198..8120b8e5 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -93,21 +93,23 @@ for bInd : 1 thru length(bName) do ( edge : edgeBool[edgeI], edgeStr : edgeOpt[edgeI], + scheme : "upwind", fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), + buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, scheme), close(fh), if (em) then ( + scheme : "upwind", fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, "upwind"), + buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, scheme), close(fh) ) ) @@ -119,23 +121,26 @@ for bInd : 1 thru length(bName) do ( edgeStr : edgeOpt[1], add_apardot : em, /* Add apardot term if EM. */ + scheme : "upwind", fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), + buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, scheme), close(fh), if (em) then ( /* Add EM terms but not Apardot (star term) */ add_apardot : false, + + scheme : "upwind", fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), disp(printf(false,"Creating flux surfvpar file: ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, "upwind"), + buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, scheme), close(fh) ) ) From 651e9677f4aae33a510194bc02e4b23fe56e90be Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 24 Feb 2026 21:01:42 -0500 Subject: [PATCH 31/54] =?UTF-8?q?=F0=9F=90=9Bit=20almost=20works=20but=20i?= =?UTF-8?q?t=20seems=20that=20an=20error=20in=20indexation=20is=20present?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- maxima/g0/gk-sheath/sheath-1x2v.mac | 87 +++++++++++++++-------------- 1 file changed, 46 insertions(+), 41 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index 54f41043..b399a53c 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -13,7 +13,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( surfVarsC,bSurf,bV,bVpar,bMu,numBsurf,zvSurfVars,nodesMu,numNodesMu,bNMu,f_e,edge, surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c,fSurf_e, fSurfMu_q,vparLo_e,vparUp_e,fReflSurfMu_e,j,nodeIdx,fSurfMu_c,fSurfMu_e,intLims,fReflSurfMu_c, - xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c], + xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c,alphaMu_e,alphaMu_vpar0_e,alphaMu_q], pdim : cdim+vdim, @@ -62,6 +62,14 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), + + /* Expand alpha_mu on vpar,mu basis (bV). */ + alphaMuVpar_e : doExpand1(alpha_mu, bV), + + /* Evaluate alpha at (vpar=0, mu_j) */ + nodesVparMu : makelist([0, nodesMu[k][1]], k, 1, numNodesMu), + alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), + alphaMu_vpar0_e : subst(vpar=0, alphaMuVpar_e), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -70,7 +78,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ @@ -78,10 +86,12 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), deltaPhi_e : phiSheath_e - phiWall_e, - /* Evaluate vcutSqQ = vcut^2. q2Dm = q*2/m. */ + /* Evaluate base potential difference: deltaPhi = phiSheath - phiWall. */ deltaPhi_q : deltaPhi_e, - vcutSq_q : gcfac(float(fullratsimp(-q2Dm*deltaPhi_q))), - + + /* Evaluate alpha(mu) at mu_j nodes. */ + alphaMu_q : evAtNodes(alphaMu_vpar0_e, nodesMu, [mu]), + /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), fSurf_e : doExpand(fSurf_c, bSurf), @@ -94,7 +104,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double vcutSq;~%"), printf(fh, " double fReflSurf[~a] = {0.}; ~%", length(bV)), printf(fh, "~%"), - + vparLo_e : subst(vpar=-1, vmap_e[1]), vparUp_e : subst(vpar=1, vmap_e[1]), printf(fh, " double vparLo = ~a;~%", float(expand(vparLo_e))), @@ -105,47 +115,20 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double vparAbsSqUp = vmap[0]>0.? vparUp*vparUp : vparLo*vparLo;~%"), printf(fh, "~%"), - /* Write vcut^2 at boundary. */ - printf(fh, " vcutSq = ~a; ~%", vcutSq_q), - printf(fh, "~%"), - - /* If vcut^2 at this node is below all vpar^2 in this cell, BC at this node should be absorbing - so set coefficients of fRefl to 0 (no reflection from this node). */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), - printf(fh, "~%"), - - writeCExprsWithZeros1(fReflSurf, makelist(0.,j,1,length(bV))), - printf(fh, "~%"), - - /* If vcut^2 at this node is above all vpar^2 in this cell, BC at this node should be full reflection. */ - /* So set coefficients of fRefl to coefficients of f. */ - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), - printf(fh, "~%"), - - /* Project f onto vpar,mu basis (bV). */ - fSurf_c : gcfac(fullratsimp(calcInnerProdList(varsV, 1, bV, fSurf_e))), - /* Full reflection: set fRefl coefficients to f coefficients. */ - writeCExprsNoExpand1(fReflSurf, fSurf_c), - printf(fh, "~%"), - - /* If vcut^2 at this node is in this cell, BC at this node is partial reflection. */ - printf(fh, " } else { // partial reflection ~%"), - printf(fh, "~%"), - /* Reflected f at (mu)_j nodes. */ fReflSurfMu_e : makelist(0,j,1,numNodesMu), - printf(fh, " double wv = ~a;~%", float(fullratsimp((vparUp + vparLo)/2))), - printf(fh, " double dv = ~a;~%", float(fullratsimp(vparUp - vparLo))), + printf(fh, " double wv = ~a;~%", float(fullratsimp((vparUp + vparLo)/2))), + printf(fh, " double dv = ~a;~%", float(fullratsimp(vparUp - vparLo))), printf(fh, "~%"), - printf(fh, " double xBar, xSqBar;~%"), - printf(fh, " double fReflSurfMu[~a][~a] = {0.}; ~%", numNodesMu, length(bVpar)), + printf(fh, " double xBar, xSqBar;~%"), + printf(fh, " double fReflSurfMu[~a][~a] = {0.}; ~%", numNodesMu, length(bVpar)), printf(fh, "~%"), /* Loop over (mu)_j nodes. */ for j : 1 thru numNodesMu do ( - printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " // node (mu)_~a ~%", j-1), nodeIdx : sublist_indices(nodesMu, lambda([x], x[1]=nodesMu[j][1]))[1], @@ -153,6 +136,28 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfMu_q[nodeIdx]))), fSurfMu_e : doExpand(fSurfMu_c, bVpar), + /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ + alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[nodeIdx]))), + alphaMu_e : doExpand(alphaMu_c, bVpar), + alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), + + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_vpar0_e*q2Dm*deltaPhi_q)))), + printf(fh, "~%"), + + /* Check regime at this mu node. */ + printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, "~%"), + writeCExprsWithZeros1(fReflSurfMu[j-1], makelist(0,i,1,length(bVpar))), + printf(fh, "~%"), + + printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, "~%"), + writeCExprsNoExpand1(fReflSurfMu[j-1], fSurfMu_c), + printf(fh, "~%"), + + printf(fh, " } else { // partial reflection ~%"), + printf(fh, "~%"), + printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), @@ -193,6 +198,9 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " }~%"), printf(fh, "~%"), + printf(fh, " }~%"), /* End of partial reflection. */ + printf(fh, "~%"), + /* Expand vpar coefficients in vpar basis at this (mu)_j node. */ fReflSurfMu_e[j] : doExpand1(fReflSurfMu[j-1], bVpar) @@ -208,9 +216,6 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( writeCExprsNoExpand1(fReflSurf, fReflSurf_c), printf(fh, "~%"), - printf(fh, " }~%"), /* End of partial reflection else. */ - printf(fh, "~%"), - /* Expansion in vpar,mu of fReflSurf. */ fReflSurf_e : doExpand1(fReflSurf, bV), From bd5e5d7906cfef1fe8537b517dd81800aec6b940 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 24 Feb 2026 21:02:40 -0500 Subject: [PATCH 32/54] also update the header of the other functions --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 8 +- maxima/g0/gk-sheath/sheath-1x1v.mac | 2 +- maxima/g0/gk-sheath/sheath-2x2v.mac | 107 ++++++++++++++------------- maxima/g0/gk-sheath/sheath-3x2v.mac | 106 +++++++++++++------------- 4 files changed, 114 insertions(+), 109 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 29ead044..17814e0e 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -11,6 +11,8 @@ load("gk-sheath/sheath-3x2v"); /* ...... USER INPUTS........ */ +outDir : "/Users/ahoffman/gkeyll_main/gkeyll/gyrokinetic/ker/bc_sheath_gyrokinetic"$ /* Output directory */ + /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -43,7 +45,7 @@ for bInd : 1 thru length(bName) do ( minPolyOrderB : minPolyOrder[bInd], maxPolyOrderB : maxPolyOrder[bInd], for polyOrder : minPolyOrderB thru maxPolyOrderB do ( - fname : sconcat("~/max-out/bc_sheath_gyrokinetic_",bName[bInd],"_p",polyOrder,".c"), + fname : sconcat(outDir,"/bc_sheath_gyrokinetic_",bName[bInd],"_p",polyOrder,".c"), fh : openw(fname), printf(fh, "#include ~%"), @@ -69,7 +71,7 @@ for bInd : 1 thru length(bName) do ( /* Create a header file for sheath kernels. */ -fh : openw("~/max-out/gkyl_bc_sheath_gyrokinetic_kernels.h")$ +fh : openw(sconcat(outDir,"/gkyl_bc_sheath_gyrokinetic_kernels.h"))$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ @@ -94,7 +96,7 @@ for bInd : 1 thru length(bName) do ( for vI : 1 thru length(vDims[cdim]) do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *f, double *fRefl); ~%", edge[sI], cdim, vDims[cdim][vI], bName[bInd], polyOrder) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl); ~%", edge[sI], cdim, vDims[cdim][vI], bName[bInd], polyOrder) ) ) diff --git a/maxima/g0/gk-sheath/sheath-1x1v.mac b/maxima/g0/gk-sheath/sheath-1x1v.mac index 92d54efd..20501d2f 100644 --- a/maxima/g0/gk-sheath/sheath-1x1v.mac +++ b/maxima/g0/gk-sheath/sheath-1x1v.mac @@ -54,7 +54,7 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ diff --git a/maxima/g0/gk-sheath/sheath-2x2v.mac b/maxima/g0/gk-sheath/sheath-2x2v.mac index 6f2f0597..6c01f3d6 100644 --- a/maxima/g0/gk-sheath/sheath-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath-2x2v.mac @@ -13,7 +13,8 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( bSurf,bV,bVpar,bMu,bX,numBsurf,zvSurfVars,nodesX,nodesXMu,nodesMu,numNodesX,numNodesXMu,numNodesMu, bNMu,bNX,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c, fSurf_e,fSurfX_q,fSurfXMu_q,fReflSurfX_e,vparLo_e,vparUp_e,i,fSurfX_c,fReflSurfXMu_e,j,nodeIdx, - fSurfXMu_c,fSurfXMu_e,intLims,fReflSurfXMu_c,xBar_v,xSqBar_v,fReflSurfX_c,fReflSurf_c,fReflSurf_e,fRefl_c], + fSurfXMu_c,fSurfXMu_e,intLims,fReflSurfXMu_c,xBar_v,xSqBar_v,fReflSurfX_c,fReflSurf_c,fReflSurf_e,fRefl_c, + alphaMu_e,alphaMu_q,nodesVparMu], pdim : cdim+vdim, @@ -80,7 +81,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ @@ -88,9 +89,16 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), deltaPhi_e : phiSheath_e - phiWall_e, - /* Evaluate vcutSq = vcut^2 at x nodes. */ + /* Evaluate deltaPhi at x nodes. */ deltaPhi_q : evAtNodes(deltaPhi_e, nodesX, surfVarsC), - vcutSq_q : gcfac(float(fullratsimp(-q2Dm*deltaPhi_q))), + + /* Expand alpha_mu on vpar,mu basis (bV). */ + alphaMu_e : doExpand1(alpha_mu, bV), + + /* Evaluate alpha at (vpar=0, mu_j) nodes. Since alpha only depends on mu, + we evaluate at vpar=0 (cell center in vpar). */ + nodesVparMu : makelist([0, nodesMu[j][1]], j, 1, numNodesMu), + alphaMu_q : evAtNodes(alphaMu_e, nodesVparMu, varsV), /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), @@ -117,51 +125,28 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double vparAbsSqUp = vmap[0]>0.? vparUp*vparUp : vparLo*vparLo;~%"), printf(fh, "~%"), - for i : 1 thru numNodesX do ( - printf(fh, " // node (x)_~a ~%", i-1), - - /* Write vcut^2 at this node. */ - printf(fh, " vcutSq = ~a;~%", vcutSq_q[i]), - printf(fh, "~%"), - - /* If vcut^2 at this node is below all vpar^2 in this cell, BC at this node should be absorbing - so set coefficients of fRefl at this (x) node to 0 (no reflection from this node). */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection)~%"), - printf(fh, "~%"), - - writeCExprsWithZeros1(fReflSurfX[i-1], makelist(0.,j,1,length(bV))), - printf(fh, "~%"), - - /* If vcut^2 at this node is above the max vpar^2 in this cell, BC at this node should be full reflection */ - /* so set coefficients of fRefl at this (x) node to coefficients of f. */ - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection~%"), - printf(fh, "~%"), + printf(fh, " double wv;~%"), + printf(fh, " double dv;~%"), + printf(fh, "~%"), - /* Project f at this (x) node onto vpar,mu basis (bV). */ - fSurfX_c : gcfac(fullratsimp(calcInnerProdList(varsV, 1, bV, fSurfX_q[i]))), - /* Full reflection: set fRefl bZVpMu coefficients to f bZVpMu coefficients at this (x)_i node. */ - writeCExprsNoExpand1(fReflSurfX[i-1], fSurfX_c), - printf(fh, "~%"), + printf(fh, " double xBar, xSqBar;~%"), + printf(fh, " double fReflSurfXMu[~a][~a] = {0.}; ~%", numNodesMu, length(bVpar)), + printf(fh, "~%"), - /* If vcut^2 at this node is in this cell, BC at this node is partial reflection. */ - printf(fh, " } else { // partial reflection~%"), + for i : 1 thru numNodesX do ( + printf(fh, " // node (x)_~a ~%", i-1), printf(fh, "~%"), - /* Reflected f at (x)_i,(mu)_j nodes. Only need to store it for one - (x)_i node at a time. */ + /* Reflected f at (x)_i,(mu)_j nodes. */ fReflSurfXMu_e : makelist(0,j,1,numNodesMu), - printf(fh, " double wv = ~a;~%", float(fullratsimp((vparUp + vparLo)/2))), - printf(fh, " double dv = ~a;~%", float(fullratsimp(vparUp - vparLo))), - printf(fh, "~%"), - - printf(fh, " double xBar, xSqBar;~%"), - printf(fh, " double fReflSurfXMu[~a][~a] = {0.}; ~%", numNodesMu, length(bVpar)), + printf(fh, " wv = ~a;~%", float(fullratsimp((vparUp + vparLo)/2))), + printf(fh, " dv = ~a;~%", float(fullratsimp(vparUp - vparLo))), printf(fh, "~%"), /* Loop over (mu)_j nodes. */ for j : 1 thru numNodesMu do ( - printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " // node (mu)_~a ~%", j-1), nodeIdx : sublist_indices(nodesXMu, lambda([x], x[1]=nodesX[i][1] and x[2]=nodesMu[j][1]))[1], @@ -169,6 +154,24 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfXMu_q[nodeIdx]))), fSurfXMu_e : doExpand(fSurfXMu_c, bVpar), + /* Compute vcut^2 at this (x,mu) node: vcutSq = alpha(mu) * q2Dm * deltaPhi(x). */ + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_q[j]*q2Dm*deltaPhi_q[i])))), + printf(fh, "~%"), + + /* Check regime at this (x,mu) node. */ + printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, "~%"), + writeCExprsWithZeros1(fReflSurfXMu[j-1], makelist(0,k,1,length(bVpar))), + printf(fh, "~%"), + + printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, "~%"), + writeCExprsNoExpand1(fReflSurfXMu[j-1], fSurfXMu_c), + printf(fh, "~%"), + + printf(fh, " } else { // partial reflection ~%"), + printf(fh, "~%"), + printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), @@ -179,7 +182,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( tempVars1 : [], tempVars1 : writeCExprs1noPowers(fReflSurfXMu[j-1], fReflSurfXMu_c, [vcut_l], tempVars1), printf(fh, "~%"), - + printf(fh, " } else {~%"), printf(fh, " // vcut in logical space.~%"), printf(fh, " double vcut_l = 2.*(-sqrt(vcutSq)-wv)/dv;~%"), @@ -198,15 +201,18 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( |bar{x}|<=1 and |bar{x^2}|<=1, where bar{g}=int g*f dx/int f dx. */ xBar_v : gcfac(float(fReflSurfXMu[j-1][1]/(sqrt(3)*fReflSurfXMu[j-1][0]))), xSqBar_v : gcfac(float((2*sqrt(5)*fReflSurfXMu[j-1][2]+5*fReflSurfXMu[j-1][0])/(15*fReflSurfXMu[j-1][0]))), - printf(fh, " // If the cut distribution f(vpar), where vpar \in [-1,vcut_l] or [vcut_l/1],~%"), - printf(fh, " // has a cell average < 0, set to 0. If it's >0 but not realizable, set to p=0.~%"), - printf(fh, " xBar = ~a;~%", xBar_v), - printf(fh, " xSqBar = ~a;~%", xSqBar_v), - printf(fh, " if (fReflSurfXMu[~a][0]<0.) {~%",j-1), - writeCExprsWithZeros1(fReflSurfXMu[j-1], makelist(0,i,1,length(bVpar))), - printf(fh, " } else if (fabs(xBar)>=1. || fabs(xSqBar)>=1.) {~%"), - writeCExprsWithZeros1(fReflSurfXMu[j-1], makelist(0,i,1,length(bVpar))), - printf(fh, " }~%"), + printf(fh, " // If the cut distribution f(vpar), where vpar \in [-1,vcut_l] or [vcut_l/1],~%"), + printf(fh, " // has a cell average < 0, set to 0. If it's >0 but not realizable, set to p=0.~%"), + printf(fh, " xBar = ~a;~%", xBar_v), + printf(fh, " xSqBar = ~a;~%", xSqBar_v), + printf(fh, " if (fReflSurfXMu[~a][0]<0.) {~%",j-1), + writeCExprsWithZeros1(fReflSurfXMu[j-1], makelist(0,k,1,length(bVpar))), + printf(fh, " } else if (fabs(xBar)>=1. || fabs(xSqBar)>=1.) {~%"), + writeCExprsWithZeros1(fReflSurfXMu[j-1], makelist(0,k,1,length(bVpar))), + printf(fh, " }~%"), + printf(fh, "~%"), + + printf(fh, " }~%"), /* End of partial reflection. */ printf(fh, "~%"), /* Expand vpar coefficients in vpar basis at this (x)_i (mu)_j node. */ @@ -224,9 +230,6 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( writeCExprsNoExpand1(fReflSurfX[i-1], fReflSurfX_c), printf(fh, "~%"), - printf(fh, " }~%"), /* End of partial reflection else. */ - printf(fh, "~%"), - /* Expansion in vpar,mu of fReflSurf at each (x)_i node. */ fReflSurfX_e[i] : doExpand1(fReflSurfX[i-1], bV) diff --git a/maxima/g0/gk-sheath/sheath-3x2v.mac b/maxima/g0/gk-sheath/sheath-3x2v.mac index 826a9a7a..989651d7 100644 --- a/maxima/g0/gk-sheath/sheath-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath-3x2v.mac @@ -14,7 +14,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( numNodesMu,bNMu,bNXY,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q, vcutSq_q,fSurf_c,fSurf_e,fSurfXY_q,fSurfXYMu_q,fReflSurfXY_e,vparLo_e,vparUp_e,i,fSurfXY_c, fReflSurfXYMu_e,j,nodeIdx,fSurfXYMu_c,fSurfXYMu_e,intLims,fReflSurfXYMu_c,xBar_v,xSqBar_v, - fReflSurfXY_c,fReflSurf_c,fReflSurf_e,fRefl_c], + fReflSurfXY_c,fReflSurf_c,fReflSurf_e,fRefl_c,alphaMu_e,alphaMu_q,nodesVparMu], pdim : cdim+vdim, @@ -81,7 +81,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ @@ -89,9 +89,16 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), deltaPhi_e : phiSheath_e - phiWall_e, - /* Evaluate vcutSq = vcut^2 at x,y nodes. */ + /* Evaluate deltaPhi at x,y nodes. */ deltaPhi_q : evAtNodes(deltaPhi_e, nodesXY, surfVarsC), - vcutSq_q : gcfac(float(fullratsimp(-q2Dm*deltaPhi_q))), + + /* Expand alpha_mu on vpar,mu basis (bV). */ + alphaMu_e : doExpand1(alpha_mu, bV), + + /* Evaluate alpha at (vpar=0, mu_j) nodes. Since alpha only depends on mu, + we evaluate at vpar=0 (cell center in vpar). */ + nodesVparMu : makelist([0, nodesMu[j][1]], j, 1, numNodesMu), + alphaMu_q : evAtNodes(alphaMu_e, nodesVparMu, varsV), /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), @@ -118,51 +125,26 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double vparAbsSqUp = vmap[0]>0.? vparUp*vparUp : vparLo*vparLo;~%"), printf(fh, "~%"), + printf(fh, " double wv;~%"), + printf(fh, " double dv;~%"), + printf(fh, " double xBar, xSqBar;~%"), + printf(fh, " double fReflSurfXYMu[~a][~a] = {0.}; ~%", numNodesMu, length(bVpar)), + printf(fh, "~%"), + for i : 1 thru numNodesXY do ( printf(fh, " // node (x,y)_~a ~%", i-1), - - /* Write vcut^2 at this node. */ - printf(fh, " vcutSq = ~a;~%", vcutSq_q[i]), - printf(fh, "~%"), - - /* If vcut^2 at this node is below all vpar^2 in this cell, BC at this node should be absorbing - so set coefficients of fRefl at this (x,y) node to 0 (no reflection from this node). */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection)~%"), - printf(fh, "~%"), - - writeCExprsWithZeros1(fReflSurfXY[i-1], makelist(0.,j,1,length(bV))), printf(fh, "~%"), - /* If vcut^2 at this node is above the max vpar^2 in this cell, BC at this node should be full reflection */ - /* so set coefficients of fRefl at this (x,y) node to coefficients of f. */ - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection~%"), - printf(fh, "~%"), - - /* Project f at this (x,y) node onto vpar,mu basis (bV). */ - fSurfXY_c : gcfac(fullratsimp(calcInnerProdList(varsV, 1, bV, fSurfXY_q[i]))), - /* Full reflection: set fRefl bZVpMu coefficients to f bZVpMu coefficients at this (x,y)_i node. */ - writeCExprsNoExpand1(fReflSurfXY[i-1], fSurfXY_c), - printf(fh, "~%"), - - /* If vcut^2 at this node is in this cell, BC at this node is partial reflection. */ - printf(fh, " } else { // partial reflection~%"), - printf(fh, "~%"), - - /* Reflected f at (x,y)_i,(mu)_j nodes. Only need to store it for one - (x,y)_i node at a time. */ + /* Reflected f at (x,y)_i,(mu)_j nodes. */ fReflSurfXYMu_e : makelist(0,j,1,numNodesMu), - printf(fh, " double wv = ~a;~%", float(fullratsimp((vparUp + vparLo)/2))), - printf(fh, " double dv = ~a;~%", float(fullratsimp(vparUp - vparLo))), - printf(fh, "~%"), - - printf(fh, " double xBar, xSqBar;~%"), - printf(fh, " double fReflSurfXYMu[~a][~a] = {0.}; ~%", numNodesMu, length(bVpar)), + printf(fh, " wv = ~a;~%", float(fullratsimp((vparUp + vparLo)/2))), + printf(fh, " dv = ~a;~%", float(fullratsimp(vparUp - vparLo))), printf(fh, "~%"), /* Loop over (mu)_j nodes. */ for j : 1 thru numNodesMu do ( - printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " // node (mu)_~a ~%", j-1), nodeIdx : sublist_indices(nodesXYMu, lambda([x], x[1]=nodesXY[i][1] and x[2]=nodesXY[i][2] and x[3]=nodesMu[j][1]))[1], @@ -170,6 +152,24 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXYMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfXYMu_q[nodeIdx]))), fSurfXYMu_e : doExpand(fSurfXYMu_c, bVpar), + /* Compute vcut^2 at this (x,y,mu) node: vcutSq = alpha(mu) * q2Dm * deltaPhi(x,y). */ + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_q[j]*q2Dm*deltaPhi_q[i])))), + printf(fh, "~%"), + + /* Check regime at this (x,y,mu) node. */ + printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, "~%"), + writeCExprsWithZeros1(fReflSurfXYMu[j-1], makelist(0,k,1,length(bVpar))), + printf(fh, "~%"), + + printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, "~%"), + writeCExprsNoExpand1(fReflSurfXYMu[j-1], fSurfXYMu_c), + printf(fh, "~%"), + + printf(fh, " } else { // partial reflection ~%"), + printf(fh, "~%"), + printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), @@ -180,7 +180,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( tempVars1 : [], tempVars1 : writeCExprs1noPowers(fReflSurfXYMu[j-1], fReflSurfXYMu_c, [vcut_l], tempVars1), printf(fh, "~%"), - + printf(fh, " } else {~%"), printf(fh, " // vcut in logical space.~%"), printf(fh, " double vcut_l = 2.*(-sqrt(vcutSq)-wv)/dv;~%"), @@ -194,20 +194,23 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " }~%"), printf(fh, "~%"), - + /* Evaluate realizability. In 1D a function is realization if |bar{x}|<=1 and |bar{x^2}|<=1, where bar{g}=int g*f dx/int f dx. */ xBar_v : gcfac(float(fReflSurfXYMu[j-1][1]/(sqrt(3)*fReflSurfXYMu[j-1][0]))), xSqBar_v : gcfac(float((2*sqrt(5)*fReflSurfXYMu[j-1][2]+5*fReflSurfXYMu[j-1][0])/(15*fReflSurfXYMu[j-1][0]))), - printf(fh, " // If the cut distribution f(vpar), where vpar \in [-1,vcut_l] or [vcut_l/1],~%"), - printf(fh, " // has a cell average < 0, set to 0. If it's >0 but not realizable, set to p=0.~%"), - printf(fh, " xBar = ~a;~%", xBar_v), - printf(fh, " xSqBar = ~a;~%", xSqBar_v), - printf(fh, " if (fReflSurfXYMu[~a][0]<0.) {~%",j-1), - writeCExprsWithZeros1(fReflSurfXYMu[j-1], makelist(0,i,1,length(bVpar))), - printf(fh, " } else if (fabs(xBar)>=1. || fabs(xSqBar)>=1.) {~%"), - writeCExprsWithZeros1(fReflSurfXYMu[j-1], makelist(0,i,1,length(bVpar))), - printf(fh, " }~%"), + printf(fh, " // If the cut distribution f(vpar), where vpar \in [-1,vcut_l] or [vcut_l/1],~%"), + printf(fh, " // has a cell average < 0, set to 0. If it's >0 but not realizable, set to p=0.~%"), + printf(fh, " xBar = ~a;~%", xBar_v), + printf(fh, " xSqBar = ~a;~%", xSqBar_v), + printf(fh, " if (fReflSurfXYMu[~a][0]<0.) {~%",j-1), + writeCExprsWithZeros1(fReflSurfXYMu[j-1], makelist(0,k,1,length(bVpar))), + printf(fh, " } else if (fabs(xBar)>=1. || fabs(xSqBar)>=1.) {~%"), + writeCExprsWithZeros1(fReflSurfXYMu[j-1], makelist(0,k,1,length(bVpar))), + printf(fh, " }~%"), + printf(fh, "~%"), + + printf(fh, " }~%"), /* End of partial reflection. */ printf(fh, "~%"), /* Expand vpar coefficients in vpar basis at this (x,y)_i (mu)_j node. */ @@ -225,9 +228,6 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( writeCExprsNoExpand1(fReflSurfXY[i-1], fReflSurfXY_c), printf(fh, "~%"), - printf(fh, " }~%"), /* End of partial reflection else. */ - printf(fh, "~%"), - /* Expansion in vpar,mu of fReflSurf at each (x,y)_i node. */ fReflSurfXY_e[i] : doExpand1(fReflSurfXY[i-1], bV) From 4763487381f7c4e461e386f0d8b0c0e8ff360ed6 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 24 Feb 2026 21:46:42 -0500 Subject: [PATCH 33/54] =?UTF-8?q?=F0=9F=94=A5=F0=9F=90=9B=F0=9F=94=A5=20th?= =?UTF-8?q?e=201x2v=20kernel=20works=20fine=20now?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- maxima/g0/gk-sheath/sheath-1x2v.mac | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index b399a53c..d647ef34 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -69,7 +69,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Evaluate alpha at (vpar=0, mu_j) */ nodesVparMu : makelist([0, nodesMu[k][1]], k, 1, numNodesMu), alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), - alphaMu_vpar0_e : subst(vpar=0, alphaMuVpar_e), + /* alphaMu_vpar0_e : subst(vpar=0, alphaMuVpar_e), */ /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -89,9 +89,6 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Evaluate base potential difference: deltaPhi = phiSheath - phiWall. */ deltaPhi_q : deltaPhi_e, - /* Evaluate alpha(mu) at mu_j nodes. */ - alphaMu_q : evAtNodes(alphaMu_vpar0_e, nodesMu, [mu]), - /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), fSurf_e : doExpand(fSurf_c, bSurf), @@ -137,7 +134,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfMu_e : doExpand(fSurfMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[nodeIdx]))), + alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[j]))), alphaMu_e : doExpand(alphaMu_c, bVpar), alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), From 969382455c5a42e7bf647aa65a309165fb4739ab Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Tue, 24 Feb 2026 21:59:16 -0500 Subject: [PATCH 34/54] not all local variables were declared --- maxima/g0/gk-sheath/sheath-1x2v.mac | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index d647ef34..9f180325 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -13,7 +13,8 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( surfVarsC,bSurf,bV,bVpar,bMu,numBsurf,zvSurfVars,nodesMu,numNodesMu,bNMu,f_e,edge, surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c,fSurf_e, fSurfMu_q,vparLo_e,vparUp_e,fReflSurfMu_e,j,nodeIdx,fSurfMu_c,fSurfMu_e,intLims,fReflSurfMu_c, - xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c,alphaMu_e,alphaMu_vpar0_e,alphaMu_q], + xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c,alphaMu_e,alphaMu_vpar0_e,alphaMu_q, + alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], pdim : cdim+vdim, From 93bebbca705e89c509c134cc4a841c710f65d4e8 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 26 Feb 2026 11:20:03 -0500 Subject: [PATCH 35/54] unify coding style with 1x2v --- maxima/g0/gk-sheath/sheath-2x2v.mac | 25 ++++++++++++++----------- maxima/g0/gk-sheath/sheath-3x2v.mac | 26 +++++++++++++++----------- 2 files changed, 29 insertions(+), 22 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath-2x2v.mac b/maxima/g0/gk-sheath/sheath-2x2v.mac index 6c01f3d6..a9b037d4 100644 --- a/maxima/g0/gk-sheath/sheath-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath-2x2v.mac @@ -14,7 +14,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( bNMu,bNX,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c, fSurf_e,fSurfX_q,fSurfXMu_q,fReflSurfX_e,vparLo_e,vparUp_e,i,fSurfX_c,fReflSurfXMu_e,j,nodeIdx, fSurfXMu_c,fSurfXMu_e,intLims,fReflSurfXMu_c,xBar_v,xSqBar_v,fReflSurfX_c,fReflSurf_c,fReflSurf_e,fRefl_c, - alphaMu_e,alphaMu_q,nodesVparMu], + alphaMu_q,alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -74,6 +74,13 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), + /* Expand alpha_mu on vpar,mu basis (bV). */ + alphaMuVpar_e : doExpand1(alpha_mu, bV), + + /* Evaluate alpha at (vpar=0, mu_j) */ + nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), + alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), + /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], surfPerpVal : [-1, 1], @@ -92,14 +99,6 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Evaluate deltaPhi at x nodes. */ deltaPhi_q : evAtNodes(deltaPhi_e, nodesX, surfVarsC), - /* Expand alpha_mu on vpar,mu basis (bV). */ - alphaMu_e : doExpand1(alpha_mu, bV), - - /* Evaluate alpha at (vpar=0, mu_j) nodes. Since alpha only depends on mu, - we evaluate at vpar=0 (cell center in vpar). */ - nodesVparMu : makelist([0, nodesMu[j][1]], j, 1, numNodesMu), - alphaMu_q : evAtNodes(alphaMu_e, nodesVparMu, varsV), - /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), fSurf_e : doExpand(fSurf_c, bSurf), @@ -154,8 +153,12 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfXMu_q[nodeIdx]))), fSurfXMu_e : doExpand(fSurfXMu_c, bVpar), - /* Compute vcut^2 at this (x,mu) node: vcutSq = alpha(mu) * q2Dm * deltaPhi(x). */ - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_q[j]*q2Dm*deltaPhi_q[i])))), + /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ + alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[j]))), + alphaMu_e : doExpand(alphaMu_c, bVpar), + alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), + + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_vpar0_e*q2Dm*deltaPhi_q[i])))), printf(fh, "~%"), /* Check regime at this (x,mu) node. */ diff --git a/maxima/g0/gk-sheath/sheath-3x2v.mac b/maxima/g0/gk-sheath/sheath-3x2v.mac index 989651d7..9de1caad 100644 --- a/maxima/g0/gk-sheath/sheath-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath-3x2v.mac @@ -14,7 +14,8 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( numNodesMu,bNMu,bNXY,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q, vcutSq_q,fSurf_c,fSurf_e,fSurfXY_q,fSurfXYMu_q,fReflSurfXY_e,vparLo_e,vparUp_e,i,fSurfXY_c, fReflSurfXYMu_e,j,nodeIdx,fSurfXYMu_c,fSurfXYMu_e,intLims,fReflSurfXYMu_c,xBar_v,xSqBar_v, - fReflSurfXY_c,fReflSurf_c,fReflSurf_e,fRefl_c,alphaMu_e,alphaMu_q,nodesVparMu], + fReflSurfXY_c,fReflSurf_c,fReflSurf_e,fRefl_c, + alphaMu_e,alphaMu_vpar0_e,alphaMu_q,alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -74,6 +75,13 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), + /* Expand alpha_mu on vpar,mu basis (bV). */ + alphaMuVpar_e : doExpand1(alpha_mu, bV), + + /* Evaluate alpha at (vpar=0, mu_j) */ + nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), + alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), + /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], surfPerpVal : [-1, 1], @@ -92,14 +100,6 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Evaluate deltaPhi at x,y nodes. */ deltaPhi_q : evAtNodes(deltaPhi_e, nodesXY, surfVarsC), - /* Expand alpha_mu on vpar,mu basis (bV). */ - alphaMu_e : doExpand1(alpha_mu, bV), - - /* Evaluate alpha at (vpar=0, mu_j) nodes. Since alpha only depends on mu, - we evaluate at vpar=0 (cell center in vpar). */ - nodesVparMu : makelist([0, nodesMu[j][1]], j, 1, numNodesMu), - alphaMu_q : evAtNodes(alphaMu_e, nodesVparMu, varsV), - /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), fSurf_e : doExpand(fSurf_c, bSurf), @@ -152,8 +152,12 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXYMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfXYMu_q[nodeIdx]))), fSurfXYMu_e : doExpand(fSurfXYMu_c, bVpar), - /* Compute vcut^2 at this (x,y,mu) node: vcutSq = alpha(mu) * q2Dm * deltaPhi(x,y). */ - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_q[j]*q2Dm*deltaPhi_q[i])))), + /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ + alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[j]))), + alphaMu_e : doExpand(alphaMu_c, bVpar), + alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), + + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_vpar0_e*q2Dm*deltaPhi_q[i])))), printf(fh, "~%"), /* Check regime at this (x,y,mu) node. */ From 72e96774720fae3d762001c127638b6bf141ba69 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 26 Feb 2026 11:38:08 -0500 Subject: [PATCH 36/54] little cleaning --- maxima/g0/gk-sheath/sheath-1x2v.mac | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index 9f180325..84cc034d 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -13,8 +13,8 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( surfVarsC,bSurf,bV,bVpar,bMu,numBsurf,zvSurfVars,nodesMu,numNodesMu,bNMu,f_e,edge, surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c,fSurf_e, fSurfMu_q,vparLo_e,vparUp_e,fReflSurfMu_e,j,nodeIdx,fSurfMu_c,fSurfMu_e,intLims,fReflSurfMu_c, - xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c,alphaMu_e,alphaMu_vpar0_e,alphaMu_q, - alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], + xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c, + alphaMu_e,alphaMu_vpar0_e,alphaMu_q,alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -68,9 +68,8 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( alphaMuVpar_e : doExpand1(alpha_mu, bV), /* Evaluate alpha at (vpar=0, mu_j) */ - nodesVparMu : makelist([0, nodesMu[k][1]], k, 1, numNodesMu), + nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), - /* alphaMu_vpar0_e : subst(vpar=0, alphaMuVpar_e), */ /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], From 742bf9d6e546520a53be74f116195f06c7d7288f Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 27 Feb 2026 11:44:24 -0500 Subject: [PATCH 37/54] refactor alpha_mu name to vcut_fact --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 2 +- maxima/g0/gk-sheath/sheath-1x1v.mac | 2 +- maxima/g0/gk-sheath/sheath-1x2v.mac | 18 +++++++++--------- maxima/g0/gk-sheath/sheath-2x2v.mac | 18 +++++++++--------- maxima/g0/gk-sheath/sheath-3x2v.mac | 18 +++++++++--------- 5 files changed, 29 insertions(+), 29 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 17814e0e..56d6d21b 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -96,7 +96,7 @@ for bInd : 1 thru length(bName) do ( for vI : 1 thru length(vDims[cdim]) do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl); ~%", edge[sI], cdim, vDims[cdim][vI], bName[bInd], polyOrder) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl); ~%", edge[sI], cdim, vDims[cdim][vI], bName[bInd], polyOrder) ) ) diff --git a/maxima/g0/gk-sheath/sheath-1x1v.mac b/maxima/g0/gk-sheath/sheath-1x1v.mac index 20501d2f..a046fd57 100644 --- a/maxima/g0/gk-sheath/sheath-1x1v.mac +++ b/maxima/g0/gk-sheath/sheath-1x1v.mac @@ -54,7 +54,7 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index 84cc034d..bd8eb815 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -14,7 +14,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c,fSurf_e, fSurfMu_q,vparLo_e,vparUp_e,fReflSurfMu_e,j,nodeIdx,fSurfMu_c,fSurfMu_e,intLims,fReflSurfMu_c, xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c, - alphaMu_e,alphaMu_vpar0_e,alphaMu_q,alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], + vcutFact_e,vcutFact_vpar0_e,vcutFact_q,vcutFactVpar_e,nodesVparMu,vcutFact_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -64,12 +64,12 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand alpha_mu on vpar,mu basis (bV). */ - alphaMuVpar_e : doExpand1(alpha_mu, bV), + /* Expand vcut_fact on vpar,mu basis (bV). */ + vcutFactVpar_e : doExpand1(vcut_fact, bV), /* Evaluate alpha at (vpar=0, mu_j) */ nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), - alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), + vcutFact_q : evAtNodes(vcutFactVpar_e, nodesVparMu, varsV), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -78,7 +78,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ @@ -134,11 +134,11 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfMu_e : doExpand(fSurfMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[j]))), - alphaMu_e : doExpand(alphaMu_c, bVpar), - alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), + vcutFact_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, vcutFact_q[j]))), + vcutFact_e : doExpand(vcutFact_c, bVpar), + vcutFact_vpar0_e : subst(vpar=0, vcutFact_e), - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_vpar0_e*q2Dm*deltaPhi_q)))), + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_vpar0_e*q2Dm*deltaPhi_q)))), printf(fh, "~%"), /* Check regime at this mu node. */ diff --git a/maxima/g0/gk-sheath/sheath-2x2v.mac b/maxima/g0/gk-sheath/sheath-2x2v.mac index a9b037d4..f2e14c74 100644 --- a/maxima/g0/gk-sheath/sheath-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath-2x2v.mac @@ -14,7 +14,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( bNMu,bNX,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c, fSurf_e,fSurfX_q,fSurfXMu_q,fReflSurfX_e,vparLo_e,vparUp_e,i,fSurfX_c,fReflSurfXMu_e,j,nodeIdx, fSurfXMu_c,fSurfXMu_e,intLims,fReflSurfXMu_c,xBar_v,xSqBar_v,fReflSurfX_c,fReflSurf_c,fReflSurf_e,fRefl_c, - alphaMu_q,alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], + vcutFact_q,vcutFactVpar_e,nodesVparMu,vcutFact_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -74,12 +74,12 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand alpha_mu on vpar,mu basis (bV). */ - alphaMuVpar_e : doExpand1(alpha_mu, bV), + /* Expand vcut_fact on vpar,mu basis (bV). */ + vcutFactVpar_e : doExpand1(vcut_fact, bV), /* Evaluate alpha at (vpar=0, mu_j) */ nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), - alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), + vcutFact_q : evAtNodes(vcutFactVpar_e, nodesVparMu, varsV), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -88,7 +88,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ @@ -154,11 +154,11 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXMu_e : doExpand(fSurfXMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[j]))), - alphaMu_e : doExpand(alphaMu_c, bVpar), - alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), + vcutFact_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, vcutFact_q[j]))), + vcutFact_e : doExpand(vcutFact_c, bVpar), + vcutFact_vpar0_e : subst(vpar=0, vcutFact_e), - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_vpar0_e*q2Dm*deltaPhi_q[i])))), + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_vpar0_e*q2Dm*deltaPhi_q[i])))), printf(fh, "~%"), /* Check regime at this (x,mu) node. */ diff --git a/maxima/g0/gk-sheath/sheath-3x2v.mac b/maxima/g0/gk-sheath/sheath-3x2v.mac index 9de1caad..8f4e12e2 100644 --- a/maxima/g0/gk-sheath/sheath-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath-3x2v.mac @@ -15,7 +15,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( vcutSq_q,fSurf_c,fSurf_e,fSurfXY_q,fSurfXYMu_q,fReflSurfXY_e,vparLo_e,vparUp_e,i,fSurfXY_c, fReflSurfXYMu_e,j,nodeIdx,fSurfXYMu_c,fSurfXYMu_e,intLims,fReflSurfXYMu_c,xBar_v,xSqBar_v, fReflSurfXY_c,fReflSurf_c,fReflSurf_e,fRefl_c, - alphaMu_e,alphaMu_vpar0_e,alphaMu_q,alphaMuVpar_e,nodesVparMu,alphaMu_c,tempVars1,tempVars2], + vcutFact_e,vcutFact_vpar0_e,vcutFact_q,vcutFactVpar_e,nodesVparMu,vcutFact_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -75,12 +75,12 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand alpha_mu on vpar,mu basis (bV). */ - alphaMuVpar_e : doExpand1(alpha_mu, bV), + /* Expand vcut_fact on vpar,mu basis (bV). */ + vcutFactVpar_e : doExpand1(vcut_fact, bV), /* Evaluate alpha at (vpar=0, mu_j) */ nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), - alphaMu_q : evAtNodes(alphaMuVpar_e, nodesVparMu, varsV), + vcutFact_q : evAtNodes(vcutFactVpar_e, nodesVparMu, varsV), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -89,7 +89,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *alpha_mu, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ @@ -153,11 +153,11 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXYMu_e : doExpand(fSurfXYMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - alphaMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, alphaMu_q[j]))), - alphaMu_e : doExpand(alphaMu_c, bVpar), - alphaMu_vpar0_e : subst(vpar=0, alphaMu_e), + vcutFact_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, vcutFact_q[j]))), + vcutFact_e : doExpand(vcutFact_c, bVpar), + vcutFact_vpar0_e : subst(vpar=0, vcutFact_e), - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-alphaMu_vpar0_e*q2Dm*deltaPhi_q[i])))), + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_vpar0_e*q2Dm*deltaPhi_q[i])))), printf(fh, "~%"), /* Check regime at this (x,y,mu) node. */ From 29bb010912afb8bccf202dfac24abfb5eebf0cd6 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Mon, 2 Mar 2026 11:05:34 -0500 Subject: [PATCH 38/54] The vcut factor is now defined on the perpendicular conf dims and mu --- maxima/g0/gk-sheath/sheath-1x2v.mac | 19 +++++++------------ maxima/g0/gk-sheath/sheath-2x2v.mac | 17 +++++++---------- maxima/g0/gk-sheath/sheath-3x2v.mac | 15 ++++++--------- 3 files changed, 20 insertions(+), 31 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index bd8eb815..493e3183 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -36,12 +36,12 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( bSurf : basisFromVars("gkhyb",surfVars,polyOrder), bV : basisFromVars("gkhyb",[vpar,mu],polyOrder), bVpar : basisFromVars("gkhyb",[vpar],polyOrder), - bMu : basisFromVars("gkhyb",[mu],polyOrder) + bMu : basisFromVars("ser",[mu],polyOrder) ) else ( bSurf : basisFromVars(basisFun,surfVars,polyOrder), bV : basisFromVars(basisFun,[vpar,mu],polyOrder), bVpar : basisFromVars(basisFun,[vpar],polyOrder), - bMu : basisFromVars(basisFun,[mu],polyOrder) + bMu : basisFromVars("ser",[mu],polyOrder) ), numBsurf : length(bSurf), @@ -64,12 +64,11 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand vcut_fact on vpar,mu basis (bV). */ - vcutFactVpar_e : doExpand1(vcut_fact, bV), + /* Expand vcut_fact on mu basis (bMu). */ + vcutFactVpar_e : doExpand1(vcut_fact, bMu), - /* Evaluate alpha at (vpar=0, mu_j) */ - nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), - vcutFact_q : evAtNodes(vcutFactVpar_e, nodesVparMu, varsV), + /* Evaluate vcut_fact at (mu_j) */ + vcutFact_q : evAtNodes(vcutFactVpar_e, nodesMu, zvSurfVars), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -134,11 +133,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfMu_e : doExpand(fSurfMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - vcutFact_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, vcutFact_q[j]))), - vcutFact_e : doExpand(vcutFact_c, bVpar), - vcutFact_vpar0_e : subst(vpar=0, vcutFact_e), - - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_vpar0_e*q2Dm*deltaPhi_q)))), + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_q[nodeIdx]*q2Dm*deltaPhi_q)))), printf(fh, "~%"), /* Check regime at this mu node. */ diff --git a/maxima/g0/gk-sheath/sheath-2x2v.mac b/maxima/g0/gk-sheath/sheath-2x2v.mac index f2e14c74..ac20b634 100644 --- a/maxima/g0/gk-sheath/sheath-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath-2x2v.mac @@ -37,12 +37,14 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( bV : basisFromVars("gkhyb",[vpar,mu],polyOrder), bVpar : basisFromVars("gkhyb",[vpar],polyOrder), bMu : basisFromVars("gkhyb",[mu],polyOrder), + bXMu : basisFromVars("ser",[x,mu],polyOrder), bX : basisFromVars("gkhyb",[x],polyOrder) ) else ( bSurf : basisFromVars(basisFun,surfVars,polyOrder), bV : basisFromVars(basisFun,[vpar,mu],polyOrder), bVpar : basisFromVars(basisFun,[vpar],polyOrder), bMu : basisFromVars(basisFun,[mu],polyOrder), + bXMu : basisFromVars("ser",[x,mu],polyOrder), bX : basisFromVars(basisFun,[x],polyOrder) ), numBsurf : length(bSurf), @@ -74,12 +76,11 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand vcut_fact on vpar,mu basis (bV). */ - vcutFactVpar_e : doExpand1(vcut_fact, bV), + /* Expand vcut_fact on mu basis (bXMu). */ + vcutFactVpar_e : doExpand1(vcut_fact, bXMu), - /* Evaluate alpha at (vpar=0, mu_j) */ - nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), - vcutFact_q : evAtNodes(vcutFactVpar_e, nodesVparMu, varsV), + /* Evaluate vcut_fact at (x,mu)_ij nodes. */ + vcutFact_q : evAtNodes(vcutFactVpar_e, nodesXMu, zvSurfVars), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -154,11 +155,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXMu_e : doExpand(fSurfXMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - vcutFact_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, vcutFact_q[j]))), - vcutFact_e : doExpand(vcutFact_c, bVpar), - vcutFact_vpar0_e : subst(vpar=0, vcutFact_e), - - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_vpar0_e*q2Dm*deltaPhi_q[i])))), + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_q[nodeIdx]*q2Dm*deltaPhi_q[i])))), printf(fh, "~%"), /* Check regime at this (x,mu) node. */ diff --git a/maxima/g0/gk-sheath/sheath-3x2v.mac b/maxima/g0/gk-sheath/sheath-3x2v.mac index 8f4e12e2..fdb826b4 100644 --- a/maxima/g0/gk-sheath/sheath-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath-3x2v.mac @@ -38,12 +38,14 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( bV : basisFromVars("gkhyb",[vpar,mu],polyOrder), bVpar : basisFromVars("gkhyb",[vpar],polyOrder), bMu : basisFromVars("gkhyb",[mu],polyOrder), + bXYMu : basisFromVars("ser",[x,y,mu],polyOrder), bXY : basisFromVars("gkhyb",[x,y],polyOrder) ) else ( bSurf : basisFromVars(basisFun,surfVars,polyOrder), bV : basisFromVars(basisFun,[vpar,mu],polyOrder), bVpar : basisFromVars(basisFun,[vpar],polyOrder), bMu : basisFromVars(basisFun,[mu],polyOrder), + bXYMu : basisFromVars("ser",[x,y,mu],polyOrder), bXY : basisFromVars(basisFun,[x,y],polyOrder) ), numBsurf : length(bSurf), @@ -76,11 +78,10 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( f_e : doExpand1(f, bP), /* Expand vcut_fact on vpar,mu basis (bV). */ - vcutFactVpar_e : doExpand1(vcut_fact, bV), + vcutFactVpar_e : doExpand1(vcut_fact, bXYMu), - /* Evaluate alpha at (vpar=0, mu_j) */ - nodesVparMu : makelist([0, nodesMu[inmu][1]], inmu, 1, numNodesMu), - vcutFact_q : evAtNodes(vcutFactVpar_e, nodesVparMu, varsV), + /* Evaluate vcut_fact at (x,y,mu)_ij nodes. */ + vcutFact_q : evAtNodes(vcutFactVpar_e, nodesXYMu, zvSurfVars), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -153,11 +154,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXYMu_e : doExpand(fSurfXYMu_c, bVpar), /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - vcutFact_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, vcutFact_q[j]))), - vcutFact_e : doExpand(vcutFact_c, bVpar), - vcutFact_vpar0_e : subst(vpar=0, vcutFact_e), - - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_vpar0_e*q2Dm*deltaPhi_q[i])))), + printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_q[nodeIdx]*q2Dm*deltaPhi_q[i])))), printf(fh, "~%"), /* Check regime at this (x,y,mu) node. */ From 558caeb74ed4a6522556a572474e1cdc1141123c Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 5 Mar 2026 15:21:12 -0500 Subject: [PATCH 39/54] add the sheath surrogate kernels --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 25 +++- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 98 ++++++++++++++ maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 127 ++++++++++++++++++ maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 126 +++++++++++++++++ 4 files changed, 375 insertions(+), 1 deletion(-) create mode 100644 maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac create mode 100644 maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac create mode 100644 maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 56d6d21b..184a829f 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -8,10 +8,13 @@ load("gk-sheath/sheath-1x1v"); load("gk-sheath/sheath-1x2v"); load("gk-sheath/sheath-2x2v"); load("gk-sheath/sheath-3x2v"); +load("gk-sheath/sheath_surrogate-1x2v"); +load("gk-sheath/sheath_surrogate-2x2v"); +load("gk-sheath/sheath_surrogate-3x2v"); /* ...... USER INPUTS........ */ -outDir : "/Users/ahoffman/gkeyll_main/gkeyll/gyrokinetic/ker/bc_sheath_gyrokinetic"$ /* Output directory */ +outDir : "~/max-out"$ /* Output directory */ /* Serendipity basis. */ minPolyOrder_Ser : 1$ @@ -65,6 +68,18 @@ for bInd : 1 thru length(bName) do ( ) ) ), + + for cdim : minDim[bInd] thru maxDim[bInd] do ( + if (polyOrder = 1) then ( + if cdim=1 then ( + genGkSheathSurrKer1x2v(fh, cdim, 2, bName[bInd], polyOrder) + ) else if cdim=2 then ( + genGkSheathSurrKer2x2v(fh, cdim, 2, bName[bInd], polyOrder) + ) else if cdim=3 then ( + genGkSheathSurrKer3x2v(fh, cdim, 2, bName[bInd], polyOrder) + ) + ) + ), close(fh) ) )$ @@ -74,6 +89,7 @@ for bInd : 1 thru length(bName) do ( fh : openw(sconcat(outDir,"/gkyl_bc_sheath_gyrokinetic_kernels.h"))$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ +printf(fh, "#include ~%"), printf(fh, "#include ~%")$ printf(fh, "#include ~%")$ printf(fh, "~%")$ @@ -104,6 +120,13 @@ for bInd : 1 thru length(bName) do ( ) )$ +/* surrogate kernels. */ +for cdim : minDim_Ser thru maxDim_Ser do ( + for sI : 1 thru length(edge) do ( + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", edge[sI], cdim) + ) +)$ + printf(fh, "~%")$ printf(fh, "EXTERN_C_END~%")$ printf(fh, "~%")$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac new file mode 100644 index 00000000..89aa7400 --- /dev/null +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -0,0 +1,98 @@ +/* + Gyrokinetic sheath function for 1x2v kernel. +*/ +load("modal-basis")$ +load("out-scripts")$ +load("nodal_operations/nodal_functions")$ +load("utilities_gyrokinetic")$ +load(stringproc)$ +fpprec : 24$ + +genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVarsC, + bMu,bCperpMu,zvSurfVars,nodesMu,numNodesMu,j,bNMu,edge,surfPerpVal,sI,surfVarsCmu, + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_fact_e,vcut_fact_c], + + pdim : cdim+vdim, + + /* Get desired basis. */ + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + NP : length(bP), + varsV : copylist(varsP), for d : 1 thru cdim do (varsV : delete(varsC[d],varsV)), + + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Get name of last config space dimension, which is always assumed to be + the direction parallel to the magnetic field (z). */ + surfPerpVar : varsC[cdim], + surfVarsC : delete(surfPerpVar, varsC), /* = x. */ + surfVarsCmu : append(surfVarsC, [mu]), /* = x,mu. */ + + /* Set up mu basis and perp conf + mu basis. */ + bMu : basisFromVars("ser",[mu],polyOrder), + bCperpMu : basisFromVars("ser",surfVarsCmu,polyOrder), + + zvSurfVars : append(surfVarsC, [mu]), /* = x,mu. */ + /* Set up surface nodes. */ + if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ + nodesMu : gaussOrdGkHyb(polyOrder+1, [], [mu]) + ) else ( + nodesMu : gaussOrd(polyOrder+1, length([mu])) + ), + numNodesMu : length(nodesMu), + + /* Get nodal basis sets. */ + bNMu : getVarsNodalBasisWithNodesHyb("gkhyb", 0, 1, [mu], nodesMu), + + /* Generate separate kernels for lower/upper boundaries. */ + edge : ["lower", "upper"], + surfPerpVal : [-1, 1], + + for sI : 1 thru length(edge) do ( + + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), + + /* Define nodal values */ + printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), + printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), + printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), + printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), + printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), + printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, "~%"), + + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, mass, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Reconstruct the mu modal representation via a nodal-modal conversion. */ + vcut_fact_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcut_fact_n, bNMu)), + + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + + + printf(fh, "}~%") + ) +)$ + diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac new file mode 100644 index 00000000..59e7619d --- /dev/null +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -0,0 +1,127 @@ +/* + Gyrokinetic sheath function for 1x2v kernel. +*/ +load("modal-basis")$ +load("out-scripts")$ +load("nodal_operations/nodal_functions")$ +load("utilities_gyrokinetic")$ +load(stringproc)$ +fpprec : 24$ + +genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsX, + bMu,bX,bXMu,VarsXMu,nodesMu,nodesX,numNodesMu,numNodesX,j,i,bNMu,bNX,edge,surfPerpVal,sI,surfVarsCmu, + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_fact_e,vcut_fact_c, + phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q,vcut_fact,vcut_factX_e], + + pdim : cdim+vdim, + + /* Get desired basis. */ + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + NP : length(bP), + varsV : copylist(varsP), for d : 1 thru cdim do (varsV : delete(varsC[d],varsV)), + + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Get name of last config space dimension, which is always assumed to be + the direction parallel to the magnetic field (z). */ + surfPerpVar : varsC[cdim], + VarsX : delete(surfPerpVar, varsC), /* = x. */ + surfVarsCmu : append(VarsX, [mu]), /* = x,mu. */ + + /* Set up mu basis and perp conf + mu basis. */ + bMu : basisFromVars("ser",[mu],polyOrder), + bX : basisFromVars("ser",[x],polyOrder), + bXMu : basisFromVars("ser",surfVarsCmu,polyOrder), + + VarsXMu : append(VarsX, [mu]), /* = x,mu. */ + /* Set up surface nodes. */ + nodesMu : gaussOrdGkHyb(polyOrder+1, [], [mu]), + nodesX : gaussOrdGkHyb(polyOrder+1, VarsX, []), + + numNodesMu : length(nodesMu), + numNodesX : length(nodesX), + + /* Get nodal basis sets. */ + bNMu : getVarsNodalBasisWithNodesHyb("gkhyb", 0, 1, [mu], nodesMu), + bNX : getVarsNodalBasisWithNodesHyb("gkhyb", length(VarsX), polyOrder, VarsX, nodesX), + + /* Generate separate kernels for lower/upper boundaries. */ + edge : ["lower", "upper"], + surfPerpVal : [-1, 1], + + for sI : 1 thru length(edge) do ( + + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), + + /* Evaluate at x nodes */ + phi_q : evAtNodes(phi_e, nodesX, VarsX), + phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), + density_q : evAtNodes(density_e, nodesX, VarsX), + temperature_q : evAtNodes(temperature_e, nodesX, VarsX), + bmag_q : evAtNodes(bmag_e, nodesX, VarsX), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), + + printf(fh, " double phi_n; ~%"), + printf(fh, " double phi_wall_n; ~%"), + printf(fh, " double dens_n; ~%"), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double angle_n; ~%"), + + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + vcut_factX_e : makelist(0,i,1,numNodesX), + + for i : 1 thru numNodesX do ( + printf(fh, " // node (x)_~a ~%", i-1), + + /* Define nodal values */ + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, "~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, mass, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Expansion in mu at each (x)_i node. */ + vcut_factX_e[i] : doExpand1(vcut_fact_n, bNMu) + ), + + /* We project the mu expansion at each x node onto the x,mu basis. */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcut_factX_e, bNX)))), + vcut_fact_e : doExpand(vcut_fact_c, bX), + + /* Project expansion onto confperp + mu basis */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_fact_e))), + + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + + printf(fh, "}~%") + ) +)$ + diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac new file mode 100644 index 00000000..2f8b4dab --- /dev/null +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -0,0 +1,126 @@ +/* + Gyrokinetic sheath function for 3x2v kernel. +*/ +load("modal-basis")$ +load("out-scripts")$ +load("nodal_operations/nodal_functions")$ +load("utilities_gyrokinetic")$ +load(stringproc)$ +fpprec : 24$ + +genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, + bMu,bXY,bXYMu,VarsXYMu,nodesMu,nodesXY,numNodesMu,numNodesXY,j,i,bNMu,bNXY,edge,surfPerpVal,sI,surfVarsCmu, + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_fact_e,vcut_fact_c, + phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q,vcut_fact,vcut_factXY_e], + + pdim : cdim+vdim, + + /* Get desired basis. */ + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + NP : length(bP), + varsV : copylist(varsP), for d : 1 thru cdim do (varsV : delete(varsC[d],varsV)), + + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + /* Get name of last config space dimension, which is always assumed to be + the direction parallel to the magnetic field (z). */ + surfPerpVar : varsC[cdim], + VarsXY : delete(surfPerpVar, varsC), /* = [x, y]. */ + surfVarsCmu : append(VarsXY, [mu]), /* = [x, y, mu]. */ + + /* Set up mu basis and perp conf + mu basis. */ + bMu : basisFromVars("ser",[mu],polyOrder), + bXY : basisFromVars("ser",VarsXY,polyOrder), + bXYMu : basisFromVars("ser",surfVarsCmu,polyOrder), + + VarsXYMu : append(VarsXY, [mu]), /* = [x, y, mu]. */ + /* Set up surface nodes. */ + nodesMu : gaussOrdGkHyb(polyOrder+1, [], [mu]), + nodesXY : gaussOrdGkHyb(polyOrder+1, VarsXY, []), + + numNodesMu : length(nodesMu), + numNodesXY : length(nodesXY), + + /* Get nodal basis sets. */ + bNMu : getVarsNodalBasisWithNodesHyb("gkhyb", 0, 1, [mu], nodesMu), + bNXY : getVarsNodalBasisWithNodesHyb("gkhyb", length(VarsXY), polyOrder, VarsXY, nodesXY), + + /* Generate separate kernels for lower/upper boundaries. */ + edge : ["lower", "upper"], + surfPerpVal : [-1, 1], + + for sI : 1 thru length(edge) do ( + + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), + + /* Evaluate at perpendicular config space nodes */ + phi_q : evAtNodes(phi_e, nodesXY, VarsXY), + phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), + density_q : evAtNodes(density_e, nodesXY, VarsXY), + temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), + bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), + + printf(fh, " double phi_n; ~%"), + printf(fh, " double phi_wall_n; ~%"), + printf(fh, " double dens_n; ~%"), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double angle_n; ~%"), + + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + vcut_factXY_e : makelist(0,i,1,numNodesXY), + + for i : 1 thru numNodesXY do ( + printf(fh, " // node (x,y)_~a ~%", i-1), + + /* Define nodal values */ + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, " ~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, mass, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Expansion in mu at each perpendicular config space node. */ + vcut_factXY_e[i] : doExpand1(vcut_fact_n, bNMu) + ), + + /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcut_factXY_e, bNXY)))), + vcut_fact_e : doExpand(vcut_fact_c, bXY), + + /* Project expansion onto confperp + mu basis */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_fact_e))), + + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + + printf(fh, "}~%") + ) +)$ From 6c32acfa21a8c1f8188bda2a1a33eb075de27e98 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Mon, 16 Mar 2026 09:35:36 +0100 Subject: [PATCH 40/54] use q2Dm directly in the kernel --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 17 +++++++---------- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 4 ++-- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 4 ++-- 4 files changed, 12 insertions(+), 15 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 184a829f..14ab2d7b 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -123,7 +123,7 @@ for bInd : 1 thru length(bName) do ( /* surrogate kernels. */ for cdim : minDim_Ser thru maxDim_Ser do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", edge[sI], cdim) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", edge[sI], cdim) ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 89aa7400..610e89de 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -25,20 +25,17 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Get name of last config space dimension, which is always assumed to be the direction parallel to the magnetic field (z). */ surfPerpVar : varsC[cdim], - surfVarsC : delete(surfPerpVar, varsC), /* = x. */ - surfVarsCmu : append(surfVarsC, [mu]), /* = x,mu. */ + surfVarsC : delete(surfPerpVar, varsC), /* = [] */ + surfVarsCmu : append(surfVarsC, [mu]), /* = mu. */ /* Set up mu basis and perp conf + mu basis. */ bMu : basisFromVars("ser",[mu],polyOrder), bCperpMu : basisFromVars("ser",surfVarsCmu,polyOrder), - zvSurfVars : append(surfVarsC, [mu]), /* = x,mu. */ + zvSurfVars : append(surfVarsC, [mu]), /* = mu. */ /* Set up surface nodes. */ - if polyOrder = 1 then ( /* Force p=1 to use hybrid basis. */ - nodesMu : gaussOrdGkHyb(polyOrder+1, [], [mu]) - ) else ( - nodesMu : gaussOrd(polyOrder+1, length([mu])) - ), + /* nodesMu : gaussOrdGkHyb(polyOrder+1, [], [mu]) */ + nodesMu : gaussOrd(polyOrder+1, length([mu])), numNodesMu : length(nodesMu), /* Get nodal basis sets. */ @@ -51,7 +48,7 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Expand input fields at the sheath surface. */ phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), @@ -80,7 +77,7 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, mass, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), printf(fh, "~%") ), diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 59e7619d..2c19e81b 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -53,7 +53,7 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Expand input fields at the sheath surface. */ phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), @@ -102,7 +102,7 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, mass, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), printf(fh, "~%") ), diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index 2f8b4dab..94b9cd0e 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -53,7 +53,7 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double mass, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Expand input fields at the sheath surface. */ phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), @@ -102,7 +102,7 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, mass, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), printf(fh, "~%") ), From 910aed4e61edaa092598db014e253c441ab42f47 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Wed, 1 Apr 2026 09:33:55 -0400 Subject: [PATCH 41/54] Add kernels that use the convergence check before using the surrogate --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 7 +- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 94 ++++++------ maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 133 +++++++++-------- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 137 +++++++++--------- 4 files changed, 195 insertions(+), 176 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 14ab2d7b..1ff392de 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -121,9 +121,12 @@ for bInd : 1 thru length(bName) do ( )$ /* surrogate kernels. */ +convEval : ["", "conv_"]$ for cdim : minDim_Ser thru maxDim_Ser do ( - for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", edge[sI], cdim) + for sC : 1 thru length(convEval) do ( + for sI : 1 thru length(edge) do ( + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", convEval[sC], edge[sI], cdim) + ) ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 610e89de..0a8e787c 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -45,51 +45,57 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( edge : ["lower", "upper"], surfPerpVal : [-1, 1], - for sI : 1 thru length(edge) do ( - - printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Generate separate kernels for conv. eval or unconstrained eval of surrogate */ + convEval : ["", "conv_"], + + for sC : 1 thru length(convEval) do ( + + for sI : 1 thru length(edge) do ( - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), - - /* Define nodal values */ - printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), - printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), - printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), - printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), - printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), - printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, "~%"), - - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), - printf(fh, "~%"), - - for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), - printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), - printf(fh, "~%") - ), - - /* Reconstruct the mu modal representation via a nodal-modal conversion. */ - vcut_fact_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcut_fact_n, bNMu)), - - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), - - - printf(fh, "}~%") + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", convEval[sC], edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), + + /* Define nodal values */ + printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), + printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), + printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), + printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), + printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), + printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, "~%"), + + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_~aeval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%", convEval[sC]), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Reconstruct the mu modal representation via a nodal-modal conversion. */ + vcut_fact_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcut_fact_n, bNMu)), + + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + + + printf(fh, "}~%") + ) ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 2c19e81b..6d8f84a3 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -49,79 +49,84 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], surfPerpVal : [-1, 1], - - for sI : 1 thru length(edge) do ( - printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), - - /* Evaluate at x nodes */ - phi_q : evAtNodes(phi_e, nodesX, VarsX), - phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), - density_q : evAtNodes(density_e, nodesX, VarsX), - temperature_q : evAtNodes(temperature_e, nodesX, VarsX), - bmag_q : evAtNodes(bmag_e, nodesX, VarsX), - bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), - - printf(fh, " double phi_n; ~%"), - printf(fh, " double phi_wall_n; ~%"), - printf(fh, " double dens_n; ~%"), - printf(fh, " double temp_n; ~%"), - printf(fh, " double bmag_n; ~%"), - printf(fh, " double angle_n; ~%"), + /* Generate separate kernels for conv. eval or unconstrained eval of surrogate */ + convEval : ["", "conv_"], + + for sC : 1 thru length(convEval) do ( + for sI : 1 thru length(edge) do ( - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, "~%"), - - vcut_factX_e : makelist(0,i,1,numNodesX), - - for i : 1 thru numNodesX do ( - printf(fh, " // node (x)_~a ~%", i-1), - - /* Define nodal values */ - printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), - printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), - printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), - printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), - printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", convEval[sC], edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), + + /* Evaluate at x nodes */ + phi_q : evAtNodes(phi_e, nodesX, VarsX), + phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), + density_q : evAtNodes(density_e, nodesX, VarsX), + temperature_q : evAtNodes(temperature_e, nodesX, VarsX), + bmag_q : evAtNodes(bmag_e, nodesX, VarsX), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), + + printf(fh, " double phi_n; ~%"), + printf(fh, " double phi_wall_n; ~%"), + printf(fh, " double dens_n; ~%"), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double angle_n; ~%"), + + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), printf(fh, "~%"), - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ - for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), - printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), - printf(fh, "~%") + vcut_factX_e : makelist(0,i,1,numNodesX), + + for i : 1 thru numNodesX do ( + printf(fh, " // node (x)_~a ~%", i-1), + + /* Define nodal values */ + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, "~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_~aeval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%", convEval[sC]), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Expansion in mu at each (x)_i node. */ + vcut_factX_e[i] : doExpand1(vcut_fact_n, bNMu) ), - /* Expansion in mu at each (x)_i node. */ - vcut_factX_e[i] : doExpand1(vcut_fact_n, bNMu) - ), - - /* We project the mu expansion at each x node onto the x,mu basis. */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcut_factX_e, bNX)))), - vcut_fact_e : doExpand(vcut_fact_c, bX), + /* We project the mu expansion at each x node onto the x,mu basis. */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcut_factX_e, bNX)))), + vcut_fact_e : doExpand(vcut_fact_c, bX), - /* Project expansion onto confperp + mu basis */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_fact_e))), + /* Project expansion onto confperp + mu basis */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_fact_e))), - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), - printf(fh, "}~%") + printf(fh, "}~%") + ) ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index 94b9cd0e..e34a7bdb 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -50,77 +50,82 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( edge : ["lower", "upper"], surfPerpVal : [-1, 1], - for sI : 1 thru length(edge) do ( - - printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), - - /* Evaluate at perpendicular config space nodes */ - phi_q : evAtNodes(phi_e, nodesXY, VarsXY), - phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), - density_q : evAtNodes(density_e, nodesXY, VarsXY), - temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), - bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), - bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), - - printf(fh, " double phi_n; ~%"), - printf(fh, " double phi_wall_n; ~%"), - printf(fh, " double dens_n; ~%"), - printf(fh, " double temp_n; ~%"), - printf(fh, " double bmag_n; ~%"), - printf(fh, " double angle_n; ~%"), + /* Generate separate kernels for conv. eval or unconstrained eval of surrogate */ + convEval : ["", "conv_"], + + for sC : 1 thru length(convEval) do ( + for sI : 1 thru length(edge) do ( - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, "~%"), - - vcut_factXY_e : makelist(0,i,1,numNodesXY), - - for i : 1 thru numNodesXY do ( - printf(fh, " // node (x,y)_~a ~%", i-1), - - /* Define nodal values */ - printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), - printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), - printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), - printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), - printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), - printf(fh, " ~%"), - - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ - for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), - printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_physical_vcut_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), - printf(fh, "~%") + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", convEval[sC], edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), + + /* Evaluate at perpendicular config space nodes */ + phi_q : evAtNodes(phi_e, nodesXY, VarsXY), + phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), + density_q : evAtNodes(density_e, nodesXY, VarsXY), + temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), + bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), + + printf(fh, " double phi_n; ~%"), + printf(fh, " double phi_wall_n; ~%"), + printf(fh, " double dens_n; ~%"), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double angle_n; ~%"), + + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + vcut_factXY_e : makelist(0,i,1,numNodesXY), + + for i : 1 thru numNodesXY do ( + printf(fh, " // node (x,y)_~a ~%", i-1), + + /* Define nodal values */ + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, " ~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_~aeval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%", convEval[sC]), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Expansion in mu at each perpendicular config space node. */ + vcut_factXY_e[i] : doExpand1(vcut_fact_n, bNMu) ), - /* Expansion in mu at each perpendicular config space node. */ - vcut_factXY_e[i] : doExpand1(vcut_fact_n, bNMu) - ), - - /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcut_factXY_e, bNXY)))), - vcut_fact_e : doExpand(vcut_fact_c, bXY), + /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcut_factXY_e, bNXY)))), + vcut_fact_e : doExpand(vcut_fact_c, bXY), - /* Project expansion onto confperp + mu basis */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_fact_e))), + /* Project expansion onto confperp + mu basis */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_fact_e))), - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), - printf(fh, "}~%") + printf(fh, "}~%") + ) ) )$ From d6af53bb1cae26cba522535320edc1c972c486f1 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 28 May 2026 17:26:03 -0400 Subject: [PATCH 42/54] restore collisionless kernel to main, EM sneaked in --- maxima/g0/gk_collisionless/dg_gk-surf.mac | 5 +- maxima/g0/gk_collisionless/dg_gk-vol.mac | 440 ++---------------- .../gk_collisionless_flux-surf-conf.mac | 94 +--- .../gk_collisionless_flux-surf-vpar.mac | 172 ++----- .../ms-dg_gyrokinetic-header.mac | 26 +- .../ms-dg_gyrokinetic-surf.mac | 11 +- .../ms-dg_gyrokinetic-vol.mac | 25 +- .../ms-gk_collisionless_flux-header.mac | 139 +++--- .../ms-gk_collisionless_flux.mac | 138 ++---- maxima/g0/gk_collisionless/verify_no_leak.mac | 21 - 10 files changed, 208 insertions(+), 863 deletions(-) delete mode 100644 maxima/g0/gk_collisionless/verify_no_leak.mac diff --git a/maxima/g0/gk_collisionless/dg_gk-surf.mac b/maxima/g0/gk_collisionless/dg_gk-surf.mac index d8d97ea6..77901135 100644 --- a/maxima/g0/gk_collisionless/dg_gk-surf.mac +++ b/maxima/g0/gk_collisionless/dg_gk-surf.mac @@ -26,7 +26,7 @@ calcGKSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, vars BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, hamil_e,alphaSurfL_e,alphaSurfR_e, fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - fnodal_l_e,fnodal_r_e,fmodproj_e,numC,vmap_prime_fac_l,vmap_prime_fac_c,vmap_prime_fac_r,vmap_prime_e,basisNodal,i], + fnodal_l_e, fnodal_r_e, fmodproj_e], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, @@ -143,8 +143,7 @@ calcGKBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrd rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, - fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - numC,vmap_prime_fac_edge,vmap_prime_fac_skin,vmap_prime_e,basisNodal,i,fnodal_l_e,fnodal_r_e,fmodproj_e], + fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 93e42e7c..01905ad3 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -11,22 +11,18 @@ load("utilities")$ fpprec : 24$ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,vmap_e,BstardBmag_e, + [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, - dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, - replaceList,dvparSimp,phi_e,bmag_e,dualcurlbhatoverB_x_e,dualcurlbhatoverB_y_e,dualcurlbhatoverB_z_e, - rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,dualcurlbhatoverB_list,bioverJB_list, - vmapSq_e,vmap_prime_e,hamilCvar,hamilNoZero_c,hamil_c,vpardim,i,k,curvdriftdir,clst], + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], kill(varsC,varsP,bC,bP), - pdim : cdim+vdim, + pDim : cdim+vdim, [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), numC : length(bC), numP : length(bP), - varLabel : makelist(string(varsP[d]),d,1,pdim), + varLabel : makelist(string(varsP[d]),d,1,pDim), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, @@ -45,19 +41,19 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "~%"), /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pdim do ( + for d : 1 thru pDim do ( printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) ), printf(fh, "~%"), rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), printf(fh, "~%"), replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pdim), + dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), [dvparSq=4/rdvpar2Sq]), /* Create pointers to the components of b_i. */ @@ -114,9 +110,9 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := Jf_e : doExpand1(fin,bP), /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pdim-1, - if vdim = 1 then ( vpardim : pdim ), - dH_dz_e : makelist(0, i, 1, pdim), + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_e : makelist(0, i, 1, pDim), for i : 1 thru vpardim do ( if i = vpardim then ( dH_dz_e[i] : diff(hamil_e,varsP[i]) @@ -159,25 +155,21 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := dirVar : varsP[dir], /* Variable in current direction. */ if dir = cdim then ( - alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ /* Contribution from B_0 . dH/dvpar . ∇ψ in z*/ + alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ ) else if dir = vpardim then ( - alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ /* Contribution from B_0 . ∇H . dψ/dvpar in z */ + alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ ) else ( - alpha_e : 0 /* all other B_0 contributions are 0 since B_0_x,y = 0 */ + alpha_e : 0 ), if no_by = false then ( - - /* Add curvature drift terms (m vpar/q * ∇ x b)/mB = (m vpar * (∇ x b)/B)/qm */ if cdim = 3 then ( - /* Sum each directions */ curvdriftdir : dir ), if cdim = 2 then ( - /* Select only x and z */ if dir = 1 then ( curvdriftdir : dir ), @@ -186,28 +178,12 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := ) ), if cdim = 1 then ( - /* Select z */ curvdriftdir : 3 ), + if dir < vpardim then ( - /* Config space contributions ( curv drift * dH/dvpar . ∇ψ ) */ - alpha_e : alpha_e + mvpar_e*dualcurlbhatoverB_list[curvdriftdir] * dH_dz_e[vpardim]/vmap_prime_e[1] / (q_*m_) - ) else ( - /* Vpar contribution ( curv drift . ∇H * dψ/dvpar )*/ - if cdim = 3 then ( - for k : 1 thru cdim do ( - alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[k]*dH_dz_e[k]/(q_*m_) - ) - ), - if cdim = 2 then ( - alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[1] * dH_dz_e[1]/(q_*m_) - mvpar_e*dualcurlbhatoverB_list[3] * dH_dz_e[2]/(q_*m_) - ), - if cdim = 1 then ( - alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[3] * dH_dz_e[1]/(q_*m_) - ) + alpha_e : alpha_e + dualcurlbhatoverB_list[curvdriftdir]*dH_dz_e[vpardim]/vmap_prime_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/m_/q_ ), - - /* Add b x ∇H / qB term (only in configuration space) */ if cdim = 3 then ( if dir = 1 then ( alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[3] - bioverJB_list[3]*dH_dz_e[2]) @@ -226,13 +202,27 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := if dir = 2 then ( alpha_e : alpha_e - 1/q_ * (bioverJB_list[2]*dH_dz_e[1]) ) + ), + if dir = vpardim then ( + if cdim = 3 then ( + for k : 1 thru cdim do ( + alpha_e : alpha_e - dualcurlbhatoverB_list[k]*dH_dz_e[k]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ) + ), + if cdim = 2 then ( + alpha_e : alpha_e - dualcurlbhatoverB_list[1]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - dualcurlbhatoverB_list[3]*dH_dz_e[2]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ), + if cdim = 1 then ( + alpha_e : alpha_e - dualcurlbhatoverB_list[3]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ) ) + ), if dir < vpardim then ( alpha_e : alpha_e*rdx2vec[dir] ) - else ( + else if dir = vpardim then ( alpha_e : alpha_e/vmap_prime_e[1] ), @@ -245,7 +235,7 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := alpha_c : subst(dvparSimp, alpha_c), alphaLabel : eval_string(sconcat(alpha, dirLabel)), clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], writeCExprsCollect1(alphaLabel, alpha_c, clst), printf(fh, "~%"), flush_output(fh), @@ -267,369 +257,3 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "} ~%") )$ - -addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, - replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e,dim_idx_list, xidx, yidx, zidx, vidx, - replaceList,dvparSimp,phi_e,bmag_e,rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,bioverJB_list, - dualcurlbhatoverB_x_e,dualcurlbhatoverB_y_e,dualcurlbhatoverB_z_e, dH_dx, dH_dy, dH_dz, dH_dvpar, gradH_vec, - vmapSq_e,vmap_prime_e,hamil_c,hamilCvar,hamilNoZero_c,vpardim,i,k,Apar_e, dA_dx, dA_dy, dA_dz, gradA_vec, - rotAbovermB_x,rotAbovermB_y,rotAbovermB_z,rotAbovermB_list, gradAxbhatoverB_x,gradAxbhatoverB_y,gradAxbhatoverB_z,gradAxbhatoverB_vec, - curvdriftdir,clst], - - kill(varsC,varsP,bC,bP), - pdim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - varLabel : makelist(string(varsP[d]),d,1,pdim), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, - const double q_, const double m_, const double *bmag, const double *jacobtot_inv, const double *dualcurlbhatoverB, const double *bioverJB, - const double *b_i, const double *phi, const double *apar, const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // jacobtot_inv: reciprocal of the conf-space jacobian time the guiding center coordinate Jacobian.~%"), - printf(fh, " // dualcurlbhatoverB: dual curl of bhat over B.~%"), - printf(fh, " // bioverJB: b_i over J times B.~%"), - printf(fh, " // b_i: covariant components of the field aligned unit vector.~%"), - printf(fh, " // apar: parallel component of magnetic vector potential.~%"), - printf(fh, " // phi: electrostatic potential .~%"), - printf(fh, " // fin: Distribution function.~%"), - printf(fh, " // out: output increment.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pdim do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), - - /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ - /* printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), */ - /* printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), */ - printf(fh, "~%"), - replaceList : [rdx^2=dx2Sq, rdy^2=dy2Sq, rdz^2=dx2Sq, rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pdim), - [dvparSq=4/rdvpar2Sq]), - - /* Store indices of the coordinate directions. */ - if cdim = 3 then ( - xidx : 1, yidx : 2, zidx : 3, vidx : 4 - ) else if cdim = 2 then ( - xidx : 1, zidx : 2, vidx : 3 - ) else if cdim = 1 then ( - zidx : 1, vidx : 2 - ), - - /* Create pointers to the components of b_i. */ - allVarLabelsC : ["x","y","z"], - for d : 1 thru 3 do ( - printf(fh, " const double *b_~a = &b_i[~a];~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - for d : 1 thru 3 do ( - printf(fh, " const double *bioverJB_~a = &bioverJB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - /* Create pointers to the components of dualcurlbhatoverB. */ - for d : 1 thru 3 do ( - printf(fh, " const double *dualcurlbhatoverB_~a = &dualcurlbhatoverB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmag_e : doExpand1(bmag, bmagBasis), - rtg33inv_e : doExpand1(rtg33inv, bmagBasis), - dualcurlbhatoverB_x_e : doExpand1(dualcurlbhatoverB_x, bmagBasis), - dualcurlbhatoverB_y_e : doExpand1(dualcurlbhatoverB_y, bmagBasis), - dualcurlbhatoverB_z_e : doExpand1(dualcurlbhatoverB_z, bmagBasis), - bioverJB_x_e : doExpand1(bioverJB_x, bmagBasis), - bioverJB_y_e : doExpand1(bioverJB_y, bmagBasis), - bioverJB_z_e : doExpand1(bioverJB_z, bmagBasis), - b_x_e : doExpand1(b_x, bmagBasis), - b_y_e : doExpand1(b_y, bmagBasis), - if (no_by or cdim = 1) then (b_y_e : 0), - b_z_e : doExpand1(b_z, bmagBasis), - jacobTotInv_e : doExpand1(jacobtot_inv, bmagBasis), - - dualcurlbhatoverB_list : [dualcurlbhatoverB_x_e, dualcurlbhatoverB_y_e, dualcurlbhatoverB_z_e], - bioverJB_list : [bioverJB_x_e, bioverJB_y_e, bioverJB_z_e], - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - /* Write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, rdy2^2=rdy2Sq, rdz2^2=rdz2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - - /*Expand Jf*/ - Jf_e : doExpand1(fin,bP), - - /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pdim-1, - if vdim = 1 then ( vpardim : pdim ), - dH_dz_e : makelist(0, i, 1, pdim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_e[i] : diff(hamil_e,varsP[i]) - ) - else ( - dH_dz_e[i] : diff(hamil_e*rdx2vec[i],varsP[i]) - ) - ), - dH_dvpar : diff(hamil_e,varsP[vpardim])/vmap_prime_e[1], /* We do not multply by rdv2vec because it is inside vmap_prime */ - if cdim = 3 then ( - dH_dx : diff(hamil_e*rdx2vec[xidx],varsP[xidx]), - dH_dy : diff(hamil_e*rdx2vec[yidx],varsP[yidx]), - dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), - gradH_vec : [dH_dx, dH_dy, dH_dz, dH_dvpar] - ) else if cdim = 2 then ( - dH_dx : diff(hamil_e*rdx2vec[xidx],varsP[xidx]), - dH_dy : 0, - dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), - gradH_vec : [dH_dx, dH_dz, dH_dvpar] - ) else if cdim = 1 then ( - dH_dx : 0, - dH_dy : 0, - dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), - gradH_vec : [dH_dz, dH_dvpar] - ), - - /*Make sure to avoid having hamil[i]^2 or vmap[i]^2 in expressions*/ - replaceListVpar : [vmap[1]^2=vmap2], - printf(fh, " double vmap2 = vmap[1]*vmap[1]; ~%"), - printf(fh, "~%"), - - mvpar_e : dH_dz_e[vpardim]/vmap_prime_e[1], - mvparsq_e : mvpar_e*mvpar_e/m_, - isqlist : [], - for i : 1 thru numP do ( - if freeof(hamil[i]^2, expand(mvparsq_e)) = false then ( - isqlist : append(isqlist,[i]) - ) - ), - - replaceListHamil : [], - printf(fh, " double hamil2[~a] = {0.}; ~%", length(isqlist)), - for i : 1 thru length(isqlist) do ( - printf(fh, " hamil2[~a] = hamil[~a]*hamil[~a]; ~%", i-1, isqlist[i], isqlist[i]), - replaceListHamil : append(replaceListHamil, [hamil[isqlist[i]]^2=hamil2[i-1]]) - ), - printf(fh, "~%"), - - /* Expand Apar.*/ - /* Apar_e : subst(y=0, doExpand1(apar,bC)), */ - Apar_e : doExpand1(apar,bC), - - /* Expand dBperp/Bmag. */ - /* Direct method ∇ x (Apar bhat) */ - rotAbovermB_x : (rdy2*diff(Apar_e*b_z_e,y) - rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e/m_, - rotAbovermB_y : (rdz2*diff(Apar_e*b_x_e,z) - rdx2*diff(Apar_e*b_z_e,x))*jacobTotInv_e/m_, - rotAbovermB_z : (rdx2*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y))*jacobTotInv_e/m_, - rotAbovermB_list : [rotAbovermB_x, rotAbovermB_y, rotAbovermB_z], - - /* Product rule method Apar ∇ x bhat + ∇Apar x bhat. */ - /* Calculate ∇Apar in a list */ - if cdim = 3 then ( - dA_dx : diff(Apar_e*rdx2vec[xidx],varsC[xidx]), - dA_dy : diff(Apar_e*rdx2vec[yidx],varsC[yidx]), - dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), - gradA_vec : [dA_dx, dA_dy, dA_dz] - ) else if cdim = 2 then ( - dA_dx : diff(Apar_e*rdx2vec[xidx],varsC[xidx]), - dA_dy : 0, - dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), - gradA_vec : [dA_dx, dA_dz] - ) else if cdim = 1 then ( - dA_dx : 0, - dA_dy : 0, - dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), - gradA_vec : [dA_dz] - ), - - /* Use bioverJB to calculate ∇Apar x b / B in a list */ - if cdim = 3 then ( - gradAxbhatoverB_x : gradA_vec[yidx]*bioverJB_list[3] - gradA_vec[zidx]*bioverJB_list[2], - gradAxbhatoverB_y : gradA_vec[zidx]*bioverJB_list[1] - gradA_vec[xidx]*bioverJB_list[3], - gradAxbhatoverB_z : gradA_vec[xidx]*bioverJB_list[2] - gradA_vec[yidx]*bioverJB_list[1], - gradAxbhatoverB_vec : [gradAxbhatoverB_x, gradAxbhatoverB_y, gradAxbhatoverB_z] - ) else if cdim = 2 then ( - gradAxbhatoverB_x : -gradA_vec[zidx]*bioverJB_list[2], - gradAxbhatoverB_y : 0, - gradAxbhatoverB_z : +gradA_vec[xidx]*bioverJB_list[2], - gradAxbhatoverB_vec : [gradAxbhatoverB_x, gradAxbhatoverB_z] - ) else if cdim = 1 then ( - gradAxbhatoverB_x : 0, - gradAxbhatoverB_y : 0, - gradAxbhatoverB_z : 0, - gradAxbhatoverB_vec : [gradAxbhatoverB_z] - ), - - dim_idx_list : [3, 1, 2], - - /* Note: no contribution from mu. */ - for dir : 1 thru cdim+1 do ( - - dirLabel : varLabel[dir], - - wDir : eval_string(sconcat("w",dirLabel)), - rdDirVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - dirVar : varsP[dir], /* Variable in current direction. */ - - alpha_e : 0, - - if no_by = false then ( - if dir < vpardim then ( /* Config space contributions ( curv drift * dH/dvpar . ∇ψ ) */ - list_idx : dim_idx_list[dir], - /* This is [Apar . (∇ x b)/B + ∇Apar x b/B]/m dH/dvpar . ∇ψ */ - alpha_e : alpha_e + 1/m_ * Apar_e * dualcurlbhatoverB_list[list_idx] * gradH_vec[vpardim], - /* This term is responsible of y oscillations in the Alfven 3x2v regression test. */ - /* The oscillation builds up at longer time (not observable at frame 1). */ - alpha_e : alpha_e + 1/m_ * gradAxbhatoverB_vec[dir] * gradH_vec[vpardim], - /* basis function gradient ∇ψ factor */ - alpha_e : alpha_e*rdx2vec[dir] - ) else ( /* Vpar contribution ( curv drift . ∇H * dψ/dvpar )*/ - for k : 1 thru cdim do ( - list_idx : dim_idx_list[k], - /* this is [Apar . (∇ x b)/B]/m . ∇H * dψ/dvpar */ - alpha_e : alpha_e - 1/m_ * (Apar_e * dualcurlbhatoverB_list[list_idx]) * gradH_vec[k], - /* this is [∇Apar x b/B]/m . ∇H * dψ/dvpar */ - alpha_e : alpha_e - 1/m_ * gradAxbhatoverB_vec[k] * gradH_vec[k] - ), - /* basis function gradient dψ/dvpar factor */ - alpha_e : alpha_e/vmap_prime_e[1] - ) - ), - - /* Project alpha on basis and write to array. */ - printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), - alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), - alpha_c : subst(replaceList, alpha_c), - alpha_c : subst(replaceListHamil, alpha_c), - alpha_c : subst(replaceListVpar, alpha_c), - alpha_c : subst(dvparSimp, alpha_c), - alphaLabel : eval_string(sconcat(alpha, dirLabel)), - clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], - writeCExprsCollect1(alphaLabel, alpha_c, clst), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), - alpha_e : doExpand(alphaNoZero_c, bP), - - alphaJf_e : alpha_e*Jf_e, - - printf(fh, "~%"), - volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), - volTerm_c : subst(replaceList, volTerm_c), - writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), - flush_output(fh), - printf(fh, "~%") - - ), - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") - -)$ - -addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,vpardir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, - alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, - vmapSq_e,vmap_prime_e,apardot_e,clst], - - kill(varsC,varsP,bC,bP), - pdim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - varLabel : makelist(string(varsP[d]),d,1,pdim), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *vmap, const double q_, const double m_, const double *apardot, - const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // apardot: time derivative of parallel component of magnetic vector potential.~%"), - printf(fh, " // fin: Distribution function.~%"), - printf(fh, " // out: output increment.~%"), - printf(fh, "~%"), - - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), - - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - /*Expand Jf*/ - Jf_e : doExpand1(fin,bP), - - /* Expand Apardot */ - apardot_e : doExpand1(apardot,bC), - - /* Note: only a vpar contribution. */ - vpardir : cdim+1, - dirLabel : varLabel[vpardir], - - alpha_e : -q_/m_ * apardot_e /vmap_prime_e[1], - - /* Project alpha on basis and write to array. */ - printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), - alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), - alphaLabel : eval_string(sconcat(alpha, dirLabel)), - clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], - writeCExprsCollect1(alphaLabel, alpha_c, clst), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), - alpha_e : doExpand(alphaNoZero_c, bP), - - alphaJf_e : alpha_e*Jf_e, - - printf(fh, "~%"), - volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[vpardir]), alphaJf_e)), - writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), - flush_output(fh), - printf(fh, "~%"), - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") - -)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index dcc33e8e..34e06ea7 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -6,15 +6,13 @@ load("utilities_gyrokinetic")$ load("nodal_operations/nodal_functions")$ fpprec : 24$ -buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound, scheme) := block( +buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, - numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,apar_e, - bmagSurf_e,vmap_e,vmapSq_e, + numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, - surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_nodes,apar_c,dA_dx_nodes + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL ], kill(varsC,varsP,bC,bP), @@ -62,8 +60,7 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b const double *w, const double *dxv, const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *apardot, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), @@ -76,8 +73,6 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // apardot: time derivative of parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -125,7 +120,7 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : doExpand(hamilNoZero_c, bSurf), + hamil_e : hamilNoZero_c . bSurf, /* fl and fr */ JfL_e : doExpand1(JfL, bP), @@ -190,23 +185,6 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b di3 : false ), - /* Expand Aparallel. */ - apar_e : doExpand1(apar,bC), - apar_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,apar_e)), - /* printf(fh, " double apar[~a] = {0.}; ~%", numP), */ - aparCvar : eval_string(sconcat("apar")), - apar_c : makelistNoZeros1(apar_c, aparCvar), - /* Expand projected Apar on basis. */ - apar_e : doExpand(apar_c, bSurf), - /* Eval Aparallel at nodes. */ - apar_nodes : float(evAtNodes(apar_e,surfNodes,surfIntVars)), - /* Compute gradient of Aparallel */ - dA_dx_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ), - /* It will be used to compute the contribution as ∇ x (A b) = ∇A x b + A ∇ x b */ - /* Now calculate flux at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), @@ -251,8 +229,6 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b vparindex : mod(j-1, numVparNodes) + 1, vpar0index : mod(j-1, numVparNodes), printf(fh, "~%"), - - /* Electrostatic term */ if no_by = true then ( if di3 = true then ( printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) @@ -260,7 +236,8 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b else ( printf(fh, " alpha_quad = 0.0; ~%") ) - ) else ( + ), + if no_by = false then ( /*printf(fh, " alpha_quad += mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) ;~%", vpar0index),*/ if cdim = 3 then ( if surfDir = 1 then( @@ -283,60 +260,33 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b ), if cdim = 1 then ( printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) - ), - - if em = true then ( - /* Electromagnetic Apar contribution curl(Apar b) = grad(Apar) x b + Apar curl(b)*/ - /* No contribution for cdim = 1 */ - if cdim > 1 then ( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]) - ), - /* grad(Aparallel) x b contribution*/ - if cdim = 3 then ( - if surfDir = 1 then( - /* This term is responsible of y oscillations in the Alfven 3x2v regression test. */ - /* The oscillation appears at short time (observable frame 1). */ - printf(fh, " alpha_quad += 0*mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) - ), - if surfDir = 3 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) - ) - ), - if cdim = 2 then ( - if surfDir = 1 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) - ) - ) ) ), printf(fh, "~%"), + /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), - if scheme = "upwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ) else if scheme = "central" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) - ) else if scheme = "downwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ) else ( - /* Stop the script if an invalid scheme is provided. */ - error("Invalid flux scheme provided. Options are: upwind, central, downwind.") - ) + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) ), printf(fh, "~%") ), + /* Do the quad nodal to modal ops directly here*/ + /*printf(fh, "~%"), + printf(fh, " double *fmodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), + flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), + fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), + + for i : 1 thru length(fmodproj_e) do ( + printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) + ), + + printf(fh, "~%"),*/ + /*Calculate the cfl*/ pOrderCFL : polyOrder, printf(fh, "~%"), @@ -346,4 +296,4 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 8bcccdd0..a172abb2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -5,14 +5,13 @@ load("scifac")$ load("utilities_gyrokinetic")$ fpprec : 24$ -buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, add_apardot, scheme) := block( +buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_nodes,dA_dx_nodes,k, - apardot_e,apardot_nodes + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr ], kill(varsC,varsP,bC,bP), @@ -58,17 +57,18 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b NSurfIndexing : length(tempBasis), numNodesIndexing : length(tempBasis) ) else ( - error("Only p=1 is currently supported for the surfvpar kernels.") + NSurfIndexing : NSurf, + numNodesIndexing : numNodes ), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), @@ -79,8 +79,6 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), printf(fh, " // bmag: magnetic field amplitude.~%"), printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // apardot: time derivative of parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -129,18 +127,9 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : doExpand(hamilNoZero_c,bP), + hamil_e : hamilNoZero_c . bP, /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ - /* Expand Apar */ - apar_e : doExpand1(apar, bC), - apar_nodes : float(evAtNodes(apar_e,configNodes,surf_cvars)), - /* Compute gradient of Aparallel */ - dA_dx_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsC[i]),configNodes,surf_cvars)) - ), - /*fl and fr */ JfL_e : doExpand1(JfL, bP), JfR_e : doExpand1(JfR, bP), @@ -168,7 +157,7 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b ) ), - /* Now calculate alpha at all quadrature nodes */ + /* Now calculate apha at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), printf(fh, " double cfl = 0.0; ~%"), @@ -176,114 +165,44 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " double B3_quad = 0.0; ~%"), printf(fh, " double Jc_quad = 0.0; ~%"), printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), + printf(fh, " double alpha_quad = 0.0; ~%"), printf(fh, " double JfL_quad = 0.0; ~%"), printf(fh, " double JfR_quad = 0.0; ~%"), printf(fh, " double Jfavg_quad = 0.0; ~%"), printf(fh, " double Jfjump_quad = 0.0; ~%"), - if em = true then ( - printf(fh, " double m_bmag_inv = 0.0; ~%"), - printf(fh, " double mvpar_over_q = 0.0; ~%"), - printf(fh, " double g_13 = 0.0; ~%"), - printf(fh, " double g_23 = 0.0; ~%"), - printf(fh, " double g_33 = 0.0; ~%"), - printf(fh, " double mag_e_3 = 0.0; ~%") - ), printf(fh, "~%"), for i : 1 thru numConfigNodes do ( - i0index : i-1, - i1index : i, - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i0index), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i0index), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i0index), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i0index), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i0index), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i0index), - - if em = true then ( - printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), - /* - We develop the component grad(Apar) x b as - e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| - which gives - coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 - coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 - coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 - with - coeff = Jc/sqrt(g_33) - */ - printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), - printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), - printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), - printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1) - ), - + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + printf(fh, "~%"), for j : 1 thru numVelNodes do ( j0index : j-1+(i-1)*numVelNodes, j1index : j+(i-1)*numVelNodes, printf(fh, "~%"), - /* printf(fh, " mvpar_over_q = (~a)/q_; ~%", dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), */ - if no_by = true then ( - /* Start ES term */ printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) ), if no_by = false then ( - /* Start ES term */ printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), - if cdim = 3 then ( - /* Finish ES term */ - for k : 1 thru cdim do ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - printf(fh, ";~%"), - if em = true then ( - /* EM term curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - for k : 1 thru cdim do ( - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[i1index], k-1) - ), - /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index], dA_dx_nodes[3][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][i1index], dA_dx_nodes[1][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][i1index], dA_dx_nodes[2][i1index]) - ) - ), - if cdim = 2 then ( - /* Finish ES term */ - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, ";~%"), - if em = true then ( - /* EM term curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 0), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[i1index], 2), - /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][i1index]) - ) - ), - if cdim = 1 then ( - /* Finish ES term */ - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, ";~%"), - if em = true then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 2) - /* grad(Apar) x b */ - /* none */ - ) - ) - ), - - /* Add apardot contribution if requested */ - if add_apardot = true then ( - apardot_e : doExpand1(apardot, bC), - apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)), - printf(fh, " alpha_quad += -q_/m_*(~a); ~%", apardot_nodes[i1index]) + if cdim = 3 then ( + for k : 1 thru cdim do ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ) + ), + if cdim = 2 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + if cdim = 1 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + printf(fh, ";~%") ), printf(fh, "~%"), @@ -292,21 +211,22 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - if scheme = "upwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ) else if scheme = "central" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) - ) else if scheme = "downwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ) else ( - /* Stop the script if an invalid scheme is provided. */ - error("Invalid flux scheme provided. Options are: upwind, central, downwind.") - ) + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) ), printf(fh, "~%") ), - printf(fh, "~%"), + /* Do the quad nodal to modal ops directly here*/ + /*printf(fh, "~%"), + printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), + fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), + + for i : 1 thru length(fmodproj_e) do ( + printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) + ), + + printf(fh, "~%"),*/ /*Calculate the cfl*/ pOrderCFL : polyOrder, if polyOrder=1 then ( pOrderCFL : 2 ), @@ -319,4 +239,4 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 06c9a6de..08e41563 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -2,9 +2,6 @@ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ @@ -89,31 +86,10 @@ printPrototypes() := block([], ) ) ) - ), - /* EM terms */ - for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apar_vol_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const double *bmag, const double *jacobtot_inv, const double *dualcurlbhatoverB, const double *bioverJB, - const double *b_i, const double *phi, const double *apar, - const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apardot_vol_~ax~av_~a_p~a(const double *vmap, const double q_, const double m_, - const double *apardot, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "~%") - ) - ) - ) ) )$ -fh : openw(sconcat(outputDir, "gkyl_dg_gyrokinetic_kernels.h"))$ +fh : openw("~/max-out/gkyl_dg_gyrokinetic_kernels.h")$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac index f8dc8b49..18f5db41 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac @@ -9,9 +9,6 @@ load("gk_collisionless/dg_gk-surf")$ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -63,7 +60,7 @@ for bInd : 1 thru length(bName) do ( for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( for dir : 1 thru c do ( /* Advection in configuration space.*/ - fname : sconcat(outputDir,"dg_gyrokinetic_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -73,7 +70,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Advection in configuration space in the skin cell (for boundary flux operations) .*/ - fname : sconcat(outputDir,"dg_gyrokinetic_boundary_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_boundary_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -84,7 +81,7 @@ for bInd : 1 thru length(bName) do ( ), /* Advection in velocity space.*/ - fname : sconcat(outputDir,"dg_gyrokinetic_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -94,7 +91,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Advection in velocity space in the skin cell along vpar (for zero-flux BCs).*/ - fname : sconcat(outputDir,"dg_gyrokinetic_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index 965586ee..ef0b8a40 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -7,9 +7,6 @@ load("gk_collisionless/dg_gk-vol")$ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -47,35 +44,19 @@ for bInd : 1 thru length(bName) do ( maxPolyOrderB : maxPolyOrder[bInd], if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - fname : sconcat(outputDir,"dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file: ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), + funcName : sconcat("dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), close(fh), - /* Add em kernels */ - fname : sconcat(outputDir,"dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file (add em): ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - addAparGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), - close(fh), - - fname : sconcat(outputDir,"dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file (add em): ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - addApardotGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), - close(fh), - /* if cdim > 1, also generate a set of kernels for the case where there is no toroidal field (by = 0) */ if (c > 1) then ( - fname : sconcat(outputDir,"dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file (no by): ~a",fname)), fh : openw(fname), diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index 7b35759d..ebef045a 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -2,11 +2,8 @@ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ -maxPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ minVdim_Ser : 1$ maxCdim_Ser : 3$ @@ -46,84 +43,70 @@ byStr : ["", "no_by_"]$ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -emStr : ["", "em_", "em_star_"]$ - -/* Options for writing kernels at surface and edge surfaces. */ -edgeBool : [false, true]$ -edgeOpt : ["surf", "edge_surf"]$ - printPrototypes() := block([], - for emI : 1 thru 3 do ( - em_label : emStr[emI], - - for bInd : 1 thru length(bName) do ( - - for c : minCdim[bInd] thru maxCdim[bInd] do ( - - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - - for byI : 1 thru length(byOpt[c]) do ( - no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - - for edgeI : 1 thru 2 do ( - edge : edgeBool[edgeI], - edgeStr : edgeOpt[edgeI], - - funcName : sconcat("gk_collisionless_flux_",em_label,no_byStr,mb_boundStr,edgeStr,dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName) - ) - ) - ), - - dirlabel : varsV[1], - edgeStr : edgeOpt[1], - edge : false, - funcName : sconcat("gk_collisionless_flux_",em_label,no_byStr,edgeStr,dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName), - - printf(fh, "~%") - ) - ) - ) - ) + for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + + for byI : 1 thru length(byOpt[c]) do ( + no_by : byOpt[c][byI], + no_byStr : byStr[byI], + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ) + ), + + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ), + + printf(fh, "~%") + ) + ) ) - ), - - printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf);~%") + ) )$ -fh : openw(sconcat(outputDir,"gkyl_gk_collisionless_flux_kernels.h"))$ +fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels.h")$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 8120b8e5..25581b85 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -8,9 +8,6 @@ load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -43,127 +40,66 @@ vlabels : ["vpar","mu"]$ byOpt : [[false], [false, true], [false, true]]$ byStr : ["", "no_by_"]$ -/* Options for writing electromagnetic and electrostatic kernels. */ -emBool : [false, true]$ -emOpt : ["", "em_"]$ - /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -/* Options for writing kernels at surface and edge surfaces. */ -edgeBool : [false, true]$ -edgeOpt : ["surf", "edge_surf"]$ - /* Generate kernels of selected types. */ for bInd : 1 thru length(bName) do ( - bStr : bName[bInd], - /* Loop over configuration space dimensions. */ for c : minCdim[bInd] thru maxCdim[bInd] do ( - /* Loop over velocity space dimensions. */ for gkV : 1 thru length(gkVdims[c]) do ( v : gkVdims[c][gkV], + maxPolyOrderB : maxPolyOrder[bInd], if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - /* Loop over polynomial order. */ - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - /* With/without toroidal field loop. */ + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], no_byStr : byStr[byI], - /* Electrostatic/electromagnetic loop. */ - for emI : 1 thru length(emOpt) do ( - em : emBool[emI], - emStr : emOpt[emI], - - /* Singleblock/multiblock loop. */ - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - /* Configuration space surface direction loop. */ - for dir : 1 thru c do ( - dirStr : clabels[dir], - - /* Surface/edge surface loop. */ - for edgeI : 1 thru length(edgeBool) do ( - edge : edgeBool[edgeI], - edgeStr : edgeOpt[edgeI], - - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, scheme), - close(fh), - - if (em) then ( - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, scheme), - close(fh) - ) - ) - ), - - /* Surface flux in vparallel direction (no edge).*/ - dirStr : vlabels[1], - edge : false, - edgeStr : edgeOpt[1], - add_apardot : em, /* Add apardot term if EM. */ - - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + /* Surface flux in direction dir in configuration space.*/ + for dir : 1 thru c do ( + + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, scheme), + + funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), close(fh), - - if (em) then ( - /* Add EM terms but not Apardot (star term) */ - add_apardot : false, - - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar file: ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, scheme), - close(fh) - ) + + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), + close(fh) ) - ) + ), + + /* Surface flux in vparallel direction.*/ + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxVparESKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false), + close(fh) ) ) ) ) )$ - -/* Generate the return zero kernel */ -fname : sconcat(outputDir,"gk_collisionless_flux_surf_return_zero.c")$ -disp(printf(false,"Creating return zero kernel file: ~a",fname))$ -fh : openw(fname)$ -printf(fh, "#include ~%")$ -printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surf_return_zero(~%")$ -printf(fh, " const double *w, const double *dxv,~%")$ -printf(fh, " const double *vmap, const double *vmapSq, const double q_, const double m_,~%")$ -printf(fh, " const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ~%")$ -printf(fh, " const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, ~%")$ -printf(fh, " const double *phi, const double *apar, const double *apardot, ~%")$ -printf(fh, " const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%")$ -printf(fh, "{ ~%")$ -printf(fh, " return 0.0; ~%")$ -printf(fh, "}~%")$ -close(fh)$ diff --git a/maxima/g0/gk_collisionless/verify_no_leak.mac b/maxima/g0/gk_collisionless/verify_no_leak.mac deleted file mode 100644 index 90621efd..00000000 --- a/maxima/g0/gk_collisionless/verify_no_leak.mac +++ /dev/null @@ -1,21 +0,0 @@ -kill(all)$ -/* load("dg_gk-vol.mac")$ */ -/* load("nodal_operations/node_locations")$ */ -/* load(stringproc)$ */ -/* fpprec : 24$ */ -/* load("eigen")$ */ - -/* values()$ */ -/* print(values)$ */ - -load("modal-basis")$ - -vars : [z,v,m]$ -n : 1$ -basis : makeSerendipBasis(vars, n)$ - -print("Serendipity basis:")$ -for i : 1 thru length(basis) do ( - printf(true, " basis[~a] = ~a~%", i, basis[i]) -)$ - From f7ce0fae1fac3e2112815584b116c6d94133f40c Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 28 May 2026 17:26:34 -0400 Subject: [PATCH 43/54] restore collisionless kernel to main, EM sneaked in --- maxima/g0/gk_collisionless/dg_gk-surf.mac | 5 +- maxima/g0/gk_collisionless/dg_gk-vol.mac | 440 ++---------------- .../gk_collisionless_flux-surf-conf.mac | 94 +--- .../gk_collisionless_flux-surf-vpar.mac | 172 ++----- .../ms-dg_gyrokinetic-header.mac | 26 +- .../ms-dg_gyrokinetic-surf.mac | 11 +- .../ms-dg_gyrokinetic-vol.mac | 25 +- .../ms-gk_collisionless_flux-header.mac | 139 +++--- .../ms-gk_collisionless_flux.mac | 138 ++---- maxima/g0/gk_collisionless/verify_no_leak.mac | 21 - 10 files changed, 208 insertions(+), 863 deletions(-) delete mode 100644 maxima/g0/gk_collisionless/verify_no_leak.mac diff --git a/maxima/g0/gk_collisionless/dg_gk-surf.mac b/maxima/g0/gk_collisionless/dg_gk-surf.mac index d8d97ea6..77901135 100644 --- a/maxima/g0/gk_collisionless/dg_gk-surf.mac +++ b/maxima/g0/gk_collisionless/dg_gk-surf.mac @@ -26,7 +26,7 @@ calcGKSurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, vars BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, hamil_e,alphaSurfL_e,alphaSurfR_e, fl_e,fc_e,fr_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - fnodal_l_e,fnodal_r_e,fmodproj_e,numC,vmap_prime_fac_l,vmap_prime_fac_c,vmap_prime_fac_r,vmap_prime_e,basisNodal,i], + fnodal_l_e, fnodal_r_e, fmodproj_e], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, @@ -143,8 +143,7 @@ calcGKBoundarySurfUpdateInDir(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrd rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e, BstarXdBmag_e,BstarYdBmag_e,BstarZdBmag_e,BstardBmag_e, hamil_e,alphaUpL_e,alphaSurfL_e,alphaUpSurfL_e,alphaUpR_e,alphaSurfR_e,alphaUpSurfR_e, - fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL, - numC,vmap_prime_fac_edge,vmap_prime_fac_skin,vmap_prime_e,basisNodal,i,fnodal_l_e,fnodal_r_e,fmodproj_e], + fEdge_e,fSkin_e,fUpL_e,fUpR_e,GhatL_c,GhatR_c,GhatL_e,GhatR_e,incrL_c,incrR_c,pOrderCFL], kill(varsC,varsP,bC,bP), pDim : cdim+vdim, diff --git a/maxima/g0/gk_collisionless/dg_gk-vol.mac b/maxima/g0/gk_collisionless/dg_gk-vol.mac index 93e42e7c..01905ad3 100644 --- a/maxima/g0/gk_collisionless/dg_gk-vol.mac +++ b/maxima/g0/gk_collisionless/dg_gk-vol.mac @@ -11,22 +11,18 @@ load("utilities")$ fpprec : 24$ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,vmap_e,BstardBmag_e, + [pDim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, + bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, - dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, - replaceList,dvparSimp,phi_e,bmag_e,dualcurlbhatoverB_x_e,dualcurlbhatoverB_y_e,dualcurlbhatoverB_z_e, - rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,dualcurlbhatoverB_list,bioverJB_list, - vmapSq_e,vmap_prime_e,hamilCvar,hamilNoZero_c,hamil_c,vpardim,i,k,curvdriftdir,clst], + dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e], kill(varsC,varsP,bC,bP), - pdim : cdim+vdim, + pDim : cdim+vdim, [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), numC : length(bC), numP : length(bP), - varLabel : makelist(string(varsP[d]),d,1,pdim), + varLabel : makelist(string(varsP[d]),d,1,pDim), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, @@ -45,19 +41,19 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "~%"), /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pdim do ( + for d : 1 thru pDim do ( printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) ), printf(fh, "~%"), rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), + rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pDim), /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), printf(fh, "~%"), replaceList : [rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pdim), + dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pDim), [dvparSq=4/rdvpar2Sq]), /* Create pointers to the components of b_i. */ @@ -114,9 +110,9 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := Jf_e : doExpand1(fin,bP), /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pdim-1, - if vdim = 1 then ( vpardim : pdim ), - dH_dz_e : makelist(0, i, 1, pdim), + vpardim : pDim-1, + if vdim = 1 then ( vpardim : pDim ), + dH_dz_e : makelist(0, i, 1, pDim), for i : 1 thru vpardim do ( if i = vpardim then ( dH_dz_e[i] : diff(hamil_e,varsP[i]) @@ -159,25 +155,21 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := dirVar : varsP[dir], /* Variable in current direction. */ if dir = cdim then ( - alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ /* Contribution from B_0 . dH/dvpar . ∇ψ in z*/ + alpha_e : rtg33inv_e*dH_dz_e[vpardim]/vmap_prime_e[1]/m_ ) else if dir = vpardim then ( - alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ /* Contribution from B_0 . ∇H . dψ/dvpar in z */ + alpha_e : -rtg33inv_e * dH_dz_e[cdim]/m_ ) else ( - alpha_e : 0 /* all other B_0 contributions are 0 since B_0_x,y = 0 */ + alpha_e : 0 ), if no_by = false then ( - - /* Add curvature drift terms (m vpar/q * ∇ x b)/mB = (m vpar * (∇ x b)/B)/qm */ if cdim = 3 then ( - /* Sum each directions */ curvdriftdir : dir ), if cdim = 2 then ( - /* Select only x and z */ if dir = 1 then ( curvdriftdir : dir ), @@ -186,28 +178,12 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := ) ), if cdim = 1 then ( - /* Select z */ curvdriftdir : 3 ), + if dir < vpardim then ( - /* Config space contributions ( curv drift * dH/dvpar . ∇ψ ) */ - alpha_e : alpha_e + mvpar_e*dualcurlbhatoverB_list[curvdriftdir] * dH_dz_e[vpardim]/vmap_prime_e[1] / (q_*m_) - ) else ( - /* Vpar contribution ( curv drift . ∇H * dψ/dvpar )*/ - if cdim = 3 then ( - for k : 1 thru cdim do ( - alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[k]*dH_dz_e[k]/(q_*m_) - ) - ), - if cdim = 2 then ( - alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[1] * dH_dz_e[1]/(q_*m_) - mvpar_e*dualcurlbhatoverB_list[3] * dH_dz_e[2]/(q_*m_) - ), - if cdim = 1 then ( - alpha_e : alpha_e - mvpar_e*dualcurlbhatoverB_list[3] * dH_dz_e[1]/(q_*m_) - ) + alpha_e : alpha_e + dualcurlbhatoverB_list[curvdriftdir]*dH_dz_e[vpardim]/vmap_prime_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/m_/q_ ), - - /* Add b x ∇H / qB term (only in configuration space) */ if cdim = 3 then ( if dir = 1 then ( alpha_e : alpha_e + 1/q_ * (bioverJB_list[2]*dH_dz_e[3] - bioverJB_list[3]*dH_dz_e[2]) @@ -226,13 +202,27 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := if dir = 2 then ( alpha_e : alpha_e - 1/q_ * (bioverJB_list[2]*dH_dz_e[1]) ) + ), + if dir = vpardim then ( + if cdim = 3 then ( + for k : 1 thru cdim do ( + alpha_e : alpha_e - dualcurlbhatoverB_list[k]*dH_dz_e[k]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ) + ), + if cdim = 2 then ( + alpha_e : alpha_e - dualcurlbhatoverB_list[1]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ - dualcurlbhatoverB_list[3]*dH_dz_e[2]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ), + if cdim = 1 then ( + alpha_e : alpha_e - dualcurlbhatoverB_list[3]*dH_dz_e[1]*dH_dz_e[vpardim]/vmap_prime_e[1]/q_/m_ + ) ) + ), if dir < vpardim then ( alpha_e : alpha_e*rdx2vec[dir] ) - else ( + else if dir = vpardim then ( alpha_e : alpha_e/vmap_prime_e[1] ), @@ -245,7 +235,7 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := alpha_c : subst(dvparSimp, alpha_c), alphaLabel : eval_string(sconcat(alpha, dirLabel)), clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], + makelist(dxv[i-1],i,1,pDim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], writeCExprsCollect1(alphaLabel, alpha_c, clst), printf(fh, "~%"), flush_output(fh), @@ -267,369 +257,3 @@ buildGKVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := printf(fh, "} ~%") )$ - -addAparGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,dir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, alphaJf_e, Jf_e, - replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e,dim_idx_list, xidx, yidx, zidx, vidx, - replaceList,dvparSimp,phi_e,bmag_e,rtg33inv_e,bioverJB_x_e,bioverJB_y_e,bioverJB_z_e,bioverJB_list, - dualcurlbhatoverB_x_e,dualcurlbhatoverB_y_e,dualcurlbhatoverB_z_e, dH_dx, dH_dy, dH_dz, dH_dvpar, gradH_vec, - vmapSq_e,vmap_prime_e,hamil_c,hamilCvar,hamilNoZero_c,vpardim,i,k,Apar_e, dA_dx, dA_dy, dA_dz, gradA_vec, - rotAbovermB_x,rotAbovermB_y,rotAbovermB_z,rotAbovermB_list, gradAxbhatoverB_x,gradAxbhatoverB_y,gradAxbhatoverB_z,gradAxbhatoverB_vec, - curvdriftdir,clst], - - kill(varsC,varsP,bC,bP), - pdim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - varLabel : makelist(string(varsP[d]),d,1,pdim), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *w, const double *dxv, const double *vmap, const double *vmapSq, - const double q_, const double m_, const double *bmag, const double *jacobtot_inv, const double *dualcurlbhatoverB, const double *bioverJB, - const double *b_i, const double *phi, const double *apar, const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // w[NDIM]: cell-center.~%"), - printf(fh, " // dxv[NDIM]: cell length.~%"), - printf(fh, " // vmap: velocity space mapping.~%"), - printf(fh, " // vmapSq: velocity space mapping squared.~%"), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // bmag: magnetic field amplitude.~%"), - printf(fh, " // jacobtot_inv: reciprocal of the conf-space jacobian time the guiding center coordinate Jacobian.~%"), - printf(fh, " // dualcurlbhatoverB: dual curl of bhat over B.~%"), - printf(fh, " // bioverJB: b_i over J times B.~%"), - printf(fh, " // b_i: covariant components of the field aligned unit vector.~%"), - printf(fh, " // apar: parallel component of magnetic vector potential.~%"), - printf(fh, " // phi: electrostatic potential .~%"), - printf(fh, " // fin: Distribution function.~%"), - printf(fh, " // out: output increment.~%"), - printf(fh, "~%"), - - /* Declare cell-center variables and variables multiplying gradients. */ - for d : 1 thru pdim do ( - printf(fh, " double rd~a2 = 2.0/dxv[~a];~%", varLabel[d], d-1) - ), - printf(fh, "~%"), - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), - - /* Declare variables with squared of cell centers and rdx2 variables (only need vpar^2). */ - /* printf(fh, " double rdvpar2Sq = rdvpar2*rdvpar2;~%"), */ - /* printf(fh, " double dvparSq = dxv[~a]*dxv[~a];~%", cdim, cdim), */ - printf(fh, "~%"), - replaceList : [rdx^2=dx2Sq, rdy^2=dy2Sq, rdz^2=dx2Sq, rdvpar2^2=rdvpar2Sq,dxv[cdim]^2=dvparSq,rdvpar2Sq=4/dvparSq], - dvparSimp : append(makelist(dxv[i-1]=2/eval_string(sconcat("rd",varLabel[i],"2")),i,1,pdim), - [dvparSq=4/rdvpar2Sq]), - - /* Store indices of the coordinate directions. */ - if cdim = 3 then ( - xidx : 1, yidx : 2, zidx : 3, vidx : 4 - ) else if cdim = 2 then ( - xidx : 1, zidx : 2, vidx : 3 - ) else if cdim = 1 then ( - zidx : 1, vidx : 2 - ), - - /* Create pointers to the components of b_i. */ - allVarLabelsC : ["x","y","z"], - for d : 1 thru 3 do ( - printf(fh, " const double *b_~a = &b_i[~a];~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - for d : 1 thru 3 do ( - printf(fh, " const double *bioverJB_~a = &bioverJB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - /* Create pointers to the components of dualcurlbhatoverB. */ - for d : 1 thru 3 do ( - printf(fh, " const double *dualcurlbhatoverB_~a = &dualcurlbhatoverB[~a]; ~%", allVarLabelsC[d], numC*(d-1)) - ), - printf(fh, "~%"), - - /* Axisymmetric basis (independent of y). */ - bmagBasis : getAxisymmetricConfBasis(bC), - /* Expand input fields for Hamiltonian calculation */ - phi_e : doExpand1(phi,bC), - bmag_e : doExpand1(bmag, bmagBasis), - rtg33inv_e : doExpand1(rtg33inv, bmagBasis), - dualcurlbhatoverB_x_e : doExpand1(dualcurlbhatoverB_x, bmagBasis), - dualcurlbhatoverB_y_e : doExpand1(dualcurlbhatoverB_y, bmagBasis), - dualcurlbhatoverB_z_e : doExpand1(dualcurlbhatoverB_z, bmagBasis), - bioverJB_x_e : doExpand1(bioverJB_x, bmagBasis), - bioverJB_y_e : doExpand1(bioverJB_y, bmagBasis), - bioverJB_z_e : doExpand1(bioverJB_z, bmagBasis), - b_x_e : doExpand1(b_x, bmagBasis), - b_y_e : doExpand1(b_y, bmagBasis), - if (no_by or cdim = 1) then (b_y_e : 0), - b_z_e : doExpand1(b_z, bmagBasis), - jacobTotInv_e : doExpand1(jacobtot_inv, bmagBasis), - - dualcurlbhatoverB_list : [dualcurlbhatoverB_x_e, dualcurlbhatoverB_y_e, dualcurlbhatoverB_z_e], - bioverJB_list : [bioverJB_x_e, bioverJB_y_e, bioverJB_z_e], - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - - /* Redefine vmap_prime to exploit the relationship between it and vmap. */ - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - /* Write out the hamiltonian*/ - hamil_e : q_*phi_e + (1/2)*m_*vmapSq_e[1], - if vdim > 1 then ( hamil_e : hamil_e + vmap_e[2]*bmag_e ), - hamil_c : calcInnerProdList(varsP, 1, bP, hamil_e), - printf(fh, " double hamil[~a] = {0.}; ~%", numP), - replaceList : [wvpar^2=wvparSq, rdvpar2^2=rdvpar2Sq, rdx2^2=rdx2Sq, rdy2^2=rdy2Sq, rdz2^2=rdz2Sq, m_^2=mSq, q_^2=qSq], - hamilCvar : eval_string(sconcat("hamil")), - writeCExprsNoExpand1(hamilCvar, gcfac(float(expand(subst(replaceList, hamil_c))))), - printf(fh, "~%"), - flush_output(fh), - hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), - /* Expand projected Hamiltonian on basis. */ - hamil_e : hamilNoZero_c . bP, - - /*Expand Jf*/ - Jf_e : doExpand1(fin,bP), - - /* Calculate expressions for dericatives of the hamiltonian*/ - vpardim : pdim-1, - if vdim = 1 then ( vpardim : pdim ), - dH_dz_e : makelist(0, i, 1, pdim), - for i : 1 thru vpardim do ( - if i = vpardim then ( - dH_dz_e[i] : diff(hamil_e,varsP[i]) - ) - else ( - dH_dz_e[i] : diff(hamil_e*rdx2vec[i],varsP[i]) - ) - ), - dH_dvpar : diff(hamil_e,varsP[vpardim])/vmap_prime_e[1], /* We do not multply by rdv2vec because it is inside vmap_prime */ - if cdim = 3 then ( - dH_dx : diff(hamil_e*rdx2vec[xidx],varsP[xidx]), - dH_dy : diff(hamil_e*rdx2vec[yidx],varsP[yidx]), - dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), - gradH_vec : [dH_dx, dH_dy, dH_dz, dH_dvpar] - ) else if cdim = 2 then ( - dH_dx : diff(hamil_e*rdx2vec[xidx],varsP[xidx]), - dH_dy : 0, - dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), - gradH_vec : [dH_dx, dH_dz, dH_dvpar] - ) else if cdim = 1 then ( - dH_dx : 0, - dH_dy : 0, - dH_dz : diff(hamil_e*rdx2vec[zidx],varsP[zidx]), - gradH_vec : [dH_dz, dH_dvpar] - ), - - /*Make sure to avoid having hamil[i]^2 or vmap[i]^2 in expressions*/ - replaceListVpar : [vmap[1]^2=vmap2], - printf(fh, " double vmap2 = vmap[1]*vmap[1]; ~%"), - printf(fh, "~%"), - - mvpar_e : dH_dz_e[vpardim]/vmap_prime_e[1], - mvparsq_e : mvpar_e*mvpar_e/m_, - isqlist : [], - for i : 1 thru numP do ( - if freeof(hamil[i]^2, expand(mvparsq_e)) = false then ( - isqlist : append(isqlist,[i]) - ) - ), - - replaceListHamil : [], - printf(fh, " double hamil2[~a] = {0.}; ~%", length(isqlist)), - for i : 1 thru length(isqlist) do ( - printf(fh, " hamil2[~a] = hamil[~a]*hamil[~a]; ~%", i-1, isqlist[i], isqlist[i]), - replaceListHamil : append(replaceListHamil, [hamil[isqlist[i]]^2=hamil2[i-1]]) - ), - printf(fh, "~%"), - - /* Expand Apar.*/ - /* Apar_e : subst(y=0, doExpand1(apar,bC)), */ - Apar_e : doExpand1(apar,bC), - - /* Expand dBperp/Bmag. */ - /* Direct method ∇ x (Apar bhat) */ - rotAbovermB_x : (rdy2*diff(Apar_e*b_z_e,y) - rdz2*diff(Apar_e*b_y_e,z))*jacobTotInv_e/m_, - rotAbovermB_y : (rdz2*diff(Apar_e*b_x_e,z) - rdx2*diff(Apar_e*b_z_e,x))*jacobTotInv_e/m_, - rotAbovermB_z : (rdx2*diff(Apar_e*b_y_e,x) - rdy2*diff(Apar_e*b_x_e,y))*jacobTotInv_e/m_, - rotAbovermB_list : [rotAbovermB_x, rotAbovermB_y, rotAbovermB_z], - - /* Product rule method Apar ∇ x bhat + ∇Apar x bhat. */ - /* Calculate ∇Apar in a list */ - if cdim = 3 then ( - dA_dx : diff(Apar_e*rdx2vec[xidx],varsC[xidx]), - dA_dy : diff(Apar_e*rdx2vec[yidx],varsC[yidx]), - dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), - gradA_vec : [dA_dx, dA_dy, dA_dz] - ) else if cdim = 2 then ( - dA_dx : diff(Apar_e*rdx2vec[xidx],varsC[xidx]), - dA_dy : 0, - dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), - gradA_vec : [dA_dx, dA_dz] - ) else if cdim = 1 then ( - dA_dx : 0, - dA_dy : 0, - dA_dz : diff(Apar_e*rdx2vec[zidx],varsC[zidx]), - gradA_vec : [dA_dz] - ), - - /* Use bioverJB to calculate ∇Apar x b / B in a list */ - if cdim = 3 then ( - gradAxbhatoverB_x : gradA_vec[yidx]*bioverJB_list[3] - gradA_vec[zidx]*bioverJB_list[2], - gradAxbhatoverB_y : gradA_vec[zidx]*bioverJB_list[1] - gradA_vec[xidx]*bioverJB_list[3], - gradAxbhatoverB_z : gradA_vec[xidx]*bioverJB_list[2] - gradA_vec[yidx]*bioverJB_list[1], - gradAxbhatoverB_vec : [gradAxbhatoverB_x, gradAxbhatoverB_y, gradAxbhatoverB_z] - ) else if cdim = 2 then ( - gradAxbhatoverB_x : -gradA_vec[zidx]*bioverJB_list[2], - gradAxbhatoverB_y : 0, - gradAxbhatoverB_z : +gradA_vec[xidx]*bioverJB_list[2], - gradAxbhatoverB_vec : [gradAxbhatoverB_x, gradAxbhatoverB_z] - ) else if cdim = 1 then ( - gradAxbhatoverB_x : 0, - gradAxbhatoverB_y : 0, - gradAxbhatoverB_z : 0, - gradAxbhatoverB_vec : [gradAxbhatoverB_z] - ), - - dim_idx_list : [3, 1, 2], - - /* Note: no contribution from mu. */ - for dir : 1 thru cdim+1 do ( - - dirLabel : varLabel[dir], - - wDir : eval_string(sconcat("w",dirLabel)), - rdDirVar2 : eval_string(sconcat("rd",dirLabel,"2")), - - dirVar : varsP[dir], /* Variable in current direction. */ - - alpha_e : 0, - - if no_by = false then ( - if dir < vpardim then ( /* Config space contributions ( curv drift * dH/dvpar . ∇ψ ) */ - list_idx : dim_idx_list[dir], - /* This is [Apar . (∇ x b)/B + ∇Apar x b/B]/m dH/dvpar . ∇ψ */ - alpha_e : alpha_e + 1/m_ * Apar_e * dualcurlbhatoverB_list[list_idx] * gradH_vec[vpardim], - /* This term is responsible of y oscillations in the Alfven 3x2v regression test. */ - /* The oscillation builds up at longer time (not observable at frame 1). */ - alpha_e : alpha_e + 1/m_ * gradAxbhatoverB_vec[dir] * gradH_vec[vpardim], - /* basis function gradient ∇ψ factor */ - alpha_e : alpha_e*rdx2vec[dir] - ) else ( /* Vpar contribution ( curv drift . ∇H * dψ/dvpar )*/ - for k : 1 thru cdim do ( - list_idx : dim_idx_list[k], - /* this is [Apar . (∇ x b)/B]/m . ∇H * dψ/dvpar */ - alpha_e : alpha_e - 1/m_ * (Apar_e * dualcurlbhatoverB_list[list_idx]) * gradH_vec[k], - /* this is [∇Apar x b/B]/m . ∇H * dψ/dvpar */ - alpha_e : alpha_e - 1/m_ * gradAxbhatoverB_vec[k] * gradH_vec[k] - ), - /* basis function gradient dψ/dvpar factor */ - alpha_e : alpha_e/vmap_prime_e[1] - ) - ), - - /* Project alpha on basis and write to array. */ - printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), - alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), - alpha_c : subst(replaceList, alpha_c), - alpha_c : subst(replaceListHamil, alpha_c), - alpha_c : subst(replaceListVpar, alpha_c), - alpha_c : subst(dvparSimp, alpha_c), - alphaLabel : eval_string(sconcat(alpha, dirLabel)), - clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], - writeCExprsCollect1(alphaLabel, alpha_c, clst), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), - alpha_e : doExpand(alphaNoZero_c, bP), - - alphaJf_e : alpha_e*Jf_e, - - printf(fh, "~%"), - volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[dir]), alphaJf_e)), - volTerm_c : subst(replaceList, volTerm_c), - writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), - flush_output(fh), - printf(fh, "~%") - - ), - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") - -)$ - -addApardotGKEMVolKernel(fh, funcNm, cdim, vdim, basisFun, polyOrder, varsInB, no_by) := block( - [pdim,varsC,bC,varsP,bP,varsV,vSub,numC,numP,varLabel,d,rdx2vec,rdv2vec,allVarLabelsC, - bmagBasis,ignoreVars,inFlds_e,cmag_e,b_x_e,b_y_e,b_z_e,jacobTotInv_e,vmap_e,BstardBmag_e, - hamil_e,pbAuxFlds,alphaSum_e,vd,vpardir,dirLabel,wDir,rdDirVar2,vmap_prime_fac,dirVar, - dirVar_phys,alpha_e,alpha_c,alphaLabel,alphaNoZero_c,alphaDotGradBasis_e,f_e,volTerm_c, dH_dz_e, - alphaJf_e, Jf_e, replaceListHamil, replaceListVpar,hamil2_c,isqlist,mvpar_e,mvparsq_e, - vmapSq_e,vmap_prime_e,apardot_e,clst], - - kill(varsC,varsP,bC,bP), - pdim : cdim+vdim, - - [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), - numC : length(bC), numP : length(bP), - - varLabel : makelist(string(varsP[d]),d,1,pdim), - - print("Working on ", funcNm), - printf(fh, "GKYL_CU_DH double ~a(const double *vmap, const double q_, const double m_, const double *apardot, - const double *fin, double* GKYL_RESTRICT out) ~%{ ~%", funcNm), - printf(fh, " // q_,m_: species charge and mass.~%"), - printf(fh, " // apardot: time derivative of parallel component of magnetic vector potential.~%"), - printf(fh, " // fin: Distribution function.~%"), - printf(fh, " // out: output increment.~%"), - printf(fh, "~%"), - - rdx2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,1,cdim), - rdv2vec : makelist(eval_string(sconcat("rd",varLabel[i],"2")),i,cdim+1,pdim), - - - /* Velocity mapping fields. */ - [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), - vmap_prime_e : makelist(diff(vmap_e[d],varsP[cdim+d]),d,1,vdim), - - /*Expand Jf*/ - Jf_e : doExpand1(fin,bP), - - /* Expand Apardot */ - apardot_e : doExpand1(apardot,bC), - - /* Note: only a vpar contribution. */ - vpardir : cdim+1, - dirLabel : varLabel[vpardir], - - alpha_e : -q_/m_ * apardot_e /vmap_prime_e[1], - - /* Project alpha on basis and write to array. */ - printf(fh, " double alpha~a[~a] = {0.}; ~%", dirLabel, numP), - alpha_c : fullratsimp(calcInnerProdList(varsP, 1, bP, alpha_e)), - alphaLabel : eval_string(sconcat(alpha, dirLabel)), - clst : [rdx2vec, rdv2vec, m_, q_, wvpar, rdvpar2Sq, - makelist(dxv[i-1],i,1,pdim), makelist(vmap[i-1],i,1,2*length(vmap_e[1]))], - writeCExprsCollect1(alphaLabel, alpha_c, clst), - printf(fh, "~%"), - flush_output(fh), - alphaNoZero_c : makelistNoZeros1(alpha_c, alphaLabel), - alpha_e : doExpand(alphaNoZero_c, bP), - - alphaJf_e : alpha_e*Jf_e, - - printf(fh, "~%"), - volTerm_c : fullratsimp(calcInnerProdList(varsP, 1, diff(bP,varsP[vpardir]), alphaJf_e)), - writeCIncrExprsNoExpand(gcfac(float(expand(volTerm_c)))), - flush_output(fh), - printf(fh, "~%"), - - printf(fh, " return 0.; ~%"), - printf(fh, "} ~%") - -)$ \ No newline at end of file diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac index dcc33e8e..34e06ea7 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-conf.mac @@ -6,15 +6,13 @@ load("utilities_gyrokinetic")$ load("nodal_operations/nodal_functions")$ fpprec : 24$ -buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, mb_bound, scheme) := block( +buildGKFluxConfESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge, mb_bound) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfNodes,nodeVars,bSurf,basisNodal,surfConfigNodes,numSurfNodes,numSurfConfigNodes,numVelNodes, - numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,apar_e, - bmagSurf_e,vmap_e,vmapSq_e, + numMuNodes,numVparNodes,d,rdx2vec,rdv2vec,rdSurfVar2,bmagBasis,phi_e,bmagSurf_e,vmap_e,vmapSq_e, vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c, jacobgeo_rat_surfR_e,jacobgeo_rat_surfL_e,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL, - surfIntVarsC,bSurfC,hamilCvar,aparCvar,apar_nodes,apar_c,dA_dx_nodes + dH_dz_nodes,mvpar_nodes,di3,i,j,j0index,j1index,vparindex,vpar0index,pOrderCFL ], kill(varsC,varsP,bC,bP), @@ -62,8 +60,7 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b const double *w, const double *dxv, const double *vmap, const double *vmapSq, const double q_, const double m_, const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *apardot, + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, const double *phi, const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), @@ -76,8 +73,6 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " // jacobgeo_rat_surfL: Ratio of surface conf-space Jacobians in left cell.~%"), printf(fh, " // jacobgeo_rat_surfR: Ratio of surface conf-space Jacobians in right cell.~%"), printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // apardot: time derivative of parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -125,7 +120,7 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : doExpand(hamilNoZero_c, bSurf), + hamil_e : hamilNoZero_c . bSurf, /* fl and fr */ JfL_e : doExpand1(JfL, bP), @@ -190,23 +185,6 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b di3 : false ), - /* Expand Aparallel. */ - apar_e : doExpand1(apar,bC), - apar_c : calcInnerProdList(surfIntVars, 1, bSurf, subst(surfVar=evPoint,apar_e)), - /* printf(fh, " double apar[~a] = {0.}; ~%", numP), */ - aparCvar : eval_string(sconcat("apar")), - apar_c : makelistNoZeros1(apar_c, aparCvar), - /* Expand projected Apar on basis. */ - apar_e : doExpand(apar_c, bSurf), - /* Eval Aparallel at nodes. */ - apar_nodes : float(evAtNodes(apar_e,surfNodes,surfIntVars)), - /* Compute gradient of Aparallel */ - dA_dx_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsP[i]),surfNodes,surfIntVars)) - ), - /* It will be used to compute the contribution as ∇ x (A b) = ∇A x b + A ∇ x b */ - /* Now calculate flux at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), @@ -251,8 +229,6 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b vparindex : mod(j-1, numVparNodes) + 1, vpar0index : mod(j-1, numVparNodes), printf(fh, "~%"), - - /* Electrostatic term */ if no_by = true then ( if di3 = true then ( printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) @@ -260,7 +236,8 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b else ( printf(fh, " alpha_quad = 0.0; ~%") ) - ) else ( + ), + if no_by = false then ( /*printf(fh, " alpha_quad += mvparsq_quad[~a]*normcurlbhat_quad/(bmag_quad*q_) ;~%", vpar0index),*/ if cdim = 3 then ( if surfDir = 1 then( @@ -283,60 +260,33 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b ), if cdim = 1 then ( printf(fh, " alpha_quad = (mvpar_quad[~a]*B3_quad/(m_*bmag_quad))*area_elem_quad/Jc_quad; ~%", vpar0index) - ), - - if em = true then ( - /* Electromagnetic Apar contribution curl(Apar b) = grad(Apar) x b + Apar curl(b)*/ - /* No contribution for cdim = 1 */ - if cdim > 1 then ( - /* Aparallel curl b contribution */ - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * (~a) * normcurlbhat_quad; ~%", vpar0index, apar_nodes[j1index]) - ), - /* grad(Aparallel) x b contribution*/ - if cdim = 3 then ( - if surfDir = 1 then( - /* This term is responsible of y oscillations in the Alfven 3x2v regression test. */ - /* The oscillation appears at short time (observable frame 1). */ - printf(fh, " alpha_quad += 0*mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[2] - (~a) * bhat_quad[1]); ~%", vpar0index, dA_dx_nodes[2][j1index], dA_dx_nodes[3][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[0] - (~a) * bhat_quad[2]); ~%", vpar0index, dA_dx_nodes[3][j1index], dA_dx_nodes[1][j1index]) - ), - if surfDir = 3 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * ((~a) * bhat_quad[1] - (~a) * bhat_quad[0]); ~%", vpar0index, dA_dx_nodes[1][j1index], dA_dx_nodes[2][j1index]) - ) - ), - if cdim = 2 then ( - if surfDir = 1 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[2][j1index]) - ), - if surfDir = 2 then( - printf(fh, " alpha_quad += mvpar_quad[~a]/(m_*bmag_quad) * bhat_quad[1]*(~a); ~%", vpar0index, dA_dx_nodes[1][j1index]) - ) - ) ) ), printf(fh, "~%"), + /*printf(fh, " alpha_quad = alpha_quad*area_elem_quad/Jc_quad; ~%"),*/ printf(fh, " cfl = fmax(fabs(alpha_quad), fabs(cfl)); ~%"), printf(fh, " JfL_quad = ~a; ~%", JfL_nodes[j1index]), printf(fh, " JfR_quad = ~a; ~%", JfR_nodes[j1index]), printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0; ~%"), printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0; ~%"), - if scheme = "upwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ) else if scheme = "central" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) - ) else if scheme = "downwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ) else ( - /* Stop the script if an invalid scheme is provided. */ - error("Invalid flux scheme provided. Options are: upwind, central, downwind.") - ) + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad; ~%", j0index) ), printf(fh, "~%") ), + /* Do the quad nodal to modal ops directly here*/ + /*printf(fh, "~%"), + printf(fh, " double *fmodal = &flux_surf[~a]; ~%", length(bSurf)*(surfDir-1)), + flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), + fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), + + for i : 1 thru length(fmodproj_e) do ( + printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) + ), + + printf(fh, "~%"),*/ + /*Calculate the cfl*/ pOrderCFL : polyOrder, printf(fh, "~%"), @@ -346,4 +296,4 @@ buildGKFluxConfKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac index 8bcccdd0..a172abb2 100644 --- a/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac +++ b/maxima/g0/gk_collisionless/gk_collisionless_flux-surf-vpar.mac @@ -5,14 +5,13 @@ load("scifac")$ load("utilities_gyrokinetic")$ fpprec : 24$ -buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, em, edge, add_apardot, scheme) := block( +buildGKFluxVparESKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_by, edge) := block( [pDim,varsC,bC,varsP,bP,vSub,numC,numP,surfVar,varLabel,dirLabel,surfIntVars,surf_cvars,surf_vvars, surfIntVarsC,bSurfC,surfNodes,nodeVars,bSurf,basisNodal,configNodes,numSurfNodes,numConfigNodes, numVelNodes,tempVars,tempBasis,NSurfIndexing,numNodesIndexing,d,rdx2vec,rdv2vec,rdSurfVar2, bmagBasis,phi_e,bmag_e,vmap_e,vmapSq_e,vmap_prime_e,evPoint,hamil_e,hamil_c,replaceList, hamilCvar,hamilNoZero_c,JfL_e,JfR_e,JfL_c,JfR_c,JfL_nodes,JfR_nodes,vmap_prime_nodes,vpardim, - dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr,apar_e,apar_nodes,dA_dx_nodes,k, - apardot_e,apardot_nodes + dH_dz_nodes,i,j,j0index,j1index,pOrderCFL,vprimeStr ], kill(varsC,varsP,bC,bP), @@ -58,17 +57,18 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b NSurfIndexing : length(tempBasis), numNodesIndexing : length(tempBasis) ) else ( - error("Only p=1 is currently supported for the surfvpar kernels.") + NSurfIndexing : NSurf, + numNodesIndexing : numNodes ), print("Working on ", funcNm), printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), + const double *w, const double *dxv, + const double *vmap_prime_l, const double *vmap_prime_r, + const double *vmap, const double *vmapSq, const double q_, const double m_, + const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf) ~%{ ~%", funcNm), printf(fh, " // w[NDIM]: cell-center.~%"), printf(fh, " // dxv[NDIM]: cell length.~%"), printf(fh, " // vmap_prime_l,vmap_prime_r: velocity space mapping derivative in left and right cells.~%"), @@ -79,8 +79,6 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " // gkdgv: gyrokinetic volume DG geometry.~%"), printf(fh, " // bmag: magnetic field amplitude.~%"), printf(fh, " // phi: electrostatic potential.~%"), - printf(fh, " // apar: parallel component of vector potential.~%"), - printf(fh, " // apardot: time derivative of parallel component of vector potential.~%"), printf(fh, " // JfL: distribution times total jacobian in left cell.~%"), printf(fh, " // JfR: distribution times total jacobian in right cell.~%"), printf(fh, " // flux_surf: output surface phase space flux in each direction (cdim + 1 components).~%"), @@ -129,18 +127,9 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), hamilNoZero_c : makelistNoZeros1(hamil_c, hamilCvar), /* Expand projected Hamiltonian on basis. */ - hamil_e : doExpand(hamilNoZero_c,bP), + hamil_e : hamilNoZero_c . bP, /*hamil_e : subst(surfVar=evPoint,hamil_e),*/ - /* Expand Apar */ - apar_e : doExpand1(apar, bC), - apar_nodes : float(evAtNodes(apar_e,configNodes,surf_cvars)), - /* Compute gradient of Aparallel */ - dA_dx_nodes : makelist(0, i, 1, cdim), - for i : 1 thru cdim do ( - dA_dx_nodes[i] : float(evAtNodes(diff(apar_e*rdx2vec[i],varsC[i]),configNodes,surf_cvars)) - ), - /*fl and fr */ JfL_e : doExpand1(JfL, bP), JfR_e : doExpand1(JfR, bP), @@ -168,7 +157,7 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b ) ), - /* Now calculate alpha at all quadrature nodes */ + /* Now calculate apha at all quadrature nodes */ /*printf(fh, " double flux_surf_nodal[~a]= {0.0}; ~%", numSurfNodes),*/ printf(fh, " double *flux_surf_nodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), printf(fh, " double cfl = 0.0; ~%"), @@ -176,114 +165,44 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " double B3_quad = 0.0; ~%"), printf(fh, " double Jc_quad = 0.0; ~%"), printf(fh, " double dualcurlbhat_quad[3] = {0.0}; ~%"), + printf(fh, " double alpha_quad = 0.0; ~%"), printf(fh, " double JfL_quad = 0.0; ~%"), printf(fh, " double JfR_quad = 0.0; ~%"), printf(fh, " double Jfavg_quad = 0.0; ~%"), printf(fh, " double Jfjump_quad = 0.0; ~%"), - if em = true then ( - printf(fh, " double m_bmag_inv = 0.0; ~%"), - printf(fh, " double mvpar_over_q = 0.0; ~%"), - printf(fh, " double g_13 = 0.0; ~%"), - printf(fh, " double g_23 = 0.0; ~%"), - printf(fh, " double g_33 = 0.0; ~%"), - printf(fh, " double mag_e_3 = 0.0; ~%") - ), printf(fh, "~%"), for i : 1 thru numConfigNodes do ( - i0index : i-1, - i1index : i, - printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i0index), - printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i0index), - printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i0index), - printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i0index), - printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i0index), - printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i0index), - - if em = true then ( - printf(fh, " m_bmag_inv = 1.0/(m_*bmag_quad); ~%"), - /* - We develop the component grad(Apar) x b as - e^m . grad(Apar) x b = e^m x grad(Apar) . b = e^m x e^i dApar/dx^i . e_3/|e_3| - which gives - coeff * (g_33 dApar/dx2 - g_23 dApar/dx3) for m=1 - coeff * (g_13 dApar/dx3 - g_33 dApar/dx1) for m=2 - coeff * (g_23 dApar/dx1 - g_13 dApar/dx2) for m=3 - with - coeff = Jc/sqrt(g_33) - */ - printf(fh, " g_13 = gkdgv[~a].g_13; ~%", i-1), - printf(fh, " g_23 = gkdgv[~a].g_23; ~%", i-1), - printf(fh, " g_33 = gkdgv[~a].g_33; ~%", i-1), - printf(fh, " mag_e_3 = gkdgv[~a].mag_e_3; ~%", i-1) - ), - + printf(fh, " bmag_quad = gkdgv[~a].bmag; ~%", i-1), + printf(fh, " B3_quad = gkdgv[~a].B3; ~%", i-1), + printf(fh, " Jc_quad = dgv[~a].Jc; ~%", i-1), + printf(fh, " dualcurlbhat_quad[0] = gkdgv[~a].dualcurlbhat.x[0]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[1] = gkdgv[~a].dualcurlbhat.x[1]; ~%", i-1), + printf(fh, " dualcurlbhat_quad[2] = gkdgv[~a].dualcurlbhat.x[2]; ~%", i-1), + printf(fh, "~%"), for j : 1 thru numVelNodes do ( j0index : j-1+(i-1)*numVelNodes, j1index : j+(i-1)*numVelNodes, printf(fh, "~%"), - /* printf(fh, " mvpar_over_q = (~a)/q_; ~%", dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), */ - if no_by = true then ( - /* Start ES term */ printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ;~%", dH_dz_nodes[cdim][j1index]) ), if no_by = false then ( - /* Start ES term */ printf(fh, " alpha_quad = -(~a)/m_/bmag_quad * B3_quad ", dH_dz_nodes[cdim][j1index]), - if cdim = 3 then ( - /* Finish ES term */ - for k : 1 thru cdim do ( - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) - ), - printf(fh, ";~%"), - if em = true then ( - /* EM term curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - for k : 1 thru cdim do ( - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[k][j1index], apar_nodes[i1index], k-1) - ), - /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_33 * (~a) - g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index], dA_dx_nodes[3][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_13 * (~a) - g_33 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[3][i1index], dA_dx_nodes[1][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (g_23 * (~a) - g_13 * (~a)); ~%", dH_dz_nodes[3][j1index], dA_dx_nodes[1][i1index], dA_dx_nodes[2][i1index]) - ) - ), - if cdim = 2 then ( - /* Finish ES term */ - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, ";~%"), - if em = true then ( - /* EM term curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 0), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[2][j1index], apar_nodes[i1index], 2), - /* grad(Apar) x b */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * (-g_23 * (~a)); ~%", dH_dz_nodes[1][j1index], dA_dx_nodes[2][i1index]), - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * 1/mag_e_3/Jc_quad * ( g_23 * (~a)); ~%", dH_dz_nodes[2][j1index], dA_dx_nodes[1][i1index]) - ) - ), - if cdim = 1 then ( - /* Finish ES term */ - printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), - printf(fh, ";~%"), - if em = true then ( - /* Terms related to Aparallel following curl(Apar*b) = Apar * curl(b) + grad(Apar) x b */ - /* Apar * curl(b) */ - printf(fh, " alpha_quad += -(~a)*m_bmag_inv * (~a)*dualcurlbhat_quad[~a]; ~%", dH_dz_nodes[1][j1index], apar_nodes[i1index], 2) - /* grad(Apar) x b */ - /* none */ - ) - ) - ), - - /* Add apardot contribution if requested */ - if add_apardot = true then ( - apardot_e : doExpand1(apardot, bC), - apardot_nodes : float(evAtNodes(apardot_e,configNodes,surf_cvars)), - printf(fh, " alpha_quad += -q_/m_*(~a); ~%", apardot_nodes[i1index]) + if cdim = 3 then ( + for k : 1 thru cdim do ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[k][j1index], k-1, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ) + ), + if cdim = 2 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 0, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]), + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[2][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + if cdim = 1 then ( + printf(fh, "-(~a)/m_/bmag_quad * 1/q_*dualcurlbhat_quad[~a]*(~a)", dH_dz_nodes[1][j1index], 2, dH_dz_nodes[vpardim][j1index]/vmap_prime_nodes[j1index]) + ), + printf(fh, ";~%") ), printf(fh, "~%"), @@ -292,21 +211,22 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b printf(fh, " JfR_quad = (~a)/~a;~%", JfR_nodes[j1index], vmap_prime_r[surfDir-cdim-1]), printf(fh, " Jfavg_quad = (JfL_quad + JfR_quad)/2.0 ;~%"), printf(fh, " Jfjump_quad = (JfR_quad - JfL_quad)/2.0 ;~%"), - if scheme = "upwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) - ) else if scheme = "central" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad; ~%", j0index) - ) else if scheme = "downwind" then ( - printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad + fabs(alpha_quad)*Jfjump_quad; ~%", j0index) - ) else ( - /* Stop the script if an invalid scheme is provided. */ - error("Invalid flux scheme provided. Options are: upwind, central, downwind.") - ) + printf(fh, " flux_surf_nodal[~a] = alpha_quad*Jfavg_quad - fabs(alpha_quad)*Jfjump_quad ;~%", j0index) ), printf(fh, "~%") ), - printf(fh, "~%"), + /* Do the quad nodal to modal ops directly here*/ + /*printf(fh, "~%"), + printf(fh, " double *fmodal = &flux_surf[~a]; ~%", NSurfIndexing*(surfDir-1)), + flux_surf_nodal_e : doExpand1(flux_surf_nodal,basisNodal), + fmodproj_e : fullratsimp(calcInnerProdList(surfIntVars, 1, bSurf, flux_surf_nodal_e)), + + for i : 1 thru length(fmodproj_e) do ( + printf(fh, " fmodal[~a] = ~a; ~%", i-1, float(expand(fmodproj_e[i]))) + ), + + printf(fh, "~%"),*/ /*Calculate the cfl*/ pOrderCFL : polyOrder, if polyOrder=1 then ( pOrderCFL : 2 ), @@ -319,4 +239,4 @@ buildGKFluxVparKernel(surfDir, fh, funcNm, cdim, vdim, basisFun, polyOrder, no_b flush_output(fh), printf(fh, "} ~%") -)$ \ No newline at end of file +)$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac index 06c9a6de..08e41563 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-header.mac @@ -2,9 +2,6 @@ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ @@ -89,31 +86,10 @@ printPrototypes() := block([], ) ) ) - ), - /* EM terms */ - for bInd : 1 thru length(bName) do ( - for c : minCdim[bInd] thru maxCdim[bInd] do ( - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apar_vol_~ax~av_~a_p~a(const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const double *bmag, const double *jacobtot_inv, const double *dualcurlbhatoverB, const double *bioverJB, - const double *b_i, const double *phi, const double *apar, - const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "GKYL_CU_DH double dg_gyrokinetic_add_apardot_vol_~ax~av_~a_p~a(const double *vmap, const double q_, const double m_, - const double *apardot, const double *fin, double* GKYL_RESTRICT out); ~%", c, v, bName[bInd], polyOrder), - printf(fh, "~%") - ) - ) - ) ) )$ -fh : openw(sconcat(outputDir, "gkyl_dg_gyrokinetic_kernels.h"))$ +fh : openw("~/max-out/gkyl_dg_gyrokinetic_kernels.h")$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac index f8dc8b49..18f5db41 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-surf.mac @@ -9,9 +9,6 @@ load("gk_collisionless/dg_gk-surf")$ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -63,7 +60,7 @@ for bInd : 1 thru length(bName) do ( for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( for dir : 1 thru c do ( /* Advection in configuration space.*/ - fname : sconcat(outputDir,"dg_gyrokinetic_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -73,7 +70,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Advection in configuration space in the skin cell (for boundary flux operations) .*/ - fname : sconcat(outputDir,"dg_gyrokinetic_boundary_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_boundary_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -84,7 +81,7 @@ for bInd : 1 thru length(bName) do ( ), /* Advection in velocity space.*/ - fname : sconcat(outputDir,"dg_gyrokinetic_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), @@ -94,7 +91,7 @@ for bInd : 1 thru length(bName) do ( close(fh), /* Advection in velocity space in the skin cell along vpar (for zero-flux BCs).*/ - fname : sconcat(outputDir,"dg_gyrokinetic_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_boundary_surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p",polyOrder, ".c"), disp(printf(false,"Creating surface file: ~a",fname)), fh : openw(fname), diff --git a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac index 965586ee..ef0b8a40 100644 --- a/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac +++ b/maxima/g0/gk_collisionless/ms-dg_gyrokinetic-vol.mac @@ -7,9 +7,6 @@ load("gk_collisionless/dg_gk-vol")$ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -47,35 +44,19 @@ for bInd : 1 thru length(bName) do ( maxPolyOrderB : maxPolyOrder[bInd], if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - fname : sconcat(outputDir,"dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file: ~a",fname)), fh : openw(fname), printf(fh, "#include ~%"), + funcName : sconcat("dg_gyrokinetic_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), buildGKVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), close(fh), - /* Add em kernels */ - fname : sconcat(outputDir,"dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file (add em): ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("dg_gyrokinetic_add_apar_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - addAparGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), - close(fh), - - fname : sconcat(outputDir,"dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), - disp(printf(false,"Creating volume file (add em): ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("dg_gyrokinetic_add_apardot_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), - addApardotGKEMVolKernel(fh, funcName, c, v, bName[bInd], polyOrder, bVarsList, false), - close(fh), - /* if cdim > 1, also generate a set of kernels for the case where there is no toroidal field (by = 0) */ if (c > 1) then ( - fname : sconcat(outputDir,"dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + fname : sconcat("~/max-out/dg_gyrokinetic_no_by_vol_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), disp(printf(false,"Creating volume file (no by): ~a",fname)), fh : openw(fname), diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac index 7b35759d..ebef045a 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux-header.mac @@ -2,11 +2,8 @@ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ -maxPolyOrder_Ser : 1$ +maxPolyOrder_Ser : 2$ minCdim_Ser : 1$ minVdim_Ser : 1$ maxCdim_Ser : 3$ @@ -46,84 +43,70 @@ byStr : ["", "no_by_"]$ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -emStr : ["", "em_", "em_star_"]$ - -/* Options for writing kernels at surface and edge surfaces. */ -edgeBool : [false, true]$ -edgeOpt : ["surf", "edge_surf"]$ - printPrototypes() := block([], - for emI : 1 thru 3 do ( - em_label : emStr[emI], - - for bInd : 1 thru length(bName) do ( - - for c : minCdim[bInd] thru maxCdim[bInd] do ( - - for gkV : 1 thru length(gkVdims[c]) do ( - v : gkVdims[c][gkV], - - maxPolyOrderB : maxPolyOrder[bInd], - if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ - for polyOrder : 1 thru maxPolyOrderB do ( - - for byI : 1 thru length(byOpt[c]) do ( - no_by : byOpt[c][byI], - no_byStr : byStr[byI], - - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - for surfDir : 1 thru c do ( - dirlabel : varsC[surfDir], - - for edgeI : 1 thru 2 do ( - edge : edgeBool[edgeI], - edgeStr : edgeOpt[edgeI], - - funcName : sconcat("gk_collisionless_flux_",em_label,no_byStr,mb_boundStr,edgeStr,dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName) - ) - ) - ), - - dirlabel : varsV[1], - edgeStr : edgeOpt[1], - edge : false, - funcName : sconcat("gk_collisionless_flux_",em_label,no_byStr,edgeStr,dirlabel,"_",c,"x",v,"v_",bName[bInd],"_p",polyOrder), - printf(fh, "GKYL_CU_DH double ~a( - const double *w, const double *dxv, - const double *vmap_prime_l, const double *vmap_prime_r, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, - const double *bmag, const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf); ~%", funcName), - - printf(fh, "~%") - ) - ) - ) - ) + for bInd : 1 thru length(bName) do ( + for c : minCdim[bInd] thru maxCdim[bInd] do ( + for gkV : 1 thru length(gkVdims[c]) do ( + v : gkVdims[c][gkV], + + maxPolyOrderB : maxPolyOrder[bInd], + if (c=3) then maxPolyOrderB : 1, /* Only declare p=1 kernels for 3x2v */ + for polyOrder : 1 thru maxPolyOrderB do ( + + for byI : 1 thru length(byOpt[c]) do ( + no_by : byOpt[c][byI], + no_byStr : byStr[byI], + + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + for surfDir : 1 thru c do ( + dirlabel : varsC[surfDir], + extraargs : "const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ", + vprimeargs : "", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs), + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~a~aedge_surf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, + const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, mb_boundStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ) + ), + + dirlabel : varsV[1], + extraargs : "const struct gkyl_dg_vol_geom *dgv, const struct gkyl_gk_dg_vol_geom *gkdgv, ", + vprimeargs : "const double *vmap_prime_l, const double *vmap_prime_r, ", + + printf(fh, "GKYL_CU_DH double gk_collisionless_flux_~asurf~a_~ax~av_~a_p~a( + const double *w, const double *dxv, + ~a + const double *vmap, const double *vmapSq, const double q_, const double m_, + ~a + const double *bmag, const double *phi, const double *JfL, const double *JfR, + double* GKYL_RESTRICT flux_surf); ~%", no_byStr, dirlabel, c, v, bName[bInd], polyOrder, vprimeargs, extraargs) + ), + + printf(fh, "~%") + ) + ) ) - ), - - printf(fh,"GKYL_CU_DH double gk_collisionless_flux_surf_return_zero( - const double *w, const double *dxv, - const double *vmap, const double *vmapSq, const double q_, const double m_, - const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, - const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, - const double *phi, const double *apar, const double *apardot, const double *JfL, const double *JfR, - double* GKYL_RESTRICT flux_surf);~%") + ) )$ -fh : openw(sconcat(outputDir,"gkyl_gk_collisionless_flux_kernels.h"))$ +fh : openw("~/max-out/gkyl_gk_collisionless_flux_kernels.h")$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%")$ diff --git a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac index 8120b8e5..25581b85 100644 --- a/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac +++ b/maxima/g0/gk_collisionless/ms-gk_collisionless_flux.mac @@ -8,9 +8,6 @@ load("gk_collisionless/gk_collisionless_flux-surf-vpar")$ /* ...... USER INPUTS........ */ -/* Output directory for generated files. */ -outputDir : "~/max-out/"$ - /* Serendipity basis. */ minPolyOrder_Ser : 1$ maxPolyOrder_Ser : 1$ @@ -43,127 +40,66 @@ vlabels : ["vpar","mu"]$ byOpt : [[false], [false, true], [false, true]]$ byStr : ["", "no_by_"]$ -/* Options for writing electromagnetic and electrostatic kernels. */ -emBool : [false, true]$ -emOpt : ["", "em_"]$ - /* Options for writing kernels used at multiblock boundaries. One for each dimension. */ mb_bcOpt : [[false,true],[false,true],[false,true]]$ mb_bcStr : ["", "multib_boundary_"]$ -/* Options for writing kernels at surface and edge surfaces. */ -edgeBool : [false, true]$ -edgeOpt : ["surf", "edge_surf"]$ - /* Generate kernels of selected types. */ for bInd : 1 thru length(bName) do ( - bStr : bName[bInd], - /* Loop over configuration space dimensions. */ for c : minCdim[bInd] thru maxCdim[bInd] do ( - /* Loop over velocity space dimensions. */ for gkV : 1 thru length(gkVdims[c]) do ( v : gkVdims[c][gkV], + maxPolyOrderB : maxPolyOrder[bInd], if (c=3) then maxPolyOrderB : 1, /* Only generate p=1 kernels for 3x2v */ - /* Loop over polynomial order. */ - for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( - /* With/without toroidal field loop. */ + for polyOrder : minPolyOrder[bInd] thru maxPolyOrderB do ( for byI : 1 thru length(byOpt[c]) do ( no_by : byOpt[c][byI], no_byStr : byStr[byI], - /* Electrostatic/electromagnetic loop. */ - for emI : 1 thru length(emOpt) do ( - em : emBool[emI], - emStr : emOpt[emI], - - /* Singleblock/multiblock loop. */ - for mbI : 1 thru length(mb_bcOpt[c]) do ( - mb_bound : mb_bcOpt[c][mbI], - mb_boundStr : mb_bcStr[mbI], - - /* Configuration space surface direction loop. */ - for dir : 1 thru c do ( - dirStr : clabels[dir], - - /* Surface/edge surface loop. */ - for edgeI : 1 thru length(edgeBool) do ( - edge : edgeBool[edgeI], - edgeStr : edgeOpt[edgeI], - - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, scheme), - close(fh), - - if (em) then ( - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating ~a flux surf~a ~a ~a file: ~a",edgeStr,dirStr,no_byStr,mb_boundStr,fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,mb_boundStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxConfKernel(dir, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, mb_bound, scheme), - close(fh) - ) - ) - ), - - /* Surface flux in vparallel direction (no edge).*/ - dirStr : vlabels[1], - edge : false, - edgeStr : edgeOpt[1], - add_apardot : em, /* Add apardot term if EM. */ - - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + for mbI : 1 thru length(mb_bcOpt[c]) do ( + mb_bound : mb_bcOpt[c][mbI], + mb_boundStr : mb_bcStr[mbI], + + /* Surface flux in direction dir in configuration space.*/ + for dir : 1 thru c do ( + + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + fh : openw(fname), printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_",emStr,no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, scheme), + + funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false, mb_bound), close(fh), - - if (em) then ( - /* Add EM terms but not Apardot (star term) */ - add_apardot : false, - - scheme : "upwind", - fname : sconcat(outputDir,"gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder, ".c"), - disp(printf(false,"Creating flux surfvpar file: ~a",fname)), - fh : openw(fname), - printf(fh, "#include ~%"), - funcName : sconcat("gk_collisionless_flux_em_star_",no_byStr,edgeStr,dirStr,"_", c, "x", v, "v_", bStr, "_p", polyOrder), - buildGKFluxVparKernel(c+1, fh, funcName, c, v, bStr, polyOrder, no_by, em, edge, add_apardot, scheme), - close(fh) - ) + + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux edge surf~a ~a ~a file: ~a",clabels[dir],no_byStr,mb_boundStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_",no_byStr,mb_boundStr,"edge_surf",clabels[dir],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxConfESKernel(dir, fh, funcName, c, v, bName[bInd], polyOrder, no_by, true, mb_bound), + close(fh) ) - ) + ), + + /* Surface flux in vparallel direction.*/ + fname : sconcat("~/max-out/gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder, ".c"), + disp(printf(false,"Creating flux surfvpar ~a file: ~a",no_byStr,fname)), + + fh : openw(fname), + printf(fh, "#include ~%"), + + funcName : sconcat("gk_collisionless_flux_",no_byStr,"surf",vlabels[1],"_", c, "x", v, "v_", bName[bInd], "_p", polyOrder), + buildGKFluxVparESKernel(c+1, fh, funcName, c, v, bName[bInd], polyOrder, no_by, false), + close(fh) ) ) ) ) )$ - -/* Generate the return zero kernel */ -fname : sconcat(outputDir,"gk_collisionless_flux_surf_return_zero.c")$ -disp(printf(false,"Creating return zero kernel file: ~a",fname))$ -fh : openw(fname)$ -printf(fh, "#include ~%")$ -printf(fh, "GKYL_CU_DH double gk_collisionless_flux_surf_return_zero(~%")$ -printf(fh, " const double *w, const double *dxv,~%")$ -printf(fh, " const double *vmap, const double *vmapSq, const double q_, const double m_,~%")$ -printf(fh, " const struct gkyl_dg_surf_geom *dgs, const struct gkyl_gk_dg_surf_geom *gkdgs, ~%")$ -printf(fh, " const double *bmag, const double *jacobgeo_rat_surfL, const double *jacobgeo_rat_surfR, ~%")$ -printf(fh, " const double *phi, const double *apar, const double *apardot, ~%")$ -printf(fh, " const double *JfL, const double *JfR, double* GKYL_RESTRICT flux_surf) ~%")$ -printf(fh, "{ ~%")$ -printf(fh, " return 0.0; ~%")$ -printf(fh, "}~%")$ -close(fh)$ diff --git a/maxima/g0/gk_collisionless/verify_no_leak.mac b/maxima/g0/gk_collisionless/verify_no_leak.mac deleted file mode 100644 index 90621efd..00000000 --- a/maxima/g0/gk_collisionless/verify_no_leak.mac +++ /dev/null @@ -1,21 +0,0 @@ -kill(all)$ -/* load("dg_gk-vol.mac")$ */ -/* load("nodal_operations/node_locations")$ */ -/* load(stringproc)$ */ -/* fpprec : 24$ */ -/* load("eigen")$ */ - -/* values()$ */ -/* print(values)$ */ - -load("modal-basis")$ - -vars : [z,v,m]$ -n : 1$ -basis : makeSerendipBasis(vars, n)$ - -print("Serendipity basis:")$ -for i : 1 thru length(basis) do ( - printf(true, " basis[~a] = ~a~%", i, basis[i]) -)$ - From 7fdc7a0e288e4e8e0d4f05de0369317eb9974fe0 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 28 May 2026 18:56:59 -0400 Subject: [PATCH 44/54] remove the converged surrogate kernels --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 1ff392de..14ab2d7b 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -121,12 +121,9 @@ for bInd : 1 thru length(bName) do ( )$ /* surrogate kernels. */ -convEval : ["", "conv_"]$ for cdim : minDim_Ser thru maxDim_Ser do ( - for sC : 1 thru length(convEval) do ( - for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", convEval[sC], edge[sI], cdim) - ) + for sI : 1 thru length(edge) do ( + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", edge[sI], cdim) ) )$ From f46be8042cc0b4fde2c7522407aad041809fc54f Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 28 May 2026 18:57:14 -0400 Subject: [PATCH 45/54] adapt the kernels to use the surface representation of bimpact angle --- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 94 ++++++------ maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 133 ++++++++--------- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 137 +++++++++--------- 3 files changed, 174 insertions(+), 190 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 0a8e787c..801219f8 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -45,57 +45,51 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( edge : ["lower", "upper"], surfPerpVal : [-1, 1], - /* Generate separate kernels for conv. eval or unconstrained eval of surrogate */ - convEval : ["", "conv_"], - - for sC : 1 thru length(convEval) do ( - - for sI : 1 thru length(edge) do ( + for sI : 1 thru length(edge) do ( + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", convEval[sC], edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), - - /* Define nodal values */ - printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), - printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), - printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), - printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), - printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), - printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, "~%"), - - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), - printf(fh, "~%"), - - for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), - printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_~aeval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%", convEval[sC]), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), - printf(fh, "~%") - ), - - /* Reconstruct the mu modal representation via a nodal-modal conversion. */ - vcut_fact_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcut_fact_n, bNMu)), - - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), - - - printf(fh, "}~%") - ) + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + /* bimpact_angle lives on the surface (0D for 1x) basis; no z-substitution needed. */ + bimpactAngle_e : doExpand1(bimpact_angle, [1]), + + /* Define nodal values */ + printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), + printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), + printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), + printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), + printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), + printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, "~%"), + + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") + ), + + /* Reconstruct the mu modal representation via a nodal-modal conversion. */ + vcut_fact_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcut_fact_n, bNMu)), + + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + + + printf(fh, "}~%") ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 6d8f84a3..9e1d0ae8 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -49,84 +49,79 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], surfPerpVal : [-1, 1], - - /* Generate separate kernels for conv. eval or unconstrained eval of surrogate */ - convEval : ["", "conv_"], - for sC : 1 thru length(convEval) do ( - for sI : 1 thru length(edge) do ( + for sI : 1 thru length(edge) do ( + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", convEval[sC], edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), - - /* Evaluate at x nodes */ - phi_q : evAtNodes(phi_e, nodesX, VarsX), - phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), - density_q : evAtNodes(density_e, nodesX, VarsX), - temperature_q : evAtNodes(temperature_e, nodesX, VarsX), - bmag_q : evAtNodes(bmag_e, nodesX, VarsX), - bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), - - printf(fh, " double phi_n; ~%"), - printf(fh, " double phi_wall_n; ~%"), - printf(fh, " double dens_n; ~%"), - printf(fh, " double temp_n; ~%"), - printf(fh, " double bmag_n; ~%"), - printf(fh, " double angle_n; ~%"), - - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + /* bimpact_angle lives on the surface (x) basis; no z-substitution needed. */ + bimpactAngle_e : doExpand1(bimpact_angle, bX), + + /* Evaluate at x nodes */ + phi_q : evAtNodes(phi_e, nodesX, VarsX), + phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), + density_q : evAtNodes(density_e, nodesX, VarsX), + temperature_q : evAtNodes(temperature_e, nodesX, VarsX), + bmag_q : evAtNodes(bmag_e, nodesX, VarsX), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), + + printf(fh, " double phi_n; ~%"), + printf(fh, " double phi_wall_n; ~%"), + printf(fh, " double dens_n; ~%"), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double angle_n; ~%"), + + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + vcut_factX_e : makelist(0,i,1,numNodesX), + + for i : 1 thru numNodesX do ( + printf(fh, " // node (x)_~a ~%", i-1), + + /* Define nodal values */ + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), printf(fh, "~%"), - vcut_factX_e : makelist(0,i,1,numNodesX), - - for i : 1 thru numNodesX do ( - printf(fh, " // node (x)_~a ~%", i-1), - - /* Define nodal values */ - printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), - printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), - printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), - printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), - printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), - printf(fh, "~%"), - - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ - for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), - printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_~aeval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%", convEval[sC]), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), - printf(fh, "~%") - ), - - /* Expansion in mu at each (x)_i node. */ - vcut_factX_e[i] : doExpand1(vcut_fact_n, bNMu) + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") ), - /* We project the mu expansion at each x node onto the x,mu basis. */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcut_factX_e, bNX)))), - vcut_fact_e : doExpand(vcut_fact_c, bX), + /* Expansion in mu at each (x)_i node. */ + vcut_factX_e[i] : doExpand1(vcut_fact_n, bNMu) + ), + + /* We project the mu expansion at each x node onto the x,mu basis. */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcut_factX_e, bNX)))), + vcut_fact_e : doExpand(vcut_fact_c, bX), - /* Project expansion onto confperp + mu basis */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_fact_e))), + /* Project expansion onto confperp + mu basis */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_fact_e))), - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), - printf(fh, "}~%") - ) + printf(fh, "}~%") ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index e34a7bdb..c60ba696 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -50,82 +50,77 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( edge : ["lower", "upper"], surfPerpVal : [-1, 1], - /* Generate separate kernels for conv. eval or unconstrained eval of surrogate */ - convEval : ["", "conv_"], - - for sC : 1 thru length(convEval) do ( - for sI : 1 thru length(edge) do ( + for sI : 1 thru length(edge) do ( + printf(fh, "~%"), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Expand input fields at the sheath surface. */ + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + /* bimpact_angle lives on the surface (x,y) basis; no z-substitution needed. */ + bimpactAngle_e : doExpand1(bimpact_angle, bXY), + + /* Evaluate at perpendicular config space nodes */ + phi_q : evAtNodes(phi_e, nodesXY, VarsXY), + phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), + density_q : evAtNodes(density_e, nodesXY, VarsXY), + temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), + bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), + + printf(fh, " double phi_n; ~%"), + printf(fh, " double phi_wall_n; ~%"), + printf(fh, " double dens_n; ~%"), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double angle_n; ~%"), - printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", convEval[sC], edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - bimpactAngle_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bimpact_angle, bC)), - - /* Evaluate at perpendicular config space nodes */ - phi_q : evAtNodes(phi_e, nodesXY, VarsXY), - phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), - density_q : evAtNodes(density_e, nodesXY, VarsXY), - temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), - bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), - bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), - - printf(fh, " double phi_n; ~%"), - printf(fh, " double phi_wall_n; ~%"), - printf(fh, " double dens_n; ~%"), - printf(fh, " double temp_n; ~%"), - printf(fh, " double bmag_n; ~%"), - printf(fh, " double angle_n; ~%"), - - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, "~%"), - - vcut_factXY_e : makelist(0,i,1,numNodesXY), - - for i : 1 thru numNodesXY do ( - printf(fh, " // node (x,y)_~a ~%", i-1), - - /* Define nodal values */ - printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), - printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), - printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), - printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), - printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), - printf(fh, " ~%"), - - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ - for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), - printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_~aeval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%", convEval[sC]), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), - printf(fh, "~%") - ), - - /* Expansion in mu at each perpendicular config space node. */ - vcut_factXY_e[i] : doExpand1(vcut_fact_n, bNMu) + printf(fh, " double mu;~%"), + printf(fh, " double vcut_fact;~%"), + printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + printf(fh, "~%"), + + vcut_factXY_e : makelist(0,i,1,numNodesXY), + + for i : 1 thru numNodesXY do ( + printf(fh, " // node (x,y)_~a ~%", i-1), + + /* Define nodal values */ + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, " ~%"), + + /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ + for j : 1 thru numNodesMu do ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " // node (mu)_~a ~%", j-1), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, "~%") ), - /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcut_factXY_e, bNXY)))), - vcut_fact_e : doExpand(vcut_fact_c, bXY), + /* Expansion in mu at each perpendicular config space node. */ + vcut_factXY_e[i] : doExpand1(vcut_fact_n, bNMu) + ), + + /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcut_factXY_e, bNXY)))), + vcut_fact_e : doExpand(vcut_fact_c, bXY), - /* Project expansion onto confperp + mu basis */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_fact_e))), + /* Project expansion onto confperp + mu basis */ + vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_fact_e))), - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), - printf(fh, "}~%") - ) + printf(fh, "}~%") ) )$ From 537b353453abc68c560971aeec6bfa5086038a24 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Wed, 3 Jun 2026 10:40:39 -0400 Subject: [PATCH 46/54] Split the kernels for surrogate sheath BC in two, one infer and get the raw output, the other interpolates and normalizes. --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 23 +++- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 79 +++++++++--- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 118 ++++++++++++----- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 120 +++++++++++++----- 4 files changed, 254 insertions(+), 86 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 14ab2d7b..23d5b2a4 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -80,6 +80,18 @@ for bInd : 1 thru length(bName) do ( ) ) ), + + for cdim : minDim[bInd] thru maxDim[bInd] do ( + if (polyOrder = 1) then ( + if cdim=1 then ( + genGkSheathInferKer1x2v(fh, cdim, 2, bName[bInd], polyOrder) + ) else if cdim=2 then ( + genGkSheathInferKer2x2v(fh, cdim, 2, bName[bInd], polyOrder) + ) else if cdim=3 then ( + genGkSheathInferKer3x2v(fh, cdim, 2, bName[bInd], polyOrder) + ) + ) + ), close(fh) ) )$ @@ -90,6 +102,8 @@ fh : openw(sconcat(outDir,"/gkyl_bc_sheath_gyrokinetic_kernels.h"))$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ printf(fh, "#include ~%"), +printf(fh, "#include ~%")$ +printf(fh, "#include ~%")$ printf(fh, "#include ~%")$ printf(fh, "#include ~%")$ printf(fh, "~%")$ @@ -123,7 +137,14 @@ for bInd : 1 thru length(bName) do ( /* surrogate kernels. */ for cdim : minDim_Ser thru maxDim_Ser do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax2v_ser_p1(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ; ~%", edge[sI], cdim) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax2v_ser_p1(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ; ~%", edge[sI], cdim) + ) +)$ + +/* infer kernels. */ +for cdim : minDim_Ser thru maxDim_Ser do ( + for sI : 1 thru length(edge) do ( + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax2v_ser_p1(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ; ~%", edge[sI], cdim) ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 801219f8..6eb5b8ed 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -47,28 +47,18 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + /* Vcut_fact kernel: takes pre-computed NN output nn_out (SRGRZ_N_MU values), + evaluates vcut at mu nodes via interpolation, and projects to DG. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Only temperature and bmag are needed to compute mu_ref = T/B. */ temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - /* bimpact_angle lives on the surface (0D for 1x) basis; no z-substitution needed. */ - bimpactAngle_e : doExpand1(bimpact_angle, [1]), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - /* Define nodal values */ - printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), - printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), - printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), - printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), + printf(fh, " double mu_ref = temp_n/bmag_n;~%"), printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, "~%"), - - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ printf(fh, " double mu;~%"), printf(fh, " double vcut_fact;~%"), printf(fh, "~%"), @@ -77,7 +67,7 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interp(nn_out, &mu, 1, mu_ref, &vcut_fact);~%"), printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), printf(fh, "~%") ), @@ -88,7 +78,60 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Write coefficients. */ writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + printf(fh, "}~%") + ) +)$ + +/* Generate the infer kernel: evaluates NN features at the sheath surface + and runs gkyl_kann_net_apply, writing SRGRZ_N_MU raw outputs to *out. + For 1x the perpendicular space is 0D so there is a single inference call. */ +genGkSheathInferKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVarsC, + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, + edge,surfPerpVal,sI], + + pdim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + NP : length(bP), + varsV : copylist(varsP), for d : 1 thru cdim do (varsV : delete(varsC[d],varsV)), + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + surfPerpVar : varsC[cdim], + surfVarsC : delete(surfPerpVar, varsC), /* = [] */ + + edge : ["lower", "upper"], + surfPerpVal : [-1, 1], + + for sI : 1 thru length(edge) do ( + printf(fh, "~%"), + /* Infer kernel: evaluates (alpha, gamma, phinorm) at the sheath surface, + calls gkyl_kann_net_apply, stores SRGRZ_N_MU outputs to *out. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax~av_~a_p~a(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : doExpand1(bimpact_angle, [1]), /* 0D surface for 1x */ + + printf(fh, " double phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_e)))), + printf(fh, " double phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_e)))), + printf(fh, " double dens_n = ~a; ~%", gcfac(float(fullratsimp(density_e)))), + printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), + printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), + printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), + printf(fh, "~%"), + printf(fh, " inp_k->vals[0][0] = (float)(angle_n*(180.0/GKYL_PI));~%"), + printf(fh, " inp_k->vals[0][1] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), + printf(fh, " inp_k->vals[0][2] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), + printf(fh, "~%"), + printf(fh, " gkyl_kann_net_apply(net, inp_k, out_k);~%"), + printf(fh, "~%"), + printf(fh, " for (int i = 0; i < SRGRZ_N_MU; i++)~%"), + printf(fh, " out[i] = (double)out_k->vals[0][i];~%"), printf(fh, "}~%") ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 9e1d0ae8..504449ac 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -52,63 +52,45 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + /* Vcut_fact kernel: takes pre-computed NN output nn_out (numNodesX*SRGRZ_N_MU values), + evaluates vcut at mu nodes via interpolation per x-node, projects to DG. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Only temperature and bmag are needed: mu_ref = T/B varies per x-node. */ temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - /* bimpact_angle lives on the surface (x) basis; no z-substitution needed. */ - bimpactAngle_e : doExpand1(bimpact_angle, bX), - - /* Evaluate at x nodes */ - phi_q : evAtNodes(phi_e, nodesX, VarsX), - phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), - density_q : evAtNodes(density_e, nodesX, VarsX), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), temperature_q : evAtNodes(temperature_e, nodesX, VarsX), - bmag_q : evAtNodes(bmag_e, nodesX, VarsX), - bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), + bmag_q : evAtNodes(bmag_e, nodesX, VarsX), - printf(fh, " double phi_n; ~%"), - printf(fh, " double phi_wall_n; ~%"), - printf(fh, " double dens_n; ~%"), printf(fh, " double temp_n; ~%"), printf(fh, " double bmag_n; ~%"), - printf(fh, " double angle_n; ~%"), - + printf(fh, " double mu_ref; ~%"), printf(fh, " double mu;~%"), printf(fh, " double vcut_fact;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + for i : 1 thru numNodesX do ( + printf(fh, " double vcut_fact_n_~a[~a] = {0.}; ~%", i-1, numNodesMu) + ), printf(fh, "~%"), vcut_factX_e : makelist(0,i,1,numNodesX), for i : 1 thru numNodesX do ( printf(fh, " // node (x)_~a ~%", i-1), - - /* Define nodal values */ - printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), - printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), - printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, " mu_ref = temp_n/bmag_n;~%"), printf(fh, "~%"), - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ for j : 1 thru numNodesMu do ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interp(nn_out+~a*SRGRZ_N_MU, &mu, 1, mu_ref, &vcut_fact);~%", i-1), + printf(fh, " vcut_fact_n_~a[~a] = vcut_fact;~%", i-1, j-1), printf(fh, "~%") ), - /* Expansion in mu at each (x)_i node. */ - vcut_factX_e[i] : doExpand1(vcut_fact_n, bNMu) + vcut_factX_e[i] : doExpand(makelist(concat(vcut_fact_n_, i-1)[j-1], j, 1, numNodesMu), bNMu) ), /* We project the mu expansion at each x node onto the x,mu basis. */ @@ -125,3 +107,73 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( ) )$ +/* Generate the infer kernel for 2x2v: loops over x-nodes, evaluates NN features + at each node, calls gkyl_kann_net_apply, writes SRGRZ_N_MU outputs per node + to out[node*SRGRZ_N_MU .. (node+1)*SRGRZ_N_MU - 1]. */ +genGkSheathInferKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsX, + bX,nodesX,numNodesX,i,edge,surfPerpVal,sI, + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, + phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q], + + pdim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + NP : length(bP), + varsV : copylist(varsP), for d : 1 thru cdim do (varsV : delete(varsC[d],varsV)), + + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + surfPerpVar : varsC[cdim], + VarsX : delete(surfPerpVar, varsC), /* = x. */ + + bX : basisFromVars("ser",[x],polyOrder), + nodesX : gaussOrdGkHyb(polyOrder+1, VarsX, []), + numNodesX : length(nodesX), + + edge : ["lower", "upper"], + surfPerpVal : [-1, 1], + + for sI : 1 thru length(edge) do ( + printf(fh, "~%"), + /* Infer kernel: evaluates (alpha,gamma,phinorm) per x-node, runs NN once per node, + and stores SRGRZ_N_MU outputs at out[node*SRGRZ_N_MU]. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax~av_~a_p~a(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : doExpand1(bimpact_angle, bX), /* bimpact_angle lives on x basis */ + + phi_q : evAtNodes(phi_e, nodesX, VarsX), + phiWall_q : evAtNodes(phiWall_e, nodesX, VarsX), + density_q : evAtNodes(density_e, nodesX, VarsX), + temperature_q : evAtNodes(temperature_e, nodesX, VarsX), + bmag_q : evAtNodes(bmag_e, nodesX, VarsX), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesX, VarsX), + + printf(fh, " double phi_n, phi_wall_n, dens_n, temp_n, bmag_n, angle_n;~%"), + printf(fh, "~%"), + + for i : 1 thru numNodesX do ( + printf(fh, " // node (x)_~a ~%", i-1), + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, " inp_k->vals[0][0] = (float)(angle_n*(180.0/GKYL_PI));~%"), + printf(fh, " inp_k->vals[0][1] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), + printf(fh, " inp_k->vals[0][2] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), + printf(fh, " gkyl_kann_net_apply(net, inp_k, out_k);~%"), + printf(fh, " for (int _i = 0; _i < SRGRZ_N_MU; _i++) out[~a*SRGRZ_N_MU+_i] = (double)out_k->vals[0][_i];~%", i-1), + printf(fh, "~%") + ), + + printf(fh, "}~%") + ) +)$ + diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index c60ba696..f9f7e144 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -52,63 +52,45 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_surrogate_~a_~ax~av_~a_p~a(const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double q2Dm, const double *bmag, const double *bimpact_angle, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Expand input fields at the sheath surface. */ - phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), - density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + /* Vcut_fact kernel: takes pre-computed NN output nn_out (numNodesXY*SRGRZ_N_MU values), + evaluates vcut at mu nodes via interpolation per (x,y)-node, projects to DG. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + /* Only temperature and bmag are needed: mu_ref = T/B varies per (x,y)-node. */ temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - /* bimpact_angle lives on the surface (x,y) basis; no z-substitution needed. */ - bimpactAngle_e : doExpand1(bimpact_angle, bXY), - - /* Evaluate at perpendicular config space nodes */ - phi_q : evAtNodes(phi_e, nodesXY, VarsXY), - phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), - density_q : evAtNodes(density_e, nodesXY, VarsXY), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), - bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), - bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), + bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), - printf(fh, " double phi_n; ~%"), - printf(fh, " double phi_wall_n; ~%"), - printf(fh, " double dens_n; ~%"), printf(fh, " double temp_n; ~%"), printf(fh, " double bmag_n; ~%"), - printf(fh, " double angle_n; ~%"), - + printf(fh, " double mu_ref; ~%"), printf(fh, " double mu;~%"), printf(fh, " double vcut_fact;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), + for i : 1 thru numNodesXY do ( + printf(fh, " double vcut_fact_n_~a[~a] = {0.}; ~%", i-1, numNodesMu) + ), printf(fh, "~%"), vcut_factXY_e : makelist(0,i,1,numNodesXY), for i : 1 thru numNodesXY do ( printf(fh, " // node (x,y)_~a ~%", i-1), - - /* Define nodal values */ - printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), - printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), - printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), - printf(fh, " ~%"), + printf(fh, " mu_ref = temp_n/bmag_n;~%"), + printf(fh, "~%"), - /* Loop over (mu)_j nodes to fill the nodal values of vcut_fact. */ for j : 1 thru numNodesMu do ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_eval_fact(&mu, 1, phi_n, phi_wall_n, dens_n, temp_n, q2Dm, bmag_n, angle_n, &vcut_fact);~%"), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interp(nn_out+~a*SRGRZ_N_MU, &mu, 1, mu_ref, &vcut_fact);~%", i-1), + printf(fh, " vcut_fact_n_~a[~a] = vcut_fact;~%", i-1, j-1), printf(fh, "~%") ), - /* Expansion in mu at each perpendicular config space node. */ - vcut_factXY_e[i] : doExpand1(vcut_fact_n, bNMu) + vcut_factXY_e[i] : doExpand(makelist(concat(vcut_fact_n_, i-1)[j-1], j, 1, numNodesMu), bNMu) ), /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ @@ -124,3 +106,73 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, "}~%") ) )$ + +/* Generate the infer kernel for 3x2v: loops over (x,y)-nodes, evaluates NN features + at each node, calls gkyl_kann_net_apply, writes SRGRZ_N_MU outputs per node + to out[node*SRGRZ_N_MU .. (node+1)*SRGRZ_N_MU - 1]. */ +genGkSheathInferKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, + bXY,nodesXY,numNodesXY,i,edge,surfPerpVal,sI, + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, + phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q], + + pdim : cdim+vdim, + + [varsC,bC,varsP,bP,vSub] : loadGkBasis(basisFun, cdim, vdim, polyOrder), + NP : length(bP), + varsV : copylist(varsP), for d : 1 thru cdim do (varsV : delete(varsC[d],varsV)), + + [vmap_e,vmapSq_e,vmap_prime_e] : expandVmapFields(varsP), + + surfPerpVar : varsC[cdim], + VarsXY : delete(surfPerpVar, varsC), /* = [x, y]. */ + + bXY : basisFromVars("ser",VarsXY,polyOrder), + nodesXY : gaussOrdGkHyb(polyOrder+1, VarsXY, []), + numNodesXY : length(nodesXY), + + edge : ["lower", "upper"], + surfPerpVal : [-1, 1], + + for sI : 1 thru length(edge) do ( + printf(fh, "~%"), + /* Infer kernel: evaluates (alpha,gamma,phinorm) per (x,y)-node, runs NN once per node, + and stores SRGRZ_N_MU outputs at out[node*SRGRZ_N_MU]. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax~av_~a_p~a(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + density_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(density, bC)), + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + bimpactAngle_e : doExpand1(bimpact_angle, bXY), /* bimpact_angle lives on (x,y) basis */ + + phi_q : evAtNodes(phi_e, nodesXY, VarsXY), + phiWall_q : evAtNodes(phiWall_e, nodesXY, VarsXY), + density_q : evAtNodes(density_e, nodesXY, VarsXY), + temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), + bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), + bimpactAngle_q : evAtNodes(bimpactAngle_e, nodesXY, VarsXY), + + printf(fh, " double phi_n, phi_wall_n, dens_n, temp_n, bmag_n, angle_n;~%"), + printf(fh, "~%"), + + for i : 1 thru numNodesXY do ( + printf(fh, " // node (x,y)_~a ~%", i-1), + printf(fh, " phi_n = ~a; ~%", gcfac(float(fullratsimp(phi_q[i])))), + printf(fh, " phi_wall_n = ~a; ~%", gcfac(float(fullratsimp(phiWall_q[i])))), + printf(fh, " dens_n = ~a; ~%", gcfac(float(fullratsimp(density_q[i])))), + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), + printf(fh, " inp_k->vals[0][0] = (float)(angle_n*(180.0/GKYL_PI));~%"), + printf(fh, " inp_k->vals[0][1] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), + printf(fh, " inp_k->vals[0][2] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), + printf(fh, " gkyl_kann_net_apply(net, inp_k, out_k);~%"), + printf(fh, " for (int _i = 0; _i < SRGRZ_N_MU; _i++) out[~a*SRGRZ_N_MU+_i] = (double)out_k->vals[0][_i];~%", i-1), + printf(fh, "~%") + ), + + printf(fh, "}~%") + ) +)$ From 3603e302690473785705ce78f4a0d3867b92fdd3 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Wed, 3 Jun 2026 17:56:44 -0400 Subject: [PATCH 47/54] Include the stride as input and change the double to float arrays --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 12 +++++----- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 22 ++++++++----------- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 20 ++++++++--------- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 20 ++++++++--------- 4 files changed, 33 insertions(+), 41 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 23d5b2a4..e96f94c5 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -84,11 +84,11 @@ for bInd : 1 thru length(bName) do ( for cdim : minDim[bInd] thru maxDim[bInd] do ( if (polyOrder = 1) then ( if cdim=1 then ( - genGkSheathInferKer1x2v(fh, cdim, 2, bName[bInd], polyOrder) + genGkSheathInputKer1x2v(fh, cdim, 2, bName[bInd], polyOrder) ) else if cdim=2 then ( - genGkSheathInferKer2x2v(fh, cdim, 2, bName[bInd], polyOrder) + genGkSheathInputKer2x2v(fh, cdim, 2, bName[bInd], polyOrder) ) else if cdim=3 then ( - genGkSheathInferKer3x2v(fh, cdim, 2, bName[bInd], polyOrder) + genGkSheathInputKer3x2v(fh, cdim, 2, bName[bInd], polyOrder) ) ) ), @@ -137,14 +137,14 @@ for bInd : 1 thru length(bName) do ( /* surrogate kernels. */ for cdim : minDim_Ser thru maxDim_Ser do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax2v_ser_p1(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ; ~%", edge[sI], cdim) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax2v_ser_p1(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ; ~%", edge[sI], cdim) ) )$ -/* infer kernels. */ +/* input builder kernels. */ for cdim : minDim_Ser thru maxDim_Ser do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax2v_ser_p1(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ; ~%", edge[sI], cdim) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_build_input_~a_~ax2v_ser_p1(const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, int n_inp, float *nn_inp_out) ; ~%", edge[sI], cdim) ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 6eb5b8ed..bb7b4844 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -49,7 +49,7 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, "~%"), /* Vcut_fact kernel: takes pre-computed NN output nn_out (SRGRZ_N_MU values), evaluates vcut at mu nodes via interpolation, and projects to DG. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Only temperature and bmag are needed to compute mu_ref = T/B. */ temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), @@ -67,7 +67,7 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interp(nn_out, &mu, 1, mu_ref, &vcut_fact);~%"), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut_fact);~%", j-1), printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), printf(fh, "~%") ), @@ -82,10 +82,10 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( ) )$ -/* Generate the infer kernel: evaluates NN features at the sheath surface +/* Generate the input kernel: constructs NN input features at the sheath surface and runs gkyl_kann_net_apply, writing SRGRZ_N_MU raw outputs to *out. For 1x the perpendicular space is 0D so there is a single inference call. */ -genGkSheathInferKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( +genGkSheathInputKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVarsC, phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, edge,surfPerpVal,sI], @@ -106,9 +106,9 @@ genGkSheathInferKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - /* Infer kernel: evaluates (alpha, gamma, phinorm) at the sheath surface, + /* Input kernel: constructs NN input features at the sheath surface, calls gkyl_kann_net_apply, stores SRGRZ_N_MU outputs to *out. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax~av_~a_p~a(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_build_input_~a_~ax~av_~a_p~a(const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, int n_inp, float *nn_inp_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), @@ -124,14 +124,10 @@ genGkSheathInferKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), printf(fh, "~%"), - printf(fh, " inp_k->vals[0][0] = (float)(angle_n*(180.0/GKYL_PI));~%"), - printf(fh, " inp_k->vals[0][1] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), - printf(fh, " inp_k->vals[0][2] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), + printf(fh, " nn_inp_out[0+n_inp*0] = (float)(angle_n*(180.0/GKYL_PI));~%"), + printf(fh, " nn_inp_out[1+n_inp*0] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), + printf(fh, " nn_inp_out[2+n_inp*0] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), printf(fh, "~%"), - printf(fh, " gkyl_kann_net_apply(net, inp_k, out_k);~%"), - printf(fh, "~%"), - printf(fh, " for (int i = 0; i < SRGRZ_N_MU; i++)~%"), - printf(fh, " out[i] = (double)out_k->vals[0][i];~%"), printf(fh, "}~%") ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 504449ac..f7f0bfb8 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -54,7 +54,7 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, "~%"), /* Vcut_fact kernel: takes pre-computed NN output nn_out (numNodesX*SRGRZ_N_MU values), evaluates vcut at mu nodes via interpolation per x-node, projects to DG. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Only temperature and bmag are needed: mu_ref = T/B varies per x-node. */ temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), @@ -85,7 +85,7 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interp(nn_out+~a*SRGRZ_N_MU, &mu, 1, mu_ref, &vcut_fact);~%", i-1), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut_fact);~%", i-1), printf(fh, " vcut_fact_n_~a[~a] = vcut_fact;~%", i-1, j-1), printf(fh, "~%") ), @@ -110,7 +110,7 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Generate the infer kernel for 2x2v: loops over x-nodes, evaluates NN features at each node, calls gkyl_kann_net_apply, writes SRGRZ_N_MU outputs per node to out[node*SRGRZ_N_MU .. (node+1)*SRGRZ_N_MU - 1]. */ -genGkSheathInferKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( +genGkSheathInputKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsX, bX,nodesX,numNodesX,i,edge,surfPerpVal,sI, phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, @@ -136,9 +136,9 @@ genGkSheathInferKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - /* Infer kernel: evaluates (alpha,gamma,phinorm) per x-node, runs NN once per node, - and stores SRGRZ_N_MU outputs at out[node*SRGRZ_N_MU]. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax~av_~a_p~a(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Input kernel: constructs NN input features at the sheath surface, + calls gkyl_kann_net_apply, stores SRGRZ_N_MU outputs to *out. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_build_input_~a_~ax~av_~a_p~a(const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, int n_inp, float *nn_inp_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), @@ -165,11 +165,9 @@ genGkSheathInferKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), - printf(fh, " inp_k->vals[0][0] = (float)(angle_n*(180.0/GKYL_PI));~%"), - printf(fh, " inp_k->vals[0][1] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), - printf(fh, " inp_k->vals[0][2] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), - printf(fh, " gkyl_kann_net_apply(net, inp_k, out_k);~%"), - printf(fh, " for (int _i = 0; _i < SRGRZ_N_MU; _i++) out[~a*SRGRZ_N_MU+_i] = (double)out_k->vals[0][_i];~%", i-1), + printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), + printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%", i-1), + printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), printf(fh, "~%") ), diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index f9f7e144..60993ac2 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -54,7 +54,7 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, "~%"), /* Vcut_fact kernel: takes pre-computed NN output nn_out (numNodesXY*SRGRZ_N_MU values), evaluates vcut at mu nodes via interpolation per (x,y)-node, projects to DG. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const double *nn_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Only temperature and bmag are needed: mu_ref = T/B varies per (x,y)-node. */ temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), @@ -85,7 +85,7 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interp(nn_out+~a*SRGRZ_N_MU, &mu, 1, mu_ref, &vcut_fact);~%", i-1), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut_fact);~%", i-1), printf(fh, " vcut_fact_n_~a[~a] = vcut_fact;~%", i-1, j-1), printf(fh, "~%") ), @@ -110,7 +110,7 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Generate the infer kernel for 3x2v: loops over (x,y)-nodes, evaluates NN features at each node, calls gkyl_kann_net_apply, writes SRGRZ_N_MU outputs per node to out[node*SRGRZ_N_MU .. (node+1)*SRGRZ_N_MU - 1]. */ -genGkSheathInferKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( +genGkSheathInputKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, bXY,nodesXY,numNodesXY,i,edge,surfPerpVal,sI, phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, @@ -136,9 +136,9 @@ genGkSheathInferKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - /* Infer kernel: evaluates (alpha,gamma,phinorm) per (x,y)-node, runs NN once per node, - and stores SRGRZ_N_MU outputs at out[node*SRGRZ_N_MU]. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_infer_~a_~ax~av_~a_p~a(struct gkyl_kann_net *net, struct gkyl_kn_vec *inp_k, struct gkyl_kn_vec *out_k, const double *vmap, const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, double *out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Input kernel: constructs NN input features at the sheath surface, + calls gkyl_kann_net_apply, stores SRGRZ_N_MU outputs to *out. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_build_input_~a_~ax~av_~a_p~a(const double *phi, const double *phi_wall, const double *density, const double *temperature, const double *bmag, const double *bimpact_angle, int n_inp, float *nn_inp_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), @@ -165,11 +165,9 @@ genGkSheathInferKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), - printf(fh, " inp_k->vals[0][0] = (float)(angle_n*(180.0/GKYL_PI));~%"), - printf(fh, " inp_k->vals[0][1] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), - printf(fh, " inp_k->vals[0][2] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), - printf(fh, " gkyl_kann_net_apply(net, inp_k, out_k);~%"), - printf(fh, " for (int _i = 0; _i < SRGRZ_N_MU; _i++) out[~a*SRGRZ_N_MU+_i] = (double)out_k->vals[0][_i];~%", i-1), + printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), + printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%", i-1), + printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), printf(fh, "~%") ), From ee819224bdaf23861938b259892b33e27ea152d1 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 5 Jun 2026 15:10:56 -0400 Subject: [PATCH 48/54] The reflection kernels expect vcut as an input now. New kernels are created to compute vcut using the conducting sheath model. --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 33 ++++--- maxima/g0/gk-sheath/sheath-1x1v.mac | 29 ++----- maxima/g0/gk-sheath/sheath-1x2v.mac | 37 +++----- maxima/g0/gk-sheath/sheath-2x2v.mac | 38 +++------ maxima/g0/gk-sheath/sheath-3x2v.mac | 37 +++----- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 64 ++++++++------ maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 84 +++++++++++------- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 85 ++++++++++++------- 8 files changed, 214 insertions(+), 193 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index e96f94c5..1016a951 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -69,19 +69,23 @@ for bInd : 1 thru length(bName) do ( ) ), - for cdim : minDim[bInd] thru maxDim[bInd] do ( - if (polyOrder = 1) then ( - if cdim=1 then ( - genGkSheathSurrKer1x2v(fh, cdim, 2, bName[bInd], polyOrder) - ) else if cdim=2 then ( - genGkSheathSurrKer2x2v(fh, cdim, 2, bName[bInd], polyOrder) - ) else if cdim=3 then ( - genGkSheathSurrKer3x2v(fh, cdim, 2, bName[bInd], polyOrder) + for useSurrogate : 0 thru 1 do ( + for cdim : minDim[bInd] thru maxDim[bInd] do ( + print(sconcat("Creating vcut kernels for serendipity basis, surrogate = ", useSurrogate, " for ", cdim, "x2v, p", polyOrder)), + if (polyOrder = 1) then ( + if cdim=1 then ( + genGkSheathVcutCalcKer1x2v(fh, cdim, 2, bName[bInd], polyOrder, useSurrogate) + ) else if cdim=2 then ( + genGkSheathVcutCalcKer2x2v(fh, cdim, 2, bName[bInd], polyOrder, useSurrogate) + ) else if cdim=3 then ( + genGkSheathVcutCalcKer3x2v(fh, cdim, 2, bName[bInd], polyOrder, useSurrogate) + ) ) ) ), for cdim : minDim[bInd] thru maxDim[bInd] do ( + print(sconcat("Creating input builder kernels for serendipity basis for ", cdim, "x2v, p", polyOrder)), if (polyOrder = 1) then ( if cdim=1 then ( genGkSheathInputKer1x2v(fh, cdim, 2, bName[bInd], polyOrder) @@ -126,7 +130,7 @@ for bInd : 1 thru length(bName) do ( for vI : 1 thru length(vDims[cdim]) do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl); ~%", edge[sI], cdim, vDims[cdim][vI], bName[bInd], polyOrder) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double *vcutsq, const double *f, double *fRefl); ~%", edge[sI], cdim, vDims[cdim][vI], bName[bInd], polyOrder) ) ) @@ -134,10 +138,17 @@ for bInd : 1 thru length(bName) do ( ) )$ -/* surrogate kernels. */ +/* Eval vcutconst kernels. */ +for cdim : minDim_Ser thru maxDim_Ser do ( + for sI : 1 thru length(edge) do ( + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_const_~a_~ax2v_ser_p1(const double *phi, const double *phi_wall, double q2Dm, double *vcutSq_n) ; ~%", edge[sI], cdim) + ) +)$ + +/* Eval vcutsq surrogate kernels. */ for cdim : minDim_Ser thru maxDim_Ser do ( for sI : 1 thru length(edge) do ( - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax2v_ser_p1(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ; ~%", edge[sI], cdim) + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_surr_~a_~ax2v_ser_p1(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcutsq_out) ; ~%", edge[sI], cdim) ) )$ diff --git a/maxima/g0/gk-sheath/sheath-1x1v.mac b/maxima/g0/gk-sheath/sheath-1x1v.mac index a046fd57..953f8067 100644 --- a/maxima/g0/gk-sheath/sheath-1x1v.mac +++ b/maxima/g0/gk-sheath/sheath-1x1v.mac @@ -11,7 +11,7 @@ fpprec : 24$ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,vparLo_e,vparUp_e,surfPerpVar, surfVars,surfVarsC,bSurf,bV,bVpar,bMu,numBsurf,zvSurfVars,nodesMu,numNodesMu,bNMu,f_e,edge, - surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c,fSurf_e,fSurfMu_q, + surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutsq_q,fSurf_c,fSurf_e,fSurfMu_q, fReflSurfMu_e,j,nodeIdx,fSurfMu_c,fSurfMu_e,intLims,fReflSurfMu_c, xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c], @@ -54,24 +54,13 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, - where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ - phiSheath_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), - deltaPhi_e : phiSheath_e - phiWall_e, - - /* Evaluate vcutSqQ = vcut^2. q2Dm = q*2/m. */ - deltaPhi_q : deltaPhi_e, - vcutSq_q : gcfac(float(fullratsimp(-q2Dm*deltaPhi_q))), - + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double *vcutsq, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), fSurf_e : doExpand(fSurf_c, bSurf), /* Variable declarations/allocations. */ - printf(fh, " double vcutSq;~%"), printf(fh, " double fReflSurf[~a] = {0.}; ~%", length(bV)), printf(fh, "~%"), @@ -85,13 +74,13 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double vparAbsSqUp = vmap[0]>0.? vparUp*vparUp : vparLo*vparLo;~%"), printf(fh, "~%"), - /* Write vcut^2 at boundary. */ - printf(fh, " vcutSq = ~a; ~%", vcutSq_q), + /* vcutsq is passed as a pre-computed DG field; read the single surface value. */ + printf(fh, " double vcutsq_n = vcutsq[0]; ~%"), printf(fh, "~%"), /* If vcut^2 at this node is below all vpar^2 in this cell, BC at this node should be absorbing so set coefficients of fRefl to 0 (no reflection from this node). */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, " if (vcutsq_n <= vparAbsSqLo) { // absorb (no reflection) ~%"), printf(fh, "~%"), writeCExprsWithZeros1(fReflSurf, makelist(0.,j,1,length(bV))), @@ -99,7 +88,7 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( /* If vcut^2 at this node is above all vpar^2 in this cell, BC at this node should be full reflection. */ /* So set coefficients of fRefl to coefficients of f. */ - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, " } else if (vcutsq_n > vparAbsSqUp) { // full reflection ~%"), printf(fh, "~%"), /* Project f onto vpar basis (bV). */ @@ -124,7 +113,7 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[-1,vcut_l]], @@ -135,7 +124,7 @@ genGkSheathKer1x1v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " } else {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(-sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(-sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[vcut_l,1]], diff --git a/maxima/g0/gk-sheath/sheath-1x2v.mac b/maxima/g0/gk-sheath/sheath-1x2v.mac index 493e3183..ab43f903 100644 --- a/maxima/g0/gk-sheath/sheath-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath-1x2v.mac @@ -11,10 +11,10 @@ fpprec : 24$ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVars, surfVarsC,bSurf,bV,bVpar,bMu,numBsurf,zvSurfVars,nodesMu,numNodesMu,bNMu,f_e,edge, - surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c,fSurf_e, + surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutsq_q,fSurf_c,fSurf_e, fSurfMu_q,vparLo_e,vparUp_e,fReflSurfMu_e,j,nodeIdx,fSurfMu_c,fSurfMu_e,intLims,fReflSurfMu_c, xBar_v,xSqBar_v,fReflSurf_c,fReflSurf_e,fRefl_c, - vcutFact_e,vcutFact_vpar0_e,vcutFact_q,vcutFactVpar_e,nodesVparMu,vcutFact_c,tempVars1,tempVars2], + vcutsq_e,nodesVparMu,tempVars1,tempVars2], pdim : cdim+vdim, @@ -64,11 +64,11 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand vcut_fact on mu basis (bMu). */ - vcutFactVpar_e : doExpand1(vcut_fact, bMu), + /* Expand vcutsq on mu basis (bMu). */ + vcutsq_e : doExpand1(vcutsq, bMu), - /* Evaluate vcut_fact at (mu_j) */ - vcutFact_q : evAtNodes(vcutFactVpar_e, nodesMu, zvSurfVars), + /* Evaluate vcutsq at (mu_j) */ + vcutsq_q : evAtNodes(vcutsq_e, nodesMu, zvSurfVars), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -77,16 +77,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, - where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ - phiSheath_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), - deltaPhi_e : phiSheath_e - phiWall_e, - - /* Evaluate base potential difference: deltaPhi = phiSheath - phiWall. */ - deltaPhi_q : deltaPhi_e, + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double *vcutsq, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), @@ -97,7 +88,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfMu_q : evAtNodes(fSurf_e, nodesMu, zvSurfVars), /* Variable declarations/allocations. */ - printf(fh, " double vcutSq;~%"), + printf(fh, " double vcutsq_n;~%"), printf(fh, " double fReflSurf[~a] = {0.}; ~%", length(bV)), printf(fh, "~%"), @@ -132,17 +123,17 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfMu_q[nodeIdx]))), fSurfMu_e : doExpand(fSurfMu_c, bVpar), - /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_q[nodeIdx]*q2Dm*deltaPhi_q)))), + /* Get vcutsq at this mu node from the DG field. */ + printf(fh, " vcutsq_n = ~a; ~%", gcfac(float(fullratsimp(vcutsq_q[nodeIdx])))), printf(fh, "~%"), /* Check regime at this mu node. */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, " if (vcutsq_n <= vparAbsSqLo) { // absorb (no reflection) ~%"), printf(fh, "~%"), writeCExprsWithZeros1(fReflSurfMu[j-1], makelist(0,i,1,length(bVpar))), printf(fh, "~%"), - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, " } else if (vcutsq_n > vparAbsSqUp) { // full reflection ~%"), printf(fh, "~%"), writeCExprsNoExpand1(fReflSurfMu[j-1], fSurfMu_c), printf(fh, "~%"), @@ -152,7 +143,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[-1,vcut_l]], @@ -163,7 +154,7 @@ genGkSheathKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " } else {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(-sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(-sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[vcut_l,1]], diff --git a/maxima/g0/gk-sheath/sheath-2x2v.mac b/maxima/g0/gk-sheath/sheath-2x2v.mac index ac20b634..ffc406d4 100644 --- a/maxima/g0/gk-sheath/sheath-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath-2x2v.mac @@ -11,10 +11,9 @@ fpprec : 24$ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVars,surfVarsC, bSurf,bV,bVpar,bMu,bX,numBsurf,zvSurfVars,nodesX,nodesXMu,nodesMu,numNodesX,numNodesXMu,numNodesMu, - bNMu,bNX,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutSq_q,fSurf_c, + bNMu,bNX,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q,vcutsq_q,fSurf_c, fSurf_e,fSurfX_q,fSurfXMu_q,fReflSurfX_e,vparLo_e,vparUp_e,i,fSurfX_c,fReflSurfXMu_e,j,nodeIdx, - fSurfXMu_c,fSurfXMu_e,intLims,fReflSurfXMu_c,xBar_v,xSqBar_v,fReflSurfX_c,fReflSurf_c,fReflSurf_e,fRefl_c, - vcutFact_q,vcutFactVpar_e,nodesVparMu,vcutFact_c,tempVars1,tempVars2], + fSurfXMu_c,fSurfXMu_e,intLims,fReflSurfXMu_c,xBar_v,xSqBar_v,fReflSurfX_c,fReflSurf_c,fReflSurf_e,fRefl_c,vcutsq_e,nodesVparMu,tempVars1,tempVars2], pdim : cdim+vdim, @@ -76,11 +75,11 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand vcut_fact on mu basis (bXMu). */ - vcutFactVpar_e : doExpand1(vcut_fact, bXMu), + /* Expand vcut^2 on (x,mu) basis (bXMu). */ + vcutsq_e : doExpand1(vcutsq, bXMu), - /* Evaluate vcut_fact at (x,mu)_ij nodes. */ - vcutFact_q : evAtNodes(vcutFactVpar_e, nodesXMu, zvSurfVars), + /* Evaluate vcutsq at (x,mu)_ij nodes. */ + vcutsq_q : evAtNodes(vcutsq_e, nodesXMu, zvSurfVars), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -89,16 +88,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, - where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ - phiSheath_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), - deltaPhi_e : phiSheath_e - phiWall_e, - - /* Evaluate deltaPhi at x nodes. */ - deltaPhi_q : evAtNodes(deltaPhi_e, nodesX, surfVarsC), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double *vcutsq, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), @@ -109,7 +99,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfX_q : evAtNodes(fSurf_e, nodesX, surfVarsC), fSurfXMu_q : evAtNodes(fSurf_e, nodesXMu, zvSurfVars), - printf(fh, " double vcutSq;~%"), + printf(fh, " double vcutsq_n;~%"), printf(fh, " double fReflSurfX[~a][~a] = {0.}; ~%", numNodesX, length(bV)), /* Reflected f at (x)_i nodes. */ @@ -154,17 +144,17 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfXMu_q[nodeIdx]))), fSurfXMu_e : doExpand(fSurfXMu_c, bVpar), - /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_q[nodeIdx]*q2Dm*deltaPhi_q[i])))), + /* Get vcut^2 at this mu node. */ + printf(fh, " vcutsq_n = ~a; ~%", gcfac(float(fullratsimp(vcutsq_q[nodeIdx])))), printf(fh, "~%"), /* Check regime at this (x,mu) node. */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, " if (vcutsq_n <= vparAbsSqLo) { // absorb (no reflection) ~%"), printf(fh, "~%"), writeCExprsWithZeros1(fReflSurfXMu[j-1], makelist(0,k,1,length(bVpar))), printf(fh, "~%"), - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, " } else if (vcutsq_n > vparAbsSqUp) { // full reflection ~%"), printf(fh, "~%"), writeCExprsNoExpand1(fReflSurfXMu[j-1], fSurfXMu_c), printf(fh, "~%"), @@ -174,7 +164,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[-1,vcut_l]], @@ -185,7 +175,7 @@ genGkSheathKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " } else {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(-sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(-sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[vcut_l,1]], diff --git a/maxima/g0/gk-sheath/sheath-3x2v.mac b/maxima/g0/gk-sheath/sheath-3x2v.mac index fdb826b4..0e3422be 100644 --- a/maxima/g0/gk-sheath/sheath-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath-3x2v.mac @@ -12,10 +12,10 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVars,surfVarsC, bSurf,bV,bVpar,bMu,bXY,numBsurf,zvSurfVars,nodesXY,nodesXYMu,nodesMu,numNodesXY,numNodesXYMu, numNodesMu,bNMu,bNXY,f_e,edge,surfPerpVal,sI,phiSheath_e,phiWall_e,deltaPhi_e,deltaPhi_q, - vcutSq_q,fSurf_c,fSurf_e,fSurfXY_q,fSurfXYMu_q,fReflSurfXY_e,vparLo_e,vparUp_e,i,fSurfXY_c, + vcutsq_q,fSurf_c,fSurf_e,fSurfXY_q,fSurfXYMu_q,fReflSurfXY_e,vparLo_e,vparUp_e,i,fSurfXY_c, fReflSurfXYMu_e,j,nodeIdx,fSurfXYMu_c,fSurfXYMu_e,intLims,fReflSurfXYMu_c,xBar_v,xSqBar_v, fReflSurfXY_c,fReflSurf_c,fReflSurf_e,fRefl_c, - vcutFact_e,vcutFact_vpar0_e,vcutFact_q,vcutFactVpar_e,nodesVparMu,vcutFact_c,tempVars1,tempVars2], + vcutsq_vpar0_e,vcutsq_e,nodesVparMu,vcutsq_c,tempVars1,tempVars2], pdim : cdim+vdim, @@ -77,11 +77,11 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( /* Expand input distribution function f on phase-space basis using input coeffs. */ f_e : doExpand1(f, bP), - /* Expand vcut_fact on vpar,mu basis (bV). */ - vcutFactVpar_e : doExpand1(vcut_fact, bXYMu), + /* Expand vcutsq on (x,y,mu) basis (bXYMu). */ + vcutsq_e : doExpand1(vcutsq, bXYMu), - /* Evaluate vcut_fact at (x,y,mu)_ij nodes. */ - vcutFact_q : evAtNodes(vcutFactVpar_e, nodesXYMu, zvSurfVars), + /* Evaluate vcutsq at (x,y,mu)_ij nodes. */ + vcutsq_q : evAtNodes(vcutsq_e, nodesXYMu, zvSurfVars), /* Generate separate kernels for lower/upper boundaries. */ edge : ["lower", "upper"], @@ -90,16 +90,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, double q2Dm, const double *phi, const double *phiWall, const double *vcut_fact, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Calculate expansion for deltaPhi = phiSheath - phiWall, evaluated at z=zVal, - where zVal=-1 or 1 depending on if we're on the left or right edge of the global domain, respectively. */ - phiSheath_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), - phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phiWall, bC)), - deltaPhi_e : phiSheath_e - phiWall_e, - - /* Evaluate deltaPhi at x,y nodes. */ - deltaPhi_q : evAtNodes(deltaPhi_e, nodesXY, surfVarsC), + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_reflectedf_~a_~ax~av_~a_p~a(const double *vmap, const double *vcutsq, const double *f, double *fRefl) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), /* Evaluate f at the z surface. */ fSurf_c : calcInnerProdList(surfVars, 1, bSurf, subst(surfPerpVar=surfPerpVal[sI], f_e)), @@ -110,7 +101,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXY_q : evAtNodes(fSurf_e, nodesXY, surfVarsC), fSurfXYMu_q : evAtNodes(fSurf_e, nodesXYMu, zvSurfVars), - printf(fh, " double vcutSq;~%"), + printf(fh, " double vcutsq_n;~%"), printf(fh, " double fReflSurfXY[~a][~a] = {0.}; ~%", numNodesXY, length(bV)), /* Reflected f at (x,y)_i nodes. */ @@ -153,17 +144,17 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( fSurfXYMu_c : gcfac(fullratsimp(calcInnerProdList([vpar], 1, bVpar, fSurfXYMu_q[nodeIdx]))), fSurfXYMu_e : doExpand(fSurfXYMu_c, bVpar), - /* Compute vcut^2 at this mu node: vcutSq = alpha(mu) * q2Dm * deltaPhi. */ - printf(fh, " vcutSq = ~a; ~%", gcfac(float(fullratsimp(-vcutFact_q[nodeIdx]*q2Dm*deltaPhi_q[i])))), + /* Get vcutsq at this (x,y,mu) node from the DG field. */ + printf(fh, " vcutsq_n = ~a; ~%", gcfac(float(fullratsimp(vcutsq_q[nodeIdx])))), printf(fh, "~%"), /* Check regime at this (x,y,mu) node. */ - printf(fh, " if (vcutSq <= vparAbsSqLo) { // absorb (no reflection) ~%"), + printf(fh, " if (vcutsq_n <= vparAbsSqLo) { // absorb (no reflection) ~%"), printf(fh, "~%"), writeCExprsWithZeros1(fReflSurfXYMu[j-1], makelist(0,k,1,length(bVpar))), printf(fh, "~%"), - printf(fh, " } else if (vcutSq > vparAbsSqUp) { // full reflection ~%"), + printf(fh, " } else if (vcutsq_n > vparAbsSqUp) { // full reflection ~%"), printf(fh, "~%"), writeCExprsNoExpand1(fReflSurfXYMu[j-1], fSurfXYMu_c), printf(fh, "~%"), @@ -173,7 +164,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " if (wv > 0.) {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[-1,vcut_l]], @@ -184,7 +175,7 @@ genGkSheathKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " } else {~%"), printf(fh, " // vcut in logical space.~%"), - printf(fh, " double vcut_l = 2.*(-sqrt(vcutSq)-wv)/dv;~%"), + printf(fh, " double vcut_l = 2.*(-sqrt(vcutsq_n)-wv)/dv;~%"), printf(fh, "~%"), intLims : [[vcut_l,1]], diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index bb7b4844..4cc7ecc4 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -8,10 +8,10 @@ load("utilities_gyrokinetic")$ load(stringproc)$ fpprec : 24$ -genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( - [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVarsC, +genGkSheathVcutCalcKer1x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,d,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,surfVarsC, bMu,bCperpMu,zvSurfVars,nodesMu,numNodesMu,j,bNMu,edge,surfPerpVal,sI,surfVarsCmu, - phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_fact_e,vcut_fact_c], + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_e,vcut_c], pdim : cdim+vdim, @@ -47,38 +47,50 @@ genGkSheathSurrKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - /* Vcut_fact kernel: takes pre-computed NN output nn_out (SRGRZ_N_MU values), - evaluates vcut at mu nodes via interpolation, and projects to DG. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Only temperature and bmag are needed to compute mu_ref = T/B. */ - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - - printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), - printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), - printf(fh, " double mu_ref = temp_n/bmag_n;~%"), - printf(fh, " double vcut_fact_n[~a] = {0.}; ~%", numNodesMu), - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), + if useSurrogate = 1 then ( + /* vcut kernel: takes pre-computed NN output nn_out (SRGRZ_N_MU values), evaluates vcut at mu nodes via interpolation, and projects to DG. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_surr_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcutsq_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Only temperature and bmag are needed to compute mu_ref = T/B. */ + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + printf(fh, " double temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_e)))), + printf(fh, " double bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_e)))), + printf(fh, " double mu_ref = temp_n/bmag_n;~%"), + printf(fh, " double vthSq = temp_n/GKYL_ELECTRON_MASS;~%"), + printf(fh, " double mu;~%"), + printf(fh, " double vcut;~%") + ) else ( + /* vcut kernel: calculates vcut using conducting sheath model (no surrogate). */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_const_~a_~ax~av_~a_p~a(const double *phi, const double *phi_wall, double q2Dm, double *vcutsq_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + deltaPhi_e : phi_e - phiWall_e, + deltaPhi_q : deltaPhi_e, + printf(fh, " double deltaphi_n = ~a; ~%", gcfac(float(fullratsimp(deltaPhi_q)))) + ), + printf(fh, " double vcutsq_n[~a] = {0.}; ~%", numNodesMu), printf(fh, "~%"), for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut_fact);~%", j-1), - printf(fh, " vcut_fact_n[~a] = vcut_fact;~%", j-1), + if useSurrogate = 1 then ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", j-1), + printf(fh, " vcutsq_n[~a] = vcut*vcut * vthSq;~%", j-1) + ) else ( + printf(fh, " vcutsq_n[~a] = -q2Dm * deltaphi_n;~%", j-1) + ), printf(fh, "~%") ), - /* Reconstruct the mu modal representation via a nodal-modal conversion. */ - vcut_fact_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcut_fact_n, bNMu)), + /* Reconstruct the mu modal representation via a nodal-modal conversion. */ + vcut_c : calcInnerProdList([mu], 1, bMu, doExpand1(vcutsq_n, bNMu)), - /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + /* Write coefficients. */ + writeCExprsWithZerosNoExpand1(vcutsq_out, vcut_c), - printf(fh, "}~%") + printf(fh, "}~%") ) )$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index f7f0bfb8..548f6219 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -8,11 +8,11 @@ load("utilities_gyrokinetic")$ load(stringproc)$ fpprec : 24$ -genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( - [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsX, +genGkSheathVcutCalcKer2x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,d,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsX, bMu,bX,bXMu,VarsXMu,nodesMu,nodesX,numNodesMu,numNodesX,j,i,bNMu,bNX,edge,surfPerpVal,sI,surfVarsCmu, - phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_fact_e,vcut_fact_c, - phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q,vcut_fact,vcut_factX_e], + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_e,vcut_c, + phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q,vcut,vcutX_e], pdim : cdim+vdim, @@ -52,56 +52,74 @@ genGkSheathSurrKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - /* Vcut_fact kernel: takes pre-computed NN output nn_out (numNodesX*SRGRZ_N_MU values), - evaluates vcut at mu nodes via interpolation per x-node, projects to DG. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Only temperature and bmag are needed: mu_ref = T/B varies per x-node. */ - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - temperature_q : evAtNodes(temperature_e, nodesX, VarsX), - bmag_q : evAtNodes(bmag_e, nodesX, VarsX), - - printf(fh, " double temp_n; ~%"), - printf(fh, " double bmag_n; ~%"), - printf(fh, " double mu_ref; ~%"), - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), + if useSurrogate = 1 then ( + /* vcut kernel: takes pre-computed NN output nn_out (numNodesX*SRGRZ_N_MU values), + evaluates vcut at mu nodes via interpolation per x-node, projects to DG. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_surr_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcutsq_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Only temperature and bmag are needed: mu_ref = T/B varies per x-node. */ + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + temperature_q : evAtNodes(temperature_e, nodesX, VarsX), + bmag_q : evAtNodes(bmag_e, nodesX, VarsX), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double mu_ref; ~%"), + printf(fh, " double vthSq; ~%"), + printf(fh, " double mu;~%"), + printf(fh, " double vcut;~%") + ) else ( + /* vcut kernel: calculates vcut using conducting sheath model (no surrogate). */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_const_~a_~ax~av_~a_p~a(const double *phi, const double *phi_wall, double q2Dm, double *vcutsq_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + deltaPhi_e : phi_e - phiWall_e, + deltaPhi_q : evAtNodes(deltaPhi_e, nodesX, VarsX), + printf(fh, " double deltaphi_n; ~%") + ), for i : 1 thru numNodesX do ( - printf(fh, " double vcut_fact_n_~a[~a] = {0.}; ~%", i-1, numNodesMu) + printf(fh, " double vcutsq_n_~a[~a] = {0.}; ~%", i-1, numNodesMu) ), printf(fh, "~%"), - vcut_factX_e : makelist(0,i,1,numNodesX), + vcutX_e : makelist(0,i,1,numNodesX), for i : 1 thru numNodesX do ( printf(fh, " // node (x)_~a ~%", i-1), - printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), - printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " mu_ref = temp_n/bmag_n;~%"), + if useSurrogate = 1 then ( + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " mu_ref = temp_n/bmag_n;~%"), + printf(fh, " vthSq = temp_n/GKYL_ELECTRON_MASS;~%") + ) else ( + printf(fh, " deltaphi_n = ~a; ~%", gcfac(float(fullratsimp(deltaPhi_q[i])))) + ), printf(fh, "~%"), for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut_fact);~%", i-1), - printf(fh, " vcut_fact_n_~a[~a] = vcut_fact;~%", i-1, j-1), + if useSurrogate = 1 then ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), + printf(fh, " vcutsq_n_~a[~a] = vcut*vcut * vthSq;~%", i-1, j-1) + ) else ( + printf(fh, " vcutsq_n_~a[~a] = -q2Dm * deltaphi_n;~%", i-1, j-1) + ), printf(fh, "~%") ), - vcut_factX_e[i] : doExpand(makelist(concat(vcut_fact_n_, i-1)[j-1], j, 1, numNodesMu), bNMu) + vcutX_e[i] : doExpand(makelist(concat(vcutsq_n_, i-1)[j-1], j, 1, numNodesMu), bNMu) ), /* We project the mu expansion at each x node onto the x,mu basis. */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcut_factX_e, bNX)))), - vcut_fact_e : doExpand(vcut_fact_c, bX), + vcut_c : gcfac(fullratsimp(calcInnerProdList(VarsX, 1, bX, doExpand(vcutX_e, bNX)))), + vcut_e : doExpand(vcut_c, bX), /* Project expansion onto confperp + mu basis */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_fact_e))), + vcut_c : gcfac(fullratsimp(calcInnerProdList(VarsXMu, 1, bXMu, vcut_e))), /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + writeCExprsWithZerosNoExpand1(vcutsq_out, vcut_c), printf(fh, "}~%") ) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index 60993ac2..1f0bda1d 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -8,11 +8,11 @@ load("utilities_gyrokinetic")$ load(stringproc)$ fpprec : 24$ -genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( - [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, +genGkSheathVcutCalcKer3x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := block( + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,d,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, bMu,bXY,bXYMu,VarsXYMu,nodesMu,nodesXY,numNodesMu,numNodesXY,j,i,bNMu,bNXY,edge,surfPerpVal,sI,surfVarsCmu, - phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_fact_e,vcut_fact_c, - phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q,vcut_fact,vcut_factXY_e], + phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e,vcut_e,vcut_c, + phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q,vcut,vcutXY_e], pdim : cdim+vdim, @@ -52,56 +52,75 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( for sI : 1 thru length(edge) do ( printf(fh, "~%"), - /* Vcut_fact kernel: takes pre-computed NN output nn_out (numNodesXY*SRGRZ_N_MU values), - evaluates vcut at mu nodes via interpolation per (x,y)-node, projects to DG. */ - printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vparcut_calc_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcut_fact_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), - - /* Only temperature and bmag are needed: mu_ref = T/B varies per (x,y)-node. */ - temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), - bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), - temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), - bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), + if useSurrogate = 1 then ( + /* vcut kernel: takes pre-computed NN output nn_out (numNodesXY*SRGRZ_N_MU values), + evaluates vcut at mu nodes via interpolation per (x,y)-node, projects to DG. */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_surr_~a_~ax~av_~a_p~a(const double *vmap, const float *nn_out, int n_out, const double *temperature, const double *bmag, double *vcutsq_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + /* Only temperature and bmag are needed: mu_ref = T/B varies per (x,y)-node. */ + temperature_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(temperature, bC)), + bmag_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(bmag, bC)), + temperature_q : evAtNodes(temperature_e, nodesXY, VarsXY), + bmag_q : evAtNodes(bmag_e, nodesXY, VarsXY), + printf(fh, " double temp_n; ~%"), + printf(fh, " double bmag_n; ~%"), + printf(fh, " double mu_ref; ~%"), + printf(fh, " double mu;~%"), + printf(fh, " double vthSq;~%"), + printf(fh, " double vcut;~%") + ) else ( + /* vcut kernel: calculates vcut using conducting sheath model (no surrogate). */ + printf(fh, "GKYL_CU_DH void bc_sheath_gyrokinetic_vcutsq_const_~a_~ax~av_~a_p~a(const double *phi, const double *phi_wall, double q2Dm, double *vcutsq_out) ~%{ ~%", edge[sI], cdim, vdim, basisFun, polyOrder), + phi_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi, bC)), + phiWall_e : subst(surfPerpVar=surfPerpVal[sI],doExpand1(phi_wall, bC)), + deltaPhi_e : phi_e - phiWall_e, + deltaphi_q : evAtNodes(deltaPhi_e, nodesXY, VarsXY), + printf(fh, " double deltaphi_n; ~%") + ), - printf(fh, " double temp_n; ~%"), - printf(fh, " double bmag_n; ~%"), - printf(fh, " double mu_ref; ~%"), - printf(fh, " double mu;~%"), - printf(fh, " double vcut_fact;~%"), for i : 1 thru numNodesXY do ( - printf(fh, " double vcut_fact_n_~a[~a] = {0.}; ~%", i-1, numNodesMu) + printf(fh, " double vcutsq_n_~a[~a] = {0.}; ~%", i-1, numNodesMu) ), printf(fh, "~%"), - vcut_factXY_e : makelist(0,i,1,numNodesXY), + vcutXY_e : makelist(0,i,1,numNodesXY), for i : 1 thru numNodesXY do ( printf(fh, " // node (x,y)_~a ~%", i-1), - printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), - printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), - printf(fh, " mu_ref = temp_n/bmag_n;~%"), + if useSurrogate = 1 then ( + printf(fh, " temp_n = ~a; ~%", gcfac(float(fullratsimp(temperature_q[i])))), + printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), + printf(fh, " mu_ref = temp_n/bmag_n;~%"), + printf(fh, " vthSq = temp_n/GKYL_ELECTRON_MASS;~%") + ) else ( + printf(fh, " deltaphi_n = ~a; ~%", gcfac(float(fullratsimp(deltaphi_q[i])))) + ), printf(fh, "~%"), for j : 1 thru numNodesMu do ( - mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " // node (mu)_~a ~%", j-1), - printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut_fact);~%", i-1), - printf(fh, " vcut_fact_n_~a[~a] = vcut_fact;~%", i-1, j-1), + if useSurrogate = 1 then ( + mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), + printf(fh, " mu = ~a; ~%", float(expand(mu_e))), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), + printf(fh, " vcutsq_n_~a[~a] = vcut*vcut * vthSq;~%", i-1, j-1) + ) else ( + printf(fh, " vcutsq_n_~a[~a] = -q2Dm * deltaphi_n;~%", i-1, j-1) + ), printf(fh, "~%") ), - vcut_factXY_e[i] : doExpand(makelist(concat(vcut_fact_n_, i-1)[j-1], j, 1, numNodesMu), bNMu) + vcutXY_e[i] : doExpand(makelist(concat(vcutsq_n_, i-1)[j-1], j, 1, numNodesMu), bNMu) ), /* We project the mu expansion at each perpendicular config space node onto the perp config + mu basis. */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcut_factXY_e, bNXY)))), - vcut_fact_e : doExpand(vcut_fact_c, bXY), + vcut_c : gcfac(fullratsimp(calcInnerProdList(VarsXY, 1, bXY, doExpand(vcutXY_e, bNXY)))), + vcut_e : doExpand(vcut_c, bXY), /* Project expansion onto confperp + mu basis */ - vcut_fact_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_fact_e))), + vcut_c : gcfac(fullratsimp(calcInnerProdList(VarsXYMu, 1, bXYMu, vcut_e))), /* Write coefficients. */ - writeCExprsWithZerosNoExpand1(vcut_fact_out, vcut_fact_c), + writeCExprsWithZerosNoExpand1(vcutsq_out, vcut_c), printf(fh, "}~%") ) @@ -111,7 +130,7 @@ genGkSheathSurrKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( at each node, calls gkyl_kann_net_apply, writes SRGRZ_N_MU outputs per node to out[node*SRGRZ_N_MU .. (node+1)*SRGRZ_N_MU - 1]. */ genGkSheathInputKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( - [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, + [pdim,varsC,bC,varsP,bP,vSub,NP,varsV,d,vmap_e,vmapSq_e,vmap_prime_e,surfPerpVar,VarsXY, bXY,nodesXY,numNodesXY,i,edge,surfPerpVal,sI, phi_e,phiWall_e,density_e,temperature_e,bmag_e,bimpactAngle_e, phi_q,phiWall_q,density_q,temperature_q,bmag_q,bimpactAngle_q], From d87192d29ba0d953255b0a99959c67d1e23129b9 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 12 Jun 2026 18:16:02 -0400 Subject: [PATCH 49/54] add fmax to cap density non negative for sqrt eval --- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 4cc7ecc4..8f2f680b 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -137,7 +137,7 @@ genGkSheathInputKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " double angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_e)))), printf(fh, "~%"), printf(fh, " nn_inp_out[0+n_inp*0] = (float)(angle_n*(180.0/GKYL_PI));~%"), - printf(fh, " nn_inp_out[1+n_inp*0] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%"), + printf(fh, " nn_inp_out[1+n_inp*0] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%"), printf(fh, " nn_inp_out[2+n_inp*0] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), printf(fh, "~%"), printf(fh, "}~%") diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 548f6219..91c5b480 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -184,7 +184,7 @@ genGkSheathInputKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), - printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%", i-1), + printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%", i-1), printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), printf(fh, "~%") ), diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index 1f0bda1d..3e3f6a90 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -185,7 +185,7 @@ genGkSheathInputKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), - printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*dens_n/GKYL_EPSILON0));~%", i-1), + printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, fmax(0.0, dens_n))/GKYL_EPSILON0));~%", i-1), printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), printf(fh, "~%") ), From 8a3950ed6a540ccd621e4045eafdfc4129cc17f4 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 19 Jun 2026 22:24:52 -0400 Subject: [PATCH 50/54] fix the node selection in 1x2v --- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 8f2f680b..44c7a81d 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -76,7 +76,7 @@ genGkSheathVcutCalcKer1x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", j-1), + printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+0*n_out, &mu, 1, mu_ref, &vcut);~%"), printf(fh, " vcutsq_n[~a] = vcut*vcut * vthSq;~%", j-1) ) else ( printf(fh, " vcutsq_n[~a] = -q2Dm * deltaphi_n;~%", j-1) From 858f8f71664277c1f25feb1988fc345bd7ccae76 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Fri, 19 Jun 2026 22:33:46 -0400 Subject: [PATCH 51/54] renam functions from srgz to surr and fix a indexation bug in the 1x2v sheath kernel --- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 44c7a81d..0d34c15f 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -76,7 +76,7 @@ genGkSheathVcutCalcKer1x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+0*n_out, &mu, 1, mu_ref, &vcut);~%"), + printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+0*n_out, &mu, 1, mu_ref, &vcut);~%"), printf(fh, " vcutsq_n[~a] = vcut*vcut * vthSq;~%", j-1) ) else ( printf(fh, " vcutsq_n[~a] = -q2Dm * deltaphi_n;~%", j-1) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 91c5b480..80036a87 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -100,7 +100,7 @@ genGkSheathVcutCalcKer2x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), + printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), printf(fh, " vcutsq_n_~a[~a] = vcut*vcut * vthSq;~%", i-1, j-1) ) else ( printf(fh, " vcutsq_n_~a[~a] = -q2Dm * deltaphi_n;~%", i-1, j-1) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index 3e3f6a90..a1bfcfdb 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -101,7 +101,7 @@ genGkSheathVcutCalcKer3x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_srgrz_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), + printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), printf(fh, " vcutsq_n_~a[~a] = vcut*vcut * vthSq;~%", i-1, j-1) ) else ( printf(fh, " vcutsq_n_~a[~a] = -q2Dm * deltaphi_n;~%", i-1, j-1) @@ -185,7 +185,7 @@ genGkSheathInputKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " bmag_n = ~a; ~%", gcfac(float(fullratsimp(bmag_q[i])))), printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), - printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, fmax(0.0, dens_n))/GKYL_EPSILON0));~%", i-1), + printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%", i-1), printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), printf(fh, "~%") ), From 5b30d7ae4ffaa9f66c19ebca927e3f5652e94d9f Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Wed, 24 Jun 2026 18:45:46 -0400 Subject: [PATCH 52/54] adapt the surrogate kernel interface to have handle the grid integration --- maxima/g0/gk-sheath/ms-gk-sheath.mac | 29 +++++++++++++++++-- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 2 +- 4 files changed, 29 insertions(+), 6 deletions(-) diff --git a/maxima/g0/gk-sheath/ms-gk-sheath.mac b/maxima/g0/gk-sheath/ms-gk-sheath.mac index 1016a951..7b5db1f7 100644 --- a/maxima/g0/gk-sheath/ms-gk-sheath.mac +++ b/maxima/g0/gk-sheath/ms-gk-sheath.mac @@ -105,9 +105,8 @@ for bInd : 1 thru length(bName) do ( fh : openw(sconcat(outDir,"/gkyl_bc_sheath_gyrokinetic_kernels.h"))$ printf(fh, "#pragma once~%")$ printf(fh, "~%")$ -printf(fh, "#include ~%"), +printf(fh, "#include ~%")$ printf(fh, "#include ~%")$ -printf(fh, "#include ~%")$ printf(fh, "#include ~%")$ printf(fh, "#include ~%")$ printf(fh, "~%")$ @@ -119,7 +118,31 @@ printf(fh, " // from Kroger ~%")$ printf(fh, " return (3.*x-x*x*x*(6. + x*x - 2.*x*x*x*x)/5.)/(1.-x*x); ~%")$ printf(fh, "}~%")$ printf(fh, "~%")$ - + +printf(fh, "// Linear interpolation of the surrogate output vcut[ng] (defined on the mu-grid~%")$ +printf(fh, "// mu_grid[ng], which the surrogate model supplies as the second half of each~%")$ +printf(fh, "// node's output block) onto mu_new[n], normalising mu by mu_ref (= T/B). Results~%")$ +printf(fh, "// are written into out[n]; clamps at the grid boundaries.~%")$ +printf(fh, "GKYL_CU_DH~%")$ +printf(fh, "static inline void~%")$ +printf(fh, "bc_sheath_gyrokinetic_surr_interpf(const float *vcut, const float *mu_grid, int ng, const double *mu_new, int n, double mu_ref, double *out)~%")$ +printf(fh, "{~%")$ +printf(fh, " for (int i = 0; i < n; i++) {~%")$ +printf(fh, " double mu = mu_new[i]/mu_ref;~%")$ +printf(fh, " if (mu <= mu_grid[0]) { out[i] = vcut[0]; continue; }~%")$ +printf(fh, " if (mu >= mu_grid[ng - 1]) { out[i] = vcut[ng - 1]; continue; }~%")$ +printf(fh, " // binary search for the bracketing interval~%")$ +printf(fh, " int lo = 0, hi = ng - 1;~%")$ +printf(fh, " while (hi - lo > 1) {~%")$ +printf(fh, " int mid = (lo + hi) >> 1;~%")$ +printf(fh, " if (mu_grid[mid] <= mu) lo = mid; else hi = mid;~%")$ +printf(fh, " }~%")$ +printf(fh, " double t = (mu - mu_grid[lo]) / (mu_grid[hi] - mu_grid[lo]);~%")$ +printf(fh, " out[i] = vcut[lo] + t * (vcut[hi] - vcut[lo]);~%")$ +printf(fh, " }~%")$ +printf(fh, "}~%")$ +printf(fh, "~%")$ + printf(fh, "EXTERN_C_BEG~%")$ printf(fh, "~%")$ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 0d34c15f..d00d3b24 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -76,7 +76,7 @@ genGkSheathVcutCalcKer1x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+0*n_out, &mu, 1, mu_ref, &vcut);~%"), + printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+0*n_out, nn_out+0*n_out+n_out/2, n_out/2, &mu, 1, mu_ref, &vcut);~%"), printf(fh, " vcutsq_n[~a] = vcut*vcut * vthSq;~%", j-1) ) else ( printf(fh, " vcutsq_n[~a] = -q2Dm * deltaphi_n;~%", j-1) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 80036a87..87370dd0 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -100,7 +100,7 @@ genGkSheathVcutCalcKer2x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), + printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+~a*n_out, nn_out+~a*n_out+n_out/2, n_out/2, &mu, 1, mu_ref, &vcut);~%", i-1, i-1), printf(fh, " vcutsq_n_~a[~a] = vcut*vcut * vthSq;~%", i-1, j-1) ) else ( printf(fh, " vcutsq_n_~a[~a] = -q2Dm * deltaphi_n;~%", i-1, j-1) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index a1bfcfdb..55ec8be2 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -101,7 +101,7 @@ genGkSheathVcutCalcKer3x2v(fh, cdim, vdim, basisFun, polyOrder, useSurrogate) := if useSurrogate = 1 then ( mu_e : subst(mu=nodesMu[j][1], vmap_e[2]), printf(fh, " mu = ~a; ~%", float(expand(mu_e))), - printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+~a*n_out, &mu, 1, mu_ref, &vcut);~%", i-1), + printf(fh, " bc_sheath_gyrokinetic_surr_interpf(nn_out+~a*n_out, nn_out+~a*n_out+n_out/2, n_out/2, &mu, 1, mu_ref, &vcut);~%", i-1, i-1), printf(fh, " vcutsq_n_~a[~a] = vcut*vcut * vthSq;~%", i-1, j-1) ) else ( printf(fh, " vcutsq_n_~a[~a] = -q2Dm * deltaphi_n;~%", i-1, j-1) From 1df7ec384ff6a321c2f1d3040c780614a87d013f Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Thu, 25 Jun 2026 09:25:41 -0400 Subject: [PATCH 53/54] add a comment about possible extension of the input parameters --- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 3 +++ maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 3 +++ maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 3 +++ 3 files changed, 9 insertions(+) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index d00d3b24..40dd0f8b 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -139,6 +139,9 @@ genGkSheathInputKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " nn_inp_out[0+n_inp*0] = (float)(angle_n*(180.0/GKYL_PI));~%"), printf(fh, " nn_inp_out[1+n_inp*0] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%"), printf(fh, " nn_inp_out[2+n_inp*0] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), + /* Note: In the future we can easily extend this to more parameters by adding more nn_inp_out entries, like: + nn_inp_out[3+n_inp*0] = (float)(tperp/tpar); // temperature anisotropy + */ printf(fh, "~%"), printf(fh, "}~%") ) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 87370dd0..9ab0735b 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -186,6 +186,9 @@ genGkSheathInputKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%", i-1), printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), + /* Note: In the future we can easily extend this to more parameters by adding more nn_inp_out entries, like: + nn_inp_out[3+n_inp*~a] = (float)(tperp/tpar); // temperature anisotropy + */ printf(fh, "~%") ), diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index 55ec8be2..adb2816b 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -187,6 +187,9 @@ genGkSheathInputKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%", i-1), printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), + /* Note: In the future we can easily extend this to more parameters by adding more nn_inp_out entries, like: + nn_inp_out[3+n_inp*~a] = (float)(tperp/tpar); // temperature anisotropy + */ printf(fh, "~%") ), From fbb63cad10954ed5a232f90045a1c2cfdaf0b205 Mon Sep 17 00:00:00 2001 From: Antoinehoff Date: Wed, 22 Jul 2026 13:28:07 -0400 Subject: [PATCH 54/54] cap density and potential drop to positive numbers to avoid evaluating the surrogate there. --- maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac | 2 +- maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac index 40dd0f8b..636c2bad 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-1x2v.mac @@ -138,7 +138,7 @@ genGkSheathInputKer1x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, "~%"), printf(fh, " nn_inp_out[0+n_inp*0] = (float)(angle_n*(180.0/GKYL_PI));~%"), printf(fh, " nn_inp_out[1+n_inp*0] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%"), - printf(fh, " nn_inp_out[2+n_inp*0] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%"), + printf(fh, " nn_inp_out[2+n_inp*0] = (float)(fmax(0.0, (GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n));~%"), /* Note: In the future we can easily extend this to more parameters by adding more nn_inp_out entries, like: nn_inp_out[3+n_inp*0] = (float)(tperp/tpar); // temperature anisotropy */ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac index 9ab0735b..2fd68a31 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-2x2v.mac @@ -185,7 +185,7 @@ genGkSheathInputKer2x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%", i-1), - printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), + printf(fh, " nn_inp_out[2+n_inp*~a] = (float)(fmax(0.0, (GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n));~%", i-1), /* Note: In the future we can easily extend this to more parameters by adding more nn_inp_out entries, like: nn_inp_out[3+n_inp*~a] = (float)(tperp/tpar); // temperature anisotropy */ diff --git a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac index adb2816b..a849d2ed 100644 --- a/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac +++ b/maxima/g0/gk-sheath/sheath_surrogate-3x2v.mac @@ -186,7 +186,7 @@ genGkSheathInputKer3x2v(fh, cdim, vdim, basisFun, polyOrder) := block( printf(fh, " angle_n = ~a; ~%", gcfac(float(fullratsimp(bimpactAngle_q[i])))), printf(fh, " nn_inp_out[0+n_inp*~a] = (float)(angle_n*(180.0/GKYL_PI));~%", i-1), printf(fh, " nn_inp_out[1+n_inp*~a] = (float)((1.0/bmag_n)*sqrt(GKYL_ELECTRON_MASS*fmax(0.0, dens_n)/GKYL_EPSILON0));~%", i-1), - printf(fh, " nn_inp_out[2+n_inp*~a] = (float)((GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n);~%", i-1), + printf(fh, " nn_inp_out[2+n_inp*~a] = (float)(fmax(0.0, (GKYL_ELEMENTARY_CHARGE*(phi_n-phi_wall_n))/temp_n));~%", i-1), /* Note: In the future we can easily extend this to more parameters by adding more nn_inp_out entries, like: nn_inp_out[3+n_inp*~a] = (float)(tperp/tpar); // temperature anisotropy */